main 2.9.3 → 3.0.1

data/README

@@ -7,7 +7,7 @@ SYNOPSIS
 URI
   http://codeforpeople.com/lib/ruby/
   http://rubyforge.org/projects/codeforpeople/
-  http://codeforpeople.rubyforge.org/svn/
+  http://github.com/ahoward/main
 
 INSTALL
   gem install main
@@ -314,26 +314,35 @@ SAMPLES
 
     require 'main'
     
+    ARGV.replace %w( x y argument )
+    
     Main {
-      argument 'global-argument'
-      option 'global-option'
+      argument 'argument'
+      option 'option'
     
-      def run() puts 'global-run' end
+      def run() puts 'run' end
     
       mode 'a' do
         option 'a-option'
+        def run() puts 'a-run' end
       end
     
-      mode 'b' do
-        option 'b-option'
+      mode 'x' do
+        option 'x-option'
+    
+        def run() puts 'x-run' end
+    
+          mode 'y' do
+            option 'y-option'
     
-        def run() puts 'b-run' end
+            def run() puts 'y-run' end
+          end
       end
     }
 
   ~ > ruby samples/e.rb
 
-    argument(global-argument)) 0/1
+    y-run
 
 
   <========< samples/f.rb >========>
@@ -342,6 +351,8 @@ SAMPLES
 
     require 'main'
     
+    ARGV.replace %W( compress /data )
+    
     Main {
       argument('directory'){ description 'the directory to operate on' }
     
@@ -370,7 +381,7 @@ SAMPLES
 
   ~ > ruby samples/f.rb
 
-    argument(directory)) 0/1
+    this is how we run in compress mode
 
 
   <========< samples/g.rb >========>
@@ -442,12 +453,17 @@ SAMPLES
 
 DOCS
   test/main.rb
