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

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

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

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

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

Към профила на Добрин Цветков

Резултати

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

Код

module ParserHelpers
def parse_arguments(command_runner, argv)
to_parse_args_index = 0
argv.each do |argument|
next if argument[0] == '-'
@to_parse_args[to_parse_args_index][0].call(command_runner, argument)
to_parse_args_index += 1
end
end
def parse_options(command_runner, argv)
@to_parse_options.each do |current|
if argv.include?("-#{current[1]}") || argv.include?("--#{current[2]}")
current[0].call(command_runner, true)
end
end
end
def parse_options_with_parameters(command_runner, argv)
@to_parse_opt_with_param.each do |option|
argv.each do |argument|
essentials = argument[2..-1]
option[1] == argument[1] && option[0].call(command_runner, essentials)
opt_name, opt_param = essentials.split('=')
option[2] == opt_name && option[0].call(command_runner, opt_param)
end
end
end
end
class CommandParser
include ParserHelpers
def initialize(command_name)
@command_name = command_name
@to_parse_args = []
@to_parse_options = []
@to_parse_opt_with_param = []
end
def argument(name, &block)
@to_parse_args << [block, name]
end
def option(short_name, long_name, text, &block)
@to_parse_options << [block, short_name, long_name, text]
end
def option_with_parameter(short_name, long_name, text, plholder, &block)
@to_parse_opt_with_param << [block, short_name, long_name, text, plholder]
end
def parse(command_runner, argv)
parse_arguments(command_runner, argv)
parse_options(command_runner, argv)
parse_options_with_parameters(command_runner, argv)
end
def help
result = "Usage: #{@command_name} "
@to_parse_args.each { |argument| result << '[' + argument[1] + '] ' }
result = result.chop
@to_parse_options.each do |option|
result << "\n -#{option[1]}, --#{option[2]} #{option[3]}"
end
@to_parse_opt_with_param.each do |option|
result << "\n -#{option[1]}, --#{option[2]}=#{option[4]} #{option[3]}"
end
result
end
end

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

...............

Finished in 0.00827 seconds
15 examples, 0 failures

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

Добрин обнови решението на 04.11.2016 17:00 (преди над 7 години)

+module ParserHelpers
+ def parse_arguments(command_runner, argv)
+ to_parse_args_index = 0
+ argv.each do |arg|
+ next if arg[0] == '-'
+ @to_parse_args[to_parse_args_index][0].call(command_runner, arg)
+ to_parse_args_index += 1
+ end
+ end
+
+ def parse_options(command_runner, argv)
+ @to_parse_options.each do |crr|
+ if argv.include?("-#{crr[1]}") || argv.include?("--#{crr[2]}")
+ crr[0].call(command_runner, true)
+ end
+ end
+ end
+
+ def parse_options_with_parameters(command_runner, argv)
+ @to_parse_opt_with_param.each do |crr|
+ argv.each do |arg|
+ crr[0].call(command_runner, arg[2..-1]) if crr[1] == arg[1]
+ arg_splited = arg[2..-1].split('=')
+ crr[0].call(command_runner, arg_splited[1]) if crr[2] == arg_splited[0]
+ end
+ end
+ end
+end
+
+class CommandParser
+ include ParserHelpers
+ def initialize(command_name)
+ @command_name = command_name
+ @to_parse_args = []
+ @to_parse_options = []
+ @to_parse_opt_with_param = []
+ end
+
+ def argument(name, &block)
+ @to_parse_args << [block, name]
+
+ end
+
+ def option(short_name, long_name, text, &block)
+ @to_parse_options << [block, short_name, long_name, text]
+ end
+
+ def option_with_parameter(short_name, long_name, text, plholder, &block)
+ @to_parse_opt_with_param << [block, short_name, long_name, text, plholder]
+ end
+
+ def parse(command_runner, argv)
+ parse_arguments(command_runner, argv)
+ parse_options(command_runner, argv)
+ parse_options_with_parameters(command_runner, argv)
+ end
+
+ def help
+ result = "Usage: #{@command_name} "
+ @to_parse_args.each { |crr| result << '[' + crr[1] + ']' }
+ @to_parse_options.each do |crr|
+ result << "\n -#{crr[1]}, --#{crr[2]} #{crr[3]}"
+ end
+ @to_parse_opt_with_param.each do |crr|
+ result << "\n -#{crr[1]}, --#{crr[2]}=#{crr[4]} #{crr[3]}"
+ end
+ result
+ end
+end

