dup_spree_core 1.3.0.rc1

data/lib/spree/core/testing_support/factories/prototype_factory.rb

@@ -0,0 +1,6 @@
+FactoryGirl.define do
+  factory :prototype, :class => Spree::Prototype do
+    name 'Baseball Cap'
+    properties { [FactoryGirl.create(:property)] }
+  end
+end

data/lib/spree/core/testing_support/factories/return_authorization_factory.rb

@@ -0,0 +1,10 @@
+FactoryGirl.define do
+  factory :return_authorization, :class => Spree::ReturnAuthorization do
+    number '100'
+    amount 100.00
+    #order { FactoryGirl.create(:order) }
+    order { FactoryGirl.create(:order_with_inventory_unit_shipped) }
+    reason 'no particular reason'
+    state 'received'
+  end
+end

data/lib/spree/core/testing_support/factories/role_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  sequence(:role_sequence) { |n| "Role ##{n}" }
+
+  factory :role, :class => Spree::Role do
+    name { FactoryGirl.generate :role_sequence }
+  end
+
+  factory :admin_role, :parent => :role do
+    name 'admin'
+  end
+end

data/lib/spree/core/testing_support/factories/shipment_factory.rb

@@ -0,0 +1,11 @@
+FactoryGirl.define do
+  factory :shipment, :class => Spree::Shipment do
+    order { FactoryGirl.create(:order) }
+    shipping_method { FactoryGirl.create(:shipping_method) }
+    tracking 'U10000'
+    number '100'
+    cost 100.00
+    address { FactoryGirl.create(:address) }
+    state 'pending'
+  end
+end

data/lib/spree/core/testing_support/factories/shipping_category_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  sequence(:shipping_category_sequence) { |n| "ShippingCategory ##{n}" }
+
+  factory :shipping_category, :class => Spree::ShippingCategory do
+    name { FactoryGirl.generate :shipping_category_sequence }
+  end
+end

data/lib/spree/core/testing_support/factories/shipping_method_factory.rb

@@ -0,0 +1,23 @@
+FactoryGirl.define do
+  factory :shipping_method, :class => Spree::ShippingMethod do
+    zone { |a| Spree::Zone.find_by_name('GlobalZone') || a.association(:global_zone) }
+    name 'UPS Ground'
+    calculator { FactoryGirl.build(:calculator) }
+  end
+
+  factory :free_shipping_method, :class => Spree::ShippingMethod do
+    zone { |a| Spree::Zone.find_by_name('GlobalZone') || a.association(:global_zone) }
+    name 'UPS Ground'
+    calculator { FactoryGirl.build(:no_amount_calculator) }
+  end
+
+  factory :shipping_method_with_category, :class => Spree::ShippingMethod do
+    zone { |a| Spree::Zone.find_by_name('GlobalZone') || a.association(:global_zone) }
+    name 'UPS Ground'
+    match_none nil
+    match_one nil
+    match_all nil
+    association(:shipping_category, :factory => :shipping_category)
+    calculator { FactoryGirl.build(:calculator) }
+  end
+end

data/lib/spree/core/testing_support/factories/state_factory.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :state, :class => Spree::State do
+    name 'Alabama'
+    abbr 'AL'
+    country do |country|
+      if usa = Spree::Country.find_by_numcode(840)
+        country = usa
+      else
+        country.association(:country)
+      end
+    end
+  end
+end

data/lib/spree/core/testing_support/factories/tax_category_factory.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :tax_category, :class => Spree::TaxCategory do
+    name { "TaxCategory - #{rand(999999)}" }
+    description { Faker::Lorem.sentence }
+  end
+
+  factory :tax_category_with_rates, :parent => :tax_category do
+    after_create do |tax_category|
+      tax_category.tax_rates.create!({
+        :amount => 0.05,
+        :calculator => Spree::Calculator::DefaultTax.new,
+        :zone => Spree::Zone.find_by_name('GlobalZone') || FactoryGirl.create(:global_zone)
+      }, :without_protection => true)
+    end
+  end
+end

data/lib/spree/core/testing_support/factories/tax_rate_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :tax_rate, :class => Spree::TaxRate do
+    zone { FactoryGirl.create(:zone) }
+    amount 100.00
+    tax_category { FactoryGirl.create(:tax_category) }
+  end
+end

