My-Commerce_core 1.0.0

data/lib/spree_core/delegate_belongs_to.rb

@@ -0,0 +1,89 @@
+##
+# Creates methods on object which delegate to an association proxy.
+# see delegate_belongs_to for two uses
+#
+# Todo - integrate with ActiveRecord::Dirty to make sure changes to delegate object are noticed
+# Should do
+# class User < ActiveRecord::Base; delegate_belongs_to :contact, :firstname; end
+# class Contact < ActiveRecord::Base; end
+# u = User.first
+# u.changed? # => false
+# u.firstname = 'Bobby'
+# u.changed? # => true
+#
+# Right now the second call to changed? would return false
+#
+# Todo - add has_one support. fairly straightforward addition
+##
+module DelegateBelongsTo
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+
+    @@default_rejected_delegate_columns = ['created_at','created_on','updated_at','updated_on','lock_version','type','id','position','parent_id','lft','rgt']
+    mattr_accessor :default_rejected_delegate_columns
+
+    ##
+    # Creates methods for accessing and setting attributes on an association.  Uses same
+    # default list of attributes as delegates_to_association.
+    # @todo Integrate this with ActiveRecord::Dirty, so if you set a property through one of these setters and then call save on this object, it will save the associated object automatically.
+    # delegate_belongs_to :contact
+    # delegate_belongs_to :contact, [:defaults]  ## same as above, and useless
+    # delegate_belongs_to :contact, [:defaults, :address, :fullname], :class_name => 'VCard'
+    ##
+    def delegate_belongs_to(association, *attrs)
+      opts = attrs.extract_options!
+      initialize_association :belongs_to, association, opts
+      attrs = get_association_column_names(association) if attrs.empty?
+      attrs.concat get_association_column_names(association) if attrs.delete :defaults
+      attrs.each do |attr|
+        class_def attr do |*args|
+          if args.empty?
+            send(:delegator_for, association).send(attr)
+          else
+            send(:delegator_for, association).send(attr, *args)
+          end
+        end
+        class_def "#{attr}=" do |val|
+          send(:delegator_for, association).send("#{attr}=", val)
+        end
+      end
+    end
+
+    protected
+
+    def get_association_column_names(association, without_default_rejected_delegate_columns=true)
+      begin
+        association_klass = reflect_on_association(association).klass
+        methods = association_klass.column_names
+        methods.reject!{|x|default_rejected_delegate_columns.include?(x.to_s)} if without_default_rejected_delegate_columns
+        return methods
+      rescue
+        return []
+      end
+    end
+
+    ##
+    # initialize_association :belongs_to, :contact
+    def initialize_association(type, association, opts={})
+      raise 'Illegal or unimplemented association type.' unless [:belongs_to].include?(type.to_s.to_sym)
+      send type, association, opts if reflect_on_association(association).nil?
+    end
+
+    private
+
+    def class_def(name, method=nil, &blk)
+      class_eval { method.nil? ? define_method(name, &blk) : define_method(name, method) }
+    end
+
+  end
+
+  module InstanceMethods
+    protected
+    def delegator_for(association)
+      send("#{association}=", self.class.reflect_on_association(association).klass.new) if send(association).nil?
+      send(association)
+    end
+  end
+
+end

data/lib/spree_core/enumerable_constants.rb