-
   vim -p lib/main.rb lib/main/*rb
-
   API section below
 
 HISTORY
+  3.0.0
+    - major refactor to support modes via module/extend vs. subclassing.
+    MIGHT NOT be backward compatible, though no known issues thus far.
+
+  2.9.0
+    - support ruby 1.9
+
   2.8.3
     - support for block defaults
 

data/README.erb

@@ -7,7 +7,7 @@ SYNOPSIS
 URI
   http://codeforpeople.com/lib/ruby/
   http://rubyforge.org/projects/codeforpeople/
-  http://codeforpeople.rubyforge.org/svn/
+  http://github.com/ahoward/main
 
 INSTALL
   gem install main
@@ -182,12 +182,14 @@ SAMPLES
 
 DOCS
   test/main.rb
-
   vim -p lib/main.rb lib/main/*rb
-
   API section below
 
 HISTORY
+  3.0.0
+    - major refactor to support modes via module/extend vs. subclassing.
+    MIGHT NOT be backward compatible, though no known issues thus far.
+
   2.9.0
     - support ruby 1.9
 

data/Rakefile

@@ -64,6 +64,7 @@ task :gemspec do
 
           Gem::Specification::new do |spec|
             spec.name = #{ lib.inspect }
+            spec.description = 'a class factory and dsl for generating command line programs real quick'
             spec.version = #{ version.inspect }
             spec.platform = Gem::Platform::RUBY
             spec.summary = #{ lib.inspect }
@@ -77,8 +78,8 @@ task :gemspec do
 
             spec.has_rdoc = #{ has_rdoc.inspect }
             spec.test_files = #{ test_files.inspect }
-            #spec.add_dependency 'lib', '>= version'
-            #spec.add_dependency 'fattr'
+            spec.add_dependency 'fattr', '>= 1.0.3'
+            spec.add_dependency 'arrayfields', '>= 4.5.0'
 
             spec.extensions.push(*#{ extensions.inspect })
 

data/TODO

@@ -9,7 +9,7 @@
 
 * figure out how to support '-' ??
 
-* clean up warnings under 'ruby -d'
+* clean up warnings under 'ruby -w'
 * error reporting weird for some errors
 
 ===============================================================================

data/a.rb

@@ -0,0 +1,5 @@
+require 'main'
+
+Main {
+  def run() p 42 end
+}

data/lib/main.rb

@@ -2,7 +2,7 @@ module Main
 #
 # top level constants
 #
-  Main::VERSION = '2.9.3' unless
+  Main::VERSION = '3.0.1' unless
     defined? Main::VERSION
   def self.version() Main::VERSION end
 
@@ -29,20 +29,7 @@ module Main
   end
 
   require 'fattr'
-  begin
-    version = Fattr.version
-    raise unless version[%r/^1\./] 
-  rescue
-    abort "main requires fattrs >= 1.0.3 - gem install fattr"
-  end
-
   require 'arrayfields'
-  begin
-    version = Arrayfields.version
-    raise unless version[%r/^4\./] 
-  rescue
-    abort "main requires arrayfields >= 4.5.0 - gem install arrayfields"
-  end
 #
 # main's own libs
 #
@@ -55,6 +42,6 @@ module Main
   require libdir + 'parameter'
   require libdir + 'getoptlong'
   require libdir + 'mode'
-  require libdir + 'base'
+  require libdir + 'program'
   require libdir + 'factories'
 end

data/lib/main/dsl.rb

@@ -0,0 +1,77 @@
+    def parameter(*a, &b)
+      (parameters << Parameter.create(:parameter, self, *a, &b)).last
+    end
+
+    def argument(*a, &b)
+      (parameters << Parameter.create(:argument, self, *a, &b)).last
+    end
+    alias_method 'arg', 'argument'
+
+    def option(*a, &b)
+      (parameters << Parameter.create(:option, self, *a, &b)).last
+    end
+    alias_method 'opt', 'option'
+    alias_method 'switch', 'option'
+
+    def keyword(*a, &b)
+      (parameters << Parameter.create(:keyword, self, *a, &b)).last
+    end
+    alias_method 'kw', 'keyword'
+
+    def environment(*a, &b)
+      (parameters << Parameter.create(:environment, self, *a, &b)).last
+    end
+    alias_method 'env', 'environment'
+
+    def default_options!
+      option 'help', 'h' unless parameters.has_option?('help', 'h')
+    end
+
+    def mode(name, &block)
+      name = name.to_s
+      modes[name] = block
+      block.fattr(:name => name)
+      block
+    end
+
+    def can_has(ptype, *a, &b)
+      key = a.map{|s| s.to_s}.sort_by{|s| -s.size }.first
+      can_has_hash.update key => [ptype, a, b]
+      key
+    end
+
+    def has(key, *keys)
+      keys = [key, *keys].flatten.compact.map{|k| k.to_s}
+      keys.map do |key|
+        ptype, a, b = can_has_hash[key]
+        abort "yo - can *not* has #{ key.inspect }!?" unless(ptype and a and b)
+        send ptype, *a, &b
+        key
+      end
+    end
+
+    def mixin(name, *names, &block)
+      names = [name, *names].flatten.compact.map{|name| name.to_s}
+      if block
+        names.each do |name|
+          mixin_table[name] = block
+        end
+      else
+        names.each do |name|
+          module_eval(&mixin_table[name])
+        end
+      end
+    end
+
+## TODO - for some reason these hork the usage!
+
+    %w[ examples samples api ].each do |chunkname|
+      module_eval <<-code
+        def #{ chunkname } *a, &b 
+          txt = b ? b.call : a.join("\\n")
+          usage['#{ chunkname }'] = txt
+        end
+      code
+    end
+    alias_method 'example', 'examples'
+    alias_method 'sample', 'samples'

data/lib/main/factories.rb

@@ -1,20 +1,26 @@
 module Main
-  def Main.create *a, &b
-    ::Main::Base.create(::Main::Base, *a, &b)
+  def Main.factory(&block)
+    Program.factory(&block)
   end
 
-  def Main.new *a, &b
-    create(::Main::Base, &b).new *a
+  def Main.create(&block)
+    factory(&block)
   end
 
-  def Main.run argv = ARGV, env = ENV, opts = {}, &block
-    Base.create(&block).new(argv, env, opts).run
+  def Main.new(*args, &block)
+    factory(&block).build(*args).new()
   end
 
-  module ::Kernel
-    def Main argv = ARGV, env = ENV, opts = {}, &block
-      ::Main.run argv, env, opts, &block
-    end
-    alias_method 'main', 'Main'
+  def Main.run(*args, &block)
+    new(*args, &block).run()
   end
 end
+
+module Kernel
+private
+  def Main(*args, &block)
+    Main.run(*args, &block)
+  end
+
+  alias_method 'main', 'Main'
+end

data/lib/main/mode.rb

@@ -12,11 +12,13 @@ module Main
       ensure
         self.fields = []
       end
+
       def add klass
         mode_name = Mode.new klass.mode_name
         raise Duplicate, mode_name if has_key? mode_name
         self[mode_name] = klass
       end
+
       def find_by_mode m, options = {}
         quiet = options['quiet'] || options[:quiet]
         each_pair do |mode, klass|
@@ -37,8 +39,8 @@ module Main
       end
     end
 
-    def self.list *a, &b
-      List.new *a, &b
+    def self.list(*a, &b)
+      List.new(*a, &b)
     end
   end
 end

data/lib/main/parameter.rb

@@ -38,22 +38,24 @@ module Main
         @sym ||= name.split(%r/::/).last.downcase.to_sym
       end
 
-      def class_for type 
+      def class_for(type)
         sym = type.to_s.downcase.to_sym
         c = Types.detect{|t| t.sym == sym}
         raise ArgumentError, type.inspect unless c
         c
       end
 
-      def create type, *a, &b 
-        c = class_for type
+      def create(type, main, *a, &b)
+        c = class_for(type)
         obj = c.allocate
         obj.type = c.sym
-        obj.instance_eval{ initialize *a, &b }
+        obj.main = main
+        obj.instance_eval{ initialize(*a, &b) }
         obj
       end
     end
 
+    fattr 'main'
     fattr 'type'
     fattr 'names'
     fattr 'abbreviations'
@@ -74,8 +76,9 @@ module Main
     fattr 'error_handler_instead'
     fattr 'error_handler_after'
 
-    def initialize name, *names, &block
-      @names = Cast.list_of_string name, *names
+    def initialize(name, *names, &block)
+      @names = Cast.list_of_string(name, *names)
+
       @names.map! do |name|
         if name =~ %r/^-+/
           name.gsub! %r/^-+/, ''
@@ -330,7 +333,7 @@ puts
         defaults!
         validate!
 
-        argv.push *ignore[1 .. -1] unless ignore.empty? 
+        argv.push(*ignore[1..-1]) unless ignore.empty? 
 
         return self
       ensure
@@ -520,8 +523,8 @@ puts
         replace keep
       end
 
-      def << *a 
-        delete *a
+      def <<(*a)
+        delete(*a)
         super
       end
     end
@@ -541,7 +544,7 @@ puts
         name = param.name
         a ||= name
         b = fattr_block_for name, &block 
-        Main.current.module_eval{ fattr *a, &b }
+        @param.main.module_eval{ fattr(*a, &b) }
       end
       alias_method 'attribute', 'fattr'
 
@@ -550,8 +553,8 @@ puts
         lambda{ block.call self.param[name] }
       end
 
-      def attr *a, &b
-        fattr *a, &b
+      def attr(*a, &b)
+        fattr(*a, &b)
       end
 
       def example *list
@@ -643,7 +646,7 @@ puts
           raise ArgumentError, 'no default'
         end
         unless values.empty?
-          param.defaults.push *values
+          param.defaults.push(*values)
         end
         unless block.nil?
           param.defaults.push block

data/lib/main/program.rb

@@ -0,0 +1,6 @@
+module Main
+  class Program
+    require 'lib/main/program/class_methods.rb'
+    require 'lib/main/program/instance_methods.rb'
+  end
+end

data/lib/main/program/class_methods.rb

@@ -0,0 +1,260 @@
+module Main
+  class Program
+    module ClassMethods
+      fattr('name'){ File.basename($0) }
+      fattr('program'){ File.basename($0) }
+      fattr('synopsis'){ Main::Usage.default_synopsis(self) }
+      fattr('description')
+      fattr('usage'){ Main::Usage.default_usage(self) }
+      fattr('modes'){ Main::Mode.list }
+
+      fattr('author')
+      fattr('version')
+      fattr('stdin'){ $stdin }
+      fattr('stdout'){ $stdout }
+      fattr('stderr'){ $stderr }
+      fattr('logger'){ Logger.new(stderr) }
+      fattr('logger_level'){ Logger::INFO }
+      fattr('exit_status'){ nil }
+      fattr('exit_success'){ Main::EXIT_SUCCESS }
+      fattr('exit_failure'){ Main::EXIT_FAILURE }
+      fattr('exit_warn'){ Main::EXIT_WARN }
+      fattr('parameters'){ Main::Parameter::List[] }
+      fattr('can_has_hash'){ Hash.new }
+      fattr('mixin_table'){ Hash.new }
+
+      fattr('factory')
+      fattr('argv')
+      fattr('env')
+      fattr('opts')
+
+      def factory(&block)
+        Factory.new(&block)
+      end
+      alias_method 'create', 'factory'
+
+      class Factory
+        def initialize(&block)
+          @block = block || lambda{}
+        end
+
+        def to_proc
+          @block
+        end
+
+        def build(*args, &block)
+          argv = (args.shift || ARGV).map{|arg| arg.dup}
+          env = (args.shift || ENV).to_hash.dup
+          opts = (args.shift || {}).to_hash.dup
+
+          factory = self
+          program = Class.new(Program)
+          program.evaluate(&factory)
+
+          program.module_eval do
+            program.factory = factory
+            program.argv = argv
+            program.env = env
+            program.opts = opts
+
+            dynamically_extend_via_commandline_modes!
+            program.set_default_options!
+
+            define_method(:run, &block) if block
+
+            wrap_run!
+          end
+          program
+        end
+      end
+
+      def new()
+        instance = allocate
+        instance.instance_eval do
+          pre_initialize()
+          before_initialize()
+          main_initialize()
+          initialize()
+          after_initialize()
+          post_initialize()
+        end
+        instance
+      end
+
+      def evaluate(&block)
+        module_eval(&block)
+      end
+
+      def set_default_options!
+        option('help', 'h') unless parameters.has_option?('help', 'h')
+      end
+
+# TODO - ambiguous modes
+
+    # extend the class based on modules given in argv
+    #
+      def dynamically_extend_via_commandline_modes!
+        size = modes.size
+        depth_first_modes = Array.fields
+
+        loop do
+          modes.each do |mode|
+            arg = argv.first && %r/^#{ argv.first }/
+            if arg and mode.name =~ arg
+              argv.shift
+              modes.clear
+              evaluate(&mode)
+              depth_first_modes[mode.name] = mode
+              break
+            end
+          end
+
+          arg = argv.first && %r/^#{ argv.first }/
+          more_modes = (
+            !modes.empty? and modes.any?{|mode| arg && mode.name =~ arg}
+          )
+
+          break unless more_modes
+        end
+
+        self.modes = depth_first_modes
+      end
+
+    # wrap up users run method to handle errors, etc
+    #
+      def wrap_run!
+        evaluate do
+          alias_method 'run!', 'run'
+
+          def run()
+            exit_status =
+              catch :exit do
+                begin
+                  parse_parameters
+
+                  if help?
+                    puts(usage)
+                    exit
+                  end
+
+                  pre_run
+                  before_run
+                  run!
+                  after_run
+                  post_run
+
+                  finalize
+                rescue Object => exception
+                  self.exit_status ||= exception.status if exception.respond_to?(:status)
+                  handle_exception(exception)
+                end
+                nil
+              end
+
+            self.exit_status ||= (exit_status || exit_success)
+            handle_exit(self.exit_status)
+          end
+        end
+      end
+
+# TODO
+      def fully_qualified_mode
+        modes.map{|mode| mode.name}.join(' ')
+      end
+
+      def mode_name
+        return 'main' if modes.empty?
+        fully_qualified_mode
+      end
+
+      undef_method 'usage'
+      def usage(*args, &block)
+        usage! unless defined? @usage 
+        return @usage if args.empty? and block.nil?
+        key, value, *ignored = args
+        value = block.call if block
+        @usage[key.to_s] = value.to_s
+      end
+
+      def parameter(*a, &b)
+        (parameters << Parameter.create(:parameter, self, *a, &b)).last
+      end
+
+      def argument(*a, &b)
+        (parameters << Parameter.create(:argument, self, *a, &b)).last
+      end
+
+      def option(*a, &b)
+        (parameters << Parameter.create(:option, self, *a, &b)).last
+      end
+
+      def keyword(*a, &b)
+        (parameters << Parameter.create(:keyword, self, *a, &b)).last
+      end
+
+      def environment(*a, &b)
+        (parameters << Parameter.create(:environment, self, *a, &b)).last
+      end
+
+      def default_options!
+        option 'help', 'h' unless parameters.has_option?('help', 'h')
+      end
+
+      def mode(name, &block)
+        name = name.to_s
+        modes[name] = block
+        block.fattr(:name => name)
+        block
+      end
+
+      def can_has(ptype, *a, &b)
+        key = a.map{|s| s.to_s}.sort_by{|s| -s.size }.first
+        can_has_hash.update key => [ptype, a, b]
+        key
+      end
+
+      def has(key, *keys)
+        keys = [key, *keys].flatten.compact.map{|k| k.to_s}
+        keys.map do |key|
+          ptype, a, b = can_has_hash[key]
+          abort "yo - can *not* has #{ key.inspect }!?" unless(ptype and a and b)
+          send ptype, *a, &b
+          key
+        end
+      end
+
+      def mixin(name, *names, &block)
+        names = [name, *names].flatten.compact.map{|name| name.to_s}
+        if block
+          names.each do |name|
+            mixin_table[name] = block
+          end
+        else
+          names.each do |name|
+            module_eval(&mixin_table[name])
+          end
+        end
+      end
+
+## TODO - for some reason these hork the usage!
+
+      %w[ examples samples api ].each do |chunkname|
+        module_eval <<-code
+          def #{ chunkname } *a, &b 
+            txt = b ? b.call : a.join("\\n")
+            usage['#{ chunkname }'] = txt
+          end
+        code
+      end
+      alias_method 'example', 'examples'
+      alias_method 'sample', 'samples'
+
+      def run(&block)
+        block ||= lambda{}
+        define_method(:run, &block) if block
+      end
+    end
+
+    extend ClassMethods
+  end
+end