Създаване на хеш чрез map

Програмиране с Ruby

Курс във Факултета по Математика и Информатика към СУ

Решение на Трета задача - Четене на командни аргументи от Кузман Белев

Обратно към всички решения

Към профила на Кузман Белев

Резултати

  • 6 точки от тестове
  • 0 бонус точки
  • 6 точки общо
  • 14 успешни тест(а)
  • 1 неуспешни тест(а)

Код

class CommandParser
attr_accessor :command_name, :objects, :arguments, :options
def initialize(command_name)
@command_name = command_name
@objects = []
@arguments = []
@options = []
end
def argument(arg_name, &block)
argument = Argument.new(arg_name, &block)
objects << argument
arguments << argument
end
def option(short_name, full_name, help_msg, &block)
option = Option.new(short_name, full_name, help_msg, &block)
objects << option
options << option
end
def option_with_parameter(short_name, full_name, help_msg, arg, &block)
option = ArgumentOption.new(short_name, full_name, help_msg, arg, &block)
objects << option
options << option
end
def parse(command_runner, argv)
i = 0
argv.each do |arg|
if objects[i] && objects[i].valid?(arg)
objects[i].parse(command_runner, arg)
i += 1
end
end
end
def help
result = "Usage: #{command_name}"
(arguments + options).each { |obj| result += obj.help }
result
end
end
class Argument
attr_accessor :arg_name, :block
def initialize(arg_name, &block)
@arg_name = arg_name
@block = block
end
def parse(command_runner, argv)
block.call(command_runner, argv)
end
def help
" [#{arg_name}]"
end
def valid?(value)
value[/^[^-]/]
end
end
module OptionsModule
private
def names
[full_name, short_name]
end
end
class OptionsBase
include OptionsModule
attr_accessor :short_name, :full_name, :help_msg, :block
def initialize(short_name, full_name, help_msg, &block)
@short_name = "-#{short_name}"
@full_name = "--#{full_name}"
@help_msg = help_msg
@block = block
end
def help(parameter = "")
"\n #{short_name}, #{full_name}#{parameter} #{help_msg}"
end
end
class Option < OptionsBase
def initialize(short_name, full_name, help_msg, &block)
super
end
def parse(command_runner, _)
block.call(command_runner, true)
end
def valid?(value)
names.include?(value)
end
end
class ArgumentOption < OptionsBase
attr_accessor :parameter
def initialize(short_name, full_name, help_msg, parameter, &block)
super(short_name, full_name, help_msg, &block)
@parameter = parameter
end
def parse(command_runner, argv)
if argv.start_with? full_name
value = argv.split("#{full_name}=")[1]
elsif argv.start_with?(short_name)
value = argv.split(short_name)[1]
end
block.call(command_runner, value)
end
def help
super("=#{parameter}")
end
def valid?(value)
names.any? { |valid_name| value.start_with? valid_name }
end
end

Лог от изпълнението

....F..........

Failures:

  1) CommandParser#option parses multiple options
     Failure/Error: expect(command_runner[:dir]).to be true
       
       expected #<TrueClass:20> => true
            got #<Symbol:252508> => :default
       
       Compared using equal?, which compares object identity,
       but expected and actual are not the same object. Use
       `expect(actual).to eq(expected)` if you don't care about
       object identity in this example.
       
       
       Diff:
       @@ -1,2 +1,2 @@
       -true
       +:default
     # /tmp/d20161113-27983-5eehz3/spec.rb:77:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (3 levels) in <top (required)>'
     # ./lib/language/ruby/run_with_timeout.rb:7:in `block (2 levels) in <top (required)>'

Finished in 0.0271 seconds
15 examples, 1 failure

Failed examples:

rspec /tmp/d20161113-27983-5eehz3/spec.rb:69 # CommandParser#option parses multiple options

История (4 версии и 0 коментара)

Кузман обнови решението на 08.11.2016 18:15 (преди над 7 години)

