goca-spree-core 3.1.14.rails.5.0

data/lib/spree/testing_support/i18n.rb

@@ -0,0 +1,97 @@
+# This file exists solely to test whether or not there are missing translations
+# within the code that Spree's test suite covers.
+#
+# If there is a translation referenced which has no corresponding key within the
+# .yml file, then there will be a message output at the end of the suite showing
+# that.
+#
+# If there is a translation within the locale file which *isn't* used in the
+# test, this will also be shown at the end of the suite run.
+module Spree
+  class << self
+    attr_accessor :used_translations, :missing_translation_messages,
+                  :unused_translations, :unused_translation_messages
+    alias_method :normal_t, :t
+  end
+
+  def self.t(*args)
+    original_args = args.dup
+    options = args.extract_options!
+    self.used_translations ||= []
+    [*args.first].each do |translation_key|
+      key = ([*options[:scope]] << translation_key).join('.')
+      self.used_translations << key
+    end
+    normal_t(*original_args)
+  end
+
+  def self.check_missing_translations
+    self.missing_translation_messages = []
+    self.used_translations ||= []
+    used_translations.map { |a| a.split('.') }.each do |translation_keys|
+      root = translations
+      processed_keys = []
+      translation_keys.each do |key|
+        begin
+          root = root.fetch(key.to_sym)
+          processed_keys << key.to_sym
+        rescue KeyError
+          error = "#{(processed_keys << key).join('.')} (#{I18n.locale})"
+          unless Spree.missing_translation_messages.include?(error)
+            Spree.missing_translation_messages << error
+          end
+        end
+      end
+    end
+  end
+
+  def self.check_unused_translations
+    self.used_translations ||= []
+    self.unused_translation_messages = []
+    self.unused_translations = []
+    self.load_translations(translations)
+    translation_diff = unused_translations - used_translations
+    translation_diff.each do |translation|
+      Spree.unused_translation_messages << "#{translation} (#{I18n.locale})"
+    end
+  end
+
+  private
+
+  def self.load_translations(hash, root=[])
+    hash.each do |k,v|
+      if v.is_a?(Hash)
+        load_translations(v, root.dup << k)
+      else
+        key = (root + [k]).join('.')
+        self.unused_translations << key
+      end
+    end
+  end
+
+  def self.translations
+    @translations ||= I18n.backend.send(:translations)[I18n.locale][:spree]
+  end
+end
+
+RSpec.configure do |config|
+  # Need to check here again because this is used in i18n_spec too.
+  if ENV['CHECK_TRANSLATIONS']
+    config.after :suite do
+      Spree.check_missing_translations
+      if Spree.missing_translation_messages.any?
+        puts "\nThere are missing translations within Spree:"
+        puts Spree.missing_translation_messages.sort
+        exit(1)
+      end
+
+      Spree.check_unused_translations
+      if false && Spree.unused_translation_messages.any?
+        puts "\nThere are unused translations within Spree:"
+        puts Spree.unused_translation_messages.sort
+        exit(1)
+      end
+    end
+  end
+end
+

data/lib/spree/testing_support/microdata.rb

@@ -0,0 +1,189 @@
+module Spree
+  module TestingSupport
+    module Microdata
+      # code extracted and modified from 'microdata' gem
+      class Document
+        attr_reader :items, :doc
+
+        def initialize(content)
+          @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

data/lib/spree/testing_support/order_walkthrough.rb

