ahoward-main 2.9.0

data/Rakefile

@@ -0,0 +1,241 @@
+This.author = "Ara T. Howard"
+This.email = "ara.t.howard@gmail.com"
+This.homepage = "http://github.com/ahoward/#{ This.lib }/tree/master"
+This.rubyforge_project = 'codeforpeople'
+
+task :default do
+  puts(Rake::Task.tasks.map{|task| task.name} - ['default'])
+end
+
+task :spec do
+  require 'spec/rake/spectask'
+  Spec::Rake::SpecTask.new do |t|
+    t.spec_files = FileList['spec/*_spec.rb']
+  end
+end
+
+task :gemspec do
+  ignore_extensions = 'git', 'svn', 'tmp', /sw./, 'bak', 'gem'
+  ignore_directories = 'pkg'
+  ignore_files = 'test/log'
+
+  shiteless = 
+    lambda do |list|
+      list.delete_if do |entry|
+        next unless test(?e, entry)
+        extension = File.basename(entry).split(%r/[.]/).last
+        ignore_extensions.any?{|ext| ext === extension}
+      end
+      list.delete_if do |entry|
+        next unless test(?d, entry)
+        dirname = File.expand_path(entry)
+        ignore_directories.any?{|dir| File.expand_path(dir) == dirname}
+      end
+      list.delete_if do |entry|
+        next unless test(?f, entry)
+        filename = File.expand_path(entry)
+        ignore_files.any?{|file| File.expand_path(file) == filename}
+      end
+    end
+
+  lib         = This.lib
+  version     = This.version
+  files       = shiteless[Dir::glob("**/**")]
+  executables = shiteless[Dir::glob("bin/*")].map{|exe| File.basename(exe)}
+  has_rdoc    = true #File.exist?('doc')
+  test_files  = "test/#{ lib }.rb" if File.file?("test/#{ lib }.rb")
+
+  extensions = This.extensions
+  if extensions.nil?
+    %w( Makefile configure extconf.rb ).each do |ext|
+      extensions << ext if File.exists?(ext)
+    end
+  end
+  extensions = [extensions].flatten.compact
+
+  template = 
+    if test(?e, 'gemspec.erb')
+      Template{ IO.read('gemspec.erb') }
+    else
+      Template {
+        <<-__
+          ## #{ lib }.gemspec
+          #
+
+          Gem::Specification::new do |spec|
+            spec.name = #{ lib.inspect }
+            spec.version = #{ version.inspect }
+            spec.platform = Gem::Platform::RUBY
+            spec.summary = #{ lib.inspect }
+
+            spec.files = #{ files.inspect }
+            spec.executables = #{ executables.inspect }
+            
+            <% if test(?d, 'lib') %>
+            spec.require_path = "lib"
+            <% end %>
+
+            spec.has_rdoc = #{ has_rdoc.inspect }
+            spec.test_files = #{ test_files.inspect }
+            #spec.add_dependency 'lib', '>= version'
+            #spec.add_dependency 'fattr'
+
+            spec.extensions.push(*#{ extensions.inspect })
+
+            spec.rubyforge_project = #{ This.rubyforge_project.inspect }
+            spec.author = #{ This.author.inspect }
+            spec.email = #{ This.email.inspect }
+            spec.homepage = #{ This.homepage.inspect }
+          end
+        __
+      }
+    end
+
+  open("#{ lib }.gemspec", "w"){|fd| fd.puts template}
+  This.gemspec = "#{ lib }.gemspec"
+end
+
+task :gem => [:clean, :gemspec] do
+  Fu.mkdir_p This.pkgdir
+  before = Dir['*.gem']
+  cmd = "gem build #{ This.gemspec }"
+  `#{ cmd }`
+  after = Dir['*.gem']
+  gem = ((after - before).first || after.first) or abort('no gem!')
+  Fu.mv gem, This.pkgdir
+  This.gem = File.basename(gem)
+end
+
+task :readme do
+  samples = ''
+  prompt = '~ > '
+  lib = This.lib
+  version = This.version
+
+  Dir['sample*/*'].sort.each do |sample|
+    samples << "\n" << "  <========< #{ sample } >========>" << "\n\n"
+
+    cmd = "cat #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+    samples << Util.indent(`#{ cmd }`, 4) << "\n"
+
+    cmd = "ruby #{ sample }"
+    samples << Util.indent(prompt + cmd, 2) << "\n\n"
+
+    cmd = "ruby -e'STDOUT.sync=true; exec %(ruby -Ilib #{ sample })'"
+    samples << Util.indent(`#{ cmd } 2>&1`, 4) << "\n"
+  end
+
+  template = 
+    if test(?e, 'readme.erb')
+      Template{ IO.read('readme.erb') }
+    else
+      Template {
+        <<-__
+          NAME
+            #{ lib }
+
+          DESCRIPTION
+
+          INSTALL
+            gem install #{ lib }
+
+          SAMPLES
+            #{ samples }
+        __
+      }
+    end
+
+  open("README", "w"){|fd| fd.puts template}
+end
+
+
+task :clean do
+  Dir[File.join(This.pkgdir, '**/**')].each{|entry| Fu.rm_rf(entry)}
+end
+
+
+task :release => [:clean, :gemspec, :gem] do
+  gems = Dir[File.join(This.pkgdir, '*.gem')].flatten
+  raise "which one? : #{ gems.inspect }" if gems.size > 1
+  raise "no gems?" if gems.size < 1
+  cmd = "rubyforge login && rubyforge add_release #{ This.rubyforge_project } #{ This.lib } #{ This.version } #{ This.pkgdir }/#{ This.gem }"
+  puts cmd
+  system cmd
+end
+
+
+
+
+
+BEGIN {
+  $VERBOSE = nil
+
+  require 'ostruct'
+  require 'erb'
+  require 'fileutils'
+
+  Fu = FileUtils
+
+  This = OpenStruct.new
+
+  This.file = File.expand_path(__FILE__)
+  This.dir = File.dirname(This.file)
+  This.pkgdir = File.join(This.dir, 'pkg')
+
+  lib = ENV['LIB']
+  unless lib
+    lib = File.basename(Dir.pwd)
+  end
+  This.lib = lib
+
+  version = ENV['VERSION']
+  unless version
+    name = lib.capitalize
+    library = "./lib/#{ lib }.rb"
+    program = "./bin/#{ lib }"
+    if test(?e, library)
+      require library
+      version = eval(name).send(:version)
+    elsif test(?e, program)
+      version = `#{ program } --version`.strip
+    end
+    abort('no version') if(version.nil? or version.empty?)
+  end
+  This.version = version
+
+  abort('no lib') unless This.lib
+  abort('no version') unless This.version
+
+  module Util
+    def indent(s, n = 2)
+      s = unindent(s)
+      ws = ' ' * n
+      s.gsub(%r/^/, ws)
+    end
+
+    def unindent(s)
+      indent = nil
+      s.each do |line|
+      next if line =~ %r/^\s*$/
+      indent = line[%r/^\s*/] and break
+    end
+    indent ? s.gsub(%r/^#{ indent }/, "") : s
+  end
+    extend self
+  end
+
+  class Template
+    def initialize(&block)
+      @block = block
+      @template = block.call.to_s
+    end
+    def expand(b=nil)
+      ERB.new(Util.unindent(@template)).result(b||@block)
+    end
+    alias_method 'to_s', 'expand'
+  end
+  def Template(*args, &block) Template.new(*args, &block) end
+
+  Dir.chdir(This.dir)
+}

data/TODO

@@ -0,0 +1,20 @@
+
+* support pathname casts
+* support uri casts
+* support filename casts
+* support directory costs
+* support io cast '-' (:input, :output)
+
+* fix weird super bug jeremy found
+
+* figure out how to support '-' ??
+
+* clean up warnings under 'ruby -d'
+* error reporting weird for some errors
+
+===============================================================================
+X calls to abort sometimes lead to STDERR prining twice ;-(
+X main's' with modes, but no run do not operate properly - add default run w/wrap_run!
+X usage fubar when extra chunks are set
+X usage of arguments is fubar when negative arities are used
+X add sanity checks at parameter contruction completion

data/lib/main.rb

@@ -0,0 +1,60 @@
+module Main
+#
+# top level constants
+#
+  Main::VERSION = '2.9.0' unless
+    defined? Main::VERSION
+  def self.version() Main::VERSION end
+
+  Main::LIBDIR = File.join(File.dirname(File.expand_path(__FILE__)), self.name.downcase, '') unless
+    defined? Main::LIBDIR
+  def self.libdir() Main::LIBDIR end
+
+  Main::EXIT_SUCCESS = 0 unless defined? Main::EXIT_SUCCESS
+  Main::EXIT_FAILURE = 1 unless defined? Main::EXIT_FAILURE
+  Main::EXIT_WARN = 42 unless defined? Main::EXIT_WARN
+#
+# built-in
+#
+  require 'logger'
+  require 'enumerator'
+  require 'set'
+#
+# use gems to pick up dependancies
+#
+  begin
+    require 'rubygems'
+  rescue LoadError
+    42
+  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
+#
+  require libdir + 'stdext'
+  require libdir + 'softspoken'
+  require libdir + 'util'
+  require libdir + 'logger'
+  require libdir + 'usage'
+  require libdir + 'cast'
+  require libdir + 'parameter'
+  require libdir + 'getoptlong'
+  require libdir + 'mode'
+  require libdir + 'base'
+  require libdir + 'factories'
+end

data/lib/main/base.rb

@@ -0,0 +1,515 @@
+module Main
+  class Base
+    class << self
+      def wrap_run!
+        const_set :RUN, instance_method(:run)
+
+        class_eval do
+          def run *a, &b
+            argv.push "--#{ argv.shift }" if argv.first == 'help'
+            return mode_run! if mode_given?
+
+            status =
+              catch :exit do
+                begin
+
+                  parse_parameters
+
+                  if params['help'] and params['help'].given?
+                    print usage.to_s
+                    exit
+                  end
+
+                  pre_run
+                  before_run
+                  self.class.const_get(:RUN).bind(self).call(*a, &b)
+                  after_run
+                  post_run
+
+                  finalize
+                rescue Exception => e
+                  handle_exception e
+                end
+                nil
+              end
+
+            handle_throw status
+          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_fattr name, &block
+        block ||= lambda{}
+        fattr( 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
+
+    # fattrs
+      fattr( 'name' ){ File.basename $0 } 
+      fattr( 'synopsis' ){ Usage.default_synopsis(self) }
+      fattr( 'description' )
+      fattr( 'usage' ){ Usage.default_usage self } 
+      fattr( 'modes' ){ Mode.list }
+      fattr( 'mode_definitions' ){ Array.new }
+      fattr( 'mode_name' ){ 'main' }
+      fattr( 'parent' ){ nil }
+      fattr( 'children' ){ Set.new }
+
+      fattr( 'program' ){ File.basename $0 } 
+      fattr( 'author' )
+      fattr( 'version' )
+      fattr( 'stdin' ){ $stdin } 
+      fattr( 'stdout' ){ $stdout } 
+      fattr( 'stderr' ){ $stderr } 
+      fattr( 'logger' ){ stderr } 
+      fattr( 'logger_level' ){ Logger::INFO } 
+      fattr( 'exit_status' ){ Main::EXIT_SUCCESS } 
+      fattr( 'exit_success' ){ Main::EXIT_SUCCESS } 
+      fattr( 'exit_failure' ){ Main::EXIT_FAILURE } 
+      fattr( 'exit_warn' ){ Main::EXIT_WARN } 
+      inheritable_fattr( 'parameters' ){ Main::Parameter::List[] }
+      inheritable_fattr( 'can_has_hash' ){ Hash.new }
+      inheritable_fattr( 'mixin_table' ){ Hash.new }
+
+    # override a few fattrs
+      def mode_name=(value)
+        @mode_name = Mode.new value
+      end
+
+      def usage *argv, &block
+        usage! unless defined? @usage 
+        return @usage if argv.empty? and block.nil?
+        key, value, *ignored = argv
+        value = block.call if block
+        @usage[key.to_s] = value.to_s
+      end
+
+      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!
+            #child.wrap_run! unless child.const_defined?(:RUN)
+            mode_definitions.each do |name, block|
+              klass = 
+                create context do
+                  mode_name name.to_s
+                  module_eval &block if block
+                end
+              modes.add klass
+            end
+          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
+
+      module ::Main
+        singleton_class{
+          def current
+            ::Main::Base.context
+          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
+
+      def new(*a, &b)
+        allocate.instance_eval do
+          pre_initialize
+          before_initialize
+          main_initialize *a, &b
+          initialize
+          after_initialize
+          post_initialize
+          self
+        end
+      end
+    end
+
+    module DSL
+      def parameter *a, &b
+        (parameters << Parameter.create(:parameter, *a, &b)).last
+      end
+
+      def option *a, &b
+        (parameters << Parameter.create(:option, *a, &b)).last
+      end
+      alias_method 'opt', 'option'
+      alias_method 'switch', 'option'
+
+      def default_options!
+        option 'help', 'h' unless parameters.has_option?('help', 'h')
+      end
+
+      def argument *a, &b
+        (parameters << Parameter.create(:argument, *a, &b)).last
+      end
+      alias_method 'arg', 'argument'
+
+      def keyword *a, &b
+        (parameters << Parameter.create(:keyword, *a, &b)).last
+      end
+      alias_method 'kw', 'keyword'
+
+      def environment *a, &b
+        (parameters << Parameter.create(:environment, *a, &b)).last
+      end
+      alias_method 'env', 'environment'
+
+=begin
+      def mode name, &b
+        klass = 
+          create context do
+            mode_name name.to_s
+            module_eval &b if b
+          end
+        modes.add klass
+      end
+=end
+
+      def mode name, &b
+        mode_definitions << [name, b]
+      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'
+    end
+    extend DSL
+
+    fattr 'argv'
+    fattr 'env'
+    fattr 'params'
+    fattr 'logger'
+    fattr 'stdin'
+    fattr 'stdout'
+    fattr 'stderr'
+
+    %w( 
+      program name synopsis description author version
+      exit_status exit_success exit_failure exit_warn
+      logger_level
+      usage
+    ).each{|a| fattr(a){ self.class.send a}}
+
+    %w( parameters param ).each do |dst|
+      alias_method "#{ dst }", "params"
+      alias_method "#{ dst }=", "params="
+      alias_method "#{ dst }?", "params?"
+    end
+
+    %w( debug info warn fatal error ).each do |m|
+      module_eval <<-code
+        def #{ m } *a, &b
+          logger.#{ m } *a, &b
+        end
+      code
+    end
+
+=begin
+=end
+    def pre_initialize() :hook end
+    def before_initialize() :hook end
+    def main_initialize argv = ARGV, env = ENV, opts = {}
+      @argv, @env, @opts = argv, env, opts
+      setup_finalizers
+      setup_io_restoration
+      setup_io_redirection
+      setup_logging
+    end
+    def initialize() :hook end
+    def after_initialize() :hook end
+    def post_initialize() :hook end
+
+    def setup_finalizers
+      @finalizers = finalizers = []
+      ObjectSpace.define_finalizer(self) do
+        while((f = finalizers.pop)); f.call; end
+      end
+    end
+
+    def finalize
+      while((f = @finalizers.pop)); f.call; end
+    end
+
+    def setup_io_redirection
+      self.stdin = @opts['stdin'] || @opts[:stdin] || self.class.stdin
+      self.stdout = @opts['stdout'] || @opts[:stdout] || self.class.stdout
+      self.stderr = @opts['stderr'] || @opts[:stderr] || self.class.stderr
+    end
+
+    def setup_logging
+      log = self.class.logger || stderr
+      self.logger = log
+    end
+    def logger= log
+      unless(defined?(@logger) and @logger == log)
+        case log 
+          when ::Logger, Logger
+            @logger = log
+          when IO, StringIO
+            @logger = Logger.new log 
+            @logger.level = logger_level 
+          else
+            @logger = Logger.new *log
+            @logger.level = logger_level 
+        end
+      end
+      @logger
+    end
+
+    def setup_io_restoration
+      [STDIN, STDOUT, STDERR].each do |io|
+        dup = io.dup and @finalizers.push lambda{ io.reopen dup rescue nil }
+      end
+    end
+
+    def stdin= io
+      unless(defined?(@stdin) and (@stdin == io))
+        @stdin =
+          if io.respond_to? 'read'
+            io
+          else
+            fd = open io.to_s, 'r+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        begin
+          STDIN.reopen @stdin
+        rescue
+          $stdin = @stdin
+          ::Object.const_set 'STDIN', @stdin
+        end
+      end
+    end
+
+    def stdout= io
+      unless(defined?(@stdout) and (@stdout == io))
+        @stdout =
+          if io.respond_to? 'write'
+            io
+          else
+            fd = open io.to_s, 'w+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        STDOUT.reopen @stdout rescue($stdout = @stdout)
+      end
+    end
+
+    def stderr= io
+      unless(defined?(@stderr) and (@stderr == io))
+        @stderr =
+          if io.respond_to? 'write'
+            io
+          else
+            fd = open io.to_s, 'w+'
+            @finalizers.push lambda{ fd.close }
+            fd
+          end
+        STDERR.reopen @stderr rescue($stderr = @stderr)
+      end
+    end
+    
+    def pre_parse_parameters() :hook end
+    def before_parse_parameters() :hook end
+    def parse_parameters
+      pre_parse_parameters
+
+      self.class.parameters.parse self
+      @params = Parameter::Table.new
+      self.class.parameters.each{|p| @params[p.name.to_s] = p}
+
+      post_parse_parameters
+    end
+    def after_parse_parameters() :hook end
+    def post_parse_parameters() :hook end
+
+    def pre_run() :hook end
+    def before_run() :hook end
+    def run
+      raise NotImplementedError, 'run not defined'
+    end
+    def after_run() :hook end
+    def post_run() :hook end
+
+    def mode_given?
+      begin
+        modes.size > 0 and
+        argv.size > 0 and
+        modes.find_by_mode(argv.first)
+      rescue Mode::Ambiguous
+        true
+      end
+    end
+    def mode_run!
+      mode = modes.find_by_mode argv.shift
+      klass = modes[mode] or abort "bad mode <#{ mode }>"
+      main = klass.new @argv, @env, @opts
+      main.mode = mode
+      main.run
+    end
+    def modes
+      self.class.modes
+    end
+    fattr 'mode'
+
+    def help! status = 0
+      print usage.to_s
+      exit(status)
+    end
+
+    def abort message = 'exit'
+      raise SystemExit.new(message)
+    end
+
+    def handle_exception e
+      if e.respond_to?(:error_handler_before)
+        fcall(e, :error_handler_before, self)
+      end
+
+      if e.respond_to?(:error_handler_instead)
+        fcall(e, :error_handler_instead, self)
+      else
+        if e.respond_to? :status
+          exit_status(( e.status ))
+        end
+
+        if Softspoken === e or SystemExit === e
+          quiet = ((SystemExit === e and e.message.respond_to?('abort')) or # see main/stdext.rb
+                  (SystemExit === e and e.message == 'exit'))
+          stderr.puts e.message unless quiet
+        else
+          fatal{ e }
+        end
+      end
+
+      if e.respond_to?(:error_handler_after)
+        fcall(e, :error_handler_after, self)
+      end
+
+      exit_status(( exit_failure )) if exit_status == exit_success
+      exit_status(( Integer(exit_status) rescue(exit_status ? 0 : 1) ))
+      exit exit_status
+    end
+
+    def fcall obj, m, *argv, &block
+      m = obj.method m
+      arity = m.arity
+      if arity >= 0
+        argv = argv[0, arity]
+      else
+        arity = arity.abs - 1
+        argv = argv[0, arity] + argv[arity .. -1]
+      end
+      m.call *argv, &block
+    end
+
+    def handle_throw status
+      exit(( Integer(status) rescue 0 ))
+    end
+
+    %w[ before instead after ].each do |which|
+      module_eval <<-code
+        def error_handler_#{ which } *argv, &block
+          block.call *argv
+        end
+      code
+    end
+
+    def instance_eval_block *argv, &block
+      sc =
+        class << self
+          self
+        end
+      sc.module_eval{ define_method '__instance_eval_block', &block }
+      fcall self, '__instance_eval_block', *argv, &block
+    end
+  end
+end