everyday_thor_util 2.0.3 → 2.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a98acaf1e9ab0aa917b49bd28b6f84f65003ccca
-  data.tar.gz: ab9475835ec4f7a83bd12fc6fe784bb21c5e00e2
+  metadata.gz: a3066504bd2d9874ff985735a77ac7d19f31e444
+  data.tar.gz: 5da393b24d21afd04c3af167e3751a57a0b1d76c
 SHA512:
-  metadata.gz: 99f8a9bb8f38205af73fcdf013d038226816cf6525f186340f058e0854ec20b22eba0cd4934dae3cb5a0e22ad028c8c302717064418791b5ad6188b1043e891e
-  data.tar.gz: df27db166a01983fd756f5e3067be264f26cfa7f37ee01fc4d5e442111ce03f60c039bc7a275ff4c2053930585d190545d9d652057ce50335d0c895af59c1ba7
+  metadata.gz: f50c9ea76a92e6441f2fe943f7298fd2940cfd2a96eda0646c673c370d3acf7cbbbe0b703656ed43d86662673bea9a5d080c9586d362b7bbcf7a4577b2542640
+  data.tar.gz: 8542499b17170b80e999c76811161d028c65bb967b8494f176da215a15599f560b52eb9c3467b3a85a05911f9e256942972be9e10b951efb6b056d258d4962fc

data/everyday_thor_util.gemspec

@@ -4,14 +4,14 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'everyday_thor_util/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = 'everyday_thor_util'
-  spec.version       = EverydayThorUtil::VERSION
-  spec.authors       = ['Eric Henderson']
-  spec.email         = ['henderea@gmail.com']
-  spec.summary       = %q{Two parts: everyday_thor_util/thor-fix has a patch for Thor and everyday_thor_util/plugin-helper has some Thor handling everyday-plugin helpers}
-  spec.description   = %q{Two parts: everyday_thor_util/thor-fix patches Thor with a fix for help messages with multi-level command nesting not showing the full command string. everyday_thor_util/plugin-helper provides everyday-plugins types for Thor commands and Thor flags}
-  spec.homepage      = 'https://github.com/henderea/everyday_thor_util'
-  spec.license       = 'MIT'
+  spec.name        = 'everyday_thor_util'
+  spec.version     = EverydayThorUtil::VERSION
+  spec.authors     = ['Eric Henderson']
+  spec.email       = ['henderea@gmail.com']
+  spec.summary     = %q{Two parts: everyday_thor_util/thor-fix has a patch for Thor and everyday_thor_util/plugin-helper has some Thor handling everyday-plugin helpers}
+  spec.description = %q{Two parts: everyday_thor_util/thor-fix patches Thor with a fix for help messages with multi-level command nesting not showing the full command string. everyday_thor_util/plugin-helper provides everyday-plugins types for Thor commands and Thor flags}
+  spec.homepage    = 'https://github.com/henderea/everyday_thor_util'
+  spec.license     = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/lib/everyday_thor_util/builder.rb

@@ -1,23 +1,14 @@
 require 'everyday_thor_util/thor-fix'
-
-class Module
-  def create_method(name, &block)
-    self.send(:define_method, name, &block)
-  end
-
-  def dup_method(new_name, old_name)
-    self.send(:alias_method, new_name, old_name)
-  end
-end
+require 'everyday_thor_util/common'
 
 module EverydayThorUtil
   module BuilderBuildItems
     class BuilderCommand
       def initialize(parent = nil, options = {}, &block)
         @aliases = options.delete(:aliases) if options.has_key?(:aliases) && !parent.nil?
-        @parent = parent
+        @parent  = parent
         @options = options
-        @body   = block
+        @body    = block
       end
 
       def parent
@@ -182,6 +173,8 @@ module EverydayThorUtil
     end
   end
   module Builder
+    include EverydayThorUtil::Common
+
     def global
       @global ||= EverydayThorUtil::BuilderBuildItems::BuilderGlobal.new
     end