@@ -0,0 +1,72 @@
+class OrderWalkthrough
+  def self.up_to(state)
+    # A default store must exist to provide store settings
+    unless Spree::Store.exists?
+      FactoryBot.create(:store)
+    end
+
+    # A payment method must exist for an order to proceed through the Address state
+    unless Spree::PaymentMethod.exists?
+      FactoryBot.create(:check_payment_method)
+    end
+
+    # Need to create a valid zone too...
+    zone = FactoryBot.create(:zone)
+    country = FactoryBot.create(:country)
+    zone.members << Spree::ZoneMember.create(:zoneable => country)
+    country.states << FactoryBot.create(:state, :country => country)
+
+    # A shipping method must exist for rates to be displayed on checkout page
+    unless Spree::ShippingMethod.exists?
+      FactoryBot.create(:shipping_method).tap do |sm|
+        sm.calculator.preferred_amount = 10
+        sm.calculator.preferred_currency = Spree::Config[:currency]
+        sm.calculator.save
+      end
+    end
+
+    order = Spree::Order.create!(email: "spree@example.com")
+    add_line_item!(order)
+    order.next!
+
+    end_state_position = states.index(state.to_sym)
+    states[0...end_state_position].each do |state|
+      send(state, order)
+    end
+
+    order
+  end
+
+  private
+
+  def self.add_line_item!(order)
+    FactoryBot.create(:line_item, order: order)
+    order.reload
+  end
+
+  def self.address(order)
+    order.bill_address = FactoryBot.create(:address, :country_id => Spree::Zone.global.members.first.zoneable.id)
+    order.ship_address = FactoryBot.create(:address, :country_id => Spree::Zone.global.members.first.zoneable.id)
+    order.next!
+  end
+
+  def self.delivery(order)
+    order.next!
+  end
+
+  def self.payment(order)
+    order.payments.create!(payment_method: Spree::PaymentMethod.first, amount: order.total)
+    # TODO: maybe look at some way of making this payment_state change automatic
+    order.payment_state = 'paid'
+    order.next!
+  end
+
+  def self.complete(order)
+    #noop?
+  end
+
+  def self.states
+    [:address, :delivery, :payment, :complete]
+  end
+
+end

data/lib/spree/testing_support/preferences.rb

@@ -0,0 +1,31 @@
+module Spree
+  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.track_inventory_levels = false
+      # end
+      #
+      def reset_spree_preferences(&config_block)
+        Spree::Preferences::Store.instance.persistence = false
+        Spree::Preferences::Store.instance.clear_cache
+
+        config = Rails.application.config.spree.preferences
+        configure_spree_preferences &config_block if block_given?
+      end
+
+      def configure_spree_preferences
+        config = Rails.application.config.spree.preferences
+        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
+

data/lib/spree/testing_support/url_helpers.rb

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

data/lib/spree_core.rb

@@ -0,0 +1 @@
+require 'spree/core'

data/lib/tasks/core.rake

