main 0.0.2 → 2.0.0

data/lib/main/attributes.rb

@@ -1,54 +1,113 @@
 module Attributes
-  VERSION = '3.2.0'
+  Attributes::VERSION = '4.0.0' unless defined? Attributes::VERSION
+  def self.version() Attributes::VERSION end
 
-  def version() VERSION end
+  class List < ::Array
+    def << element
+      super
+      self
+    ensure
+      uniq!
+      index!
+    end
+    def index!
+      @index ||= Hash.new
+      each{|element| @index[element] = true}
+    end
+    def include? element
+      @index ||= Hash.new
+      @index[element] ? true : false
+    end
+    def initializers
+      @initializers ||= Hash.new
+    end
+  end
 
   def attributes *a, &b
     unless a.empty?
-      hashes, names = a.partition{|x| Hash === x}
+      returned = Hash.new
 
+      hashes, names = a.partition{|x| Hash === x}
       names_and_defaults = {}
       hashes.each{|h| names_and_defaults.update h}
       names.flatten.compact.each{|name| names_and_defaults.update name => nil}
 
+      initializers = __attributes__.initializers
+
       names_and_defaults.each do |name, default|
-        init = b || lambda { default }
-        ivar, getter, setter, query = "@#{ name }", "#{ name }", "#{ name }=", "#{ name }?"
+        raise NameError, "bad instance variable name '@#{ name }'" if "@#{ name }" =~ %r/[!?=]$/o
+        name = name.to_s
 
-        define_method(setter) do |value|
-          instance_variable_set ivar, value
+        initialize = b || lambda { default }
+        initializer = lambda do |this|
+          Object.instance_method('instance_eval').bind(this).call &initialize
         end
+        initializer_id = initializer.object_id
+        __attributes__.initializers[name] = initializer
 
-        define_method(getter) do |*value|
-          unless value.empty?
-            send setter, value.shift
-          else
-            defined = instance_eval "defined? #{ ivar }"
-            send setter, instance_eval(&init) unless defined
-            instance_variable_get ivar
+        module_eval <<-code
+          def #{ name }=(value)
+            @#{ name } = value
           end
-        end
-
-        alias_method query, getter
+        code
+        module_eval <<-code
+          def #{ name }(*value)
+            return self.#{ name } = value.first unless value.empty?
+            #{ name }! unless defined? @#{ name }
+            @#{ name }
+          end
+        code
+        module_eval <<-code
+          def #{ name }!
+            initializer = ObjectSpace._id2ref #{ initializer_id }
+            self.#{ name } = initializer.call(self)
+            @#{ name }
+          end
+        code
+        module_eval <<-code
+          def #{ name }?
+            #{ name }
+          end
+        code
 
-        (attributes << name).uniq!
-        attributes
+        attributes << name
+        returned[name] = initializer 
       end
+
+      returned
     else
-      @attributes ||= [] 
+      begin
+        __attribute_list__
+      rescue NameError
+        singleton_class =
+          class << self
+            self
+          end
+        klass = self
+        singleton_class.module_eval do
+          attribute_list = List.new 
+          define_method('attribute_list'){ klass == self ? attribute_list : raise(NameError) }
+          alias_method '__attribute_list__', 'attribute_list'
+        end
+        __attribute_list__
+      end
     end
   end
 
-  def attribute(*a, &b) attributes *a, &b end
+  %w( __attributes__ __attribute__ attribute ).each{|dst| alias_method dst, 'attributes'}
 end
 
 class Object
   def attributes *a, &b
-    sc = class << self; self; end
+    sc = 
+      class << self
+        self
+      end
     sc.attributes *a, &b
   end
-
-  def attribute(*a, &b) attributes *a, &b end
+  %w( __attributes__ __attribute__ attribute ).each{|dst| alias_method dst, 'attributes'}
 end
 
-class Module; include Attributes; end
+class Module
+  include Attributes
+end

data/lib/main/base.rb

@@ -1,10 +1,78 @@
 module Main
   class Base
     class << self
