ThiagoLelis-backgroundjob 1.0.3 → 1.0.4

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,211 @@
+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
+
+    def delete_at key
+      self[key] = nil
+    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/lib/orderedautohash.rb

@@ -0,0 +1,25 @@
+#
+# auto vivifying ordered hash that dumps as yaml nicely
+#
+require 'orderedhash' unless defined? OrderedHash
+
+class AutoOrderedHash < OrderedHash
+  def initialize(*args)
+    super(*args){|a,k| a[k] = __class__.new(*args)}
+  end
+  def class # for nice yaml
+    Hash
+  end
+  def __class__
+    AutoOrderedHash
+  end
+end # class AutoOrderedHash
+
+OrderedAutoHash = AutoOrderedHash
+
+def OrderedAutoHash(*a, &b)
+  OrderedAutoHash.new(*a, &b)
+end
+def AutoOrderedHash(*a, &b)
+  AutoOrderedHash.new(*a, &b)
+end

data/lib/orderedhash.rb

@@ -0,0 +1,189 @@
+
+# AUTHOR
+#    jan molic /mig/at/1984/dot/cz/
+#
+# DESCRIPTION
+#    Hash with preserved order and some array-like extensions
+#    Public domain. 
+#
+# THANKS
+#    Andrew Johnson for his suggestions and fixes of Hash[],
+#    merge, to_a, inspect and shift
+class OrderedHash < ::Hash
+    attr_accessor :order
+
+    class << self
+        def [] *args
+          hsh = OrderedHash.new
+          if Hash === args[0]
+            hsh.replace args[0]
+          elsif (args.size % 2) != 0
+            raise ArgumentError, "odd number of elements for Hash"
+          else
+            0.step(args.size - 1, 2) do |a|
+              b = a + 1
+              hsh[args[a]] = args[b]
+            end
+          end
+          hsh
+        end
+    end
+    def initialize(*a, &b)
+      super
+      @order = []
+    end
+    def store_only a,b
+        store a,b
+    end
+    alias orig_store store    
+    def store a,b
+        @order.push a unless has_key? a
+        super a,b
+    end
+    alias []= store
+    def == hsh2
+        return false if @order != hsh2.order
+        super hsh2
+    end
+    def clear
+        @order = []
+        super
+    end
+    def delete key
+        @order.delete key
+        super
+    end
+    def each_key
+        @order.each { |k| yield k }
+        self
+    end
+    def each_value
+        @order.each { |k| yield self[k] }
+        self
+    end
+    def each
+        @order.each { |k| yield k,self[k] }
+        self
+    end
+    alias each_pair each    
+    def delete_if
+        @order.clone.each { |k| 
+            delete k if yield(k)
+        }
+        self
+    end
+    def values
+        ary = []
+        @order.each { |k| ary.push self[k] }
+        ary
+    end
+    def keys
+        @order
+    end
+    def invert
+        hsh2 = Hash.new    
+        @order.each { |k| hsh2[self[k]] = k }
+        hsh2
+    end
+    def reject &block
+        self.dup.delete_if &block
+    end
+    def reject! &block
+        hsh2 = reject &block
+        self == hsh2 ? nil : hsh2
+    end
+    def replace hsh2
+        @order = hsh2.keys 
+        super hsh2
+    end
+    def shift
+        key = @order.first
+        key ? [key,delete(key)] : super
+    end
+    def unshift k,v
+        unless self.include? k
+            @order.unshift k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    def push k,v
+        unless self.include? k
+            @order.push k
+            orig_store(k,v)
+            true
+        else
+            false
+        end
+    end
+    def pop
+        key = @order.last
+        key ? [key,delete(key)] : nil
+    end
+    def to_a
+        ary = []
+        each { |k,v| ary << [k,v] }
+        ary
+    end
+    def to_s
+        self.to_a.to_s
+    end
+    def inspect
+        ary = []
+        each {|k,v| ary << k.inspect + "=>" + v.inspect}
+        '{' + ary.join(", ") + '}'
+    end
+    def update hsh2
+        hsh2.each { |k,v| self[k] = v }
+        self
+    end
+    alias :merge! update
+    def merge hsh2
+        self.dup update(hsh2)
+    end
+    def select
+        ary = []
+        each { |k,v| ary << [k,v] if yield k,v }
+        ary
+    end
+    def class
+      Hash
+    end
+    def __class__
+      OrderedHash
+    end
+
+    attr_accessor "to_yaml_style"
+    def yaml_inline= bool
+      if respond_to?("to_yaml_style")
+        self.to_yaml_style = :inline
+      else
+        unless defined? @__yaml_inline_meth
+          @__yaml_inline_meth =
+            lambda {|opts|
+              YAML::quick_emit(object_id, opts) {|emitter|
+                emitter << '{ ' << map{|kv| kv.join ': '}.join(', ') << ' }'
+              }
+            }
+          class << self
+            def to_yaml opts = {}
+              begin
+                @__yaml_inline ? @__yaml_inline_meth[ opts ] : super
+              rescue
+                @to_yaml_style = :inline
+                super
+              end
+            end
+          end
+        end
+      end
+      @__yaml_inline = bool
+    end
+    def yaml_inline!() self.yaml_inline = true end
+end # class OrderedHash
+
+def OrderedHash(*a, &b)
+  OrderedHash.new(*a, &b)
+end