@@ -0,0 +1,169 @@
+require 'active_record'
+
+namespace :db do
+  desc %q{Loads a specified fixture file:
+use rake db:load_file[/absolute/path/to/sample/filename.rb]}
+
+  task :load_file , [:file, :dir] => :environment do |t, args|
+    file = Pathname.new(args.file)
+
+    puts "loading ruby #{file}"
+    require file
+  end
+
+  desc "Loads fixtures from the the dir you specify using rake db:load_dir[loadfrom]"
+  task :load_dir , [:dir] => :environment do |t, args|
+    dir = args.dir
+    dir = File.join(Rails.root, "db", dir) if Pathname.new(dir).relative?
+
+    ruby_files = {}
+    Dir.glob(File.join(dir , '**/*.{rb}')).each do |fixture_file|
+      ext = File.extname fixture_file
+      ruby_files[File.basename(fixture_file, '.*')] = fixture_file
+    end
+    ruby_files.sort.each do |fixture , ruby_file|
+      # If file exists within application it takes precendence.
+      if File.exists?(File.join(Rails.root, "db/default/spree", "#{fixture}.rb"))
+        ruby_file = File.expand_path(File.join(Rails.root, "db/default/spree", "#{fixture}.rb"))
+      end
+      # an invoke will only execute the task once
+      Rake::Task["db:load_file"].execute( Rake::TaskArguments.new([:file], [ruby_file]) )
+    end
+  end
+
+  desc "Migrate schema to version 0 and back up again. WARNING: Destroys all data in tables!!"
+  task :remigrate => :environment do
+    require 'highline/import'
+
+    if ENV['SKIP_NAG'] or ENV['OVERWRITE'].to_s.downcase == 'true' or agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [y/n] ")
+
+      # Drop all tables
+      ActiveRecord::Base.connection.tables.each { |t| ActiveRecord::Base.connection.drop_table t }
+
+      # Migrate upward
+      Rake::Task["db:migrate"].invoke
+
+      # Dump the schema
+      Rake::Task["db:schema:dump"].invoke
+    else
+      say "Task cancelled."
+      exit
+    end
+  end
+
+  desc "Bootstrap is: migrating, loading defaults, sample data and seeding (for all extensions) and load_products tasks"
+  task :bootstrap  do
+    require 'highline/import'
+
+    # remigrate unless production mode (as saftey check)
+    if %w[demo development test].include? Rails.env
+      if ENV['AUTO_ACCEPT'] or agree("This task will destroy any data in the database. Are you sure you want to \ncontinue? [y/n] ")
+        ENV['SKIP_NAG'] = 'yes'
+        Rake::Task["db:create"].invoke
+        Rake::Task["db:remigrate"].invoke
+      else
+        say "Task cancelled, exiting."
+        exit
+      end
+    else
+      say "NOTE: Bootstrap in production mode will not drop database before migration"
+      Rake::Task["db:migrate"].invoke
+    end
+
+    ActiveRecord::Base.send(:subclasses).each do |model|
+      model.reset_column_information
+    end
+
+    load_defaults  = Spree::Country.count == 0
+    unless load_defaults    # ask if there are already Countries => default data hass been loaded
+      load_defaults = agree('Countries present, load sample data anyways? [y/n]: ')
+    end
+    if load_defaults
+      Rake::Task["db:seed"].invoke
+    end
+
+    if Rails.env.production? and Spree::Product.count > 0
+      load_sample = agree("WARNING: In Production and products exist in database, load sample data anyways? [y/n]:" )
+    else
+      load_sample = true if ENV['AUTO_ACCEPT']
+      load_sample = agree('Load Sample Data? [y/n]: ') unless load_sample
+    end
+
+    if load_sample
+      # Reload models' attributes in case they were loaded in old migrations with wrong attributes
+      ActiveRecord::Base.descendants.each(&:reset_column_information)
+      Rake::Task["spree_sample:load"].invoke
+    end
+
+    puts "Bootstrap Complete.\n\n"
+  end
+
+
+
+  desc "Fix orphan line items after upgrading to Spree 3.1: only needed if you have line items attached to deleted records with Slug (product) and SKU (variant) duplicates of non-deleted records."
+  task :fix_orphan_line_items => :environment do |t, args|
+    def get_input
+      STDOUT.flush
+      input = STDIN.gets.chomp
+      case input.upcase
+        when "Y"
+          return true
+
+        when "N"
+          puts "aborting ....."
+          return false
+        else
+          return true
+      end
+    end
+
+    puts "WARNING: This task will re-associate any line_items associated with deleted variants to non-deleted variants with matching SKUs. Because other attributes and product associations may switch during the re-association, this may have unintended side-effects. If this task finishes successfully, line items for old order should no longer be orphaned from their varaints. You should run this task after you have already run the db migratoin AddDiscontinuedToProductsAndVariants. If the db migration did not warn you that it was leaving deleted records in place because of duplicate SKUs, then you do not need to run this rake task."
+    puts "Are you sure you want to continue? (Y/n):"
+
+    if get_input
+      puts "looping through all your deleted variants ..."
+
+      # first verify that I can really fix all of your line items
+
+      no_live_variants_found = []
+      variants_to_fix = []
+
+      Spree::Variant.deleted.each do |variant|
+        # check if this variant has any line items at all
+        if !variant.line_items.any?
+          next
+        end
+
+        variants_to_fix << variant
+        dup_variant = Spree::Variant.find_by(sku: variant.sku)
+        if dup_variant
+          # this variant is OK
+        else
+          no_live_variants_found << variant
+        end
+      end
+
+      if !variants_to_fix.any?
+        abort(  "ABORT: You have no deleted variants that are associated to line items. You do not need to run this raks task.")
+      end
+
+      if no_live_variants_found.any?
+        puts "ABORT: Unfortunately, I found some deleted variants in your database that do not have matching non-deleted variants to replace them with. This script can only be used to cleanup deleted variants that have SKUs that match non-deleted variants. To continue, you must either (1) un-delete these variants (hint: mark them 'discontinued' instead) or (2) create new variants with a matching SKU for each variant in the list below."
+        no_live_variants_found.each do |deleted_variant|
+          puts "variant id #{deleted_variant.id} (sku is '#{deleted_variant.sku}') ... no match found"
+        end
+        abort()
+      end
+
+
+      puts "Ready to fix..."
+      variants_to_fix.each do |variant|
+        dup_variant = Spree::Variant.find_by(sku: variant.sku)
+        puts "Changing all line items for #{variant.sku} variant id #{variant.id} (deleted) to variant id #{dup_variant.id} (not deleted) ..."
+        Spree::LineItem.unscoped.where(variant_id: variant.id).update_all(variant_id: dup_variant.id)
+      end
+
+      puts "DONE !   Your database should no longer have line items that are associated with deleted variants."
+    end
+  end
+end

data/lib/tasks/email.rake