-      attribute( 'program' ){ File.basename $0 } 
+      def wrap_run!
+        const_set :RUN, instance_method(:run)
+
+        class_eval do
+          def run *a, &b
+            begin
+              argv.push "--#{ argv.shift }" if argv.first == 'help'
+
+              return mode_run! if mode_given?
+
+              parse_parameters
+
+              if params['help'] and params['help'].given?
+                print usage.to_s
+                exit
+              end
+
+              pre_run
+
+              self.class.const_get(:RUN).bind(self).call(*a, &b)
+
+              post_run
+
+              finalize
+            rescue Exception => e
+              handle_exception e
+            end
+          end
+        end
+      end
+
+      def method_added m
+        return if @in_method_added
+        super if defined? super
+        @in_method_added = true
+        begin
+          wrap_run! if m.to_s == 'run'
+        ensure
+          @in_method_added = false 
+        end
+      end
+
+      def self.inheritable_attribute name, &block
+        block ||= lambda{}
+        attribute( name ){ 
+          catch :value do
+            if parent?
+              value = parent.send name 
+              value =
+                begin
+                  Util.mcp value
+                rescue
+                  value.clone rescue value.dup
+                end
+              throw :value, value 
+            end
+            instance_eval &block
+          end
+        } 
+      end
+
       attribute( 'name' ){ File.basename $0 } 
-      attribute( 'synopsis' ){ Usage.default_synopsis self } 
+      attribute( 'synopsis' ){ Usage.default_synopsis(self) }
       attribute( 'description' )
+      attribute( 'usage' ){ Usage.default_usage self } 
+      attribute( 'modes' ){ Mode.list }
+      attribute( 'mode_name' ){ 'main' }
+      def mode_name=(value) @mode_name = Mode.new value end
+      attribute( 'parent' ){ nil }
+      attribute( 'children' ){ Set.new }
+
+      attribute( 'program' ){ File.basename $0 } 
       attribute( 'author' )
       attribute( 'version' )
       attribute( 'stdin' ){ $stdin } 
@@ -16,12 +84,46 @@ module Main
       attribute( 'exit_success' ){ EXIT_SUCCESS } 
       attribute( 'exit_failure' ){ EXIT_FAILURE } 
       attribute( 'exit_warn' ){ EXIT_WARN } 
-      attribute( 'usage' ){ Usage.default_usage self } 
+      inheritable_attribute( 'parameters' ){ Parameter::List[] }
 
-      def parameters
-        @parameters ||= Parameter::List[]
+      def create parent = Base, *a, &b
+        Class.new parent do |child|
+          child.parent = parent unless parent == Base
+          parent.children.add child
+          child.context do
+            child.class_eval &b if b
+            child.default_options!
+          end
+        end
       end
 
+      def context &block 
+        @@context ||= []
+        unless block 
+          @@context.last
+        else
+          begin
+            @@context.push self 
+            block.call @@context.last
+          ensure
+            @@context.pop
+          end
+        end
+      end
+
+      def fully_qualified_mode
+        list = []
+        ancestors.each do |ancestor|
+          break unless ancestor < Base
+          list << ancestor.mode_name
+        end
+        list.reverse[1..-1]
+      end
+
+      def run(&b) define_method(:run, &b) end
+    end
+
+    module DSL
       def parameter *a, &b
         parameters << Parameter.new(*a, &b)
       end
@@ -33,7 +135,7 @@ module Main
       alias_method 'switch', 'option'
 
       def default_options!
-        option 'help', 'h'
+        option 'help', 'h' unless parameters.has_option?('help', 'h')
       end
 
       def argument *a, &b
@@ -51,10 +153,16 @@ module Main
       end
       alias_method 'env', 'environment'
 
-      def run *a, &b
-        define_method 'run' &b
+      def mode name, &b
+        klass = 
+          create context do
+            mode_name name
+            module_eval &b if b
+          end
+        modes.add klass
       end
     end
+    extend DSL
 
     attribute 'argv'
     attribute 'env'
@@ -77,14 +185,6 @@ module Main
       alias_method "#{ dst }?", "params?"
     end
 
-    %w( exit_success! exit_failure! exit_warn! ).each do |code|
-      module_eval <<-code
-        def #{ code } *a, &b
-          exit #{ code.chop }
-        end
-      code
-    end
-
     %w( debug info warn fatal error ).each do |m|
       module_eval <<-code
         def #{ m } *a, &b
@@ -137,6 +237,7 @@ module Main
             @logger.level = logger_level 
         end
       end
+      @logger
     end
 
     def setup_io_restoration
@@ -160,12 +261,7 @@ module Main
         rescue
           $stdin = @stdin
           ::Object.const_set 'STDIN', @stdin
-#p STDIN
-#p STDIN.read
         end
-#p 'STDIN' => STDIN
-#p '@stdin' => @stdin
-#p '$stdin' => $stdin
       end
     end
 
@@ -209,10 +305,37 @@ module Main
     end
     def post_parse_parameters() :hook end
 