@@ -214,82 +207,67 @@ module EverydayThorUtil
     end
 
     def build_recurse(p, pc)
-      if p.parent.nil?
-        build_flags(p, pc, true)
-        build_helpers(p, pc)
-      end
+      setup_root(p, pc) if p.parent.nil?
       p.commands.commands.each { |cn, c|
-        short_desc = c.options[:short_desc]
-        desc      = c.options[:desc]
-        long_desc = c.options[:long_desc]
-        aliases   = c.aliases
-        if !c.leaf?
-          cc = Class.new(Thor)
-          cc.namespace cn.to_s
-          build_helpers(c, cc)
-          build_flags(c, cc, true)
-          build_recurse(c, cc)
-          build_flags(c, pc, false)
-          pc.desc short_desc, desc if short_desc && desc
-          pc.long_desc long_desc if long_desc
-          pc.subcommand cn, cc
-          aliases.each { |an|
-            cc2 = Class.new(Thor)
-            cc2.namespace an
-            build_helpers(c, cc2)
-            build_flags(c, cc2, true)
-            build_recurse(c, cc2)
-            build_flags(c, pc, false)
-            pc.desc short_desc.gsub(/^\S+(?=\s|$)/, an.gsub(/_/, '-')), desc if short_desc && desc
-            pc.long_desc long_desc if long_desc
-            pc.subcommand an, cc2
-          } if aliases && !aliases.empty?
-        elsif c.body
-          build_flags(c, pc, false)
-          pc.desc short_desc, desc if short_desc && desc
-          pc.long_desc long_desc if long_desc
-          pc.create_method(cn.to_sym, &c.body)
-          aliases.each { |an|
-            build_flags(c, pc, false)
-            pc.desc short_desc.gsub(/^\S+(?=\s|$)/, an.gsub(/_/, '-')), desc if short_desc && desc
-            pc.long_desc long_desc if long_desc
-            pc.dup_method an.to_sym, cn.to_sym
-          } if aliases
-        end
+        aliases, desc, long_desc, short_desc = extract_command_info(c)
+        handle_command_class(c, pc, cn, aliases, desc, long_desc, short_desc) ||
+            handle_command_method(c, pc, cn, aliases, desc, long_desc, short_desc)
       }
     end
 
-    def add_debugging(base, option_sym, env_sym)
-      methods = base.commands.keys - base.subcommands
-      base.class_eval {
-        methods.each { |method_name|
-          original_method = instance_method(method_name)
-          no_commands {
-            define_method(method_name) { |*args, &block|
-              debug = if option_sym && (options.has_key?(option_sym.to_s) || options.has_key?(option_sym.to_sym))
-                        options[option_sym.to_sym]
-                      elsif env_sym
-                        d = ENV[env_sym.to_s]
-                        d == '1' || d == 1 || d == 'true' || d == 't'
-                      end
-              if debug
-                puts "command: #{self.class.basename2} #{__method__.gsub(/_/, '-').to_s}"
-                puts "parent_options: #{parent_options.inspect}"
-                puts "options: #{options.inspect}"
-                original_method.parameters.each_with_index { |p, i| puts "#{p[1].to_s}: #{args[i]}" }
-              end
-              begin
-                original_method.bind(self).call(*args, &block)
-              rescue ArgumentError => e
-                base.handle_argument_error(base.commands[method_name], e, args, original_method.arity)
-              end
-            }
-          }
-        }
-      }
-      base.subcommand_classes.values.each { |c| add_debugging(c, option_sym, env_sym) }
+    def setup_root(p, pc)
+      build_flags(p, pc, true)
+      build_helpers(p, pc)
+    end
+
+    def setup_command(c, pc, desc, long_desc, short_desc)
+      build_flags(c, pc, false)
+      pc.desc short_desc, desc if short_desc && desc
+      pc.long_desc long_desc if long_desc
+    end
+
+    def handle_command_class(c, pc, cn, aliases, desc, long_desc, short_desc)
+      !c.leaf? && create_cmd_class_and_aliases(c, pc, cn, aliases, desc, long_desc, short_desc)
+    end
+
+    def handle_command_method(c, pc, cn, aliases, desc, long_desc, short_desc)
+      c.body && create_cmd_method_and_aliases(c, pc, cn, aliases, desc, long_desc, short_desc)
+    end
+
+    def create_cmd_class_and_aliases(c, pc, cn, aliases, desc, long_desc, short_desc)
+      create_command_class(c, pc, cn, desc, long_desc, short_desc)
+      aliases.each { |an| create_command_class(c, pc, an, desc, long_desc, short_desc.gsub(/^\S+(?=\s|$)/, an.gsub(/_/, '-'))) } if aliases && !aliases.empty?
+      true
+    end
+
+    def create_cmd_method_and_aliases(c, pc, cn, aliases, desc, long_desc, short_desc)
+      setup_command(c, pc, desc, long_desc, short_desc)
+      pc.create_method(cn.to_sym, &c.body)
+      aliases.each { |an|
+        setup_command(c, pc, desc, long_desc, short_desc)
+        pc.dup_method an.to_sym, cn.to_sym
+      } if aliases
+      true
+    end
+
+    def create_command_class(c, pc, cn, desc, long_desc, short_desc)
+      cc = Class.new(Thor)
+      cc.namespace cn.to_s
+      build_helpers(c, cc)
+      build_flags(c, cc, true)
+      build_recurse(c, cc)
+      setup_command(c, pc, desc, long_desc, short_desc)
+      pc.subcommand cn, cc
+    end
+
+    def extract_command_info(c)
+      short_desc = c.options[:short_desc]
+      desc       = c.options[:desc]
+      long_desc  = c.options[:long_desc]
+      aliases    = c.aliases
+      return aliases, desc, long_desc, short_desc
     end
 
-    private :build_recurse
+    private :build_helpers, :build_flags, :build_recurse, :setup_root, :setup_command, :handle_command_class, :handle_command_method, :create_command_class, :extract_command_info
   end
 end

data/lib/everyday_thor_util/common.rb

@@ -0,0 +1,80 @@
+class Module
+  def create_method(name, &block)
+    self.send(:define_method, name, &block)
+  end
+
+  def dup_method(new_name, old_name)
+    self.send(:alias_method, new_name, old_name)
+  end
+end
+
+class Thor
+  class << self
+    def define_non_command(method_name, &block)
+      no_commands { define_method(method_name, &block) }
+    end
+  end
+end
+
+module EverydayThorUtil
+  class CommonHelpers
+    class << self
+      def print_debug_if_should(option_sym, env_sym, obj, original_method, method, args)
+        print_all_debug(args, method, obj, original_method) if should_debug?(env_sym, obj, option_sym)
+      end
+
+      def print_all_debug(args, method, obj, original_method)
+        print_base_debug(method, obj)
+        original_method.parameters.each_with_index { |p, i| puts "#{p[1].to_s}: #{args[i]}" }
+      end
+
+      def print_base_debug(method, obj)
+        puts "command: #{obj.class.basename2} #{method.gsub(/_/, '-').to_s}"
+        puts "parent_options: #{obj.parent_options.inspect}"
+        puts "options: #{obj.options.inspect}"
+      end
+
+      def should_debug?(env_sym, obj, option_sym)
+        should_use_option_sym?(obj, option_sym) ? obj.options[option_sym.to_sym] : (env_sym && env_val_true(ENV[env_sym.to_s]))
+      end
+
+      def env_val_true(d)
+        d == '1' || d == 1 || d == 'true' || d == 't'
+      end
+
+      def should_use_option_sym?(obj, option_sym)
+        option_sym && (obj.options.has_key?(option_sym.to_s) || obj.options.has_key?(option_sym.to_sym))
+      end
+
+      def call_original_method(args, base, block, method_name, original_method)
+        begin
+          original_method.bind(base).call(*args, &block)
+        rescue ArgumentError => e
+          base.handle_argument_error(base.commands[method_name], e, args, original_method.arity)
+        end
+      end
+
+      def define_debug_wrapper(base, env_sym, method_name, option_sym)
+        base.class_eval {
+          original_method = instance_method(method_name)
+          define_non_command(method_name) { |*args, &block|
+            EverydayThorUtil::CommonHelpers.debug_and_call_original(args, self, env_sym, method_name, option_sym, original_method, &block)
+          }
+        }
+      end
+
+      def debug_and_call_original(args, base, env_sym, method_name, option_sym, original_method, &block)
+        print_debug_if_should(option_sym, env_sym, base, original_method, method_name, args)
+        call_original_method(args, base, block, method_name, original_method)
+      end
+    end
+  end
+
+  module Common
+    def add_debugging(base, option_sym, env_sym)
+      methods = base.commands.keys - base.subcommands
+      methods.each { |method_name| EverydayThorUtil::CommonHelpers.define_debug_wrapper(base, env_sym, method_name, option_sym) }
+      base.subcommand_classes.values.each { |c| add_debugging(c, option_sym, env_sym) }
+    end
+  end
+end

data/lib/everyday_thor_util/plugin-helper.rb

@@ -1,154 +1,163 @@
 require 'everyday_thor_util/thor-fix'
+require 'everyday_thor_util/common'
 require 'everyday-plugins'
 include EverydayPlugins
 require 'thor'
 
-class Module
-  def create_method(name, &block)
-    self.send(:define_method, name, &block)
-  end
-
-  def dup_method(new_name, old_name)
-    self.send(:alias_method, new_name, old_name)
-  end
-end
-
 module EverydayThorUtil
   class SubCommandTypes
     extend PluginType
     extend Plugin
     extend TypeHelper
+    extend EverydayThorUtil::Common
 
     class << self
       def def_types(command_array_symbol, flag_symbol, command_symbol, helper_symbol = nil)
         register_variable command_array_symbol, []
+        register_flag_type(flag_symbol)
+        register_command_type(command_array_symbol, command_symbol, flag_symbol, helper_symbol)
+        register_helper_type(helper_symbol) unless helper_symbol.nil?
+      end
 
+      def register_flag_type(flag_symbol)
         register_type(flag_symbol) { |list, parent_class, parent, has_children|
-          filtered_list = list.select { |v| v[:options][:parent] == parent }
-          filtered_list.each { |v|
-            opts            = {}
-            name            = v[:options][:name].to_sym
-            opts[:desc]     = v[:options][:desc] if v[:options][:desc]
-            opts[:banner]   = v[:options][:banner] if v[:options][:banner]
-            opts[:required] = v[:options][:required] if v[:options][:required] && !v[:options][:default]
-            opts[:default]  = v[:options][:default] if v[:options][:default]
-            opts[:type]     = v[:options][:type] if v[:options][:type]
-            opts[:aliases]  = v[:options][:aliases] if v[:options][:aliases]
+          EverydayThorUtil::SubCommandHelpers.filter_list(list, parent).each { |v|
+            name, opts = EverydayThorUtil::SubCommandHelpers.map_flag_opts(v)
             has_children ? parent_class.class_option(name, opts) : parent_class.option(name, opts)
           }
         }
+      end
 
+      def register_command_type(command_array_symbol, command_symbol, flag_symbol, helper_symbol)
         register_type(command_symbol) { |list, parent_class, parent|
-          Plugins.get helper_symbol, parent_class, nil unless parent || helper_symbol.nil?
-          Plugins.get flag_symbol, parent_class, nil, true unless parent
-          filtered_list = list.select { |v| v[:options][:parent] == parent || nil }
-          filtered_list.each { |v|
-            id         = v[:options][:id]
-            short_desc = v[:options][:short_desc]
-            desc       = v[:options][:desc]
-            long_desc  = v[:options][:long_desc]
-            name       = v[:options][:name]
-            aliases    = v[:options][:aliases]
-            if id && name
-              has_children = list.any? { |v2| v2[:options][:parent] == id }
-              if has_children
-                command_ids = Plugins.get_var command_array_symbol
-                unless command_ids.include?(id)
-                  command_ids << id
-                  Plugins.set_var command_array_symbol, command_ids
-                  command_class = Class.new(Thor)
-                  command_class.namespace name
-                  Plugins.get helper_symbol, command_class, id unless helper_symbol.nil?
-                  Plugins.get flag_symbol, command_class, id, true
-                  Plugins.get command_symbol, command_class, id
-                  Plugins.get flag_symbol, parent_class, id, false
-                  parent_class.desc short_desc, desc if short_desc && desc
-                  parent_class.long_desc long_desc if long_desc
-                  parent_class.subcommand name, command_class
-                  aliases.each { |a|
-                    command_class2 = Class.new(Thor)
-                    command_class2.namespace a
-                    Plugins.get helper_symbol, command_class2, id unless helper_symbol.nil?
-                    Plugins.get flag_symbol, command_class2, id, true
-                    Plugins.get command_symbol, command_class2, id
-                    Plugins.get flag_symbol, parent_class, id, false
-                    parent_class.desc short_desc.gsub(/^\S+(?=\s|$)/, a.gsub(/_/, '-')), desc if short_desc && desc
-                    parent_class.long_desc long_desc if long_desc
-                    parent_class.subcommand a, command_class2
-                  } if aliases
-                end
-              elsif v[:block]
-                Plugins.get flag_symbol, parent_class, id, false
-                parent_class.desc short_desc, desc if short_desc && desc
-                parent_class.long_desc long_desc if long_desc
-                parent_class.create_method(name.to_sym, &v[:block])
-                aliases.each { |a|
-                  Plugins.get flag_symbol, parent_class, id, false
-                  parent_class.desc short_desc.gsub(/^\S+(?=\s|$)/, a.gsub(/_/, '-')), desc if short_desc && desc
-                  parent_class.long_desc long_desc if long_desc
-                  parent_class.dup_method a.to_sym, name.to_sym
-                } if aliases
-              end
-            end
+          EverydayThorUtil::SubCommandHelpers.setup_root(flag_symbol, helper_symbol, parent, parent_class)
+          EverydayThorUtil::SubCommandHelpers.filter_list(list, parent).each { |v|
+            EverydayThorUtil::SubCommandHelpers.handle_command(command_array_symbol, command_symbol, flag_symbol, helper_symbol, parent_class, list, v)
           }
         }
+      end
 
-        unless helper_symbol.nil?
-          register_type(helper_symbol) { |list, parent_class, parent|
-            filtered_list = list.select { |v| v[:options][:parent] == parent || v[:options][:global] }
-            filtered_list.each { |v|
-              name = v[:options][:name].to_sym
-              parent_class.no_commands { parent_class.create_method name, &v[:block] } if v[:block]
-            }
-          }
-        end
+      def register_helper_type(helper_symbol)
+        register_type(helper_symbol) { |list, parent_class, parent|
+          EverydayThorUtil::SubCommandHelpers.filter_list(list, parent) { |v| v[:options][:global] }.each { |v| EverydayThorUtil::SubCommandHelpers.add_helper(parent_class, v) }
+        }
       end
 
       def def_helper(helper_symbol, which_helper, method_name = nil, global = true, parent = nil)
         case (which_helper)
           when :print_info
-            register(helper_symbol, name: (method_name || 'print_info'), global: global, parent: parent) { |meth, &eval_block|
-              meth_obj = self.method(meth)
-              puts "command: #{self.class.basename2} #{meth.to_s}"
-              puts "parent_options: #{parent_options.inspect}"
-              puts "options: #{options.inspect}"
-              meth_obj.parameters.each { |p| puts "#{p[1].to_s}: #{eval_block.call(p[1].to_s)}" } if eval_block
-            }
+            EverydayThorUtil::SubCommandHelpers.register_print_info_helper(global, helper_symbol, method_name, parent)
           else
             puts "Unknown helper #{which_helper}"
         end
       end
+    end
+  end
+  module SubCommandCommonHelpers
+    def filter_list(list, parent, &extra)
+      list.select { |v| v[:options][:parent] == parent || (extra && extra.call(v)) }
+    end
+  end
+  module SubCommandFlagHelpers
+    def map_flag_opts(v)
+      opts = {}
+      name = v[:options][:name].to_sym
+      copy_opts(opts, v, :desc, :banner, :default, :type, :aliases)
+      copy_opt(opts, v, :required, !v[:options][:default])
+      return name, opts
+    end
 
-      def add_debugging(base, option_sym, env_sym)
-        methods = base.commands.keys - base.subcommands
-        base.class_eval {
-          methods.each { |method_name|
-            original_method = instance_method(method_name)
-            no_commands {
-              define_method(method_name) { |*args, &block|
-                debug = if option_sym && (options.has_key?(option_sym.to_s) || options.has_key?(option_sym.to_sym))
-                          options[option_sym.to_sym]
-                        elsif env_sym
-                          d = ENV[env_sym.to_s]
-                          d == '1' || d == 1 || d == 'true' || d == 't'
-                        end
-                if debug
-                  puts "command: #{self.class.basename2} #{__method__.gsub(/_/, '-').to_s}"
-                  puts "parent_options: #{parent_options.inspect}"
-                  puts "options: #{options.inspect}"
-                  original_method.parameters.each_with_index { |p, i| puts "#{p[1].to_s}: #{args[i]}" }
-                end
-                begin
-                  original_method.bind(self).call(*args, &block)
-                rescue ArgumentError => e
-                  base.handle_argument_error(base.commands[method_name], e, args, original_method.arity)
-                end
-              }
-            }
-          }
-        }
-        base.subcommand_classes.values.each { |c| add_debugging(c, option_sym, env_sym) }
+    def copy_opts(opts, v, *opt_name)
+      opt_name.each { |n| copy_opt(opts, v, n) }
+    end
+
+    def copy_opt(opts, v, opt_name, extra_condition = true)
+      opts[opt_name] = v[:options][opt_name] if v[:options][opt_name] && extra_condition
+    end
+  end
+  module SubCommandCommandHelpers
+    def create_cmd_class_and_aliases(aliases, command_array_symbol, command_symbol, desc, flag_symbol, helper_symbol, id, long_desc, name, parent_class, short_desc)
+      command_ids = Plugins.get_var command_array_symbol
+      unless command_ids.include?(id)
+        command_ids << id
+        Plugins.set_var command_array_symbol, command_ids
+        create_command_class(command_symbol, desc, flag_symbol, helper_symbol, id, long_desc, name, parent_class, short_desc)
+        aliases.each { |a| create_command_class(command_symbol, desc, flag_symbol, helper_symbol, id, long_desc, a, parent_class, short_desc.gsub(/^\S+(?=\s|$)/, a.gsub(/_/, '-'))) } if aliases
       end
+      true
+    end
+
+    def create_cmd_method_and_aliases(aliases, desc, flag_symbol, id, long_desc, name, parent_class, short_desc, &block)
+      setup_command(desc, flag_symbol, id, long_desc, parent_class, short_desc)
+      parent_class.create_method(name.to_sym, &block)
+      aliases.each { |a|
+        setup_command(desc, flag_symbol, id, long_desc, parent_class, short_desc)
+        parent_class.dup_method a.to_sym, name.to_sym
+      } if aliases
+      true
+    end
+
+    def extract_command_info(v)
+      return v[:options][:aliases], v[:options][:desc], v[:options][:id], v[:options][:long_desc], v[:options][:name], v[:options][:short_desc]
+    end
+
+    def setup_root(flag_symbol, helper_symbol, parent, parent_class)
+      Plugins.get helper_symbol, parent_class, nil unless parent || helper_symbol.nil?
+      Plugins.get flag_symbol, parent_class, nil, true unless parent
+    end
+
+    def create_command_class(command_symbol, desc, flag_symbol, helper_symbol, id, long_desc, name, parent_class, short_desc)
+      command_class = Class.new(Thor)
+      command_class.namespace name
+      Plugins.get helper_symbol, command_class, id unless helper_symbol.nil?
+      Plugins.get flag_symbol, command_class, id, true
+      Plugins.get command_symbol, command_class, id
+      setup_command(desc, flag_symbol, id, long_desc, parent_class, short_desc)
+      parent_class.subcommand name, command_class
+    end
+
+    def setup_command(desc, flag_symbol, id, long_desc, parent_class, short_desc)
+      Plugins.get flag_symbol, parent_class, id, false
+      parent_class.desc short_desc, desc if short_desc && desc
+      parent_class.long_desc long_desc if long_desc
     end
+
+    def handle_command(command_array_symbol, command_symbol, flag_symbol, helper_symbol, parent_class, list, v)
+      aliases, desc, id, long_desc, name, short_desc = extract_command_info(v)
+      id && name && (handle_command_class(command_array_symbol, command_symbol, flag_symbol, helper_symbol, list, parent_class, aliases, desc, id, long_desc, name, short_desc) ||
+          handle_command_method(aliases, desc, flag_symbol, id, long_desc, name, parent_class, short_desc, &v[:block]))
+    end
+
+    def handle_command_class(command_array_symbol, command_symbol, flag_symbol, helper_symbol, list, parent_class, aliases, desc, id, long_desc, name, short_desc)
+      (list.any? { |v2| v2[:options][:parent] == id } && create_cmd_class_and_aliases(aliases, command_array_symbol, command_symbol, desc, flag_symbol, helper_symbol, id, long_desc, name, parent_class, short_desc))
+    end
+
+    def handle_command_method(aliases, desc, flag_symbol, id, long_desc, name, parent_class, short_desc, &block)
+      (block && create_cmd_method_and_aliases(aliases, desc, flag_symbol, id, long_desc, name, parent_class, short_desc, &block))
+    end
+  end
+  module SubCommandHelperHelpers
+    def add_helper(parent_class, v)
+      parent_class.no_commands { parent_class.create_method v[:options][:name].to_sym, &v[:block] } if v[:block]
+    end
+
+    def register_print_info_helper(global, helper_symbol, method_name, parent)
+      register(helper_symbol, name: (method_name || 'print_info'), global: global, parent: parent) { |meth, &eval_block|
+        EverydayThorUtil::SubCommandHelpers.print_info(self, meth, &eval_block)
+      }
+    end
+
+    def print_info(obj, meth, &eval_block)
+      EverydayThorUtil::CommonHelpers.print_base_debug(meth, obj)
+      meth_obj = obj.method(meth)
+      meth_obj.parameters.each { |p| puts "#{p[1].to_s}: #{eval_block.call(p[1].to_s)}" } if eval_block
+    end
+  end
+  class SubCommandHelpers
+    extend Plugin
+    extend EverydayThorUtil::SubCommandCommonHelpers
+    extend EverydayThorUtil::SubCommandFlagHelpers
+    extend EverydayThorUtil::SubCommandCommandHelpers
+    extend EverydayThorUtil::SubCommandHelperHelpers
   end
 end

data/lib/everyday_thor_util/version.rb

@@ -1,3 +1,3 @@
 module EverydayThorUtil
-  VERSION = '2.0.3'
+  VERSION = '2.0.4'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everyday_thor_util
 version: !ruby/object:Gem::Version
-  version: 2.0.3
+  version: 2.0.4
 platform: ruby
 authors:
 - Eric Henderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-01-27 00:00:00.000000000 Z
+date: 2015-02-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -83,6 +83,7 @@ files:
 - everyday_thor_util.gemspec
 - lib/everyday_thor_util.rb
 - lib/everyday_thor_util/builder.rb
+- lib/everyday_thor_util/common.rb
 - lib/everyday_thor_util/plugin-helper.rb
 - lib/everyday_thor_util/thor-fix.rb
 - lib/everyday_thor_util/version.rb