ing 0.1.1

data/lib/ing/commands/generate.rb

@@ -0,0 +1,64 @@
+
+module Ing
+  module Commands
+  
+    # This is the boot command invoked from `ing generate ...`
+    class Generate < Boot
+
+      DEFAULTS = {
+         namespace: 'object',
+         ing_file:  'ing.rb',
+         gen_root:  ENV.fetch('ING_GENERATOR_ROOT', '~/.ing/generators')
+      }
+    
+      def self.specify_options(parser)
+        parser.text "Run a generator task"
+        parser.opt :debug, "Display debug messages"
+        parser.opt :namespace, "Top-level namespace for generators",
+                   :type => :string, :default => DEFAULTS[:namespace]
+        parser.opt :gen_root, "Generators root directory", 
+                   :type => :string, :short => 'r', 
+                   :default => DEFAULTS[:gen_root]
+        parser.opt :ing_file, "Default generator file (ruby)", 
+                   :type => :string, :short => 'f', 
+                   :default => DEFAULTS[:ing_file]
+        parser.stop_on_unknown
+      end
+
+      def generator_root
+        @generator_root ||= File.expand_path(options[:gen_root])
+      end
+      
+      # Locate and require the generator ruby file identified by the first arg,
+      # before dispatching to it.
+      def before(*args)
+        require_generator args.first
+      end
+      
+      private
+          
+      def require_generator(name)
+        path = File.expand_path(generator_name_to_path(name), generator_root)
+        f = if File.directory?(path)
+          File.join(path, options[:ing_file])
+        else
+          path
+        end
+        debug "#{__FILE__}:#{__LINE__} :: require #{f.inspect}" 
+        require f
+      rescue LoadError
+        raise LoadError, 
+          "No generator found named `#{name}`. Check that you have set the generator root directory correctly (looking for `#{f}`)"
+      end
+      
+      def generator_name_to_path(name)
+        name.split(":").join("/")
+      end
+      
+    end
+    
+    # alias
+    G = Generate
+
+  end
+end

data/lib/ing/commands/help.rb

@@ -0,0 +1,87 @@
+module Ing
+  module Commands
+  
+    class Help
+
+      DEFAULTS = {
+         namespace: 'ing:commands',
+         ing_file:  'ing.rb'
+      }
+      
+      def self.specify_options(parser)
+        parser.text "Display help on specified command"
+        parser.text "\nUsage:"
+        parser.text "  ing help generate               # help on built-in command generate"
+        parser.text "  ing help --namespace test unit  # help on command within namespace"
+        parser.text "  ing help                        # display this message"
+        parser.text "\nOptions:"
+        parser.opt :debug, "Display debug messages"
+        parser.opt :namespace, "Top-level namespace",
+                   :type => :string, :default => DEFAULTS[:namespace]   
+        parser.opt :require, "Require file or library before running (multi)", 
+                   :multi => true, :type => :string
+        parser.opt :ing_file, "Default task file (ruby)", 
+                   :type => :string, :short => 'f', 
+                   :default => DEFAULTS[:ing_file]
+      end
+      
+      attr_accessor :options 
+      attr_writer :shell
+      
+      def shell
+        @shell ||= ::Ing.shell_class.new
+      end
+      
+      def initialize(options)
+        self.options = options
+        debug "#{__FILE__}:#{__LINE__} :: options #{options.inspect}"
+      end
+      
+      # Require each passed file or library before running
+      # and require the ing file if it exists
+      def before(*args)
+        require_libs options[:require]
+        require_ing_file
+      end
+    
+      def call(cmd="help")
+        before(cmd)
+        ns        = Ing::Util.to_class_names(options[:namespace] || 'object')
+        cs        = Ing::Util.to_class_names(cmd)
+        help = Dispatcher.new(ns, cs).help
+        shell.say help.read
+      end
+      
+      private
+            
+      # require relative paths relative to the Dir.pwd
+      # otherwise, require as given (so gems can be required, etc.)
+      def require_libs(libs)
+        libs = Array(libs)
+        libs.each do |lib| 
+          f = if /\A\.{1,2}\// =~ lib
+              File.expand_path(lib)
+            else
+              lib
+            end
+          debug "#{__FILE__}:#{__LINE__} :: require #{f.inspect}"
+          require f
+        end
+      end
+
+      def require_ing_file
+        f = File.expand_path(options[:ing_file])
+        require_libs(f) if File.exists?(f)
+      end
+            
+      # Internal debugging
+      def debug(*args)
+        shell.debug(*args) if options[:debug]
+      end
+      
+    end
+    
+    H = Help
+  
+  end
+end

data/lib/ing/commands/implicit.rb

