ThiagoLelis-backgroundjob 1.0.3 → 1.0.4

data/init.rb

@@ -0,0 +1,33 @@
+dirname, basename = File.split(File.expand_path(__FILE__))
+libdir = File.join dirname, "lib"
+
+$LOAD_PATH.unshift libdir
+begin
+  require "bj"
+ensure
+  $LOAD_PATH.shift
+end
+
+
+
+=begin
+require "rubygems"
+
+dir = Gem.dir
+path = Gem.path
+
+dirname, basename = File.split(File.expand_path(__FILE__))
+gem_home = File.join dirname, "gem_home"
+gem_path = [gem_home] #, *path]
+
+Gem.send :use_paths, gem_home, gem_path
+
+begin
+  %w[ attributes systemu orderedhash bj ].each do |lib|
+    gem lib
+    require lib
+  end
+ensure
+  Gem.send :use_paths, dir, path 
+end
+=end

data/install.rb

@@ -1,210 +1,95 @@
-#!/usr/bin/env ruby
-require 'rbconfig'
-require 'find'
-require 'ftools'
-require 'tempfile'
-include Config
-
-LIBDIR      = "lib"
-LIBDIR_MODE = 0644
-
-BINDIR      = "bin"
-BINDIR_MODE = 0755
-
-
-$srcdir            = CONFIG["srcdir"]
-$version           = CONFIG["MAJOR"]+"."+CONFIG["MINOR"]
-$libdir            = File.join(CONFIG["libdir"], "ruby", $version)
-$archdir           = File.join($libdir, CONFIG["arch"])
-$site_libdir       = $:.find {|x| x =~ /site_ruby$/}
-$bindir            = CONFIG["bindir"] || CONFIG['BINDIR']
-$ruby_install_name = CONFIG['ruby_install_name'] || CONFIG['RUBY_INSTALL_NAME'] || 'ruby'
-$ruby_ext          = CONFIG['EXEEXT'] || ''
-$ruby              = File.join($bindir, ($ruby_install_name + $ruby_ext))
-
-if !$site_libdir
-  $site_libdir = File.join($libdir, "site_ruby")
-elsif $site_libdir !~ %r/#{Regexp.quote($version)}/
-  $site_libdir = File.join($site_libdir, $version)
-end
-
-def install_rb(srcdir=nil, destdir=nil, mode=nil, bin=nil)
-#{{{
-  path   = []
-  dir    = []
-  Find.find(srcdir) do |f|
-    next unless FileTest.file?(f)
-    next if (f = f[srcdir.length+1..-1]) == nil
-    next if (/CVS$/ =~ File.dirname(f))
-    next if f =~ %r/\.lnk/
-    path.push f
-    dir |= [File.dirname(f)]
-  end
-  for f in dir
-    next if f == "."
-    next if f == "CVS"
-    File::makedirs(File.join(destdir, f))
-  end
-  for f in path
-    next if (/\~$/ =~ f)
-    next if (/^\./ =~ File.basename(f))
-    unless bin
-      File::install(File.join(srcdir, f), File.join(destdir, f), mode, true)
-    else
-      from = File.join(srcdir, f)
-      to = File.join(destdir, f)
-      shebangify(from) do |sf|
-        $deferr.print from, " -> ", File::catname(from, to), "\n"
-        $deferr.printf "chmod %04o %s\n", mode, to 
-        File::install(sf, to, mode, false)
-      end
-    end
-  end
-#}}}
-end
-def shebangify f
-#{{{
-  open(f) do |fd|
-    buf = fd.read 42 
-    if buf =~ %r/^\s*#\s*!.*ruby/o
-      ftmp = Tempfile::new("#{ $$ }_#{ File::basename(f) }")
-      begin
-        fd.rewind
-        ftmp.puts "#!#{ $ruby  }"
-        while((buf = fd.read(8192)))
-          ftmp.write buf
-        end
-        ftmp.close
-        yield ftmp.path
-      ensure
-        ftmp.close!
-      end
-    else
-      yield f
-    end
-  end
-#}}}
-end
-def ARGV.switch
-#{{{
-  return nil if self.empty?
-  arg = self.shift
-  return nil if arg == '--'
-  if arg =~ /^-(.)(.*)/
-    return arg if $1 == '-'
-    raise 'unknown switch "-"' if $2.index('-')
-    self.unshift "-#{$2}" if $2.size > 0
-    "-#{$1}"
-  else
-    self.unshift arg
-    nil
-  end
-#}}}
-end
-def ARGV.req_arg
-#{{{
-  self.shift || raise('missing argument')
-#}}}
-end
-def linkify d, linked = []
-#--{{{
-  if test ?d, d
-    versioned = Dir[ File::join(d, "*-[0-9].[0-9].[0-9].rb") ]
-    versioned.each do |v| 
-      src, dst = v, v.gsub(%r/\-[\d\.]+\.rb$/, '.rb')
-      lnk = nil
-      begin
-        if test ?l, dst
-          lnk = "#{ dst }.lnk"
-          puts "#{ dst } -> #{ lnk }"
-          File::rename dst, lnk
-        end
-        unless test ?e, dst
-          puts "#{ src } -> #{ dst }"
-          File::copy src, dst 
-          linked << dst
-        end
-      ensure
-        if lnk
-          at_exit do
-            puts "#{ lnk } -> #{ dst }"
-            File::rename lnk, dst
-          end
-        end
-      end
-    end
+#! /usr/bin/env ruby
+
+dirname, basename = File.split File.expand_path(__FILE__)
+
+libidr = 'lib'
+bindir = 'bin'
+gem_home = 'gem_home'
+
+rails_root = File.expand_path File.join(dirname, '../../../')
+bj = File.join rails_root, 'script', 'bj'
+
+gems = %w[ attributes arrayfields main systemu orderedhash bj ]
+
+# in the plugin dir... 
+Dir.chdir dirname do
+  puts "in #{ dirname }..."
+
+  # install gems locally
+  puts "installing #{ gems.join ' ' }..."
+  spawn "gem install #{ gems.join ' ' } --install-dir=#{ gem_home } --remote --force --include-dependencies --no-wrappers"
+  puts "."
+
+=begin
+=end
+  # copy libs over to libdir
+  glob = File.join gem_home, "gems/*/lib/*"
+  entries = Dir.glob glob
+  entries.each do |entry|
+    next if entry =~ %r/-\d+\.\d+\.\d+\.rb$/
+    src, dst = entry, libidr
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst 
+    puts "."
   end
