ThiagoLelis-backgroundjob 1.0.4 → 1.0.5

data/lib/bj/util.rb

@@ -1,115 +1,115 @@
-class Bj
-  module Util
-    module ModuleMethods
-      def constant_get const, &block
-        begin
-          ancestors = const.split(%r/::/)
-          parent = Object
-          while((child = ancestors.shift))
-            klass = parent.const_get child
-            parent = klass
-          end
-          klass
-        rescue
-          block ? block.call : raise
-        end
-      end
-
-      def const_or_env const, &block
-        constant_get(const){ ENV[const] || block.call }
-      end
-
-      def spawn cmd, options = {}
-        options.to_options!
-        logger = options.has_key?(:logger) ? options[:logger] : Bj.logger
-        logger.info{ "cmd <#{ cmd }>" } if logger
-        status = systemu cmd, 1=>(stdout=""), 2=>(stderr="")
-        logger.info{ "status <#{ status.exitstatus }>" } if logger
-        status.exitstatus.zero? or raise "#{ cmd.inspect } failed with #{ $?.inspect }"
-        [ stdout, stderr ]
-      end
-
-      def start *a 
-        q = Queue.new
-        thread = Thread.new do
-          Thread.current.abort_on_exception = true
-          systemu(*a){|pid| q << pid}
-        end
-        pid = q.pop
-        thread.singleton_class{ define_method(:pid){ pid } }
-        thread
-      end
-
-      def alive pid
-        return false unless pid 
-        pid = Integer pid.to_s 
-        Process::kill 0, pid
-        true
-      rescue Errno::ESRCH, Errno::EPERM
-        false
-      end
-      alias_method "alive?", "alive"
-
-      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
-
-      def which_rake 
-        tmp = Tempfile.new Process.pid
-        tmp.write "task(:foobar){ puts 42 }"
-        tmp.close
-        bat = spawn("rake.bat -f #{ tmp.path.inspect } foobar", :logger => false) rescue false
-        bat ? "rake.bat" : "rake"
-      ensure
-        tmp.close! rescue nil
-      end
-
-      def ipc_signals_supported
-        @ipc_signals_supported ||=
-          IO.popen 'ruby', 'r+' do |ruby|
-            pid = ruby.pid
-            begin
-              Process.kill 'TERM', pid
-              true
-            rescue Exception
-              false
-            end
-          end
-      end
-      alias_method "ipc_signals_supported?", "ipc_signals_supported"
-
-      def find_script basename
-        path = ENV["PATH"] || ENV["path"] || Bj.default_path
-        raise "no env PATH" unless path
-        path = path.split File::PATH_SEPARATOR
-        path.unshift File.join(Bj.rails_root, "script")
-        path.each do |directory|
-          script = File.join directory, basename
-          return File.expand_path(script) if(test(?s, script) and test(?r, script))
-        end
-        raise "no #{ basename } found in #{ path.inspect }"
-      end
-
-      def valid_rails_root root = ".", expected = %w[ config script app ]
-        directories = expected.flatten.compact.map{|dir| dir.to_s}
-        directories.all?{|dir| test(?d, File.join(root, dir))}
-      end
-      alias_method "valid_rails_root?", "valid_rails_root"
-
-      def emsg e
-        m = e.message rescue ""
-        c = e.class rescue Exception
-        b = e.backtrace.join("\n") rescue ""
-        "#{ m }(#{ c })\n#{ b }"
-      end
-
-      def now
-        Bj.config["utc"] ? Time.now.utc : Time.now
-      end
-    end
-    send :extend, ModuleMethods
-  end
-end
+class Bj
+  module Util
+    module ModuleMethods
+      def constant_get const, &block
+        begin
+          ancestors = const.split(%r/::/)
+          parent = Object
+          while((child = ancestors.shift))
+            klass = parent.const_get child
+            parent = klass
+          end
+          klass
+        rescue
+          block ? block.call : raise
+        end
+      end
+
+      def const_or_env const, &block
+        constant_get(const){ ENV[const] || block.call }
+      end
+
+      def spawn cmd, options = {}
+        options.to_options!
+        logger = options.has_key?(:logger) ? options[:logger] : Bj.logger
+        logger.info{ "cmd <#{ cmd }>" } if logger
+        status = systemu cmd, 1=>(stdout=""), 2=>(stderr="")
+        logger.info{ "status <#{ status.exitstatus }>" } if logger
+        status.exitstatus.zero? or raise "#{ cmd.inspect } failed with #{ $?.inspect }"
+        [ stdout, stderr ]
+      end
+
+      def start *a 
+        q = Queue.new
+        thread = Thread.new do
+          Thread.current.abort_on_exception = true
+          systemu(*a){|pid| q << pid}
+        end
+        pid = q.pop
+        thread.singleton_class{ define_method(:pid){ pid } }
+        thread
+      end
+
+      def alive pid
+        return false unless pid 
+        pid = Integer pid.to_s 
+        Process::kill 0, pid
+        true
+      rescue Errno::ESRCH, Errno::EPERM
+        false
+      end
+      alias_method "alive?", "alive"
+
+      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
+
+      def which_rake 
+        tmp = Tempfile.new Process.pid
+        tmp.write "task(:foobar){ puts 42 }"
+        tmp.close
+        bat = spawn("rake.bat -f #{ tmp.path.inspect } foobar", :logger => false) rescue false
+        bat ? "rake.bat" : "rake"
+      ensure
+        tmp.close! rescue nil
+      end
+
+      def ipc_signals_supported
+        @ipc_signals_supported ||=
+          IO.popen 'ruby', 'r+' do |ruby|
+            pid = ruby.pid
+            begin
+              Process.kill 'TERM', pid
+              true
+            rescue Exception
+              false
+            end
+          end
+      end
+      alias_method "ipc_signals_supported?", "ipc_signals_supported"
+
+      def find_script basename
+        path = ENV["PATH"] || ENV["path"] || Bj.default_path
+        raise "no env PATH" unless path
+        path = path.split File::PATH_SEPARATOR
+        path.unshift File.join(Bj.rails_root, "script")
+        path.each do |directory|
+          script = File.join directory, basename
+          return File.expand_path(script) if(test(?s, script) and test(?r, script))
+        end
+        raise "no #{ basename } found in #{ path.inspect }"
+      end
+
+      def valid_rails_root root = ".", expected = %w[ config script app ]
+        directories = expected.flatten.compact.map{|dir| dir.to_s}
+        directories.all?{|dir| test(?d, File.join(root, dir))}
+      end
+      alias_method "valid_rails_root?", "valid_rails_root"
+
+      def emsg e
+        m = e.message rescue ""
+        c = e.class rescue Exception
+        b = e.backtrace.join("\n") rescue ""
+        "#{ m }(#{ c })\n#{ b }"
+      end
+
+      def now
+        Bj.config["utc"] ? Time.now.utc : Time.now
+      end
+    end
+    send :extend, ModuleMethods
+  end
+end