+class CommandParser
+ attr_accessor :command_name, :objects, :arguments, :options
+
+ def initialize(command_name)
+ @command_name = command_name
+ @objects = []
+ @arguments = []
+ @options = []
+ end
+
+ def argument(arg_name, &block)
+ new_argument = Argument.new(arg_name, &block)
+ objects << new_argument
+ arguments << new_argument
+ end
+
+ def option(short_name, full_name, help, &block)
+ new_option = Option.new(short_name, full_name, help, &block)
+ objects << new_option
+ options << new_option
+ end
+
+ def option_with_parameter(*params, &block)
+ new_option = OptionWithArgument.new(*params, &block)
+ objects << new_option
+ options << new_option
+ end
+
+ def parse(command_runner, argv)
+ i = 0
+ argv.each do |arg|
+ if objects[i] && objects[i].valid?(arg)
+ objects[i].parse(command_runner, arg)
+ i += 1
+ end
+ end
+ end
+
+ def help
+ result = "Usage: #{command_name}"
+ (arguments + options).each { |obj| result += obj.help }
+ result
+ end
+end
+
+# < Something
+class Argument
+ attr_accessor :arg_name, :block, :names
+
+ def initialize(arg_name, &block)
+ @arg_name = arg_name
+ @block = block
+ end
+
+ def parse(command_runner, argv)
+ block.call(command_runner, argv)
+ end
+
+ def help
+ " [#{arg_name}]"
+ end
+
+ def valid?(value)
+ value[/^[^-]/]
+ end
+end
+
+class Option
+ attr_accessor :short_name, :full_name, :help_msg, :block, :names
+
+ def initialize(*params, &block)
+ @short_name = params[0]
+ @full_name = params[1]
+ @help_msg = params[2]
+ @block = block
+ end
+
+ def parse(command_runner, argv)
+ if argv.length == 2 && short_name == argv[1]
+ block.call(command_runner, true)
+ elsif argv.length > 2 && full_name == argv[2..-1]
+ block.call(command_runner, true)
+ end
+ end
+
+ def help
+ "\n -#{short_name}, --#{full_name} #{help_msg}"
+ end
+
+ def valid?(value)
+ names.include?(value)
+ end
+
+ private
+
+ def names
+ ["--#{full_name}", "-#{short_name}"]
+ end
+end
+
+class OptionWithArgument
+ attr_accessor :short_name, :full_name, :help_msg, :parameter, :block, :names
+
+ def initialize(short_name, full_name, help_msg, parameter, &block)
+ @short_name = "-#{short_name}"
+ @full_name = "--#{full_name}"
+ @help_msg = help_msg
+ @parameter = parameter
+ @block = block
+ end
+
+ def parse(command_runner, argv)
+ if argv.start_with?(full_name)
+ value = argv.split("#{full_name}=")[1]
+ option = full_name
+ elsif argv.start_with?(short_name)
+ value = argv.split(short_name)[1]
+ option = short_name
+ end
+ block.call(command_runner, value) if names.include?(option)
+ end
+
+ def help
+ "\n #{short_name}, #{full_name}=#{parameter} #{help_msg}"
+ end
+
+ def valid?(value)
+ names.any? { |valid_name| value.start_with? valid_name }
+ end
+
+ private
+
+ def names
+ [full_name, short_name]
+ end
+end

Кузман обнови решението на 08.11.2016 21:37 (преди над 7 години)

