console_runner 0.1.9 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1c16db9e220aea79fb56dcfedbefaf35822d5759
-  data.tar.gz: 04a996f93da398cc7b3cf78054d4cbc0410d2572
+  metadata.gz: 0061346daf03362eaa69986cb0333cbe5870e51d
+  data.tar.gz: e7ca879f56d7db7f1a6906975f120099447f59e3
 SHA512:
-  metadata.gz: b250ca7da42c8f2c2940577d0706a8ebc800af3463aef7f94b75c2a6aa626e809262b2e37b5c12dce3f515855bfe39ef0bd0fcf1a67683b8338f6c51458b9f93
-  data.tar.gz: 9e0c76daa906eb6cb2224caa38d86ad0e9df4adf374c79979a3ed15186625326161f5e7bb596049c3c9fa6d101ee26987befba7298460ee3830c5b7f1bca172a
+  metadata.gz: 900719815c752294a4face86d98397987450059710c6711dfee63bef07d9565a859d7e7e390555f42da111cbb07ffd4f7cfcc245989a4d22e4aadb845594a4b8
+  data.tar.gz: 478defb882bc32bf378a682413821399612070c831f8eb83b85c5a839448b59aa340056e3f3a31a06656d079ebae87bc83f51cc6226edc51e85cf4b51e7a0108

data/README.md

@@ -63,7 +63,7 @@ Or install it yourself as:
     $ gem install console_runner
 
 ## FAQ
-##### **Can I add documentation for my tool and customize help page content?**
+#### **Can I add documentation for my tool and customize help page content?**
 Yes. Any text placed after `@runnable` tag will be displayed on the help page. You can add any additional information about how to use your tool there.
 > **Tip**: You can use multi-line text as well
 

data/lib/command_line_parser.rb

@@ -0,0 +1,54 @@
+require 'trollop'
+require 'method_parser'
+
+# Parses command line and configure #Trollop
+class CommandLineParser
+  attr_reader :method, :init_method
+
+  # Generate tool help menu.
+  # IMPORTANT! Should be executed before ARGV.shift
+  def initialize(file_parser)
+    @file_parser  = file_parser
+    @sub_commands = @file_parser.runnable_methods.map { |m| m.name.to_s }
+    @parser       = Trollop::Parser.new
+    @parser.banner(FileParser.select_runnable_tags(@file_parser.clazz).map { |t| (t.text + "\n") }.join("\n"))
+    @parser.stop_on @sub_commands
+  end
+
+  def run(action)
+    if %w(-h --help).include?(ARGV[0].strip)
+      Trollop::with_standard_exception_handling(@parser) { raise Trollop::HelpNeeded }
+    end
+    unless @sub_commands.include?(ARGV[0].strip)
+      raise ConsoleRunnerError, "You must provide one of available actions: #{@sub_commands.join ', '}"
+    end
+
+    @init_method = nil
+    @init_method = MethodParser.new(@file_parser.initialize_method) if @file_parser.initialize_method
+    @method      = MethodParser.new action
+    [@init_method, @method].each do |method|
+      next unless method
+      method.trollop_opts.each { |a| @parser.opt(*a) }
+      cmd_opts        = Trollop::with_standard_exception_handling @parser do
+        unless method.parameters.count.zero?
+          raise Trollop::HelpNeeded if ARGV.empty?
+        end
+        @parser.parse ARGV
+      end
+      given_attrs     = cmd_opts.keys.select { |k| k.to_s.include? '_given' }.map { |k| k.to_s.gsub('_given', '').to_sym }
+      method.cmd_opts = cmd_opts.select { |k, _| given_attrs.include? k }
+      method.default_values.each do |k, v|
+        method.cmd_opts[k.to_sym] ||= v
+      end
+      method.required_parameters.each do |required_param|
+        next if method.options_group? required_param
+        unless method.cmd_opts[required_param.to_sym]
+          raise ConsoleRunnerError, "You must specify required parameter: #{required_param}"
+        end
+      end
+      ARGV.shift
+    end
+  end
+
+end
+

