everyday_thor_util 1.5.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4933cc01822d079d24c49797f21f63950013a35
-  data.tar.gz: 40e091bb1f4c9c7b327b6a55181648e5c26fdf74
+  metadata.gz: 8a69cb484c769ea7cb788e188a59bb7f2ba91d7f
+  data.tar.gz: fb3f7d13eebee965f138a8d2993181e9b61102e9
 SHA512:
-  metadata.gz: 72da6bc447c1abf6622ec89dc06d0a2d71a305156dd3400e7a519cf6fe5776c588e0f339d2aa59c462c553a7db1fa87bcbab84351e807734be5debe5ad40e928
-  data.tar.gz: 90ca9175ae5d2cd262414f8d114fe29fea0409561322596b16995b71d90710946bf3ded6b8eb7cb3b1a77d90627bf5b50571270beaaf798dc31929ef8e83bb71
+  metadata.gz: 0c9a7017f4f78ac7558c79f378a434450b00dbbeaf58d766b70ff29fdd7c0bf029a9c4ff055b670fa6fed1314dbe220a481a8a2f506dea98ab72f3e26efd6fed
+  data.tar.gz: 7004a9d355ee3c1e7e5602ca698d779a3395965db5f8c4c166e16b57372a23dd73ef92b8703a15ae0fda935e3822e65848d5d91d750e02ba63b7f1325abae34a

data/everyday_thor_util.gemspec

@@ -20,8 +20,8 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 1.9.3'
 
-  spec.add_development_dependency 'bundler', '~> 1.6'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.4'
 
   spec.add_dependency 'everyday-plugins', '~> 1.2'
   spec.add_dependency 'thor', '~> 0.19'

data/lib/everyday_thor_util/builder.rb

