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

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

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

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

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

Към профила на Беатрис Бонева

Резултати

  • 5 точки от тестове
  • 0 бонус точки
  • 5 точки общо
  • 13 успешни тест(а)
  • 2 неуспешни тест(а)

Код

class Argument
def initialize(placeholder, block)
@placeholder = placeholder
@block = block
end
def call(command_runner, value)
@block.call(command_runner, value)
end
def to_s
"[#{@placeholder}]"
end
end
class OptionWithParameter < Argument
def initialize(short_name, long_name, description, placeholder, block)
@short_name = short_name
@long_name = long_name
@description = description
super(placeholder, block)
end
def name_match?(name)
name == @short_name || name == @long_name
end
def to_s
" -#{@short_name}, --#{@long_name}=#{@placeholder} #{@description}"
end
end
class Option < OptionWithParameter
def initialize(short_name, long_name, description, block)
super(short_name, long_name, description, nil, block)
end
def to_s
" -#{@short_name}, --#{@long_name} #{@description}"
end
end
class CommandParser
def initialize(command_name)
@name = command_name
@arguments = []
@options = []
@options_with_parameters = []
end
def argument(*args, &block)
@arguments.push(Argument.new(*args, block))
end
def option(*args, &block)
@options.push(Option.new(*args, block))
end
def option_with_parameter(*args, &block)
@options_with_parameters.push(OptionWithParameter.new(*args, block))
end
def parse_options_with_parameters(argv)
argv.select do |arg|
arg.start_with?('--') && arg.include?('=') ||
arg =~ /^-[[:alnum:]]/ && arg.size > 2
end
end
def call_options_with_parameters(option_names, runner)
option_pairs = option_names.map do |arg|
arg.include?('=') ? arg[2..-1].split('=') : [arg[1], arg[2..-1]]
end
option_pairs.each do |name, value|
option = @options_with_parameters.find { |opt| opt.name_match?(name) }
option ? option.call(runner, value) : nil
end
end
def parse_options(argv)
argv.select { |arg| arg.start_with? '-', '--' }
end
def call_options(option_names, runner)
option_names.map { |opt| opt.gsub(/^-+/, '') }.each do |name|
option = @options.find { |opt| opt.name_match?(name) }
option ? option.call(runner, true) : nil
end
end
def call_arguments(args, runner)
@arguments.zip(args).each { |arg, value| arg.call(runner, value) }
end
def parse(command_runner, argv)
options_with_parameter = parse_options_with_parameters(argv)
call_options_with_parameters(options_with_parameter, command_runner)
options = parse_options(argv - options_with_parameter)
call_options(options, command_runner)
args = argv - options
call_arguments(args, command_runner)
end
def help
"Usage: #{@name} " \
"#{@arguments.map(&:to_s).join(' ')}" \
"#{@options.map { |x| "\n" + x.to_s }.join('')}" \
"#{@options_with_parameters.map { |x| "\n" + x.to_s }.join('')}"
end
end

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

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

Failures:

  1) CommandParser#help shows basic usage message
     Failure/Error: expect(parser.help).to eq 'Usage: ls'
       
       expected: "Usage: ls"
            got: "Usage: ls "
       
       (compared using ==)
     # /tmp/d20161113-27983-1xaa2ot/spec.rb:104: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)>'

  2) CommandParser when having options with and without values and parameters parses all the options and arguments correctly
     Failure/Error: expect(command_runner[:first_file]).to eq 'first.rb'
       
       expected: "first.rb"
            got: "-ssize"
       
       (compared using ==)
     # /tmp/d20161113-27983-1xaa2ot/spec.rb:171: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.02085 seconds
15 examples, 2 failures

Failed examples:

rspec /tmp/d20161113-27983-1xaa2ot/spec.rb:103 # CommandParser#help shows basic usage message
rspec /tmp/d20161113-27983-1xaa2ot/spec.rb:168 # CommandParser when having options with and without values and parameters parses all the options and arguments correctly

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

Беатрис обнови решението на 09.11.2016 16:37 (преди над 7 години)

