ahoward-main 2.9.0

data/lib/main/softspoken.rb

@@ -0,0 +1,12 @@
+module Main
+  module Softspoken
+    class << self
+      fattr 'softspoken' => true
+      def on!() softspoken(true) end 
+      def off!() softspoken(false) end 
+      def === other
+        softspoken ? super : false
+      end
+    end
+  end
+end

data/lib/main/stdext.rb

@@ -0,0 +1,38 @@
+class Object
+  def singleton_class object = self, &block
+    sc =
+      class << object
+        self
+      end
+    block ? sc.module_eval(&block) : sc
+  end
+
+end
+
+module SaneAbort
+  def abort message = nil
+    if message
+      message = message.to_s
+      message.singleton_class{ fattr 'abort' => true }
+      STDERR.puts message
+    end
+    exit 1
+  end
+end
+
+  def abort message = nil
+    if message
+      message = message.to_s
+      message.singleton_class{ fattr 'abort' => true }
+      STDERR.puts message
+    end
+    exit 1
+  end
+  def Process.abort message = nil
+    if message
+      message = message.to_s
+      message.singleton_class{ fattr 'abort' => true }
+      STDERR.puts message
+    end
+    exit 1
+  end

data/lib/main/usage.rb

@@ -0,0 +1,208 @@
+module Main
+  class Usage < ::Array
+    fattr 'chunkname'
+    fattr 'upcase'
+    fattr 'eos'
+
+    def initialize opts={} 
+      self.fields=[]
+      self.chunkname = lambda{|chunkname| chunkname.to_s.strip.upcase}
+      self.upcase = true 
+      self.eos = "\n\n"
+      if opts.has_key?(:upcase) or opts.has_key?('upcase')
+        self.upcase = opts[:upcase] || opts['optcase']
+      end
+    end
+
+    def clear
+      super
+    ensure
+      fields.clear
+    end
+
+    alias_method 'delete', 'delete_at'
+
+    def self.default_synopsis main
+    # build up synopsis
+      s = "#{ main.name }"
+
+    # mode info
+      if main.mode_name != 'main'
+        s << " #{ main.fully_qualified_mode.join ' ' }"
+      end
+
+      unless main.modes.empty?
+        modes = main.modes.keys.join('|')
+        s << " (#{ modes })"
+      end
+
+    # argument info
+      main.parameters.each do |p|
+        if p.type == :argument
+          if(p.required? and p.arity != -1)
+            if p.arity > 0
+              p.arity.times{ s << " #{ p.name }" }
+            else
+              (p.arity.abs - 1).times{ s << " #{ p.name }" }
+              s << " #{ p.name }*"
+            end
+          else
+            #s << " [#{ p.name }]"
+            if p.arity > 0
+              a = []
+              p.arity.times{ a << "#{ p.name }" }
+              s << " [#{ a.join ' ' }]"
+            else
+              a = []
+              (p.arity.abs - 1).times{ a << "#{ p.name }" }
+              a << "#{ p.name }*"
+              s << " [#{ a.join ' ' }]"
+            end
+          end
+        end
+      end
+
+    # keyword info
+      main.parameters.each do |p|
+        if p.type == :keyword
+          if p.required?
+            s << " #{ p.name }=#{ p.name }"
+          else
+            s << " [#{ p.name }=#{ p.name }]"
+          end
+        end
+      end
+
+    # option info
+      n = 0
+      main.parameters.each do |p|
+        if p.type == :option
+          if p.required?
+            case p.argument
+              when :required
+                s << " --#{ p.name }=#{ p.name }"
+              when :optional
+                s << " --#{ p.name }=[#{ p.name }]"
+              else
+                s << " --#{ p.name }"
+            end
+          else
+            n += 1
+          end
+        end
+      end
+      if n > 0
+        s << " [options]+"
+      end
+
+    # help info
+=begin
+      if main.modes.size > 0
+        modes = main.modes.keys.join('|')
+        s << "\n#{ main.name } (#{ modes }) help"
+      end
+      if main.mode_name != 'main'
+        s << "\n#{ main.name } #{ main.fully_qualified_mode.join ' ' } help"
+      else
+        s << "\n#{ main.name } help"
+      end
+=end
+
+      s
+    end
+
+    def name_section
+      if main.version?
+        "#{ main.name } v#{ main.version }"
+      else
+        "#{ main.name }"
+      end
+    end
+
+    def synopsis_section
+      main.synopsis
+    end
+
+    def description_section
+      main.description if main.description?
+    end
+
+    def parameters_section
+      arguments = main.parameters.select{|p| p.type == :argument}
+      keywords = main.parameters.select{|p| p.type == :keyword}
+      options = main.parameters.select{|p| p.type == :option}
+      environment = main.parameters.select{|p| p.type == :environment}
+
+      help, nothelp = options.partition{|p| p.name == 'help'}
+      options = nothelp + help
+
+      parameters = arguments + keywords + options + environment
+
+      s =
+        parameters.map do |p|
+          ps = ''
+          ps << Util.columnize("#{ p.synopsis }", :indent => 2, :width => 78)
+          #ps << Util.columnize("* #{ p.synopsis }", :indent => 2, :width => 78)
+          #ps << "\n"
+          if p.description?
+            ps << "\n"
+            ps << Util.columnize("#{ p.description }", :indent => 6, :width => 78)
+            #ps << Util.columnize(p.description, :indent => 6, :width => 78)
+            #ps << "\n"
+          end
+          #ps << "\n"
+          unless(p.examples.nil? or p.examples.empty?)
+            p.examples.each do |example|
+              ps << "\n"
+              ps << Util.columnize("#{ example }", :indent => 8, :width => 78)
+            end
+          end
+          ps
+        end.join("\n")
+    end
+
+    def author_section
+      main.author
+    end
+
+    class << self
+      def default_usage main
+        usage = new
+        usage.main = main
+# HACK
+        %w( name synopsis description parameters author ).each do |key|
+          usage[key] = nil
+        end
+        usage
+      end
+
+      alias_method "default", "default_usage"
+    end
+
+    fattr "main"
+
+    def set_defaults!
+      usage = self
+      usage['name']        ||= name_section
+      usage['synopsis']    ||= synopsis_section
+      usage['description'] ||= description_section
+      usage['parameters']  ||= parameters_section unless main.parameters.empty?
+      usage['author']      ||= author_section if main.author?
+    end
+
+    def to_s
+      set_defaults!
+      s = '' 
+      each_pair do |key, value|
+        next unless(key and value)
+        up, down = key.to_s.upcase, key.to_s.downcase
+        if value
+          s << (upcase ? up : down) << "\n" 
+          s << Util.indent(Util.unindent(value.to_s), 2)
+          s << eos 
+        end
+      end
+      s
+    end
+  end
+end