-  linked
-#--}}}
-end
 
+  # copy bins over to bindir 
+  glob = File.join gem_home, "gems/*/bin/*"
+  entries = Dir.glob glob
+  entries.each do |entry|
+    next if entry =~ %r/-\d+\.\d+\.\d+\.rb$/
+    src, dst = entry, bindir
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst 
+    puts "."
+  end
 
-#
-# main program
-#
-
-libdir = $site_libdir
-bindir = $bindir
-no_linkify = false
-linked = nil
-help = false
-
-usage = <<-usage
-  #{ File::basename $0 }
-    -d, --destdir    <destdir>
-    -l, --libdir     <libdir>
-    -b, --bindir     <bindir>
-    -r, --ruby       <ruby>
-    -n, --no_linkify
-    -s, --sudo
-    -h, --help
-usage
-
-begin
-  while switch = ARGV.switch
-    case switch
-    when '-d', '--destdir'
-      libdir = ARGV.req_arg
-    when '-l', '--libdir'
-      libdir = ARGV.req_arg
-    when '-b', '--bindir'
-      bindir = ARGV.req_arg
-    when '-r', '--ruby'
-      $ruby = ARGV.req_arg
-    when '-n', '--no_linkify'
-      no_linkify = true
-    when '-s', '--sudo'
-      sudo = 'sudo' 
-    when '-h', '--help'
-      help = true
-    else
-      raise "unknown switch #{switch.dump}"
-    end
+=begin
+  # copy gem_home/bj-x.x.x/bin/bj to rails_root/script/bj
+  glob = File.join gem_home, "gems/bj-*/bin/*"
+  srcs = Dir.glob glob
+  srcs.each do |src|
+    basename = File.basename src
+    dst = File.join rails_root, 'script', basename 
+    puts "#{ src } -->> #{ dst }..."
+    FileUtils.cp_r src, dst
+    File.chmod 0755, dst
+    puts "."
   end