data/lib/fattr.rb

@@ -1,153 +1,153 @@
-module Fattr
-  Fattr::VERSION = '1.0.3' unless Fattr.const_defined?(:VERSION)
-  def self.version() Fattr::VERSION end
-
-  class List < ::Array
-    def << element
-      super
-      self
-    ensure
-      uniq!
-      index!
-    end
-
-    def index!
-      @index ||= Hash.new
-      each{|element| @index[element] = true}
-    end
-
-    def include? element
-      @index ||= Hash.new
-      @index[element] ? true : false
-    end
-
-    def initializers
-      @initializers ||= Hash.new
-    end
-  end
-
-  def fattrs *a, &b
-    unless a.empty?
-      returned = Hash.new
-
-      hashes, names = a.partition{|x| Hash === x}
-      names_and_defaults = {}
-      hashes.each{|h| names_and_defaults.update h}
-      names.flatten.compact.each{|name| names_and_defaults.update name => nil}
-
-      initializers = __fattrs__.initializers
-
-      names_and_defaults.each do |name, default|
-        raise NameError, "bad instance variable name '@#{ name }'" if "@#{ name }" =~ %r/[!?=]$/o
-        name = name.to_s
-
-        initialize = b || lambda { default }
-        initializer = lambda do |this|
-          Object.instance_method('instance_eval').bind(this).call &initialize
-        end
-        initializer_id = initializer.object_id
-        __fattrs__.initializers[name] = initializer
-
-        compile = lambda do |code|
-          begin
-            module_eval code
-          rescue SyntaxError
-            raise SyntaxError, "\n#{ code }\n"
-          end
-        end
-
-      # setter, block invocation caches block
-        code = <<-code
-          def #{ name }=(*value, &block)
-            value.unshift block if block
-            @#{ name } = value.first
-          end
-        code
-        compile[code]
-
-      # getter, providing a value or block causes it to acts as setter
-        code = <<-code
-          def #{ name }(*value, &block)
-            value.unshift block if block
-            return self.send('#{ name }=', value.first) unless value.empty?
-            #{ name }! unless defined? @#{ name }
-            @#{ name }
-          end
-        code
-        compile[code]
-
-      # bang method re-calls any initializer given at declaration time
-        code = <<-code
-          def #{ name }!
-            initializer = ObjectSpace._id2ref #{ initializer_id }
-            self.#{ name } = initializer.call(self)
-            @#{ name }
-          end
-        code
-        compile[code]
-
-      # query simply defers to getter - cast to bool
-        code = <<-code
-          def #{ name }?
-            self.#{ name }
-          end
-        code
-        compile[code]
-
-        fattrs << name
-        returned[name] = initializer 
-      end
-
-      returned
-    else
-      begin
-        __fattr_list__
-      rescue NameError
-        singleton_class =
-          class << self
-            self
-          end
-        klass = self
-        singleton_class.module_eval do
-          fattr_list = List.new 
-          define_method('fattr_list'){ klass == self ? fattr_list : raise(NameError) }
-          alias_method '__fattr_list__', 'fattr_list'
-        end
-        __fattr_list__
-      end
-    end
-  end
-
-  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method dst, 'fattrs'}
-end
-
-class Module
-  include Fattr
-
-  def Fattrs(*a, &b)
-    class << self
-      self
-    end.module_eval do
-      fattrs(*a, &b)
-    end
-  end
-
-  def Fattr(*a, &b)
-    class << self
-      self
-    end.module_eval do
-      fattr(*a, &b)
-    end
-  end
-end
-
-class Object
-  def fattrs *a, &b
-    sc = 
-      class << self
-        self
-      end
-    sc.fattrs *a, &b
-  end
-  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method dst, 'fattrs'}
-end
+module Fattr
+  Fattr::VERSION = '1.0.3' unless Fattr.const_defined?(:VERSION)
+  def self.version() Fattr::VERSION end
+
+  class List < ::Array
+    def << element
+      super
+      self
+    ensure
+      uniq!
+      index!
+    end
+
+    def index!
+      @index ||= Hash.new
+      each{|element| @index[element] = true}
+    end
+
+    def include? element
+      @index ||= Hash.new
+      @index[element] ? true : false
+    end
+
+    def initializers
+      @initializers ||= Hash.new
+    end
+  end
+
+  def fattrs *a, &b
+    unless a.empty?
+      returned = Hash.new
+
+      hashes, names = a.partition{|x| Hash === x}
+      names_and_defaults = {}
+      hashes.each{|h| names_and_defaults.update h}
+      names.flatten.compact.each{|name| names_and_defaults.update name => nil}
+
+      initializers = __fattrs__.initializers
+
+      names_and_defaults.each do |name, default|
+        raise NameError, "bad instance variable name '@#{ name }'" if "@#{ name }" =~ %r/[!?=]$/o
+        name = name.to_s
+
+        initialize = b || lambda { default }
+        initializer = lambda do |this|
+          Object.instance_method('instance_eval').bind(this).call &initialize
+        end
+        initializer_id = initializer.object_id
+        __fattrs__.initializers[name] = initializer
+
+        compile = lambda do |code|
+          begin
+            module_eval code
+          rescue SyntaxError
+            raise SyntaxError, "\n#{ code }\n"
+          end
+        end
+
+      # setter, block invocation caches block
+        code = <<-code
+          def #{ name }=(*value, &block)
+            value.unshift block if block
+            @#{ name } = value.first
+          end
+        code
+        compile[code]
+
+      # getter, providing a value or block causes it to acts as setter
+        code = <<-code
+          def #{ name }(*value, &block)
+            value.unshift block if block
+            return self.send('#{ name }=', value.first) unless value.empty?
+            #{ name }! unless defined? @#{ name }
+            @#{ name }
+          end
+        code
+        compile[code]
+
+      # bang method re-calls any initializer given at declaration time
+        code = <<-code
+          def #{ name }!
+            initializer = ObjectSpace._id2ref #{ initializer_id }
+            self.#{ name } = initializer.call(self)
+            @#{ name }
+          end
+        code
+        compile[code]
+
+      # query simply defers to getter - cast to bool
+        code = <<-code
+          def #{ name }?
+            self.#{ name }
+          end
+        code
+        compile[code]
+
+        fattrs << name
+        returned[name] = initializer 
+      end
+
+      returned
+    else
+      begin
+        __fattr_list__
+      rescue NameError
+        singleton_class =
+          class << self
+            self
+          end
+        klass = self
+        singleton_class.module_eval do
+          fattr_list = List.new 
+          define_method('fattr_list'){ klass == self ? fattr_list : raise(NameError) }
+          alias_method '__fattr_list__', 'fattr_list'
+        end
+        __fattr_list__
+      end
+    end
+  end
+
+  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method dst, 'fattrs'}
+end
+
+class Module
+  include Fattr
+
+  def Fattrs(*a, &b)
+    class << self
+      self
+    end.module_eval do
+      fattrs(*a, &b)
+    end
+  end
+
+  def Fattr(*a, &b)
+    class << self
+      self
+    end.module_eval do
+      fattr(*a, &b)
+    end
+  end
+end
+
+class Object
+  def fattrs *a, &b
+    sc = 
+      class << self
+        self
+      end
+    sc.fattrs *a, &b
+  end
+  %w( __fattrs__ __fattr__ fattr ).each{|dst| alias_method dst, 'fattrs'}
+end