data/lib/console_runner.rb

@@ -1,5 +1,5 @@
 require 'file_parser'
-require 'trollop_configurator'
+require 'command_line_parser'
 require 'runner'
 require 'console_runner/version'
 
@@ -19,14 +19,12 @@ module ConsoleRunner
   end
   action      = actions.first
   action      ||= file_parser.run_method
-  trol_config = TrollopConfigurator.new(file_parser)
-  raise ConsoleRunnerError, "Cannot run! You haven't specify any method to run." unless action
-  trol_config.parse_method action
+  trol_config = CommandLineParser.new(file_parser)
+  trol_config.run(action)
 
 
   puts '======================================================='
   puts 'Global options:'
-  puts trol_config.global_opts.map { |k, v| "     #{k} = #{v}" }.join("\n")
   if file_parser.initialize_method
     puts "INIT: #{file_parser.initialize_method.name}"
     puts 'INIT options:'
@@ -63,11 +61,4 @@ module ConsoleRunner
 
   }
 
-
-# raise ConsoleRunnerError, "#{clazz.name}#initialize method should be specified" unless initialize_method
-#
-# raise ConsoleRunnerError, "At least one method should be marked with @#{FileParser::RUNNABLE_TAG.to_s} tag.
-# Also you may specify #run method and it will be executed by default.
-# #run method don't need any code annotations as well." if runnable_methods.count == 0 unless run_method
-
 end

data/lib/console_runner/version.rb

@@ -1,3 +1,3 @@
 module ConsoleRunner
-  VERSION = '0.1.9'
+  VERSION = '0.1.10'
 end

data/lib/method_parser.rb

@@ -2,27 +2,84 @@
 class MethodParser
   attr_reader :method,
               :name,
+              :parameters,
               :param_tags, # All method parameters tags
-              :option_tags # Only options tags
+              :option_tags, # Only options tags
+              :trollop_opts,
+              :default_values,
+              :required_parameters
 
   attr_accessor :cmd_opts
 
+  TYPES_MAPPINGS = {
+    'String'         => :string,
+    'Integer'        => :int,
+    'Fixnum'         => :int,
+    'Float'          => :float,
+    'Boolean'        => :boolean,
+    'Array(String)'  => :strings,
+    'Array(Integer)' => :ints,
+    'Array(Fixnum)'  => :ints,
+    'Array(Float)'   => :floats,
+    'Array(Boolean)' => :booleans
+  }.freeze
+
   # @param [YARD::CodeObjects::MethodObject] method YARD method object to be parsed
   def initialize(method)
-    @method      = method
-    @name        = @method.name
-    @parameters  = @method.parameters
-    @param_tags  = FileParser.select_param_tags @method
-    @option_tags = FileParser.select_option_tags @method
-    @cmd_opts    = nil
-    same_params = param_tags_names & option_tags_names
-    if same_params.count > 0
+    @method              = method
+    @name                = @method.name
+    @parameters          = @method.parameters
+    @default_values      = default_params
+    @param_tags          = FileParser.select_param_tags @method
+    @option_tags         = FileParser.select_option_tags @method
+    @required_parameters = @param_tags.select { |t| t.tag_name == 'param' }.map(&:name)
+    @cmd_opts            = nil
+    same_params          = param_tags_names & option_tags_names
+    unless same_params.count.zero?
       raise(
         ConsoleRunnerError,
         "You have the same name for @param and @option attribute(s): #{same_params.join(', ')}.
 Use different names to `console_runner` be able to run #{@name} method."
       )
     end