data/lib/main/util.rb

@@ -0,0 +1,91 @@
+module Main
+  module Util
+    module ClassMethods
+    end
+
+    module InstanceMethods
+    end
+
+    module Methods
+      def mcp obj
+        Marshal.load(Marshal.dump(obj))
+      end
+
+      def indent chunk, n = 2
+        lines = chunk.split %r/\n/
+        re = nil
+        s = ' ' * n
+        lines.map! do |line|
+          unless re
+            margin = line[%r/^\s*/]
+            re = %r/^#{ margin }/
+          end
+          line.gsub re, s 
+        end.join("\n")
+      end
+
+      def unindent chunk
+        lines = chunk.split %r/\n/
+        indent = nil
+        re = %r/^/ 
+        lines.map! do |line|
+          unless indent 
+            indent = line[%r/^\s*/]
+            re = %r/^#{ indent }/
+          end
+          line.gsub re, ''
+        end.join("\n")
+      end
+
+      def columnize buf, opts = {}
+        width = Util.getopt 'width', opts, 80
+        indent = Util.getopt 'indent', opts
+        indent = Fixnum === indent ? (' ' * indent) : "#{ indent }"
+        column = []
+        words = buf.split %r/\s+/o
+        row = "#{ indent }"
+        while((word = words.shift))
+          if((row.size + word.size) < (width - 1))
+            row << word
+          else
+            column << row
+            row = "#{ indent }"
+            row << word
+          end
+          row << ' ' unless row.size == (width - 1)
+        end
+        column << row unless row.strip.empty?
+        column.join "\n"
+      end
+
+      def getopt opt, hash, default = nil
+        keys = opt.respond_to?('each') ? opt : [opt]
+
+        keys.each do |key|
+          return hash[key] if hash.has_key? key
+          key = "#{ key }"
+          return hash[key] if hash.has_key? key
+          key = key.intern
+          return hash[key] if hash.has_key? key
+        end
+
+        return default
+      end
+    end
+
+    BLESS = lambda do |other|
+      other.module_eval{
+        include Methods
+        include InstanceMethods
+        extend Methods
+        extend ClassMethods
+      }
+    end
+
+    def self.included other
+      BLESS[ other ]
+    end
+
+    BLESS[ self ]
+  end
+end

