emipair-delayed_job 2.0.3.1

data/lib/passive_support/core_ext/module/attr_accessor_with_default.rb

@@ -0,0 +1,31 @@
+class Module
+  # Declare an attribute accessor with an initial default return value.
+  #
+  # To give attribute <tt>:age</tt> the initial value <tt>25</tt>:
+  #  
+  #   class Person
+  #     attr_accessor_with_default :age, 25
+  #   end
+  #
+  #   some_person.age
+  #   => 25
+  #   some_person.age = 26
+  #   some_person.age
+  #   => 26
+  #
+  # To give attribute <tt>:element_name</tt> a dynamic default value, evaluated
+  # in scope of self:
+  #
+  #   attr_accessor_with_default(:element_name) { name.underscore } 
+  #
+  def attr_accessor_with_default(sym, default = nil, &block)
+    raise 'Default value or block required' unless !default.nil? || block
+    define_method(sym, block_given? ? block : Proc.new { default })
+    module_eval(<<-EVAL, __FILE__, __LINE__ + 1)
+      def #{sym}=(value)                        # def age=(value)
+        class << self; attr_reader :#{sym} end  #   class << self; attr_reader :age end
+        @#{sym} = value                         #   @age = value
+      end                                       # end
+    EVAL
+  end
+end

data/lib/passive_support/core_ext/module/attr_internal.rb

@@ -0,0 +1,32 @@
+class Module
+  # Declares an attribute reader backed by an internally-named instance variable.
+  def attr_internal_reader(*attrs)
+    attrs.each do |attr|
+      module_eval "def #{attr}() #{attr_internal_ivar_name(attr)} end"
+    end
+  end
+
+  # Declares an attribute writer backed by an internally-named instance variable.
+  def attr_internal_writer(*attrs)
+    attrs.each do |attr|
+      module_eval "def #{attr}=(v) #{attr_internal_ivar_name(attr)} = v end"
+    end
+  end
+
+  # Declares an attribute reader and writer backed by an internally-named instance
+  # variable.
+  def attr_internal_accessor(*attrs)
+    attr_internal_reader(*attrs)
+    attr_internal_writer(*attrs)
+  end
+
+  alias_method :attr_internal, :attr_internal_accessor
+
+  private
+    mattr_accessor :attr_internal_naming_format
+    self.attr_internal_naming_format = '@_%s'
+
+    def attr_internal_ivar_name(attr)
+      attr_internal_naming_format % attr
+    end
+end

data/lib/passive_support/core_ext/module/delegation.rb