@@ -0,0 +1,59 @@
+
+module Ing
+  module Commands
+  
+    # This is the default boot command when ARGV.first not recognized as
+    # a built-in Ing command. For example, `ing some:task run` .
+    class Implicit < Boot
+    
+      DEFAULTS = {
+         namespace: 'object',
+         ing_file:  'ing.rb'
+      }
+      
+      def self.specify_options(parser)
+        parser.text "(internal)"
+        parser.opt :debug, "Display debug messages"
+        parser.opt :namespace, "Top-level namespace for generators",
+                   :type => :string, :default => DEFAULTS[:namespace]
+        parser.opt :require, "Require file or library before running (multi)", 
+                   :multi => true, :type => :string
+        parser.opt :ing_file, "Default generator file (ruby)", 
+                   :type => :string, :short => 'f', 
+                   :default => DEFAULTS[:ing_file]
+        parser.stop_on_unknown
+      end
+      
+      # Require each passed file or library before running
+      # and require the ing file if it exists
+      def before(*args)
+        require_libs options[:require]
+        require_ing_file
+      end
+      
+      private
+            
+      # require relative paths relative to the Dir.pwd
+      # otherwise, require as given (so gems can be required, etc.)
+      def require_libs(libs)
+        libs = Array(libs)
+        libs.each do |lib| 
+          f = if /\A\.{1,2}\// =~ lib
+              File.expand_path(lib)
+            else
+              lib
+            end
+          debug "#{__FILE__}:#{__LINE__} :: require #{f.inspect}"
+          require f
+        end
+      end
+
+      def require_ing_file
+        f = File.expand_path(options[:ing_file])
+        require_libs(f) if File.exists?(f)
+      end
+      
+    end
+
+  end
+end

data/lib/ing/commands/list.rb

@@ -0,0 +1,108 @@
+module Ing
+  module Commands
+    
+    class List
+
+      DEFAULTS = {
+         namespace: 'ing:commands',
+         ing_file:  'ing.rb'
+      }
+      
+      def self.specify_options(parser)
+        parser.banner "List all tasks within specified namespace"
+        parser.text "\nUsage:"
+        parser.text "  ing list        # list all built-in ing commands"
+        parser.text "  ing list rspec  # list all ing commands in rspec namespace, or"
+        parser.text "  ing list --namespace rspec"
+        parser.text "\nOptions:"
+        parser.opt :debug, "Display debug messages"
+        parser.opt :namespace, "Top-level namespace",
+                   :type => :string, :default => DEFAULTS[:namespace]   
+        parser.opt :require, "Require file or library before running (multi)", 
+                   :multi => true, :type => :string
+        parser.opt :ing_file, "Default task file (ruby)", 
+                   :type => :string, :short => 'f', 
+                   :default => DEFAULTS[:ing_file]
+      end
+      
+      attr_accessor :options 
+      attr_writer :shell
+      
+      def shell
+        @shell ||= ::Ing.shell_class.new
+      end
+      
+      def initialize(options)
+        self.options = options
+        debug "#{__FILE__}:#{__LINE__} :: options #{options.inspect}"
+      end
+      
+      # Require each passed file or library before running
+      # and require the ing file if it exists
+      def before(*args)
+        require_libs options[:require]
+        require_ing_file
+      end
+
+      
+      def call(namespace=options[:namespace])
+        before(namespace)
+        ns        = Ing::Util.to_class_names(namespace)
+        mod       = Ing::Util.namespaced_const_get(ns)
+        data = mod.constants.map do |c|
+          desc = Dispatcher.new(ns, [c]).describe
+          [ "ing #{Ing::Util.encode_class_names(ns + [c])}", 
+            (desc.gets || '(no description)').chomp
+          ]
+        end.sort
+        shell.say desc_lines(ns, data).join("\n")
+      end
+      
+      private 
+            
+      # require relative paths relative to the Dir.pwd
+      # otherwise, require as given (so gems can be required, etc.)
+      def require_libs(libs)
+        libs = Array(libs)
+        libs.each do |lib| 
+          f = if /\A\.{1,2}\// =~ lib
+              File.expand_path(lib)
+            else
+              lib
+            end
+          debug "#{__FILE__}:#{__LINE__} :: require #{f.inspect}"
+          require f
+        end
+      end
+
+      def require_ing_file
+        f = File.expand_path(options[:ing_file])
+        require_libs(f) if File.exists?(f)
+      end
+      
+      def desc_lines(ns, data)
+        colwidths = data.inject([0,0]) {|max, (line, desc)| 
+          max[0] = line.length if line.length > max[0]
+          max[1] = desc.length if desc.length > max[1]
+          max
+        }
+        ["#{ns.join(' ')}: all tasks",
+         "-" * 80
+        ] +
+        data.map {|line, desc|
+          [ line.ljust(colwidths[0]),
+            desc[0...(80 - colwidths[0] - 3)]
+          ].join(" # ")
+        }
+      end
+
+      # Internal debugging
+      def debug(*args)
+        shell.debug(*args) if options[:debug]
+      end
+      
+    end
+   
+    L = List
+  end
+end