@@ -0,0 +1,289 @@
+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
+
+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
+        @options = options
+        @body   = block
+      end
+
+      def parent
+        @parent
+      end
+
+      def body
+        @body
+      end
+
+      def options
+        @options
+      end
+
+      def define(&block)
+        block.call(self.commands, self.flags, self.helpers)
+      end
+
+      def aliases
+        @aliases ||= []
+      end
+
+      def commands
+        @commands ||= EverydayThorUtil::BuilderBuildLists::BuilderCommands.new(self)
+      end
+
+      def flags
+        @flags ||= EverydayThorUtil::BuilderBuildLists::BuilderFlags.new(self)
+      end
+
+      def helpers
+        @helpers ||= EverydayThorUtil::BuilderBuildLists::BuilderHelpers.new(self)
+      end
+
+      def leaf?
+        self.commands.commands.empty? && self.helpers.helpers.empty?
+      end
+
+      def [](name)
+        if self.commands.has_key?(name)
+          self.commands[name]
+        elsif self.helpers.has_key?(name)
+          self.helpers[name]
+        elsif self.flags.has_key?(name)
+          self.flags[name]
+        else
+          nil
+        end
+      end
+
+      def []=(name, obj)
+        if obj.is_a?(Hash)
+          self.flags[name] = obj
+        elsif obj.is_a?(BuilderCommand)
+          self.commands[name] = obj
+        elsif obj.is_a?(Proc)
+          self.helpers[name] = obj
+        end
+      end
+    end
+    class BuilderGlobal
+      def helpers
+        @helpers ||= EverydayThorUtil::BuilderBuildLists::BuilderHelpers.new(self)
+      end
+    end
+  end
+  module BuilderBuildLists
+    class BuilderHelpers
+      def initialize(parent)
+        @parent  = parent
+        @helpers = {}
+      end
+
+      def helpers
+        @helpers
+      end
+
+      def [](name)
+        @helpers[name.to_sym]
+      end
+
+      def []=(name, body)
+        if body.nil?
+          self.delete(name)
+          nil
+        else
+          @parent.commands.delete(name) if @parent.respond_to?(:commands) && @parent.commands.has_key?(name)
+          @helpers[name.to_sym] = body
+        end
+      end
+
+      def has_key?(name)
+        @helpers.has_key?(name.to_sym)
+      end
+
+      def delete(name)
+        @helpers.delete(name.to_sym)
+      end
+    end
+    class BuilderFlags
+      def initialize(parent)
+        @parent = parent
+        @flags  = {}
+      end
+
+      def flags
+        @flags
+      end
+
+      def [](name)
+        @flags[name.to_sym]
+      end
+
+      def []=(name, flag)
+        if flag.nil?
+          self.delete(name)
+          nil
+        else
+          @flags[name.to_sym] = flag
+        end
+      end
+
+      def has_key?(name)
+        @flags.has_key?(name.to_sym)
+      end
+
+      def delete(name)
+        @flags.delete(name.to_sym)
+      end
+    end
+    class BuilderCommands
+      def initialize(parent)
+        @parent   = parent
+        @commands = {}
+      end
+
+      def commands
+        @commands
+      end
+
+      def [](name)
+        @commands[name.to_sym]
+      end
+
+      def []=(name, command)
+        if command.nil?
+          delete(name)
+          nil
+        else
+          @parent.helpers.delete(name) if @parent.helpers.has_key?(name)
+          @commands[name.to_sym] = EverydayThorUtil::BuilderBuildItems::BuilderCommand.new(@parent, command.options, &command.body)
+        end
+      end
+
+      def has_key?(name)
+        @commands.has_key?(name.to_sym)
+      end
+
+      def delete(name)
+        @commands.delete(name.to_sym)
+      end
+    end
+  end
+  module Builder
+    def global
+      @global ||= EverydayThorUtil::BuilderBuildItems::BuilderGlobal.new
+    end
+
+    def root_command
+      @root_command ||= EverydayThorUtil::BuilderBuildItems::BuilderCommand.new
+    end
+
+    def flag(opts = {})
+      opts
+    end
+
+    def command(options = {}, &block)
+      EverydayThorUtil::BuilderBuildItems::BuilderCommand.new(nil, options, &block)
+    end
+
+    def build!
+      rc = Class.new(Thor)
+      build_recurse(self.root_command, rc)
+      rc
+    end
+
+    def build_recurse(p, pc)
+      if p.parent.nil?
+        p.flags.flags.each { |fn, f| pc.class_option(fn.to_sym, f) }
+        self.global.helpers.helpers.each { |hn, h| pc.no_commands { pc.create_method(hn.to_sym, &h) } }
+        p.helpers.helpers.each { |hn, h| pc.no_commands { pc.create_method(hn.to_sym, &h) } }
+      end
+      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
+          self.global.helpers.helpers.each { |hn, h| cc.no_commands { cc.create_method(hn.to_sym, &h) } }
+          c.helpers.helpers.each { |hn, h| pc.no_commands { pc.create_method(hn.to_sym, &h) } }
+          c.flags.flags.each { |fn, f| cc.class_option(fn.to_sym, f) }
+          build_recurse(c, cc)
+          c.flags.flags.each { |fn, f| pc.class_option(fn.to_sym, f) }
+          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
+            self.global.helpers.helpers.each { |hn, h| cc2.no_commands { cc2.create_method(hn.to_sym, &h) } }
+            c.helpers.helpers.each { |hn, h| pc.no_commands { pc.create_method(hn.to_sym, &h) } }
+            c.flags.flags.each { |fn, f| cc2.class_option(fn.to_sym, f) }
+            build_recurse(c, cc2)
+            c.flags.flags.each { |fn, f| pc.class_option(fn.to_sym, f) }
+            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
+          c.flags.flags.each { |fn, f| pc.class_option(fn.to_sym, f) }
+          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|
+            c.flags.flags.each { |fn, f| pc.class_option(fn.to_sym, f) }
+            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
+      }
+    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) }
+    end
+
+    private :build_recurse
+  end
+end

data/lib/everyday_thor_util/version.rb

@@ -1,3 +1,3 @@
 module EverydayThorUtil
-  VERSION = '1.5.3'
+  VERSION = '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: everyday_thor_util
 version: !ruby/object:Gem::Version
-  version: 1.5.3
+  version: 2.0.0
 platform: ruby
 authors:
 - Eric Henderson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-15 00:00:00.000000000 Z
+date: 2014-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '1.7'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '10.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '10.4'
 - !ruby/object:Gem::Dependency
   name: everyday-plugins
   requirement: !ruby/object:Gem::Requirement
@@ -82,6 +82,7 @@ files:
 - Rakefile
 - everyday_thor_util.gemspec
 - lib/everyday_thor_util.rb
+- lib/everyday_thor_util/builder.rb
 - lib/everyday_thor_util/plugin-helper.rb
 - lib/everyday_thor_util/thor-fix.rb
 - lib/everyday_thor_util/version.rb
@@ -105,10 +106,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: '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'
 test_files: []
-has_rdoc: