spree_core 3.3.6 → 3.4.0.rc1

data/app/models/spree/calculator/percent_per_item.rb

@@ -1,51 +0,0 @@
-module Spree
-
-  # A calculator for promotions that calculates a percent-off discount
-  # for all matching products in an order. This should not be used as a
-  # shipping calculator since it would be the same thing as a flat percent
-  # off the entire order.
-
-  class Calculator::PercentPerItem < Calculator
-    preference :percent, :decimal, default: 0
-
-    def self.description
-      Spree.t(:percent_per_item)
-    end
-
-    def compute(object=nil)
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        Spree::Calculator::PercentPerItem will be removed in Spree 3.4
-        There is now a Promotion Action which deals with these types of promotions instead
-      EOS
-      return 0 if object.nil?
-      object.line_items.reduce(0) do |sum, line_item|
-        sum += value_for_line_item(line_item)
-      end
-    end
-
-  private
-
-    # Returns all products that match this calculator, but only if the calculator
-    # is attached to a promotion. If attached to a ShippingMethod, nil is returned.
-    # Copied from per_item.rb
-    def matching_products
-      if compute_on_promotion?
-        self.calculable.promotion.rules.map do |rule|
-          rule.respond_to?(:products) ? rule.products : []
-        end.flatten
-      end
-    end
-
-    def value_for_line_item(line_item)
-      if compute_on_promotion?
-        return 0 unless matching_products.blank? or matching_products.include?(line_item.product)
-      end
-      ((line_item.price * line_item.quantity) * preferred_percent) / 100
-    end
-
-    # Determines wether or not the calculable object is a promotion
-    def compute_on_promotion?
-      @compute_on_promotion ||= self.calculable.respond_to?(:promotion)
-    end
-  end
-end

data/config/initializers/premailer_rails.rb

@@ -1,3 +0,0 @@
-if Gem.loaded_specs['premailer-rails'].version >= Gem::Version.create('1.10.0')
-  Premailer::Rails.config[:strategies] = [:filesystem, :network, :asset_pipeline]
-end

data/lib/spree/core/delegate_belongs_to.rb