Добрин обнови решението на 08.11.2016 22:28 (преди над 7 години)

module ParserHelpers
def parse_arguments(command_runner, argv)
to_parse_args_index = 0
argv.each do |arg|
next if arg[0] == '-'
@to_parse_args[to_parse_args_index][0].call(command_runner, arg)
to_parse_args_index += 1
end
end
def parse_options(command_runner, argv)
@to_parse_options.each do |crr|
if argv.include?("-#{crr[1]}") || argv.include?("--#{crr[2]}")
crr[0].call(command_runner, true)
end
end
end
def parse_options_with_parameters(command_runner, argv)
@to_parse_opt_with_param.each do |crr|
argv.each do |arg|
crr[0].call(command_runner, arg[2..-1]) if crr[1] == arg[1]
arg_splited = arg[2..-1].split('=')
crr[0].call(command_runner, arg_splited[1]) if crr[2] == arg_splited[0]
end
end
end
end
class CommandParser
include ParserHelpers
def initialize(command_name)
@command_name = command_name
@to_parse_args = []
@to_parse_options = []
@to_parse_opt_with_param = []
end
def argument(name, &block)
@to_parse_args << [block, name]
end
def option(short_name, long_name, text, &block)
@to_parse_options << [block, short_name, long_name, text]
end
def option_with_parameter(short_name, long_name, text, plholder, &block)
@to_parse_opt_with_param << [block, short_name, long_name, text, plholder]
end
def parse(command_runner, argv)
parse_arguments(command_runner, argv)
parse_options(command_runner, argv)
parse_options_with_parameters(command_runner, argv)
end
def help
result = "Usage: #{@command_name} "
- @to_parse_args.each { |crr| result << '[' + crr[1] + ']' }
+ @to_parse_args.each { |crr| result << '[' + crr[1] + '] ' }
+ result = result.chop
@to_parse_options.each do |crr|
result << "\n -#{crr[1]}, --#{crr[2]} #{crr[3]}"
end
@to_parse_opt_with_param.each do |crr|
result << "\n -#{crr[1]}, --#{crr[2]}=#{crr[4]} #{crr[3]}"
end
result
end
end

Добрин обнови решението на 08.11.2016 22:53 (преди над 7 години)

module ParserHelpers
def parse_arguments(command_runner, argv)
to_parse_args_index = 0
argv.each do |arg|
next if arg[0] == '-'
@to_parse_args[to_parse_args_index][0].call(command_runner, arg)
to_parse_args_index += 1
end
end
def parse_options(command_runner, argv)
@to_parse_options.each do |crr|
if argv.include?("-#{crr[1]}") || argv.include?("--#{crr[2]}")
crr[0].call(command_runner, true)
end
end
end
def parse_options_with_parameters(command_runner, argv)
@to_parse_opt_with_param.each do |crr|
argv.each do |arg|
- crr[0].call(command_runner, arg[2..-1]) if crr[1] == arg[1]
+ crr[1] == arg[1] && crr[0].call(command_runner, arg[2..-1])
arg_splited = arg[2..-1].split('=')
- crr[0].call(command_runner, arg_splited[1]) if crr[2] == arg_splited[0]
+ crr[2] == arg_splited[0] && crr[0].call(command_runner, arg_splited[1])
end
end
end
end
class CommandParser
include ParserHelpers
def initialize(command_name)
@command_name = command_name
@to_parse_args = []
@to_parse_options = []
@to_parse_opt_with_param = []
end
def argument(name, &block)
@to_parse_args << [block, name]
end
def option(short_name, long_name, text, &block)
@to_parse_options << [block, short_name, long_name, text]
end
def option_with_parameter(short_name, long_name, text, plholder, &block)
@to_parse_opt_with_param << [block, short_name, long_name, text, plholder]
end
def parse(command_runner, argv)
parse_arguments(command_runner, argv)
parse_options(command_runner, argv)
parse_options_with_parameters(command_runner, argv)
end
def help
result = "Usage: #{@command_name} "
@to_parse_args.each { |crr| result << '[' + crr[1] + '] ' }
result = result.chop
@to_parse_options.each do |crr|
result << "\n -#{crr[1]}, --#{crr[2]} #{crr[3]}"
end
@to_parse_opt_with_param.each do |crr|
result << "\n -#{crr[1]}, --#{crr[2]}=#{crr[4]} #{crr[3]}"
end
result
end
end