-rescue
-  STDERR.puts $!.to_s
-  STDERR.puts usage
-  exit 1
-end    
-
-if help
-  STDOUT.puts usage
-  exit
+=end
+
+  # install bin/bj to script/bj
+  src, dst = File.join(bindir, "bj"), File.join(rails_root, "script", "bj") 
+  puts "#{ src } -->> #{ dst }..."
+  FileUtils.cp src, dst
+  File.chmod 0755, dst
+  puts "."
+
+  # kill all the local gems
+  FileUtils.rm_rf gem_home
+
+  # dump help
+  puts("=" * 79)
+  ruby = which_ruby
+  system "#{ ruby } #{ bj.inspect } '--help'"
 end
 
-system "#{ sudo } #{ $ruby } pre-install.rb" if test(?s, 'pre-install.rb')
 
-unless no_linkify
-  linked = linkify('lib') + linkify('bin')
-end
 
-system "#{ $ruby } extconf.rb && make && #{ sudo } make install" if test(?s, 'extconf.rb')
+BEGIN {
+  require 'fileutils'
+  require 'rbconfig'
 
-install_rb(LIBDIR, libdir, LIBDIR_MODE)
-install_rb(BINDIR, bindir, BINDIR_MODE, bin=true)
-
-if linked
-  linked.each{|path| File::rm_f path}
-end
+  def spawn command
+    oe = `#{ command } 2>&1`
+    raise "command <#{ command }> failed with <#{ $?.inspect }>" unless $?.exitstatus == 0
+    oe
+  end
 
-system "#{ sudo } #{ $ruby } post-install.rb" if test(?s, 'post-install.rb')
+  def which_ruby
+    c = ::Config::CONFIG
+    ruby = File::join(c['bindir'], c['ruby_install_name']) << c['EXEEXT']
+    raise "ruby @ #{ ruby } not executable!?" unless test(?e, ruby)
+    ruby
+  end
+}

data/lib/arrayfields.rb