+    @trollop_opts = prepare_opts_for_trollop
+  end
+
+  def prepare_opts_for_trollop
+    result = []
+    param_tags.each do |tag|
+      tag_name = tag.name
+      tag_text = tag.text
+      tag_type = tag.type
+      if tag_type == "Hash"
+        options = option_tags.select { |t| t.name == tag.name }
+        if options.count > 0
+          options.each do |option|
+            option_name = option.pair.name.delete(':')
+            option_text = option.pair.text
+            option_type = option.pair.type
+            result << [
+              option_name.to_sym,
+              "(Ruby class: #{option_type}) " + option_text.to_s,
+              type: parse_type(option_type)
+            ]
+          end
+        else
+          result << [
+            tag_name.to_sym,
+            "(Ruby class: #{tag_type}) " + tag_text.to_s,
+            type: parse_type(tag_type)
+          ]
+        end
+      else
+        result << [
+          tag_name.to_sym,
+          "(Ruby class: #{tag_type}) " + tag_text.to_s,
+          type: parse_type(tag_type)
+        ]
+      end
+    end
+    result
   end
 
   # Prepare
@@ -79,9 +136,18 @@ Use different names to `console_runner` be able to run #{@name} method."
     option_tags.any? { |t| t.name == param_name }
   end
 
+
+  private
+
+  def parse_type(yard_type)
+    result = TYPES_MAPPINGS[yard_type]
+    raise ConsoleRunnerError, "Unsupported YARD type: #{yard_type}" unless result
+    result
+  end
+
   # @return [Hash] default values for parameters
   def default_params
-    @parameters.map do |array|
+    @parameters.to_a.map do |array|
       array.map do |a|
         if a
           ['"', "'"].include?(a[0]) && ['"', "'"].include?(a[-1]) ? a[1..-2] : a
@@ -92,8 +158,6 @@ Use different names to `console_runner` be able to run #{@name} method."
     end.to_h
   end
 
-  private
-
   # @return [Hash] options parameter as Hash
   def option_as_hash(options_group_name)
     result = {}

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: console_runner
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.10
 platform: ruby
 authors:
 - Yury Karpovich
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-04-12 00:00:00.000000000 Z
+date: 2017-04-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -157,13 +157,13 @@ files:
 - bin/setup
 - console_runner.gemspec
 - exe/c_run
+- lib/command_line_parser.rb
 - lib/console_runner.rb
 - lib/console_runner/version.rb
 - lib/console_runner_error.rb
 - lib/file_parser.rb
 - lib/method_parser.rb
 - lib/runner.rb
-- lib/trollop_configurator.rb
 homepage: https://github.com/yuri-karpovich/console_runner
 licenses:
 - MIT

data/lib/trollop_configurator.rb