Добрин обнови решението на 09.11.2016 10:16 (преди над 7 години)

module ParserHelpers
def parse_arguments(command_runner, argv)
to_parse_args_index = 0
- argv.each do |arg|
- next if arg[0] == '-'
- @to_parse_args[to_parse_args_index][0].call(command_runner, arg)
+ argv.each do |argument|
+ next if argument[0] == '-'
+ @to_parse_args[to_parse_args_index][0].call(command_runner, argument)
to_parse_args_index += 1
end
end
def parse_options(command_runner, argv)
- @to_parse_options.each do |crr|
- if argv.include?("-#{crr[1]}") || argv.include?("--#{crr[2]}")
- crr[0].call(command_runner, true)
+ @to_parse_options.each do |current|
+ if argv.include?("-#{current[1]}") || argv.include?("--#{current[2]}")
+ current[0].call(command_runner, true)
end
end
end
def parse_options_with_parameters(command_runner, argv)
- @to_parse_opt_with_param.each do |crr|
- argv.each do |arg|
- crr[1] == arg[1] && crr[0].call(command_runner, arg[2..-1])
- arg_splited = arg[2..-1].split('=')
- crr[2] == arg_splited[0] && crr[0].call(command_runner, arg_splited[1])
+ @to_parse_opt_with_param.each do |option|
+ argv.each do |argument|
+ essentials = argument[2..-1]
+ option[1] == argument[1] && option[0].call(command_runner, essentials)
+ opt_name, opt_param = essentials.split('=')
+ option[2] == opt_name && option[0].call(command_runner, opt_param)
end
end
end
end
class CommandParser
include ParserHelpers
def initialize(command_name)
@command_name = command_name
@to_parse_args = []
@to_parse_options = []
@to_parse_opt_with_param = []
end
def argument(name, &block)
@to_parse_args << [block, name]
end
def option(short_name, long_name, text, &block)
@to_parse_options << [block, short_name, long_name, text]
end
def option_with_parameter(short_name, long_name, text, plholder, &block)
@to_parse_opt_with_param << [block, short_name, long_name, text, plholder]
end
def parse(command_runner, argv)
parse_arguments(command_runner, argv)
parse_options(command_runner, argv)
parse_options_with_parameters(command_runner, argv)
end
def help
result = "Usage: #{@command_name} "
- @to_parse_args.each { |crr| result << '[' + crr[1] + '] ' }
+ @to_parse_args.each { |argument| result << '[' + argument[1] + '] ' }
result = result.chop
- @to_parse_options.each do |crr|
- result << "\n -#{crr[1]}, --#{crr[2]} #{crr[3]}"
+ @to_parse_options.each do |option|
+ result << "\n -#{option[1]}, --#{option[2]} #{option[3]}"
end
- @to_parse_opt_with_param.each do |crr|
- result << "\n -#{crr[1]}, --#{crr[2]}=#{crr[4]} #{crr[3]}"
+ @to_parse_opt_with_param.each do |option|
+ result << "\n -#{option[1]}, --#{option[2]}=#{option[4]} #{option[3]}"
end
result
end
end