class CommandParser
attr_accessor :command_name, :objects, :arguments, :options
def initialize(command_name)
@command_name = command_name
@objects = []
@arguments = []
@options = []
end
def argument(arg_name, &block)
- new_argument = Argument.new(arg_name, &block)
- objects << new_argument
- arguments << new_argument
+ argument = Argument.new(arg_name, &block)
+ objects << argument
+ arguments << argument
end
- def option(short_name, full_name, help, &block)
- new_option = Option.new(short_name, full_name, help, &block)
- objects << new_option
- options << new_option
+ def option(short_name, full_name, help_msg, &block)
+ option = Option.new(short_name, full_name, help_msg, &block)
+ objects << option
+ options << option
end
- def option_with_parameter(*params, &block)
- new_option = OptionWithArgument.new(*params, &block)
- objects << new_option
- options << new_option
+ def option_with_parameter(short_name, full_name, help_msg, arg, &block)
+ option = ArgumentOption.new(short_name, full_name, help_msg, arg, &block)
+ objects << option
+ options << option
end
def parse(command_runner, argv)
i = 0
argv.each do |arg|
if objects[i] && objects[i].valid?(arg)
objects[i].parse(command_runner, arg)
i += 1
end
end
end
def help
result = "Usage: #{command_name}"
(arguments + options).each { |obj| result += obj.help }
result
end
end
-# < Something
class Argument
- attr_accessor :arg_name, :block, :names
+ attr_accessor :arg_name, :block
def initialize(arg_name, &block)
@arg_name = arg_name
@block = block
end
def parse(command_runner, argv)
block.call(command_runner, argv)
end
def help
" [#{arg_name}]"
end
def valid?(value)
value[/^[^-]/]
end
end
-class Option
- attr_accessor :short_name, :full_name, :help_msg, :block, :names
+module OptionsModule
+ private
+ def names
+ [full_name, short_name]
+ end
+end
- def initialize(*params, &block)
- @short_name = params[0]
- @full_name = params[1]
- @help_msg = params[2]
+class OptionsBase
+ include OptionsModule
+ attr_accessor :short_name, :full_name, :help_msg, :block
+
+ def initialize(short_name, full_name, help_msg, &block)
+ @short_name = "-#{short_name}"
+ @full_name = "--#{full_name}"
+ @help_msg = help_msg
@block = block
end
+ def help(parameter = "")
+ "\n #{short_name}, #{full_name}#{parameter} #{help_msg}"
+ end
+end
+
+class Option < OptionsBase
+ attr_accessor :short_name, :full_name, :help_msg, :block
+
+ def initialize(short_name, full_name, help_msg, &block)
+ super
+ end
+
def parse(command_runner, argv)
- if argv.length == 2 && short_name == argv[1]
+ if argv.length == 2 && short_name == argv
block.call(command_runner, true)
- elsif argv.length > 2 && full_name == argv[2..-1]
+ elsif argv.length > 2 && full_name == argv
block.call(command_runner, true)
end
end
-
- def help
- "\n -#{short_name}, --#{full_name} #{help_msg}"
- end
-
+
def valid?(value)
names.include?(value)
end
-
- private
-
- def names
- ["--#{full_name}", "-#{short_name}"]
- end
end
-class OptionWithArgument
- attr_accessor :short_name, :full_name, :help_msg, :parameter, :block, :names
+class ArgumentOption < OptionsBase
+ attr_accessor :short_name, :full_name, :help_msg, :parameter, :block
def initialize(short_name, full_name, help_msg, parameter, &block)
- @short_name = "-#{short_name}"
- @full_name = "--#{full_name}"
- @help_msg = help_msg
+ super(short_name, full_name, help_msg, &block)
@parameter = parameter
- @block = block
end
def parse(command_runner, argv)
- if argv.start_with?(full_name)
+ if argv.start_with? full_name
value = argv.split("#{full_name}=")[1]
option = full_name
elsif argv.start_with?(short_name)
value = argv.split(short_name)[1]
option = short_name
end
block.call(command_runner, value) if names.include?(option)
end
def help
- "\n #{short_name}, #{full_name}=#{parameter} #{help_msg}"
+ super("=#{parameter}")
end
def valid?(value)
names.any? { |valid_name| value.start_with? valid_name }
end
-
- private
-
- def names
- [full_name, short_name]
- end
end

Кузман обнови решението на 08.11.2016 21:54 (преди над 7 години)