@@ -0,0 +1,10 @@
+namespace :email do
+  desc 'Sends test email to specified address - Example: EMAIL=spree@example.com bundle exec rake email:test'
+  task test: :environment do
+    unless ENV['EMAIL'].present?
+      raise ArgumentError, "Must pass EMAIL environment variable. " \
+                           "Example: EMAIL=spree@example.com bundle exec rake email:test"
+    end
+    Spree::TestMailer.test_email(ENV['EMAIL']).deliver_now
+  end
+end

data/lib/tasks/exchanges.rake

@@ -0,0 +1,70 @@
+namespace :exchanges do
+  desc %q{Takes unreturned exchanged items and creates a new order to charge
+  the customer for not returning them}
+  task charge_unreturned_items: :environment do
+
+    unreturned_return_items =  Spree::ReturnItem.awaiting_return.exchange_processed.joins(:exchange_inventory_unit).where([
+      "spree_inventory_units.created_at < :days_ago AND spree_inventory_units.state = :iu_state",
+      days_ago: Spree::Config[:expedited_exchanges_days_window].days.ago, iu_state: "shipped"
+    ]).to_a
+
+    # Determine that a return item has already been deemed unreturned and therefore charged
+    # by the fact that its exchange inventory unit has popped off to a different order
+    unreturned_return_items.select! { |ri| ri.inventory_unit.order_id == ri.exchange_inventory_unit.order_id }
+
+    failed_orders = []
+
+    unreturned_return_items.group_by(&:exchange_shipment).each do |shipment, return_items|
+      begin
+        inventory_units = return_items.map(&:exchange_inventory_unit)
+
+        original_order = shipment.order
+        order_attributes = {
+          bill_address: original_order.bill_address,
+          ship_address: original_order.ship_address,
+          email: original_order.email
+        }
+        order_attributes[:store_id] = original_order.store_id
+        order = Spree::Order.create!(order_attributes)
+
+        order.associate_user!(original_order.user) if original_order.user
+
+        return_items.group_by(&:exchange_variant).map do |variant, variant_return_items|
+          variant_inventory_units = variant_return_items.map(&:exchange_inventory_unit)
+          line_item = Spree::LineItem.create!(variant: variant, quantity: variant_return_items.count, order: order)
+          variant_inventory_units.each { |i| i.update_attributes!(line_item_id: line_item.id, order_id: order.id) }
+        end
+
+        order.reload.update_with_updater!
+        while order.state != order.checkout_steps[-2] && order.next; end
+
+        unless order.payments.present?
+          card_to_reuse = original_order.valid_credit_cards.first
+          card_to_reuse = original_order.user.credit_cards.default.first if !card_to_reuse && original_order.user
+          Spree::Payment.create!(order: order,
+                                 payment_method_id: card_to_reuse.try(:payment_method_id),
+                                 source: card_to_reuse,
+                                 amount: order.total)
+        end
+
+        # the order builds a shipment on its own on transition to delivery, but we want
+        # the original exchange shipment, not the built one
+        order.shipments.destroy_all
+        shipment.update_attributes!(order_id: order.id)
+        order.update_attributes!(state: "confirm")
+
+        order.reload.next!
+        order.update_with_updater!
+        order.finalize!
+
+        failed_orders << order unless order.completed? && order.valid?
+      rescue
+        failed_orders << order
+      end
+    end
+    failure_message = failed_orders.map { |o| "#{o.number} - #{o.errors.full_messages}" }.join(", ")
+    raise UnableToChargeForUnreturnedItems.new(failure_message) if failed_orders.present?
+  end
+end
+
+class UnableToChargeForUnreturnedItems < StandardError; end

data/script/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/spree/core/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'
+

data/spec/fixtures/microdata.html

@@ -0,0 +1,22 @@
+<!DOCTYPE html>
+<html>
+    <!-- shameless -->
+    <head>
+        <title>Jason Ronallo</title>
+    </head>
+
+    <body>
+      <span itemscope itemtype="http://schema.org/Person"
+        itemid="http://ronallo.com#me">
+        <a itemprop="url" href="http://twitter.com/ronallo">
+          <span itemprop="name">Jason Ronallo</span>
+        </a> is the 
+        <span itemprop="jobTitle">Associate Head of Digital Library Initiatives</span> at 
+        <span itemprop="affiliation" itemscope itemtype="http://schema.org/Library" itemid="http://lib.ncsu.edu">
+          <span itemprop="name">
+            <a itemprop="url" href="http://www.lib.ncsu.edu">NCSU Libraries</a>
+          </span>
+        </span>
+      </span>
+    </body>
+</html>