data/lib/ing/dispatcher.rb

@@ -0,0 +1,132 @@
+require 'stringio'
+require 'set'
+      
+module Ing
+
+  class Dispatcher
+    
+    # Global set of dispatched commands as [dispatch_class, dispatch_meth], 
+    # updated before dispatch
+    def self.dispatched
+      @dispatched ||= Set.new
+    end
+    
+    # +Ing.invoke+
+    def self.invoke(klass, *args, &config)
+      allocate.tap {|d| d.initialize_preloaded(true, klass, *args) }.
+        dispatch(&config)
+    end
+    
+    # +Ing.execute+
+    def self.execute(klass, *args, &config)
+      allocate.tap {|d| d.initialize_preloaded(false, klass, *args) }.
+        dispatch(&config)
+    end
+        
+    attr_accessor :dispatch_class, :dispatch_meth, :args, :options
+    
+    # True if current dispatch class/method has been dispatched before
+    def dispatched?
+      Dispatcher.dispatched.include?([dispatch_class,dispatch_meth])
+    end
+    
+    # Default constructor from +Ing.run+ (command line)
+    def initialize(namespaces, classes, *args)
+      ns                  = Util.namespaced_const_get(namespaces)
+      self.dispatch_class = Util.namespaced_const_get(classes, ns)
+      self.dispatch_meth  = extract_method!(args, dispatch_class)
+      self.options        = parse_options!(args, dispatch_class) || {}
+      self.args           = args
+      @invoking           = false
+    end
+    
+    # Alternate constructor for preloaded object and arguments
+    # i.e. from +invoke+ or +execute+ instead of +run+
+    def initialize_preloaded(invoking, klass, *args)
+      self.options        = (Hash === args.last ? args.pop : {})
+      self.dispatch_class = klass
+      self.dispatch_meth  = extract_method!(args, dispatch_class)
+      self.args           = args
+      @invoking           = invoking
+    end
+    
+    # Returns stream (StringIO) of description text from specify_options.
+    # Note this does not parse the options. Used by +Ing::Commands::List+.
+    def describe
+      s=StringIO.new
+      with_option_parser(self.dispatch_class) do |p|
+        p.educate_banner s
+      end
+      s.rewind; s
+    end
+    
+    # Returns stream (StringIO) of help text from specify_options.
+    # Note this does not parse the options. Used by +Ing::Commands::Help+.
+    def help
+      s=StringIO.new
+      with_option_parser(self.dispatch_class) do |p|
+        p.educate s
+      end
+      s.rewind; s   
+    end
+    
+    # Public dispatch method used by all types of dispatch (run, invoke,
+    # execute). Does not dispatch if invoking and already dispatched.
+    def dispatch(&config)
+      unless @invoking && dispatched?
+        record_dispatch
+        execute(&config)
+      end
+    end
+    
+    def with_option_parser(klass)   # :nodoc:
+      return unless klass.respond_to?(:specify_options)
+      klass.specify_options(p = Trollop::Parser.new)
+      yield p
+    end
+    
+    private
+    
+    def record_dispatch
+      Dispatcher.dispatched.add [dispatch_class, dispatch_meth]
+    end
+    
+    def execute
+      if dispatch_class.respond_to?(:new)
+        cmd = dispatch_class.new(options)
+        yield cmd if block_given?
+        cmd.send(dispatch_meth, *args)
+      else
+        dispatch_class.call *args, options
+      end
+    end
+        
+    def parse_options!(args, klass)
+      with_option_parser(klass) do |p|
+        Trollop.with_standard_exception_handling(p) { p.parse(args) }
+      end
+    end
+    
+    def extract_method!(args, klass)
+      return :call if args.empty?
+      if meth = whitelist(args.first, klass)
+        args.shift
+      else
+        meth = :call
+      end
+      meth
+    end
+        
+    # Note this currently does no filtering, but basically checks for respond_to
+    def whitelist(meth, klass)
+      finder = Proc.new {|m| m == meth.to_sym}
+      if klass.respond_to?(:new)
+        klass.public_instance_methods(true).find(&finder)
+      else
+        klass.public_methods.find(&finder)
+      end
+    end
+    
+  end
+  
+end