@@ -0,0 +1,209 @@
+
+module EnumerableConstant
+
+  # default (overridable) value for any
+  def self.any_value
+    -1
+  end
+
+  def self.any
+    [any_value, '[any]']
+  end
+
+  class Tupple
+
+    include Comparable
+
+    attr_accessor :name, :value, :display_name
+
+    def initialize(name, value=nil, display_name=nil)
+      @name = name
+      @value = value
+      @display_name = display_name
+    end
+
+    def <=> other
+      self.display_name <=> other.display_name
+    end
+
+    def title_translated
+      t("order_status_#{self.name.downcase}")
+    end
+
+    def title
+      if @display_name
+        self.display_name
+      else
+        self.name.titleize.strip
+      end
+    end
+
+    def id
+      self.value
+    end
+
+  end
+
+  class Base
+
+    include Comparable
+
+    def <=>
+
+    end
+
+    def self.class_var_prefix
+      self.name.gsub!('::', '_').underscore
+    end
+
+    def self.base=(value)
+      class_eval("@@#{self.class_var_prefix}_base = value")
+    end
+
+    def self.base(value)
+      class_eval("@@#{self.class_var_prefix}_base = value")
+    end
+
+    def self.constant(name, value=nil, display_name=nil)
+      # puts "name: #{name}"
+      # puts "value: #{value}"
+      # puts "display_name: #{display_name}"
+      class_eval("@@#{self.class_var_prefix}_constants ||= []")
+      class_eval("@@#{self.class_var_prefix}_base ||= 0 ")
+      if value == nil and class_eval("@@#{self.class_var_prefix}_constants.size == 0")
+        value = class_eval("@@#{self.class_var_prefix}_base")
+      end
+      if value == nil and class_eval("@@#{self.class_var_prefix}_constants.size > 0")
+        begin
+          value = class_eval("@@#{self.class_var_prefix}_constants.last.value.succ")
+        rescue
+          value = nil
+        end
+      end
+      # puts "eval : " + "#{name.to_s.underscore.upcase} = #{value}"
+      class_eval "#{name.to_s.underscore.upcase} = #{value}"
+      # class_eval "A_STUFF = 25"
+      # puts "display_name: #{display_name}" if display_name
+      class_eval("@@#{self.class_var_prefix}_constants << EnumerableConstant::Tupple.new(name, value, display_name)")
+    end
+
+    # TODO: add method_missing for class methods so you can do stuff like:
+    # :my_constant = 2
+    # :my_constant 2
+    # MY_CONSTANT = 2
+    # MY_CONSTANT 2
+    # def self.method_missing(symbol, *params)
+    #
+    # end
+    def self.from_value value
+      self.constants.each do |constant|
+        return constant.title if constant.value == value
+      end
+      nil
+    end
+
+    def self.constants
+      class_eval("@@#{self.class_var_prefix}_constants")
+    end
+
+    def self.constant_names
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.name
+      end
+      result
+    end
+
+    def self.names
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.title
+      end
+      result
+    end
+
+    def self.values
+      result = []
+      class_eval("@@#{self.class_var_prefix}_constants").map do |tupple|
+        result << tupple.value
+      end
+      result
+    end
+
+  end
+
+  module VERSION
+    MAJOR = 1
+    MINOR = 0
+    TINY  = 0
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+
+end
+
+class ActiveRecord::Base
+
+  def self.enumerable_constant(attribute_name, options={})
+    raise ArgumentError, "you must specify a list of constants" unless options[:constants]
+    set_name = attribute_name.to_s.camelize
+    set_class = "#{self.name}::#{set_name}"
+
+    constant_definitions = ""
+    options[:constants].each do |constant|
+      if constant.is_a? Hash
+        # puts "hash"
+        constant_name = constant.to_a[0][0]
+        display_name = constant.to_a[0][1]
+        # puts "constant name: #{constant_name}"
+        # puts "display name: #{display_name}"
+        # puts "c name: #{constant_name.to_s.underscore.upcase}"
+        constant_definitions << "constant '#{constant_name.to_s.underscore.upcase}', nil, '#{display_name}'\n"
+      else
+        # puts "constant '#{constant.to_s.underscore.upcase}'\n"
+        constant_definitions << "constant '#{constant.to_s.underscore.upcase}'\n"
+      end
+    end
+
+    # allow for :connector and :skip_last_comma as used in Array#to_sentence
+    if options[:connector]
+      connector = options[:connector]
+    else
+      connector = 'or'
+    end
+    unless options[:skip_last_comma].kind_of? NilClass
+      skip_last_comma = options[:skip_last_comma]
+    else
+      skip_last_comma = true
+    end
+
+    if options[:base]
+      use_base = options[:base]
+    else
+      use_base = 1
+    end
+
+    # keep glue_text for back compat
+    if options[:glue_text]
+      connector = options[:glue_text].strip
+    end
+
+    class_eval <<-EOF
+      class #{set_name} < EnumerableConstant::Base
+        base #{use_base}
+        #{constant_definitions}
+      end
+    EOF
+
+    should_be_in_text = set_class.constantize.names.to_sentence :words_connector => connector, :last_word_connector => skip_last_comma
+
+    unless options[:no_validation]
+      class_eval <<-EOF
+        validates :#{attribute_name.to_s}, :presence => {
+          :in => #{set_name}::values,
+          :message => "should be #{should_be_in_text}"
+          }
+      EOF
+    end
+  end
+
+end