@@ -1,99 +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 < Spree::Base; delegate_belongs_to :contact, :firstname; end
-# class Contact < Spree::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)
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        DelegateBelongsTo module is deprecated and will be removed in Spree 3.4
-      EOS
-
-      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|
-          send(:delegator_for, association, attr, *args)
-        end
-
-        class_def "#{attr}=" do |val|
-          send(:delegator_for_setter, association, 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
-
-  def delegator_for(association, attr, *args)
-    return if self.class.column_names.include?(attr.to_s)
-    send "build_#{association}" if send(association).nil?
-    if args.empty?
-      send(association).send(attr)
-    else
-      send(association).send(attr, *args)
-    end
-  end
-
-  def delegator_for_setter(association, attr, val)
-    return if self.class.column_names.include?(attr.to_s)
-    send "build_#{association}" if send(association).nil?
-    send(association).send("#{attr}=", val)
-  end
-  protected :delegator_for
-  protected :delegator_for_setter
-end
-
-ActiveRecord::Base.include DelegateBelongsTo

data/lib/spree/testing_support/microdata.rb

@@ -1,192 +0,0 @@
-module Spree
-  module TestingSupport
-    module Microdata
-      # code extracted and modified from 'microdata' gem
-      class Document
-        attr_reader :items, :doc
-
-        def initialize(content)
-          ActiveSupport::Deprecation.warn(<<-EOS, caller)
-            Spree::TestingSupport::Microdata will be removed in Spree 3.4
-          EOS
-          @doc = Nokogiri::HTML(content)
-          @items = extract_items
-        end
-
-        def extract_items
-          itemscopes = @doc.search('//*[@itemscope and not(@itemprop)]')
-          return nil unless itemscopes
-
-          itemscopes.map do |itemscope|
-            Item.new(itemscope)
-          end
-        end
-      end
-
-      class Item
-        attr_reader :type, :properties, :id
-
-        def initialize(top_node)
-          @top_node = top_node
-          @type = extract_item_type
-          @id   = extract_item_id
-          @properties = {}
-          add_item_ref_properties(@top_node)
-          parse_elements(extract_elements(@top_node))
-        end
-
-        def to_hash
-          hash = {}
-          hash[:id] = id if id
-          hash[:type] = type if type
-          hash[:properties] = {}
-          properties.each do |name, values|
-            final_values = values.map do |value|
-              if value.reponds_to?(:to_hash)
-                value.to_hash
-              else
-                value
-              end
-            end
-            hash[:properties][name] = final_values
-          end
-          hash
-        end
-
-        private
-
-        def extract_elements(node)
-          node.search('./*')
-        end
-
-        def extract_item_id
-          (value = @top_node.attribute('itemid')) ? value.value : nil
-        end
-
-        def extract_item_type
-          (value = @top_node.attribute('itemtype')) ? value.value.split(' ') : nil
-        end
-
-        def parse_elements(elements)
-          elements.each { |element| parse_element(element) }
-        end
-
-        def parse_element(element)
-          item_scope = element.attribute('itemscope')
-          item_prop = element.attribute('itemprop')
-          internal_elements = extract_elements(element)
-          add_item_prop(element) if item_scope || item_prop
-          parse_elements(internal_elements) if internal_elements && !item_scope
-        end
-
-        # Add an 'itemprop' to the properties
-        def add_item_prop(item_prop)
-          properties = Itemprop.parse(item_prop, @page_url)
-          properties.each { |name, value| (@properties[name] ||= []) << value }
-        end
-
-        # Add any properties referred to by 'itemref'
-        def add_item_ref_properties(element)
-          item_ref = element.attribute('itemref')
-          if item_ref
-            item_ref.value.split(' ').each { |id| parse_elements(find_with_id(id)) }
-          end
-        end
-
-        # Find an element with a matching id
-        def find_with_id(id)
-          @top_node.search("//*[@id='#{id}']")
-        end
-      end
-
-      class Itemprop
-        NON_TEXTCONTENT_ELEMENTS = {
-          'a' => 'href',        'area' => 'href',
-          'audio' => 'src',     'embed' => 'src',
-          'iframe' => 'src',    'img' => 'src',
-          'link' => 'href',     'meta' => 'content',
-          'object' => 'data',   'source' => 'src',
-          'time' => 'datetime', 'track' => 'src',
-          'video' => 'src'
-        }.freeze
-        URL_ATTRIBUTES = ['data', 'href', 'src'].freeze
-
-        # A Hash representing the properties.
-        # Hash is of the form {'property name' => 'value'}
-        attr_reader :properties
-
-        # Create a new Itemprop object
-        # [element]  The itemprop element to be parsed
-        # [page_url] The url of the page, including filename, used to form
-        #            absolute urls
-        def initialize(element, page_url = nil)
-          @element = element
-          @page_url = page_url
-          @properties = extract_properties
-        end
-
-        # Parse the element and return a hash representing the properties.
-        # Hash is of the form {'property name' => 'value'}
-        # [element]  The itemprop element to be parsed
-        # [page_url] The url of the page, including filename, used to form
-        #            absolute urls
-        def self.parse(element, page_url = nil)
-          new(element, page_url).properties
-        end
-
-        private
-
-        def extract_properties
-          prop_names = extract_property_names
-          prop_names.each_with_object({}) do |name, memo|
-            memo[name] = extract_property
-          end
-        end
-
-        # This returns an empty string if can't form a valid
-        # absolute url as per the Microdata spec.
-
-        def make_absolute_url(url)
-          return url unless URI.parse(url).relative?
-          begin
-            URI.parse(@page_url).merge(url).to_s
-          rescue URI::Error
-            url
-          end
-        end
-
-        def non_textcontent_element?(element)
-          NON_TEXTCONTENT_ELEMENTS.has_key?(element)
-        end
-
-        def url_attribute?(attribute)
-          URL_ATTRIBUTES.include?(attribute)
-        end
-
-        def extract_property_names
-          itemprop_attr = @element.attribute('itemprop')
-          itemprop_attr ? itemprop_attr.value.split : []
-        end
-
-        def extract_property_value
-          element = @element.name
-          if non_textcontent_element?(element)
-            attribute = NON_TEXTCONTENT_ELEMENTS[element]
-            value = @element.attribute(attribute).value
-            url_attribute?(attribute) ? make_absolute_url(value) : value
-          else
-            @element.inner_text.strip
-          end
-        end
-
-        def extract_property
-          if @element.attribute('itemscope')
-            Item.new(@element)
-          else
-            extract_property_value
-          end
-        end
-      end
-    end
-  end
-end