data/lib/spree/core/testing_support/factories/taxon_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :taxon, :class => Spree::Taxon do
+    name 'Ruby on Rails'
+    taxonomy { FactoryGirl.create(:taxonomy) }
+    parent_id nil
+  end
+end

data/lib/spree/core/testing_support/factories/taxonomy_factory.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :taxonomy, :class => Spree::Taxonomy do
+    name 'Brand'
+  end
+end

data/lib/spree/core/testing_support/factories/tracker_factory.rb

@@ -0,0 +1,7 @@
+FactoryGirl.define do
+  factory :tracker, :class => Spree::Tracker do
+    environment { Rails.env }
+    analytics_id 'A100'
+    active true
+  end
+end

data/lib/spree/core/testing_support/factories/user_factory.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  sequence :user_authentication_token do |n|
+    "xxxx#{Time.now.to_i}#{rand(1000)}#{n}xxxxxxxxxxxxx"
+  end
+
+  factory :user, :class => Spree.user_class do
+    email { Faker::Internet.email }
+    login { email }
+    password 'secret'
+    password_confirmation 'secret'
+    authentication_token { FactoryGirl.generate(:user_authentication_token) } if Spree.user_class.attribute_method? :authentication_token
+  end
+
+  factory :admin_user, :parent => :user do
+    spree_roles { [Spree::Role.find_by_name('admin') || FactoryGirl.create(:role, :name => 'admin')] }
+  end
+end

data/lib/spree/core/testing_support/factories/variant_factory.rb