data/main.gemspec

@@ -0,0 +1,28 @@
+## main.gemspec
+#
+
+Gem::Specification::new do |spec|
+  spec.name = "main"
+  spec.version = "2.9.0"
+  spec.platform = Gem::Platform::RUBY
+  spec.summary = "main"
+
+  spec.files = ["lib", "lib/main", "lib/main/base.rb", "lib/main/cast.rb", "lib/main/factories.rb", "lib/main/getoptlong.rb", "lib/main/logger.rb", "lib/main/mode.rb", "lib/main/parameter.rb", "lib/main/softspoken.rb", "lib/main/stdext.rb", "lib/main/usage.rb", "lib/main/util.rb", "lib/main.rb", "main.gemspec", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb", "samples/f.rb", "samples/g.rb", "samples/h.rb", "test", "test/main.rb", "TODO"]
+  spec.executables = []
+  
+  
+  spec.require_path = "lib"
+  
+
+  spec.has_rdoc = true
+  spec.test_files = "test/main.rb"
+  #spec.add_dependency 'lib', '>= version'
+  #spec.add_dependency 'fattr'
+
+  spec.extensions.push(*[])
+
+  spec.rubyforge_project = "codeforpeople"
+  spec.author = "Ara T. Howard"
+  spec.email = "ara.t.howard@gmail.com"
+  spec.homepage = "http://github.com/ahoward/main/tree/master"
+end

data/samples/a.rb

@@ -0,0 +1,17 @@
+require 'main'
+
+ARGV.replace %w( 42 ) if ARGV.empty?
+
+Main {
+  argument('foo'){
+    required                    # this is the default
+    cast :int                   # value cast to Fixnum
+    validate{|foo| foo == 42}   # raises error in failure case 
+    description 'the foo param' # shown in --help
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].value
+  end
+}

data/samples/b.rb

@@ -0,0 +1,17 @@
+require 'main'
+
+ARGV.replace %w( 40 1 1 ) if ARGV.empty?
+
+Main {
+  argument('foo'){
+    arity 3                             # foo will given three times
+    cast :int                           # value cast to Fixnum
+    validate{|foo| [40,1].include? foo} # raises error in failure case 
+    description 'the foo param'         # shown in --help
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+  end
+}

data/samples/c.rb

@@ -0,0 +1,21 @@
+require 'main'
+
+ARGV.replace %w( foo=40 foo=2 bar=false ) if ARGV.empty?
+
+Main {
+  keyword('foo'){
+    required  # by default keywords are not required
+    arity 2
+    cast :float
+  }
+  keyword('bar'){
+    cast :bool
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+    p params['bar'].given?
+    p params['bar'].value
+  end
+}

data/samples/d.rb

@@ -0,0 +1,26 @@
+require 'main'
+
+ARGV.replace %w( --foo=40 -f2 ) if ARGV.empty?
+
+Main {
+  option('foo', 'f'){
+    required  # by default options are not required, we could use 'foo=foo'
+              # above as a shortcut
+    argument_required
+    arity 2
+    cast :float
+  }
+
+  option('bar=[bar]', 'b'){  # note shortcut syntax for optional args
+    # argument_optional      # we could also use this method
+    cast :bool
+    default false
+  }
+
+  def run
+    p params['foo'].given?
+    p params['foo'].values
+    p params['bar'].given?
+    p params['bar'].value
+  end
+}