-    def pre_run() end
+    def pre_run() :hook end
     def run
       raise NotImplementedError, 'run not defined'
     end
-    def post_run() end
+    def post_run() :hook end
+
+    def mode_given?
+      self.class.modes.find_by_mode argv.first, :quiet => true if argv.first
+    end
+
+    def mode_run!
+      mode = self.class.modes.find_by_mode argv.shift
+      klass = self.class.modes[mode] or abort "bad mode <#{ mode }>"
+      main = klass.new @argv, @env, @opts
+      main.run
+    end
+
+    def handle_exception e
+      if e.respond_to? :status
+        exit_status(( e.status ))
+      end
+
+      if Softspoken === e or SystemExit === e
+        stderr.puts e.message unless(SystemExit === e and e.message.to_s == 'exit')
+      else
+        fatal{ e }
+      end
+
+      exit_status(( exit_failure )) if exit_status == exit_success
+      exit_status(( Integer(exit_status) rescue(exit_status ? 0 : 1) ))
+      exit exit_status
+    end
   end
 end

data/lib/main/factories.rb

@@ -1,15 +1,19 @@
 module Main
-  def self.new *a, &b
-    klass = Class.new Base
-    klass.default_options!
-    klass.class_eval &b if b
-    main = klass.new *a, &b
-    Proxy.new main
+  def Main.create *a, &b
+    ::Main::Base.create(::Main::Base, *a, &b)
+  end
+
+  def Main.new *a, &b
+    create(::Main::Base, &b).new *a
+  end
+
+  def Main.run argv = ARGV, env = ENV, opts = {}, &block
+    Base.create(&block).new(argv, env, opts).run
   end
 
   module ::Kernel
-    def Main *a, &b
-      ::Main.new(*a, &b).run
+    def Main argv = ARGV, env = ENV, opts = {}, &block
+      ::Main.run argv, env, opts, &block
     end
     alias_method 'main', 'Main'
   end

data/lib/main/mode.rb

@@ -0,0 +1,42 @@
+class Mode < ::String
+  class Error < ::StandardError; end
+  class Duplicate < Error; end
+  class Ambigous < Error
+    include Main::Softspoken
+  end
+
+  class List < ::Array
+    def initialize *a, &b
+      super
+    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|
+        return mode if mode == m
+      end
+      candidates = []
+      each_pair do |mode, klass|
+        candidates << mode if mode.index(m) == 0
+      end
+      case candidates.size
+        when 0
+          nil
+        when 1
+          candidates.first
+        else
+          quiet ? nil : raise(Ambigous, m)
+      end
+    end
+  end
+
+  def self.list *a, &b
+    List.new *a, &b
+  end
+end

data/lib/main/parameter.rb

@@ -1,8 +1,11 @@
 module Main
   class Parameter
-    class Error < StandardError; attribute 'wrapped'; end
-    class NotGiven < Error; end
+    class Error < StandardError
+      include Softspoken
+      attribute 'wrapped'
+    end
     class Arity < Error; end
+    class NotGiven < Arity; end
     class InValid < Error; end
     class NoneSuch < Error; end
     class AmbigousOption < Error; end
@@ -11,10 +14,6 @@ module Main
     class InvalidOption < Error; end
 
     class << self
-      def new *a, &b
-        raise
-      end
-
       def wrapped_error w
         e = Error.new "(#{ w.message } (#{ w.class }))"
         e.wrapped = w
@@ -137,33 +136,35 @@ module Main
 
     def setup!
       return false unless given?
-      validate_arity!
-      cast!
-      validate!
+      check_arity
+      apply_casting
+      check_validation
       true
     end
 
-    def validate_arity!
-      raise Arity, "#{ typename })" if values.size.zero? and argument_required?
-      if values.size < arity
-        if argument_required?
-          raise Arity, "#{ typename }) #{ values.size }/#{ arity }" if(values.size < arity)
-        elsif argument_optional?
-          raise Arity, "#{ typename }) #{ values.size }/#{ arity }" if(values.size < arity and values.size > 0)
-        end
+    def check_arity 
+      (raise Arity, "#{ typename })" if values.size.zero? and argument_required?) unless arity == -1
+
+      if arity >= 0
+        min = arity
+        sign = ''
+      else
+        min = arity.abs - 1
+        sign = '-'
       end
-    end
 