@@ -0,0 +1,16 @@
+FactoryGirl.define do
+  factory :variant, :class => Spree::Variant do
+    price 19.99
+    cost_price 17.00
+    sku    { Faker::Lorem.sentence }
+    weight { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    height { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    width  { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    depth  { BigDecimal.new("#{rand(200)}.#{rand(99)}") }
+    on_hand 5
+
+    # associations:
+    product { |p| p.association(:product) }
+    option_values { [FactoryGirl.create(:option_value)] }
+  end
+end

data/lib/spree/core/testing_support/factories/zone_factory.rb

@@ -0,0 +1,17 @@
+FactoryGirl.define do
+  factory :global_zone, :class => Spree::Zone do
+    name 'GlobalZone'
+    description { Faker::Lorem.sentence }
+    zone_members do |proxy|
+      zone = proxy.instance_eval { @instance }
+      Spree::Country.all.map do |c|
+        zone_member = Spree::ZoneMember.create(:zoneable => c, :zone => zone)
+      end
+    end
+  end
+
+  factory :zone, :class => Spree::Zone do
+    name { Faker::Lorem.sentence }
+    description { Faker::Lorem.sentence }
+  end
+end

data/lib/spree/core/testing_support/fixtures.rb

@@ -0,0 +1,4 @@
+require 'active_record/fixtures'
+
+fixtures_dir = File.expand_path('../../../../../db/default', __FILE__)
+ActiveRecord::Fixtures.create_fixtures(fixtures_dir, ['spree/countries', 'spree/zones', 'spree/zone_members', 'spree/states', 'spree/roles'])

data/lib/spree/core/testing_support/flash.rb

@@ -0,0 +1,29 @@
+module Spree
+  module Core
+    module TestingSupport
+      module Flash
+        def assert_flash_success(flash)
+          flash = convert_flash(flash)
+
+          within("[class='flash success']") do
+            page.should have_content(flash)
+          end
+        end
+
+        def assert_successful_update_message(resource)
+          flash = I18n.t(:successfully_updated, :resource => I18n.t(resource))
+          assert_flash_success(flash)
+        end
+
+        private
+
+        def convert_flash(flash)
+          if flash.is_a?(Symbol)
+            flash = I18n.t(flash)
+          end
+          flash
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/testing_support/preferences.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Core
+    module TestingSupport
+      module Preferences
+        # Resets all preferences to default values, you can
+        # pass a block to override the defaults with a block
+        #
+        # reset_spree_preferences do |config|
+        #   config.site_name = "my fancy pants store"
+        # end
+        #
+        def reset_spree_preferences
+          Spree::Preferences::Store.instance.persistence = false
+          config = Rails.application.config.spree.preferences
+          config.reset
+          yield(config) if block_given?
+        end
+
+        def assert_preference_unset(preference)
+          find("#preferences_#{preference}")['checked'].should be_false
+          Spree::Config[preference].should be_false
+        end
+      end
+    end
+  end
+end

data/lib/spree/core/token_resource.rb

@@ -0,0 +1,27 @@
+module Spree
+  module Core
+    module TokenResource
+      module ClassMethods
+        def token_resource
+          has_one :tokenized_permission, :as => :permissable
+          delegate :token, :to => :tokenized_permission, :allow_nil => true
+          after_create :create_token
+        end
+      end
+
+      def create_token
+        permission = build_tokenized_permission
+        permission.token = token = ::SecureRandom::hex(8)
+        permission.save!
+        token
+      end
+
+      def self.included(receiver)
+        receiver.extend ClassMethods
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval { include Spree::Core::TokenResource }
+

data/lib/spree/core/url_helpers.rb

@@ -0,0 +1,9 @@
+module Spree
+  module Core
+    module UrlHelpers
+      def spree
+        Spree::Core::Engine.routes.url_helpers
+      end
+    end
+  end
+end

data/lib/spree/core/user_banners.rb

@@ -0,0 +1,25 @@
+# Utility methods for dealing with user banners and saving
+# an array of dismissed banners per user
+# use symbols as banner id
+module Spree
+  module Core
+    module UserBanners
+      def self.included(base)
+        base.preference :dismissed_banners, :string, :default => ''
+      end
+
+      def dismissed_banner_ids
+        dismissed = self.preferred_dismissed_banners
+        dismissed.split(',').map(&:to_sym)
+      end
+
+      def dismiss_banner(banner_id)
+        self.preferred_dismissed_banners = dismissed_banner_ids.push(banner_id.to_sym).uniq.join(',')
+      end
+
+      def dismissed_banner?(banner_id)
+        dismissed_banner_ids.include? banner_id.to_sym
+      end
+    end
+  end
+end

data/lib/spree/core/validators/email.rb

@@ -0,0 +1,23 @@
+# Borrowed from http://my.rails-royce.org/2010/07/21/email-validation-in-ruby-on-rails-without-regexp/
+# Mentioned in tweet here: https://twitter.com/_sohara/status/177120126083141633
+require 'mail'
+class EmailValidator < ActiveModel::EachValidator
+  def validate_each(record,attribute,value)
+    begin
+      m = Mail::Address.new(value)
+      # We must check that value contains a domain and that value is an email address
+      r = m.domain && m.address == value
+      t = m.__send__(:tree)
+      # We need to dig into treetop
+      # A valid domain must have dot_atom_text elements size > 1
+      # user@localhost is excluded
+      # treetop must respond to domain
+      # We exclude valid email values like <user@localhost.com>
+      # Hence we use m.__send__(tree).domain
+      r &&= (t.domain.dot_atom_text.elements.size > 1)
+    rescue Exception => e
+      r = false
+    end
+    record.errors[attribute] << (options[:message] || "is invalid") unless r
+  end
+end

data/lib/spree/core/version.rb

@@ -0,0 +1,5 @@
+module Spree
+  def self.version
+    "1.3.0.rc1"
+  end
+end

data/lib/spree/money.rb

@@ -0,0 +1,27 @@
+require 'money'
+
+module Spree
+  class Money
+    attr_reader :money
+
+    def initialize(amount, options={})
+      @money = ::Money.parse([amount, (options[:currency] || Spree::Config[:currency])].join)
+      @options = {}
+      @options[:with_currency] = true if Spree::Config[:display_currency]
+      @options[:symbol_position] = Spree::Config[:currency_symbol_position].to_sym
+      @options[:no_cents] = true if Spree::Config[:hide_cents]
+      @options.merge!(options)
+      # Must be a symbol because the Money gem doesn't do the conversion
+      @options[:symbol_position] = @options[:symbol_position].to_sym
+
+    end
+
+    def to_s
+      @money.format(@options)
+    end
+
+    def ==(obj)
+      @money == obj.money
+    end
+  end
+end

data/lib/spree/product_filters.rb

@@ -0,0 +1,197 @@
+module Spree
+  # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
+  #   the exact code probably won't be useful, though you're welcome to modify and reuse
+  #   the current contents are mainly for testing and documentation
+
+  # To override this file...
+  #   1) Make a copy of it in your sites local /lib/spree folder
+  #   2) Add it to the config load path, or require it in an initializer, e.g...
+  #
+  #      # config/initializers/spree.rb
+  #      require 'spree/product_filters'
+  #
+
+  # set up some basic filters for use with products
+  #
+  # Each filter has two parts
+  #  * a parametrized named scope which expects a list of labels
+  #  * an object which describes/defines the filter
+  #
+  # The filter description has three components
+  #  * a name, for displaying on pages
+  #  * a named scope which will 'execute' the filter
+  #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
+  #  * an optional list of labels and values (for use with object selection - see taxons examples below)
+  #
+  # The named scopes here have a suffix '_any', following SearchLogic's convention for a
+  # scope which returns results which match any of the inputs. This is purely a convention,
+  # but might be a useful reminder.
+  #
+  # When creating a form, the name of the checkbox group for a filter F should be
+  # the name of F's scope with [] appended, eg "price_range_any[]", and for
+  # each label you should have a checkbox with the label as its value. On submission,
+  # Rails will send the action a hash containing (among other things) an array named
+  # after the scope whose values are the active labels.
+  #
+  # SearchLogic will then convert this array to a call to the named scope with the array
+  # contents, and the named scope will build a query with the disjunction of the conditions
+  # relating to the labels, all relative to the scope's context.
+  #
+  # The details of how/when filters are used is a detail for specific models (eg products
+  # or taxons), eg see the taxon model/controller.
+
+  # See specific filters below for concrete examples.
+
+  # This module is included by Taxon. In development mode that inclusion does not
+  # happen until Taxon class is loaded. Ensure that Taxon class is loaded before
+  # you try something like Product.price_range_any
+  module ProductFilters
+    # Example: filtering by price
+    #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
+    #   'price' is in the base scope's context (ie, "select foo from products where ...") so
+    #     we can access the field right away
+    #   The filter identifies which scope to use, then sets the conditions for each price range
+    #
+    # If user checks off three different price ranges then the argument passed to
+    # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
+    #
+    Spree::Product.add_search_scope :price_range_any do |*opts|
+      conds = opts.map {|o| Spree::ProductFilters.price_filter[:conds][o]}.reject {|c| c.nil?}
+      scope = conds.shift
+      conds.each do |new_scope|
+        scope = scope.or(new_scope)
+      end
+      Spree::Product.joins(:master => :default_price).where(scope)
+    end
+
+    def ProductFilters.format_price(amount)
+      Spree::Money.new(amount)
+    end
+
+    def ProductFilters.price_filter
+      v = Spree::Price.arel_table
+      conds = [ [ I18n.t(:under_price, :price => format_price(10))   , v[:amount].lteq(10)],
+                [ "#{format_price(10)} - #{format_price(15)}"        , v[:amount].in(10..15)],
+                [ "#{format_price(15)} - #{format_price(18)}"        , v[:amount].in(15..18)],
+                [ "#{format_price(18)} - #{format_price(20)}"        , v[:amount].in(18..20)],
+                [ I18n.t(:or_over_price, :price => format_price(20)) , v[:amount].gteq(20)]]
+      { :name   => I18n.t(:price_range),
+        :scope  => :price_range_any,
+        :conds  => Hash[*conds.flatten],
+        :labels => conds.map {|k,v| [k,k]}
+      }
+    end
+
+
+    # Example: filtering by possible brands
+    #
+    # First, we define the scope. Two interesting points here: (a) we run our conditions
+    #   in the scope where the info for the 'brand' property has been loaded; and (b)
+    #   because we may want to filter by other properties too, we give this part of the
+    #   query a unique name (which must be used in the associated conditions too).
+    #
+    # Secondly, the filter. Instead of a static list of values, we pull out all existing
+    #   brands from the db, and then build conditions which test for string equality on
+    #   the (uniquely named) field "p_brand.value". There's also a test for brand info
+    #   being blank: note that this relies on with_property doing a left outer join
+    #   rather than an inner join.
+    if Spree::Property.table_exists?
+      Spree::Product.add_search_scope :brand_any do |*opts|
+        conds = opts.map {|o| ProductFilters.brand_filter[:conds][o]}.reject {|c| c.nil?}
+        scope = conds.shift
+        conds.each do |new_scope|
+          scope = scope.or(new_scope)
+        end
+        Spree::Product.with_property("brand").where(scope)
+      end
+
+      def ProductFilters.brand_filter
+        brand_property = Spree::Property.find_by_name("brand")
+        brands = Spree::ProductProperty.where(:property_id => brand_property).pluck(:value).uniq
+        pp = Spree::ProductProperty.arel_table
+        conds = Hash[*brands.map { |b| [b, pp[:value].eq(b)] }.flatten]
+        { :name   => "Brands",
+          :scope  => :brand_any,
+          :conds  => conds,
+          :labels => (brands.sort).map { |k| [k, k] }
+        }
+      end
+    end
+
+    # Example: a parameterized filter
+    #   The filter above may show brands which aren't applicable to the current taxon,
+    #   so this one only shows the brands that are relevant to a particular taxon and
+    #   its descendants.
+    #
+    #   We don't have to give a new scope since the conditions here are a subset of the
+    #   more general filter, so decoding will still work - as long as the filters on a
+    #   page all have unique names (ie, you can't use the two brand filters together
+    #   if they use the same scope). To be safe, the code uses a copy of the scope.
+    #
+    #   HOWEVER: what happens if we want a more precise scope?  we can't pass
+    #   parametrized scope names to SearchLogic, only atomic names, so couldn't ask
+    #   for taxon T's customized filter to be used. BUT: we can arrange for the form
+    #   to pass back a hash instead of an array, where the key acts as the (taxon)
+    #   parameter and value is its label array, and then get a modified named scope
+    #   to get its conditions from a particular filter.
+    #
+    #   The brand-finding code can be simplified if a few more named scopes were added to
+    #   the product properties model.
+    if Spree::Property.table_exists?
+      Spree::Product.add_search_scope :selective_brand_any do |*opts|
+        Spree::Product.brand_any(*opts)
+      end
+
+      def ProductFilters.selective_brand_filter(taxon = nil)
+        taxon ||= Spree::Taxonomy.first.root
+        brand_property = Spree::Property.find_by_name("brand")
+        scope = Spree::ProductProperty.where(:property_id => brand_property).
+                                       joins(:product => :taxons).
+                                       where("#{Spree::Taxon.table_name}.id" => [taxon] + taxon.descendants).
+                                       scoped
+        brands = scope.pluck(:value).uniq
+        {
+          :name   => "Applicable Brands",
+          :scope  => :selective_brand_any,
+          :labels => brands.sort.map { |k| [k,k] }
+        }
+      end
+    end
+
+    # Provide filtering on the immediate children of a taxon
+    #
+    # This doesn't fit the pattern of the examples above, so there's a few changes.
+    # Firstly, it uses an existing scope which was not built for filtering - and so
+    # has no need of a conditions mapping, and secondly, it has a mapping of name
+    # to the argument type expected by the other scope.
+    #
+    # This technique is useful for filtering on objects (by passing ids) or with a
+    # scope that can be used directly (eg. testing only ever on a single property).
+    #
+    # This scope selects products in any of the active taxons or their children.
+    #
+    def ProductFilters.taxons_below(taxon)
+      return Spree::ProductFilters.all_taxons if taxon.nil?
+      { :name   => "Taxons under " + taxon.name,
+        :scope  => :taxons_id_in_tree_any,
+        :labels => taxon.children.sort_by(&:position).map {|t| [t.name, t.id]},
+        :conds  => nil
+      }
+    end
+
+    # Filtering by the list of all taxons
+    #
+    # Similar idea as above, but we don't want the descendants' products, hence
+    # it uses one of the auto-generated scopes from SearchLogic.
+    #
+    # idea: expand the format to allow nesting of labels?
+    def ProductFilters.all_taxons
+      taxons = Spree::Taxonomy.all.map {|t| [t.root] + t.root.descendants }.flatten
+      { :name   => "All taxons",
+        :scope  => :taxons_id_equals_any,
+        :labels => taxons.sort_by(&:name).map {|t| [t.name, t.id]},
+        :conds  => nil # not needed
+      }
+    end
+  end
+end