@@ -0,0 +1,135 @@
+class Module
+  # Provides a delegate class method to easily expose contained objects' methods
+  # as your own. Pass one or more methods (specified as symbols or strings)
+  # and the name of the target object as the final <tt>:to</tt> option (also a symbol
+  # or string).  At least one method and the <tt>:to</tt> option are required.
+  #
+  # Delegation is particularly useful with Active Record associations:
+  #
+  #   class Greeter < ActiveRecord::Base
+  #     def hello()   "hello"   end
+  #     def goodbye() "goodbye" end
+  #   end
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :to => :greeter
+  #   end
+  #
+  #   Foo.new.hello   # => "hello"
+  #   Foo.new.goodbye # => NoMethodError: undefined method `goodbye' for #<Foo:0x1af30c>
+  #
+  # Multiple delegates to the same target are allowed:
+  #
+  #   class Foo < ActiveRecord::Base
+  #     belongs_to :greeter
+  #     delegate :hello, :goodbye, :to => :greeter
+  #   end
+  #
+  #   Foo.new.goodbye # => "goodbye"
+  #
+  # Methods can be delegated to instance variables, class variables, or constants
+  # by providing them as a symbols:
+  #
+  #   class Foo
+  #     CONSTANT_ARRAY = [0,1,2,3]
+  #     @@class_array  = [4,5,6,7]
+  #     
+  #     def initialize
+  #       @instance_array = [8,9,10,11]
+  #     end
+  #     delegate :sum, :to => :CONSTANT_ARRAY
+  #     delegate :min, :to => :@@class_array
+  #     delegate :max, :to => :@instance_array
+  #   end
+  #
+  #   Foo.new.sum # => 6
+  #   Foo.new.min # => 4
+  #   Foo.new.max # => 11
+  #
+  # Delegates can optionally be prefixed using the <tt>:prefix</tt> option. If the value
+  # is <tt>true</tt>, the delegate methods are prefixed with the name of the object being
+  # delegated to.
+  #
+  #   Person = Struct.new(:name, :address)
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => true
+  #   end
+  #
+  #   john_doe = Person.new("John Doe", "Vimmersvej 13")
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.client_name    # => "John Doe"
+  #   invoice.client_address # => "Vimmersvej 13"
+  #
+  # It is also possible to supply a custom prefix.
+  #
+  #   class Invoice < Struct.new(:client)
+  #     delegate :name, :address, :to => :client, :prefix => :customer
+  #   end
+  #
+  #   invoice = Invoice.new(john_doe)
+  #   invoice.customer_name    # => "John Doe"
+  #   invoice.customer_address # => "Vimmersvej 13"
+  #
+  # If the object to which you delegate can be nil, you may want to use the
+  # :allow_nil option. In that case, it returns nil instead of raising a
+  # NoMethodError exception:
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar
+  #  end
+  #
+  #  Foo.new.zoo   # raises NoMethodError exception (you called nil.zoo)
+  #
+  #  class Foo
+  #    attr_accessor :bar
+  #    def initialize(bar = nil)
+  #      @bar = bar
+  #    end
+  #    delegate :zoo, :to => :bar, :allow_nil => true
+  #  end
+  #
+  #  Foo.new.zoo   # returns nil
+  #
+  def delegate(*methods)
+    options = methods.pop
+    unless options.is_a?(Hash) && to = options[:to]
+      raise ArgumentError, "Delegation needs a target. Supply an options hash with a :to key as the last argument (e.g. delegate :hello, :to => :greeter)."
+    end
+
+    if options[:prefix] == true && options[:to].to_s =~ /^[^a-z_]/
+      raise ArgumentError, "Can only automatically set the delegation prefix when delegating to a method."
+    end
+
+    prefix = options[:prefix] && "#{options[:prefix] == true ? to : options[:prefix]}_"
+
+    file, line = caller.first.split(':', 2)
+    line = line.to_i
+
+    methods.each do |method|
+      on_nil =
+        if options[:allow_nil]
+          'return'
+        else
+          %(raise "#{prefix}#{method} delegated to #{to}.#{method}, but #{to} is nil: \#{self.inspect}")
+        end
+
+      module_eval(<<-EOS, file, line)
+        def #{prefix}#{method}(*args, &block)               # def customer_name(*args, &block)
+          #{to}.__send__(#{method.inspect}, *args, &block)  #   client.__send__(:name, *args, &block)
+        rescue NoMethodError                                # rescue NoMethodError
+          if #{to}.nil?                                     #   if client.nil?
+            #{on_nil}
+          else                                              #   else
+            raise                                           #     raise
+          end                                               #   end
+        end                                                 # end
+      EOS
+    end
+  end
+end

data/lib/passive_support/core_ext/module/inclusion.rb

@@ -0,0 +1,30 @@
+class Module
+  # Returns the classes in the current ObjectSpace where this module has been
+  # mixed in according to Module#included_modules.
+  #
+  #   module M
+  #   end
+  #   
+  #   module N
+  #     include M
+  #   end
+  #   
+  #   class C
+  #     include M
+  #   end
+  #   
+  #   class D < C
+  #   end
+  #
+  #   p M.included_in_classes # => [C, D]
+  #
+  def included_in_classes
+    classes = []
+    ObjectSpace.each_object(Class) { |k| classes << k if k.included_modules.include?(self) }
+
+    classes.reverse.inject([]) do |unique_classes, klass| 
+      unique_classes << klass unless unique_classes.collect { |k| k.to_s }.include?(klass.to_s)
+      unique_classes
+    end
+  end
+end