+class Argument
+ def initialize(placeholder, block)
+ @placeholder = placeholder
+ @block = block
+ end
+
+ def call(command_runner, value)
+ @block.call(command_runner, value)
+ end
+
+ def to_s
+ "[#{@placeholder}]"
+ end
+end
+
+class OptionWithParameter < Argument
+ def initialize(short_name, long_name, description, placeholder, block)
+ @short_name = short_name
+ @long_name = long_name
+ @description = description
+ super(placeholder, block)
+ end
+
+ def name_match?(name)
+ name == @short_name || name == @long_name
+ end
+
+ def to_s
+ " -#{@short_name}, --#{@long_name}=#{@placeholder} #{@description}"
+ end
+end
+
+class Option < OptionWithParameter
+ def initialize(short_name, long_name, description, block)
+ super(short_name, long_name, description, nil, block)
+ end
+
+ def to_s
+ " -#{@short_name}, --#{@long_name} #{@description}"
+ end
+end
+
+class CommandParser
+ def initialize(command_name)
+ @name = command_name
+ @arguments = []
+ @options = []
+ @options_with_parameters = []
+ end
+
+ def argument(*args, &block)
+ @arguments.push(Argument.new(*args, block))
+ end
+
+ def option(*args, &block)
+ @options.push(Option.new(*args, block))
+ end
+
+ def option_with_parameter(*args, &block)
+ @options_with_parameters.push(OptionWithParameter.new(*args, block))
+ end
+
+ def parse_options_with_parameters(argv)
+ options = []
+ argv.each do |arg|
+ if arg.start_with?('--') && arg.include?('=')
+ options.push(arg[2..-1].split('='))
+ elsif arg =~ /^-[[:alnum:]]/ && arg.size > 2
+ options.push([arg[1], arg[2..-1]])
+ end
+ end
+ options
+ end
+
+ def call_options_with_parameters(option_pairs, runner)
+ option_pairs.each do |name, value|
+ option = @options_with_parameters.find { |opt| opt.name_match?(name) }
+ option ? option.call(runner, value) : nil
+ end
+ end
+
+ def parse_options(argv)
+ argv.select { |arg| arg.start_with? '-', '--' }
+ .map { |opt| opt.gsub(/^-+/, '') }
+ end
+
+ def call_options(option_names, runner)
+ option_names.each do |name|
+ option = @options.find { |opt| opt.name_match?(name) }
+ option ? option.call(runner, true) : nil
+ end
+ end
+
+ def call_arguments(args, runner)
+ @arguments.zip(args).each { |arg, value| arg.call(runner, value) }
+ end
+
+ def parse(command_runner, argv)
+ options_with_parameter = parse_options_with_parameters(argv)
+ call_options_with_parameters(options_with_parameter, command_runner)
+
+ options = parse_options(argv - options_with_parameter)
+ call_options(options, command_runner)
+
+ args = argv - options
+ call_arguments(args, command_runner)
+ end
+
+ def help
+ "Usage: #{@name} " \
+ "#{@arguments.map(&:to_s).join(' ')}\n" \
+ "#{@options.map(&:to_s).join("\n")}\n" \
+ "#{@options_with_parameters.map(&:to_s).join("\n")}"
+ end
+end

Беатрис обнови решението на 09.11.2016 16:58 (преди над 7 години)

class Argument
def initialize(placeholder, block)
@placeholder = placeholder
@block = block
end
def call(command_runner, value)
@block.call(command_runner, value)
end
def to_s
"[#{@placeholder}]"
end
end
class OptionWithParameter < Argument
def initialize(short_name, long_name, description, placeholder, block)
@short_name = short_name
@long_name = long_name
@description = description
super(placeholder, block)
end
def name_match?(name)
name == @short_name || name == @long_name
end
def to_s
" -#{@short_name}, --#{@long_name}=#{@placeholder} #{@description}"
end
end
class Option < OptionWithParameter
def initialize(short_name, long_name, description, block)
super(short_name, long_name, description, nil, block)
end
def to_s
" -#{@short_name}, --#{@long_name} #{@description}"
end
end
class CommandParser
def initialize(command_name)
@name = command_name
@arguments = []
@options = []
@options_with_parameters = []
end
def argument(*args, &block)
@arguments.push(Argument.new(*args, block))
end
def option(*args, &block)
@options.push(Option.new(*args, block))
end
def option_with_parameter(*args, &block)
@options_with_parameters.push(OptionWithParameter.new(*args, block))
end
def parse_options_with_parameters(argv)
- options = []
- argv.each do |arg|
- if arg.start_with?('--') && arg.include?('=')
- options.push(arg[2..-1].split('='))
- elsif arg =~ /^-[[:alnum:]]/ && arg.size > 2
- options.push([arg[1], arg[2..-1]])
- end
+ argv.select do |arg|
+ arg.start_with?('--') && arg.include?('=') ||
+ arg =~ /^-[[:alnum:]]/ && arg.size > 2
end
- options
end
- def call_options_with_parameters(option_pairs, runner)
+ def call_options_with_parameters(option_names, runner)
+ option_pairs = option_names.map do |arg|
+ arg.include?('=') ? arg[2..-1].split('=') : [arg[1], arg[2..-1]]
+ end
option_pairs.each do |name, value|
option = @options_with_parameters.find { |opt| opt.name_match?(name) }
option ? option.call(runner, value) : nil
end
end
def parse_options(argv)
argv.select { |arg| arg.start_with? '-', '--' }
- .map { |opt| opt.gsub(/^-+/, '') }
end
def call_options(option_names, runner)
- option_names.each do |name|
+ option_names.map { |opt| opt.gsub(/^-+/, '') }.each do |name|
option = @options.find { |opt| opt.name_match?(name) }
option ? option.call(runner, true) : nil
end
end
def call_arguments(args, runner)
@arguments.zip(args).each { |arg, value| arg.call(runner, value) }
end
def parse(command_runner, argv)
options_with_parameter = parse_options_with_parameters(argv)
call_options_with_parameters(options_with_parameter, command_runner)
options = parse_options(argv - options_with_parameter)
+ puts "options = #{options}"
call_options(options, command_runner)
args = argv - options
+ puts "args = #{args}"
call_arguments(args, command_runner)
end
def help
"Usage: #{@name} " \
- "#{@arguments.map(&:to_s).join(' ')}\n" \
- "#{@options.map(&:to_s).join("\n")}\n" \
- "#{@options_with_parameters.map(&:to_s).join("\n")}"
+ "#{@arguments.map(&:to_s).join(' ')}" \
+ "#{@options.map { |x| "\n" + x.to_s }.join('')}" \
+ "#{@options_with_parameters.map { |x| "\n" + x.to_s }.join('')}"
end
end