data/lib/spree_core/ext/active_record.rb

@@ -0,0 +1,15 @@
+module ActiveRecord::Persistence
+
+  # Update attributes of a record in the database without callbacks, validations etc.
+  def update_attributes_without_callbacks(attributes)
+    self.send(:attributes=, attributes, false)
+    self.class.update_all(attributes, { :id => id })
+  end
+
+  # Update a single attribute in the database
+  def update_attribute_without_callbacks(name, value)
+    send("#{name}=", value)
+    update_attributes_without_callbacks(name => value)
+  end
+
+end

data/lib/spree_core/ext/array.rb

@@ -0,0 +1,14 @@
+# RAILS3 TODO (likely not needed - it was commented out before rails3 branch)
+# module SpreeCore::Ext::Array
+#   def to_hash_keys(&block)
+#     Hash[*self.collect { |v|
+#       [v, block.call(v)]
+#     }.flatten]
+#   end
+#
+#   def to_hash_values(&block)
+#     Hash[*self.collect { |v|
+#       [block.call(v), v]
+#     }.flatten]
+#   end
+# end

data/lib/spree_core/ext/hash.rb

@@ -0,0 +1,75 @@
+#
+# = Hash Recursive Merge
+#
+# Merges a Ruby Hash recursively, Also known as deep merge.
+# Recursive version of Hash#merge and Hash#merge!.
+#
+# Category::    Ruby
+# Package::     Hash
+# Author::      Simone Carletti <weppos@weppos.net>
+# Copyright::   2007-2008 The Authors
+# License::     MIT License
+# Link::        http://www.simonecarletti.com/
+# Source::      http://gist.github.com/gists/6391/
+#
+module HashRecursiveMerge
+
+  #
+  # Recursive version of Hash#merge!
+  #
+  # Adds the contents of +other_hash+ to +hsh+,
+  # merging entries in +hsh+ with duplicate keys with those from +other_hash+.
+  #
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  #
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => 300, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge!(h2)   #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #
+  # Simply using Hash#merge! would return
+  #
+  #    h1.merge!(h2)    #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  #
+  def rmerge!(other_hash)
+    merge!(other_hash) do |key, oldval, newval|
+        oldval.class == self.class ? oldval.rmerge!(newval) : newval
+    end
+  end
+
+  #
+  # Recursive version of Hash#merge
+  #
+  # Compared with Hash#merge!, this method supports nested hashes.
+  # When both +hsh+ and +other_hash+ contains an entry with the same key,
+  # it merges and returns the values from both arrays.
+  #
+  # Compared with Hash#merge, this method provides a different approch
+  # for merging nasted hashes.
+  # If the value of a given key is an Hash and both +other_hash+ abd +hsh
+  # includes the same key, the value is merged instead replaced with
+  # +other_hash+ value.
+  #
+  #    h1 = {"a" => 100, "b" => 200, "c" => {"c1" => 12, "c2" => 14}}
+  #    h2 = {"b" => 254, "c" => 300, "c" => {"c1" => 16, "c3" => 94}}
+  #    h1.rmerge(h2)    #=> {"a" => 100, "b" => 254, "c" => {"c1" => 16, "c2" => 14, "c3" => 94}}
+  #
+  # Simply using Hash#merge would return
+  #
+  #    h1.merge(h2)     #=> {"a" => 100, "b" = >254, "c" => {"c1" => 16, "c3" => 94}}
+  #
+  def rmerge(other_hash)
+    r = {}
+    merge(other_hash)  do |key, oldval, newval|
+      r[key] = oldval.class == self.class ? oldval.rmerge(newval) : newval
+    end
+  end
+
+end
+
+
+class Hash
+  include HashRecursiveMerge
+end
+

data/lib/spree_core/ext/string.rb

@@ -0,0 +1,10 @@
+module SpreeCore::Ext::String
+  def is_integer?
+    begin
+      Integer(self.to_s)
+      return true
+    rescue ArgumentError
+      return false
+    end
+  end
+end