@@ -1,124 +0,0 @@
-require 'trollop'
-require 'method_parser'
-
-# Parses command line and configure #Trollop
-class TrollopConfigurator
-  attr_reader :global_opts, :method, :init_method
-  TYPES_MAPPINGS = {
-    'String'         => :string,
-    'Integer'        => :int,
-    'Fixnum'         => :int,
-    'Float'          => :float,
-    'Boolean'        => :boolean,
-    'Array(String)'  => :strings,
-    'Array(Integer)' => :ints,
-    'Array(Fixnum)'  => :ints,
-    'Array(Float)'   => :floats,
-    'Array(Boolean)' => :booleans
-  }.freeze
-
-  # Generate tool help menu.
-  # IMPORTANT! Should be executed before ARGV.shift
-  def initialize(file_parser)
-    runnable_methods = file_parser.runnable_methods
-    init_method = file_parser.initialize_method
-    clazz        = runnable_methods.first.parent
-    sub_commands = runnable_methods.map { |m| m.name.to_s }
-    @parser      = Trollop::Parser.new
-    @parser.banner(FileParser.select_runnable_tags(clazz).map { |t| (t.text + "\n") }.join("\n"))
-    @parser.stop_on sub_commands
-
-    if init_method
-      @init_method = MethodParser.new init_method
-      @init_method.param_tags.each do |tag|
-        tag_name = tag.name
-        tag_text = tag.text
-        tag_type = tag.type
-        if tag_type == "Hash"
-          options = option_tags.select { |t| t.name == tag.name }
-          if options.count > 0
-            options.each do |option|
-              option_name = option.pair.name.delete(':')
-              option_text = option.pair.text
-              option_type = option.pair.type
-              @parser.opt(option_name.to_sym, "(Ruby class: #{option_type}) " + option_text.to_s, type: TrollopConfigurator.parse_type(option_type))
-            end
-          else
-            @parser.opt(tag_name.to_sym, "(Ruby class: #{tag_type}) " + tag_text.to_s, type: TrollopConfigurator.parse_type(tag_type))
-          end
-        else
-          @parser.opt(tag_name.to_sym, "(Ruby class: #{tag_type}) " + tag_text.to_s, type: TrollopConfigurator.parse_type(tag_type))
-        end
-      end
-    end
-
-    @global_opts = Trollop::with_standard_exception_handling(@parser) do
-      begin
-        @parser.parse ARGV
-      rescue Trollop::CommandlineError => e
-        raise ConsoleRunnerError, "You must provide one of available actions: #{sub_commands.join ', '}" unless sub_commands.include?(ARGV[0])
-        raise e
-      end
-    end
-
-    if @init_method
-      given_attrs           = @global_opts.keys.select { |k| k.to_s.include? '_given' }.map { |k| k.to_s.gsub('_given', '').to_sym }
-      @init_method.cmd_opts = @global_opts.select { |k, _| given_attrs.include? k }
-    end
-  end
-
-  # Parse method and configure #Trollop
-  def parse_method(method)
-    ARGV.shift
-    @method            = MethodParser.new method
-    method_params_tags = @method.param_tags
-
-    method_params_tags.each do |tag|
-      tag_name = tag.name
-      tag_text = tag.text
-      tag_type = tag.type
-      if tag_type == "Hash"
-        options = @method.option_tags.select { |t| t.name == tag.name }
-        if options.count > 0
-          options.each do |option|
-            option_name = option.pair.name.delete(':')
-            option_text = option.pair.text
-            option_type = option.pair.type
-            @parser.opt(option_name.to_sym, "(Ruby class: #{option_type}) " + option_text.to_s, type: TrollopConfigurator.parse_type(option_type))
-          end
-        else
-          @parser.opt(tag_name.to_sym, "(Ruby class: #{tag_type}) " + tag_text.to_s, type: TrollopConfigurator.parse_type(tag_type))
-        end
-      else
-        @parser.opt(tag_name.to_sym, "(Ruby class: #{tag_type}) " + tag_text.to_s, type: TrollopConfigurator.parse_type(tag_type))
-      end
-    end
-    cmd_opts         = Trollop::with_standard_exception_handling @parser do
-      unless method_params_tags.count.zero?
-        raise Trollop::HelpNeeded if ARGV.empty?
-      end
-      # show help screen
-      @parser.parse ARGV
-    end
-    given_attrs      = cmd_opts.keys.select { |k| k.to_s.include? '_given' }.map { |k| k.to_s.gsub('_given', '').to_sym }
-    @method.cmd_opts = cmd_opts.select { |k, _| given_attrs.include? k }
-    @method.default_params.each do |k, v|
-      @method.cmd_opts[k.to_sym] ||= v
-    end
-
-    method_params_tags.select { |t| t.tag_name == 'param' }.map(&:name).each do |required_param|
-      next if @method.options_group? required_param
-      unless @method.cmd_opts[required_param.to_sym]
-        raise ConsoleRunnerError, "You must specify required parameter: #{required_param}"
-      end
-    end
-  end
-
-  def self.parse_type(yard_type)
-    result = TYPES_MAPPINGS[yard_type]
-    raise ConsoleRunnerError, "Unsupported YARD type: #{yard_type}" unless result
-    result
-  end
-
-end
-