Беатрис обнови решението на 09.11.2016 16:59 (преди над 7 години)

class Argument
def initialize(placeholder, block)
@placeholder = placeholder
@block = block
end
def call(command_runner, value)
@block.call(command_runner, value)
end
def to_s
"[#{@placeholder}]"
end
end
class OptionWithParameter < Argument
def initialize(short_name, long_name, description, placeholder, block)
@short_name = short_name
@long_name = long_name
@description = description
super(placeholder, block)
end
def name_match?(name)
name == @short_name || name == @long_name
end
def to_s
" -#{@short_name}, --#{@long_name}=#{@placeholder} #{@description}"
end
end
class Option < OptionWithParameter
def initialize(short_name, long_name, description, block)
super(short_name, long_name, description, nil, block)
end
def to_s
" -#{@short_name}, --#{@long_name} #{@description}"
end
end
class CommandParser
def initialize(command_name)
@name = command_name
@arguments = []
@options = []
@options_with_parameters = []
end
def argument(*args, &block)
@arguments.push(Argument.new(*args, block))
end
def option(*args, &block)
@options.push(Option.new(*args, block))
end
def option_with_parameter(*args, &block)
@options_with_parameters.push(OptionWithParameter.new(*args, block))
end
def parse_options_with_parameters(argv)
argv.select do |arg|
arg.start_with?('--') && arg.include?('=') ||
arg =~ /^-[[:alnum:]]/ && arg.size > 2
end
end
def call_options_with_parameters(option_names, runner)
option_pairs = option_names.map do |arg|
arg.include?('=') ? arg[2..-1].split('=') : [arg[1], arg[2..-1]]
end
option_pairs.each do |name, value|
option = @options_with_parameters.find { |opt| opt.name_match?(name) }
option ? option.call(runner, value) : nil
end
end
def parse_options(argv)
argv.select { |arg| arg.start_with? '-', '--' }
end
def call_options(option_names, runner)
option_names.map { |opt| opt.gsub(/^-+/, '') }.each do |name|
option = @options.find { |opt| opt.name_match?(name) }
option ? option.call(runner, true) : nil
end
end
def call_arguments(args, runner)
@arguments.zip(args).each { |arg, value| arg.call(runner, value) }
end
def parse(command_runner, argv)
options_with_parameter = parse_options_with_parameters(argv)
call_options_with_parameters(options_with_parameter, command_runner)
options = parse_options(argv - options_with_parameter)
- puts "options = #{options}"
call_options(options, command_runner)
args = argv - options
- puts "args = #{args}"
call_arguments(args, command_runner)
end
def help
"Usage: #{@name} " \
"#{@arguments.map(&:to_s).join(' ')}" \
"#{@options.map { |x| "\n" + x.to_s }.join('')}" \
"#{@options_with_parameters.map { |x| "\n" + x.to_s }.join('')}"
end
end