-    def validate!
-      if validate?
-        values.each do |value|
-          validate[value] or 
-            raise InValid, "#{ typename }=#{ value.inspect }"
+      arity = min
+
+      if values.size < arity
+        if argument_required? or argument_none?
+          raise Arity, "#{ typename }) #{ values.size }/#{ sign }#{ arity }" if(values.size < arity)
+        elsif argument_optional?
+          raise Arity, "#{ typename }) #{ values.size }/#{ sign }#{ arity }" if(values.size < arity and values.size > 0)
         end
       end
     end
 
-    def cast!
+    def apply_casting 
       if cast?
         op = cast.respond_to?('call') ? cast : Cast[cast]
         values.map! do |val|
@@ -172,15 +173,24 @@ module Main
       end
     end
 
+    def check_validation 
+      if validate?
+        values.each do |value|
+          validate[value] or 
+            raise InValid, "invalid: #{ typename }=#{ value.inspect }"
+        end
+      end
+    end
+
     class Argument < Parameter
-      attribute 'required' => true 
+      attribute 'required' => true
 
       attribute 'synopsis' do
         label = name
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
         value = "#{ cast }(#{ value })" if cast
-        "#{ label } [ #{ arity } #{ op } #{ value } ]"
+        "#{ label } (#{ arity } #{ op } #{ value })"
       end
     end
 
@@ -196,7 +206,7 @@ module Main
           op = required ? "->" : "~>"
           value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
           value = "#{ cast }(#{ value })" if cast
-          "#{ label } [ #{ arity } #{ op } #{ value } ]"
+          "#{ label } (#{ arity } #{ op } #{ value })"
         else
           label
         end
@@ -212,7 +222,7 @@ module Main
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
         value = "#{ cast }(#{ value })" if cast
-        "#{ label } [ #{ arity } #{ op } #{ value } ]"
+        "#{ label } (#{ arity } #{ op } #{ value })"
       end
     end
 
@@ -224,7 +234,7 @@ module Main
         op = required ? "->" : "~>"
         value = defaults.size > 0 ? "#{ name }=#{ defaults.join ',' }" : name 
         value = "#{ cast }(#{ value })" if cast
-        "#{ label } [ #{ arity } #{ op } #{ value } ]"
+        "#{ label } (#{ arity } #{ op } #{ value })"
       end
     end
 
@@ -241,7 +251,7 @@ module Main
       end
 
       def parse_options argv, params = nil
-        params ||= select{|p| p.type == :option}
+        params ||= options 
 
         spec, h, s = [], {}, {}
 
@@ -279,6 +289,7 @@ module Main
           c = Parameter.const_get e.class.name.split(/::/).last
           ex = c.new e.message
           ex.set_backtrace e.message
+          ex.extend Softspoken
           raise ex
         end
 
@@ -291,10 +302,23 @@ module Main
         params ||= select{|p| p.type == :argument}
 
         params.each do |p|
-          p.arity.times do
-            break if argv.empty?
-            value = argv.shift
-            p.add_value value
+          if p.arity >= 0
+            p.arity.times do
+              break if argv.empty?
+              value = argv.shift
+              p.add_value value
+            end
+          else
+            arity = p.arity.abs - 1
+            arity.times do
+              break if argv.empty?
+              value = argv.shift
+              p.add_value value
+            end
+            argv.size.times do
+              value = argv.shift
+              p.add_value value
+            end
           end
         end
 
@@ -351,11 +375,9 @@ module Main
 
       def defaults!
         each do |p|
-          #p.add_value p.default if(p.default? and (not p.given?)) 
           if(p.defaults? and (not p.given?)) 
             p.defaults.each do |default|
-              #p.add_value default
-              p.values << default # so as NOT to set given?
+              p.values << default # so as NOT to set 'given?'
             end
           end
         end
@@ -363,7 +385,23 @@ module Main
 
       def validate!
         each do |p|
-          raise NotGiven, p.typename if(p.required? and (not p.given?))
+          next if p.arity == -1
+          raise NotGiven, "#{ p.typename } not given" if(p.required? and (not p.given?))
+        end
+      end
+
+      [:parameter, :option, :argument, :keyword, :environment].each do |m| 
+        define_method("#{ m }s"){ select{|p| p.type == m or m == :parameter} }
+
+        define_method("has_#{ m }?") do |name, *names|
+          catch :has do
+            names = Cast.list_of_string name, *names
+            send("#{ m }s").each do |param|
+              common = Cast.list_of_string(param.names) & names 
+              throw :has, true unless common.empty?
+            end
+            false
+          end
         end
       end
     end
@@ -472,6 +510,7 @@ module Main
       end
 
       def arity value
+        value = -1 if value.to_s == '*'
         p.arity = Integer value
       end
       def arity?