ThiagoLelis-backgroundjob 1.0.3 → 1.0.4

data/lib/main.rb

@@ -0,0 +1,60 @@
+module Main
+#
+# top level constants
+#
+  Main::VERSION = '2.8.2' 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' ){ EXIT_SUCCESS } 
+      fattr( 'exit_success' ){ EXIT_SUCCESS } 
+      fattr( 'exit_failure' ){ EXIT_FAILURE } 
+      fattr( 'exit_warn' ){ EXIT_WARN } 
+      inheritable_fattr( 'parameters' ){ 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 }
+      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 @argv, @env
+      @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