data/lib/passive_support/core_ext/module/introspection.rb

@@ -0,0 +1,90 @@
+module PassiveSupport
+  module CoreExtensions
+    module Module
+      # Returns the name of the module containing this one.
+      #
+      #   p M::N.parent_name # => "M"
+      def parent_name
+        unless defined? @parent_name
+          @parent_name = name =~ /::[^:]+\Z/ ? $`.freeze : nil
+        end
+        @parent_name
+      end
+
+      # Returns the module which contains this one according to its name.
+      #
+      #   module M
+      #     module N
+      #     end
+      #   end
+      #   X = M::N
+      #
+      #   p M::N.parent # => M
+      #   p X.parent    # => M
+      #
+      # The parent of top-level and anonymous modules is Object.
+      #
+      #   p M.parent          # => Object
+      #   p Module.new.parent # => Object
+      #
+      def parent
+        parent_name ? parent_name.constantize : Object
+      end
+
+      # Returns all the parents of this module according to its name, ordered from
+      # nested outwards. The receiver is not contained within the result.
+      #
+      #   module M
+      #     module N
+      #     end
+      #   end
+      #   X = M::N
+      #
+      #   p M.parents    # => [Object]
+      #   p M::N.parents # => [M, Object]
+      #   p X.parents    # => [M, Object]
+      #
+      def parents
+        parents = []
+        if parent_name
+          parts = parent_name.split('::')
+          until parts.empty?
+            parents << (parts * '::').constantize
+            parts.pop
+          end
+        end
+        parents << Object unless parents.include? Object
+        parents
+      end
+
+      if RUBY_VERSION < '1.9'
+        # Returns the constants that have been defined locally by this object and
+        # not in an ancestor. This method is exact if running under Ruby 1.9. In
+        # previous versions it may miss some constants if their definition in some
+        # ancestor is identical to their definition in the receiver.
+        def local_constants
+          inherited = {}
+
+          ancestors.each do |anc|
+            next if anc == self
+            anc.constants.each { |const| inherited[const] = anc.const_get(const) }
+          end
+
+          constants.select do |const|
+            !inherited.key?(const) || inherited[const].object_id != const_get(const).object_id
+          end
+        end
+      else
+        def local_constants #:nodoc:
+          constants(false)
+        end
+      end
+
+      # Returns the names of the constants defined locally rather than the
+      # constants themselves. See <tt>local_constants</tt>.
+      def local_constant_names
+        local_constants.map { |c| c.to_s }
+      end
+    end
+  end
+end

data/lib/passive_support/core_ext/module/loading.rb

@@ -0,0 +1,23 @@
+class Module
+  # Returns String#underscore applied to the module name minus trailing classes.
+  #
+  #   ActiveRecord.as_load_path               # => "active_record"
+  #   ActiveRecord::Associations.as_load_path # => "active_record/associations"
+  #   ActiveRecord::Base.as_load_path         # => "active_record" (Base is a class)
+  #
+  # The Kernel module gives an empty string by definition.
+  #
+  #   Kernel.as_load_path # => ""
+  #   Math.as_load_path   # => "math"
+  def as_load_path
+    if self == Object || self == Kernel
+      ''
+    elsif is_a? Class
+      parent == self ? '' : parent.as_load_path
+    else
+      name.split('::').collect do |word|
+        word.underscore
+      end * '/'
+    end
+  end
+end

data/lib/passive_support/core_ext/module/model_naming.rb

@@ -0,0 +1,25 @@
+module PassiveSupport
+  class ModelName < String
+    attr_reader :singular, :plural, :element, :collection, :partial_path
+    alias_method :cache_key, :collection
+
+    def initialize(name)
+      super
+      @singular = PassiveSupport::Inflector.underscore(self).tr('/', '_').freeze
+      @plural = PassiveSupport::Inflector.pluralize(@singular).freeze
+      @element = PassiveSupport::Inflector.underscore(PassiveSupport::Inflector.demodulize(self)).freeze
+      @collection = PassiveSupport::Inflector.tableize(self).freeze
+      @partial_path = "#{@collection}/#{@element}".freeze
+    end
+  end
+
+  module CoreExtensions
+    module Module
+      # Returns an PassiveSupport::ModelName object for module. It can be
+      # used to retrieve all kinds of naming-related information.
+      def model_name
+        @model_name ||= ::PassiveSupport::ModelName.new(name)
+      end
+    end
+  end
+end

data/lib/passive_support/core_ext/module/synchronization.rb

@@ -0,0 +1,39 @@
+class Module
+  # Synchronize access around a method, delegating synchronization to a
+  # particular mutex. A mutex (either a Mutex, or any object that responds to 
+  # #synchronize and yields to a block) must be provided as a final :with option.
+  # The :with option should be a symbol or string, and can represent a method, 
+  # constant, or instance or class variable.
+  # Example:
+  #   class SharedCache
+  #     @@lock = Mutex.new
+  #     def expire
+  #       ...
+  #     end
+  #     synchronize :expire, :with => :@@lock
+  #   end
+  def synchronize(*methods)
+    options = methods.extract_options!
+    unless options.is_a?(Hash) && with = options[:with]
+      raise ArgumentError, "Synchronization needs a mutex. Supply an options hash with a :with key as the last argument (e.g. synchronize :hello, :with => :@mutex)."
+    end
+
+    methods.each do |method|
+      aliased_method, punctuation = method.to_s.sub(/([?!=])$/, ''), $1
+
+      if method_defined?("#{aliased_method}_without_synchronization#{punctuation}")
+        raise ArgumentError, "#{method} is already synchronized. Double synchronization is not currently supported."
+      end
+
+      module_eval(<<-EOS, __FILE__, __LINE__ + 1)
+        def #{aliased_method}_with_synchronization#{punctuation}(*args, &block)     # def expire_with_synchronization(*args, &block)
+          #{with}.synchronize do                                                    #   @@lock.synchronize do
+            #{aliased_method}_without_synchronization#{punctuation}(*args, &block)  #     expire_without_synchronization(*args, &block)
+          end                                                                       #   end
+        end                                                                         # end
+      EOS
+
+      alias_method_chain method, :synchronization
+    end
+  end
+end

data/lib/passive_support/core_ext/numeric.rb

@@ -0,0 +1,9 @@
+require 'passive_support/core_ext/numeric/time'
+require 'passive_support/core_ext/numeric/bytes'
+require 'passive_support/core_ext/numeric/conversions'
+
+class Numeric #:nodoc:
+  include PassiveSupport::CoreExtensions::Numeric::Time
+  include PassiveSupport::CoreExtensions::Numeric::Bytes
+  include PassiveSupport::CoreExtensions::Numeric::Conversions
+end

data/lib/passive_support/core_ext/numeric/bytes.rb

@@ -0,0 +1,50 @@
+module PassiveSupport #:nodoc:
+  module CoreExtensions #:nodoc:
+    module Numeric #:nodoc:
+      # Enables the use of byte calculations and declarations, like 45.bytes + 2.6.megabytes
+      module Bytes
+        KILOBYTE = 1024
+        MEGABYTE = KILOBYTE * 1024
+        GIGABYTE = MEGABYTE * 1024
+        TERABYTE = GIGABYTE * 1024
+        PETABYTE = TERABYTE * 1024
+        EXABYTE  = PETABYTE * 1024
+
+        def bytes
+          self
+        end
+        alias :byte :bytes
+
+        def kilobytes
+          self * KILOBYTE
+        end
+        alias :kilobyte :kilobytes
+
+        def megabytes
+          self * MEGABYTE
+        end
+        alias :megabyte :megabytes
+
+        def gigabytes
+          self * GIGABYTE
+        end
+        alias :gigabyte :gigabytes
+
+        def terabytes
+          self * TERABYTE
+        end
+        alias :terabyte :terabytes
+
+        def petabytes
+          self * PETABYTE
+        end
+        alias :petabyte :petabytes
+
+        def exabytes
+          self * EXABYTE
+        end
+        alias :exabyte :exabytes
+      end
+    end
+  end
+end