@@ -0,0 +1,435 @@
+#
+# The ArrayFields module implements methods which allow an Array to be indexed
+# by String or Symbol. It is not required to manually use this module to
+# extend Arrays - they are auto-extended on a per-object basis when
+# Array#fields= is called
+#
+  module ArrayFields 
+    self::VERSION = '4.6.0' unless defined? self::VERSION
+    def self.version() VERSION end
+  #
+  # multiton cache of fields - wraps fields and fieldpos map to save memory
+  #
+    class FieldSet
+      class << self
+        def new fields
+          @sets[fields] ||= super
+        end
+        def init_sets
+          @sets = {}
+        end
+      end
+
+      init_sets
+
+      attr :fields
+      attr :fieldpos
+      def initialize fields
+        raise ArgumentError, "<#{ fields.inspect }> not inject-able" unless
+          fields.respond_to? :inject
+
+        @fieldpos =
+          fields.inject({}) do |h, f|
+            unless String === f or Symbol === f
+              raise ArgumentError, "<#{ f.inspect }> neither String nor Symbol"
+            end
+            h[f] = h.size
+            h
+          end
+
+        @fields = fields
+      end
+      def pos f
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        f = f.to_s
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        f = f.intern
+        return @fieldpos[f] if @fieldpos.has_key? f 
+        nil
+      end
+    end
+  #
+  # methods redefined to work with fields as well as numeric indexes
+  #
+    def [] idx, *args
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super(pos, *args)
+      else
+        super
+      end
+    end
+    def slice idx, *args
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super(pos, *args)
+      else
+        super
+      end
+    end
+
+    def []=(idx, *args) 
+      if @fieldset and (String === idx or Symbol === idx) 
+        pos = @fieldset.pos idx
+        unless pos
+          @fieldset.fields << idx
+          @fieldset.fieldpos[idx] = pos = size
+        end
+        super(pos, *args)
+      else
+        super
+      end
+    end
+    def at idx
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super pos
+      else
+        super
+      end
+    end
+    def delete_at idx
+      if @fieldset and (String === idx or Symbol === idx)
+        pos = @fieldset.pos idx
+        return nil unless pos
+        super pos
+      else
+        super
+      end
+    end
+    def fill(obj, *args)
+      idx = args.first
+      if idx and @fieldset and (String === idx or Symbol === idx)
+        idx = args.shift
+        pos = @fieldset.pos idx
+        super(obj, pos, *args)
+      else
+        super
+      end
+    end
+
+    def values_at(*idxs)
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+    end
+    def indices(*idxs)
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+    end
+    def indexes(*idxs)
+      idxs.flatten!
+      if @fieldset
+        idxs.map!{|i| (String === i or Symbol === i) ? @fieldset.pos(i) : i}
+      end
+      super(*idxs)
+    end
+
+    def slice!(*args)
+      ret = self[*args]
+      self[*args] = nil
+      ret
+    end
+    def each_with_field
+      each_with_index do |elem, i|
+        yield elem, @fieldset.fields[i]
+      end
+    end
+  #
+  # methods which give a hash-like interface 
+  #
+    def each_pair
+      each_with_index do |elem, i|
+        yield @fieldset.fields[i], elem
+      end
+    end
+    def each_key
+      @fieldset.each{|field| yield field}
+    end
+    def each_value *args, &block
+      each *args, &block
+    end
+    def fetch key
+      self[key] or raise IndexError, 'key not found'
+    end
+
+    def has_key? key
+      @fieldset.fields.include? key
+    end
+    def member? key
+      @fieldset.fields.include? key
+    end
+    def key? key
+      @fieldset.fields.include? key
+    end
+
+    def has_value? value
+      if respond_to? 'include?'
+        self.include? value
+      else
+        a = []
+        each{|val| a << val}
+        a.include? value
+      end
+    end
+    def value? value
+      if respond_to? 'include?'
+        self.include? value
+      else
+        a = []
+        each{|val| a << val}
+        a.include? value
+      end
+    end
+
+    def keys
+      fields
+    end
+    def store key, value
+      self[key] = value
+    end
+    def values
+      if respond_to? 'to_ary'
+        self.to_ary
+      else
+        a = []
+        each{|val| a << val}
+        a
+      end
+    end
+
+    def to_hash
+      if respond_to? 'to_ary'
+        h = {}
+        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
+        h
+      else
+        a = []
+        each{|val| a << val}
+        h = {}
+        @fieldset.fields.zip(a){|f,e| h[f] = e}
+        h
+      end
+    end
+    def to_h
+      if respond_to? 'to_ary'
+        h = {}
+        @fieldset.fields.zip(to_ary){|f,e| h[f] = e}
+        h
+      else
+        a = []
+        each{|val| a << val}
+        h = {}
+        @fieldset.fields.zip(a){|f,e| h[f] = e}
+        h
+      end
+    end
+
+    def update other
+      other.each{|k,v| self[k] = v}
+      to_hash
+    end
+    def replace other
+      Hash === other ? update(other) : super
+    end
+    def invert
+      to_hash.invert
+    end
+
+    def to_pairs
+      fields.zip values
+    end
+    alias_method 'pairs', 'to_pairs'
+
+    def copy 
+      cp = clone
+      cp.fields = fields.clone
+      cp 
+    end
+
+    alias_method 'dup', 'copy'
+    alias_method 'clone', 'copy'
+
+    def deepcopy 
+      cp = Marshal.load(Marshal.dump(self))
+      cp.fields = Marshal.load(Marshal.dump(self.fields))
+      cp 
+    end
+  end
+  Arrayfields = ArrayFields
+
+  module Arrayfields
+    def self.new *pairs
+      pairs = pairs.map{|pair| Enumerable === pair ? pair.to_a : pair}.flatten
+      raise ArgumentError, "pairs must be evenly sized" unless(pairs.size % 2 == 0)
+      (( array = [] )).fields = []
+      0.step(pairs.size - 2, 2) do |a|
+        b = a + 1
+        array[ pairs[a] ] = pairs[b]
+      end
+      array
+    end
+    def self.[] *pairs
+      new *pairs
+    end
+  end
+  def Arrayfields(*a, &b) Arrayfields.new(*a, &b) end
+#
+# Fieldable encapsulates methods in common for classes which may have their
+# fields set and subsequently be auto-extended by ArrayFields
+#
+  module Fieldable
+  #
+  # sets fields an dynamically extends this Array instance with methods for
+  # keyword access
+  #
+    def fields= fields
+      extend ArrayFields unless ArrayFields === self
+
+      @fieldset = 
+        if ArrayFields::FieldSet === fields
+          fields
+        else
+          ArrayFields::FieldSet.new fields
+        end
+    end
+  #
+  # access to fieldset
+  #
+    attr_reader :fieldset
+  #
+  # access to field list
+  #
+    def fields *values
+      return(send('fields=', *values)) unless values.empty?
+      @fieldset and @fieldset.fields
+    end
+  end
+#
+# Array instances are extened with two methods only: Fieldable#fields= and
+# Fieldable#fields.  only when Fieldable#fields= is called will the full set
+# of ArrayFields methods auto-extend the Array instance.  the Array class also
+# has added a class generator when the fields are known apriori.
+#
+  class Array
+    include Fieldable
+
+    class << self
+      def struct *fields
+        fields = fields.flatten
+        Class.new(self) do
+          include ArrayFields
+          const_set :FIELDS, ArrayFields::FieldSet.new(fields)
+          fields.each do |field|
+            field = field.to_s
+            if field =~ %r/^[a-zA-Z_][a-zA-Z0-9_]*$/
+              begin
+                module_eval <<-code
+                  def #{ field } *a
+                    a.size == 0 ? self['#{ field }'] : (self.#{ field } = a.shift) 
+                  end
+                  def #{ field }= value
+                    self['#{ field }'] = value
+                  end
+                code
+              rescue SyntaxError
+                :by_ignoring_it
+              end
+            end
+          end
+          def initialize *a, &b
+            super
+          ensure
+            @fieldset = self.class.const_get :FIELDS
+          end
+          def self.[] *elements
+            array = new
+            array.replace elements
+            array
+          end
+        end
+      end
+      def fields *fields, &block
+        (( array = new(&block) )).fields = fields.map{|x| Enumerable === x ? x.to_a : x}.flatten
+        array
+      end
+    end
+  end
+#
+# proxy class that allows an array to be wrapped in a way that still allows #
+# keyword access.  also facilitate usage of ArrayFields with arraylike objects.
+# thnx to Sean O'Dell for the suggestion.
+#
+# sample usage
+#
+# fa = FieldedArray.new %w(zero one two), [0,1,2]
+# p fa['zero']   #=> 0
+#
+#
+  class FieldedArray
+    include Fieldable
+    class << self
+      def [](*pairs)
+        pairs.flatten!
+        raise ArgumentError, "argument must be key/val pairs" unless 
+          (pairs.size % 2 == 0)
+        fields, elements = [], []
+        while((f = pairs.shift) and (e = pairs.shift)) 
+          fields << f and elements << e
+        end
+        new fields, elements
+      end
+    end
+    def initialize fields = [], array = []
+      @a = array
+      self.fields = fields
+    end
+    def method_missing(meth, *args, &block)
+      @a.send(meth, *args, &block)
+    end
+    delegates =
+      %w(
+        to_s
+        to_str
+        inspect
+      )
+    delegates.each do |meth| 
+      class_eval "def #{ meth }(*a,&b); @a.#{ meth }(*a,&b);end"
+    end
+  end
+  Fieldedarray = FieldedArray
+
+  class PseudoHash < ::Array
+    class << self
+      def [](*pairs)
+        pairs.flatten!
+        raise ArgumentError, "argument must be key/val pairs" unless 
+          (pairs.size % 2 == 0 and pairs.size >= 2)
+        keys, values = [], []
+        while((k = pairs.shift) and (v = pairs.shift)) 
+          keys << k and values << v
+        end
+        new keys, values
+      end
+    end
+    def initialize keys = [], values = []
+      self.fields = keys
+      self.replace values
+    end
+    def to_yaml opts = {}
+      YAML::quick_emit object_id, opts do |out|
+        out.map taguri, to_yaml_style do |map|
+          each_pair{|f,v| map.add f,v}
+        end
+      end
+   end 
+  end
+  Pseudohash = PseudoHash