class CommandParser
attr_accessor :command_name, :objects, :arguments, :options
def initialize(command_name)
@command_name = command_name
@objects = []
@arguments = []
@options = []
end
def argument(arg_name, &block)
argument = Argument.new(arg_name, &block)
objects << argument
arguments << argument
end
def option(short_name, full_name, help_msg, &block)
option = Option.new(short_name, full_name, help_msg, &block)
objects << option
options << option
end
def option_with_parameter(short_name, full_name, help_msg, arg, &block)
option = ArgumentOption.new(short_name, full_name, help_msg, arg, &block)
objects << option
options << option
end
def parse(command_runner, argv)
i = 0
argv.each do |arg|
if objects[i] && objects[i].valid?(arg)
objects[i].parse(command_runner, arg)
i += 1
end
end
end
def help
result = "Usage: #{command_name}"
(arguments + options).each { |obj| result += obj.help }
result
end
end
class Argument
attr_accessor :arg_name, :block
def initialize(arg_name, &block)
@arg_name = arg_name
@block = block
end
def parse(command_runner, argv)
block.call(command_runner, argv)
end
def help
" [#{arg_name}]"
end
def valid?(value)
value[/^[^-]/]
end
end
module OptionsModule
private
def names
[full_name, short_name]
end
end
class OptionsBase
include OptionsModule
attr_accessor :short_name, :full_name, :help_msg, :block
def initialize(short_name, full_name, help_msg, &block)
@short_name = "-#{short_name}"
@full_name = "--#{full_name}"
@help_msg = help_msg
@block = block
end
def help(parameter = "")
"\n #{short_name}, #{full_name}#{parameter} #{help_msg}"
end
end
-class Option < OptionsBase
- attr_accessor :short_name, :full_name, :help_msg, :block
-
+class Option < OptionsBase
def initialize(short_name, full_name, help_msg, &block)
super
end
def parse(command_runner, argv)
if argv.length == 2 && short_name == argv
block.call(command_runner, true)
elsif argv.length > 2 && full_name == argv
block.call(command_runner, true)
end
end
def valid?(value)
names.include?(value)
end
end
class ArgumentOption < OptionsBase
- attr_accessor :short_name, :full_name, :help_msg, :parameter, :block
+ attr_accessor :parameter
def initialize(short_name, full_name, help_msg, parameter, &block)
super(short_name, full_name, help_msg, &block)
@parameter = parameter
end
def parse(command_runner, argv)
if argv.start_with? full_name
value = argv.split("#{full_name}=")[1]
option = full_name
elsif argv.start_with?(short_name)
value = argv.split(short_name)[1]
option = short_name
end
block.call(command_runner, value) if names.include?(option)
end
def help
super("=#{parameter}")
end
def valid?(value)
names.any? { |valid_name| value.start_with? valid_name }
end
end

Кузман обнови решението на 09.11.2016 14:47 (преди над 7 години)

class CommandParser
attr_accessor :command_name, :objects, :arguments, :options
def initialize(command_name)
@command_name = command_name
@objects = []
@arguments = []
@options = []
end
def argument(arg_name, &block)
argument = Argument.new(arg_name, &block)
objects << argument
arguments << argument
end
def option(short_name, full_name, help_msg, &block)
option = Option.new(short_name, full_name, help_msg, &block)
objects << option
options << option
end
def option_with_parameter(short_name, full_name, help_msg, arg, &block)
option = ArgumentOption.new(short_name, full_name, help_msg, arg, &block)
objects << option
options << option
end
def parse(command_runner, argv)
i = 0
argv.each do |arg|
if objects[i] && objects[i].valid?(arg)
objects[i].parse(command_runner, arg)
i += 1
end
end
end
def help
result = "Usage: #{command_name}"
(arguments + options).each { |obj| result += obj.help }
result
end
end
class Argument
attr_accessor :arg_name, :block
def initialize(arg_name, &block)
@arg_name = arg_name
@block = block
end
def parse(command_runner, argv)
block.call(command_runner, argv)
end
def help
" [#{arg_name}]"
end
def valid?(value)
value[/^[^-]/]
end
end
module OptionsModule
private
def names
[full_name, short_name]
end
end
class OptionsBase
include OptionsModule
attr_accessor :short_name, :full_name, :help_msg, :block
def initialize(short_name, full_name, help_msg, &block)
@short_name = "-#{short_name}"
@full_name = "--#{full_name}"
@help_msg = help_msg
@block = block
end
def help(parameter = "")
"\n #{short_name}, #{full_name}#{parameter} #{help_msg}"
end
end
class Option < OptionsBase
def initialize(short_name, full_name, help_msg, &block)
super
end
- def parse(command_runner, argv)
- if argv.length == 2 && short_name == argv
- block.call(command_runner, true)
- elsif argv.length > 2 && full_name == argv
- block.call(command_runner, true)
- end
+ def parse(command_runner, _)
+ block.call(command_runner, true)
end
def valid?(value)
names.include?(value)
end
end
class ArgumentOption < OptionsBase
attr_accessor :parameter
def initialize(short_name, full_name, help_msg, parameter, &block)
super(short_name, full_name, help_msg, &block)
@parameter = parameter
end
def parse(command_runner, argv)
if argv.start_with? full_name
value = argv.split("#{full_name}=")[1]
- option = full_name
elsif argv.start_with?(short_name)
value = argv.split(short_name)[1]
- option = short_name
end
- block.call(command_runner, value) if names.include?(option)
+ block.call(command_runner, value)
end
def help
super("=#{parameter}")
end
def valid?(value)
names.any? { |valid_name| value.start_with? valid_name }
end
end