rfcommerce_core 0.0.3

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

data/lib/spree_core/preferences/model_hooks.rb

@@ -0,0 +1,293 @@
+# Most of this code is from the preferences plugin available at
+# http://github.com/pluginaweek/preferences/tree/master
+
+module Spree
+  module Preferences
+    # Adds support for defining preferences on ActiveRecord models.
+    #
+    # == Saving preferences
+    #
+    # Preferences are not automatically saved when they are set.  You must save
+    # the record that the preferences were set on.
+    #
+    # For example,
+    #
+    #   class User < ActiveRecord::Base
+    #     preference :notifications
+    #   end
+    #
+    #   u = User.new(:login => 'admin', :prefers_notifications => false)
+    #   u.save!
+    #
+    #   u = User.find_by_login('admin')
+    #   u.attributes = {:prefers_notifications => true}
+    #   u.save!
+    module ModelHooks
+      def self.included(base) #:nodoc:
+        base.class_eval do
+          extend Spree::Preferences::ModelHooks::MacroMethods
+        end
+      end
+
+      module MacroMethods
+        # Defines a new preference for all records in the model.  By default, preferences
+        # are assumed to have a boolean data type, so all values will be typecasted
+        # to true/false based on ActiveRecord rules.
+        #
+        # Configuration options:
+        # * +default+ - The default value for the preference. Default is nil.
+        #
+        # == Examples
+        #
+        # The example below shows the various ways to define a preference for a
+        # particular model.
+        #
+        #   class User < ActiveRecord::Base
+        #     preference :notifications, :default => false
+        #     preference :color, :string, :default => 'red'
+        #     preference :favorite_number, :integer
+        #     preference :data, :any # Allows any data type to be stored
+        #   end
+        #
+        # All preferences are also inherited by subclasses.
+        #
+        # == Associations
+        #
+        # After the first preference is defined, the following associations are
+        # created for the model:
+        # * +stored_preferences+ - A collection of all the custom preferences specified for a record
+        #
+        # == Generated shortcut methods
+        #
+        # In addition to calling <tt>prefers?</tt> and +preferred+ on a record, you
+        # can also use the shortcut methods that are generated when a preference is
+        # defined.  For example,
+        #
+        #   class User < ActiveRecord::Base
+        #     preference :notifications
+        #   end
+        #
+        # ...generates the following methods:
+        # * <tt>prefers_notifications?</tt> - The same as calling <tt>record.prefers?(:notifications)</tt>
+        # * <tt>prefers_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
+        # * <tt>preferred_notifications</tt> - The same as called <tt>record.preferred(:notifications)</tt>
+        # * <tt>preferred_notifications=(value)</tt> - The same as calling <tt>record.set_preference(:notifications, value)</tt>
+        #
+        # Notice that there are two tenses used depending on the context of the
+        # preference.  Conventionally, <tt>prefers_notifications?</tt> is better
+        # for boolean preferences, while +preferred_color+ is better for non-boolean
+        # preferences.
+        #
+        # Example:
+        #
+        #   user = User.find(:first)
+        #   user.prefers_notifications?         # => false
+        #   user.prefers_color?                 # => true
+        #   user.preferred_color                # => 'red'
+        #   user.preferred_color = 'blue'       # => 'blue'
+        #
+        #   user.prefers_notifications = true
+        #
+        #   car = Car.find(:first)
+        #   user.preferred_color = 'red', car   # => 'red'
+        #   user.preferred_color(car)           # => 'red'
+        #   user.prefers_color?(car)            # => true
+        #
+        #   user.save!  # => true
+        def preference(name, *args)
+          unless included_modules.include?(InstanceMethods)
+            class_inheritable_hash :preference_definitions
+            self.preference_definitions = {}
+
+            class_inheritable_hash :default_preferences
+            self.default_preferences = {}
+
+            has_many  :stored_preferences, :as => :owner, :class_name => 'Preference'
+
+            after_save :update_preferences
+
+            include Spree::Preferences::ModelHooks::InstanceMethods
+          end
+
+          # Create the definition
+          name = name.to_s
+          definition = PreferenceDefinition.new(name, *args)
+          self.preference_definitions[name] = definition
+          self.default_preferences[name] = definition.default_value
+
+          # Create short-hand helper methods, making sure that the attribute
+          # is method-safe in terms of what characters are allowed
+          name = name.gsub(/[^A-Za-z0-9_-]/, '').underscore
+
+          # Query lookup
+          define_method("prefers_#{name}?") do |*group|
+            prefers?(name, group.first)
+          end
+
+          # Writer
+          define_method("prefers_#{name}=") do |*args|
+            set_preference(*([name] + [args].flatten))
+          end
+          alias_method "preferred_#{name}=", "prefers_#{name}="
+
+          # Reader
+          define_method("preferred_#{name}") do |*group|
+            preferred(name, group.first)
+          end
+
+          definition
+        end
+      end
+
+      module InstanceMethods
+        def self.included(base) #:nodoc:
+          base.class_eval do
+            alias_method :prefs, :preferences
+          end
+        end
+
+        # Finds all preferences, including defaults, for the current record.  If
+        # any custom group preferences have been stored, then this will include
+        # all default preferences within that particular group.
+        #
+        # == Examples
+        #
+        # A user with no stored values:
+        #   user = User.find(:first)
+        #   user.preferences
+        #   => {"language"=>"English", "color"=>nil}
+        #
+        # A user with stored values for a particular group:
+        #   user.preferred_color = 'red', 'cars'
+        #   user.preferences
+        #   => {"language"=>"English", "color"=>nil, "cars"=>{"language=>"English", "color"=>"red"}}
+        #
+        # Getting preference values for the owning record:
+        #   user.preferences(nil)
+        #   => {"language"=>"English", "color"=>nil}
+        #
+        # Getting preference values for a particular group:
+        #   user.preferences('cars')
+        #   => {"language"=>"English", "color"=>"red"}
+        def preferences(*args)
+          if args.empty?
+            group = nil
+            conditions = {}
+          else
+            group = args.first
+            group_id, group_type = Preference.split_group(group)
+            conditions = {:group_id => group_id, :group_type => group_type}
+          end
+
+          # Find all of the stored preferences
+          stored_preferences = self.stored_preferences.where(conditions)
+
+          # Hashify attribute -> value or group -> attribute -> value
+          stored_preferences.inject(self.class.default_preferences.dup) do |all_preferences, preference|
+            if !group && (preference_group = preference.group)
+              preferences = all_preferences[preference_group] ||= self.class.default_preferences.dup
+            else
+              preferences = all_preferences
+            end
+
+            preferences[preference.name] = preference.value
+            all_preferences
+          end
+        end
+
+        # Queries whether or not a value has been specified for the given attribute.
+        # This is dependent on how the value is type-casted.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.prefers?(:notifications)             # => true
+        #
+        #   user.prefers(:notifications, 'error')     # => true
+        #
+        #   newsgroup = Newsgroup.find(:first)
+        #   user.prefers?(:notifications, newsgroup)  # => false
+        def prefers?(name, group = nil)
+          name = name.to_s
+
+          value = preferred(name, group)
+          preference_definitions[name].query(value)
+        end
+
+        # Gets the preferred value for the given attribute.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.preferred(:color)          # => 'red'
+        #
+        #   user.preferred(:color, 'cars')  # => 'blue'
+        #
+        #   car = Car.find(:first)
+        #   user.preferred(:color, car)     # => 'black'
+        def preferred(name, group = nil)
+          name = name.to_s
+
+          if @preference_values && @preference_values[name] && @preference_values[name].include?(group)
+            value = @preference_values[name][group]
+          else
+            group_id, group_type = Preference.split_group(group)
+            preference = stored_preferences.find(:first, :conditions => {:name => name, :group_id => group_id, :group_type => group_type})
+            value = preference ? preference.value : preference_definitions[name].default_value
+          end
+
+          value
+        end
+
+        # Sets a new value for the given attribute.  The actual Preference record
+        # is *not* created until the actual record is saved.
+        #
+        # == Examples
+        #
+        #   user = User.find(:first)
+        #   user.set_preference(:notifications, false) # => false
+        #   user.save!
+        #
+        #   newsgroup = Newsgroup.find(:first)
+        #   user.set_preference(:notifications, true, newsgroup)  # => true
+        #   user.save!
+        def set_preference(name, value, group = nil)
+          name = name.to_s
+
+          @preference_values ||= {}
+          @preference_values[name] ||= {}
+          @preference_values[name][group] = value
+
+          value
+        end
+
+        private
+
+        # Updates any preferences that have been changed/added since the record
+        # was last saved
+        def update_preferences
+          if @preference_values
+            @preference_values.each do |name, grouped_records|
+              grouped_records.each do |group, value|
+                group_id, group_type = Preference.split_group(group)
+                attributes = {:name => name, :group_id => group_id, :group_type => group_type}
+
+                # Find an existing preference or build a new one
+                preference = stored_preferences.find(:first, :conditions => attributes)
+                if preference.nil?
+                  attribute = attributes.delete(:attribute)
+                  preference = stored_preferences.build(attributes)
+                  preference['attribute'] = attribute
+                end
+                preference.value = value
+                preference.save!
+              end
+            end
+
+            @preference_values = nil
+          end
+        end
+      end
+    end
+  end
+end