spree_core 0.70.7 → 1.0.0.rc1

data/lib/spree_core/delegate_belongs_to.rb

@@ -1,89 +0,0 @@
-##
-# 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

@@ -1,209 +0,0 @@
-
-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/array.rb

@@ -1,14 +0,0 @@
-# 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/string.rb

@@ -1,10 +0,0 @@
-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

@@ -1,297 +0,0 @@
-# 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_attribute :preference_definitions
-            self.preference_definitions = {}
-
-            class_attribute :default_preferences
-            self.default_preferences = {}
-
-            has_many  :stored_preferences, :as => :owner, :class_name => 'Preference'
-
-            after_save :update_preferences
-
-            include Spree::Preferences::ModelHooks::InstanceMethods
-          end
-          
-          # Reset definitions so that other subclass definitions aren't inherited
-          self.preference_definitions = self.preference_definitions.dup
-          self.default_preferences = self.default_preferences.dup
-          
-          # 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