solidus_fulfillment 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8cfed147ac17cacd2145fdcf48a2ceb3c3c227a8
+  data.tar.gz: 4f21644a4f060d33977c0e9a68ded129b77e366c
+SHA512:
+  metadata.gz: d2bfcbcef93c29bd6f451cd80273447c449e4e35c3d8bc857da22adc32a43e15c22c3ace44a5cb771879ebac48dcac58380b8d3a824e1319af1252af074cd9e0
+  data.tar.gz: ce90938443ba6f680edf947ee85bbd8737e032d2b805d62ef5db1d6ac3604605acefcdea4bd8488124ef3042d331ce5fc8d1702e7113bebf89a9e8a300ed2ae6

data/.gitignore

@@ -0,0 +1,14 @@
+\#*
+*~
+.#*
+.DS_Store
+.idea
+.project
+.sass-cache
+coverage
+Gemfile.lock
+tmp
+nbproject
+pkg
+*.swp
+spec/dummy

data/.rspec

@@ -0,0 +1 @@
+--colour

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,27 @@
+Copyright (c) 2017 Rémy Coutable, released under the New BSD License
+Copyright (c) 2011 WIMM Labs, released under the New BSD License
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+      this list of conditions and the following disclaimer in the documentation
+      and/or other materials provided with the distribution.
+    * Neither the name of the Rails Dog LLC nor the names of its
+      contributors may be used to endorse or promote products derived from this
+      software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
+CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/README.md

@@ -0,0 +1,74 @@
+SolidusFulfillment is a solidus extension to do fulfillment processing via
+various fulfillment services when a shipment becomes ready.
+
+The extension adds an additional state to the Shipment state machine called
+`fulfilling` which acts as the transition between `ready` and `shipped`.
+
+When a shipment becomes `ready` it is eligible for fulfillment:
+
+1. A `solidus_fulfillment:process` rake task intended to be called from a cron
+  job checks for `ready` shipments (by delegating to the
+  `solidus_fulfillment:process:ready` task) and initiates the fulfillment via
+  the merchant API.
+1. If the fulfillment transaction succeeds, the shipment enters the `fulfilling`
+  state.
+1. The `solidus_fulfillment:process:fulfilling` rake task then queries the
+  merchant's API for tracking numbers of any orders that are being fulfilled.
+1. If the tracking numbers are found, the shipment transitions into the
+  `shipped` state and an email is sent to the customer.
+
+Stock levels can also be updated with the
+`solidus_fulfillment:process:stock_levels` rake task which is intended to be
+called from a cron job.
+
+## Installation
+
+### Add to your gemfile:
+
+```ruby
+gem 'whenever', require: false # if you want whenever to manage the cron job
+gem 'solidus_fulfillment'
+```
+
+### Create config/fulfillment.yml:
+
+```yml
+development:
+  adapter: amazon
+  api_key: <YOUR AMAZON AWS API KEY>
+  secret_key: <YOUR AMAZON AWS SECRET KEY>
+  development_mode: true
+
+test:
+  adapter: amazon
+  api_key: <YOUR AMAZON AWS API KEY>
+  secret_key: <YOUR AMAZON AWS SECRET KEY>
+
+production:
+  adapter: amazon
+  api_key: <YOUR AMAZON AWS API KEY>
+  secret_key: <YOUR AMAZON AWS SECRET KEY>
+```
+
+### Create config/schedule.rb:
+
+```ruby
+every :hour do
+  rake "solidus_fulfillment:process"
+end
+```
+
+### Add to deploy.rb:
+
+```ruby
+require 'whenever/capistrano' # if you want whenever to manage the cron job
+```
+
+### Configure the store
+
+Set the SKU code for your products to be equal to the Amazon fulfillment SKU code.
+
+----
+
+Copyright (c) 2017 Rémy Coutable, released under the New BSD License
+Copyright (c) 2011 WIMM Labs, released under the New BSD License

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => [:spec]
+
+desc 'Generates a dummy app for testing'
+task :test_app do
+  ENV['LIB_NAME'] = 'spree_fulfillment'
+  Rake::Task['common:test_app'].invoke
+end

data/Versionfile

@@ -0,0 +1,4 @@
+# This file is used to designate compatibilty with different versions of Spree
+# Please see http://spreecommerce.com/documentation/extensions.html#versionfile for details
+
+'1.3.x' => { :branch => 'master' }

data/app/models/spree/fulfillment.rb

@@ -0,0 +1,134 @@
+module Spree
+  class Fulfillment
+    CONFIG_FILE = Rails.root.join('config/fulfillment.yml')
+    CONFIG = HashWithIndifferentAccess.new(YAML.load_file(CONFIG_FILE)[Rails.env])
+
+    TrackingInfo = Struct.new(:carrier, :tracking_number, :ship_time) do
+      def to_hash
+        {
+          carrier: carrier,
+          tracking_number: tracking_number,
+          ship_time: ship_time
+        }
+      end
+    end
+
+    def self.service(shipment = nil)
+      ('Solidus::Fulfillment::' + "#{adapter}_fulfillment".camelize).constantize.new(shipment)
+    rescue NameError
+      require "solidus/fulfillment/#{adapter}_fulfillment"
+      retry
+    rescue LoadError
+      log "Spree::Fulfillment.service: cannot load #{'Solidus::Fulfillment::' + "#{adapter}_fulfillment".camelize}"
+    end
+
+    def self.adapter
+      return @adapter if defined?(@adapter)
+
+      @adapter = config[:adapter]
+
+      unless @adapter
+        raise "Missing adapter for #{Rails.env} -- Check config/fulfillment.yml"
+      end
+
+      @adapter
+    end
+
+    def self.fulfill(shipment)
+      service(shipment).fulfill
+    end
+
+    def self.config
+      CONFIG
+    end
+
+    def self.log(msg)
+      Rails.logger.info "**** solidus_fulfillment: #{msg}"
+    end
+
+    # Passes any shipments that are ready to the fulfillment service
+    def self.process_ready
+      log 'Spree::Fulfillment.process_ready start'
+
+      Spree::Shipment.ready.ids.each do |shipment_id|
+        shipment = Spree::Shipment.find(shipment_id)
+
+        next unless shipment && shipment.ready?
+
+        log "Request to ship shipment ##{shipment.id}"
+        begin
+          shipment.ship!
+        rescue => ex
+          log "Spree::Fulfillment.process_ready: Failed to ship id #{shipment.id} due to #{ex}"
+          Airbrake.notify(e) if defined?(Airbrake)
+          # continue on and try other shipments so that one bad shipment doesn't
+          # block an entire queue
+        end
+      end
+    end
+
+    # Gets tracking number and sends ship email when fulfillment house is done
+    def self.process_fulfilling
+      log 'Spree::Fulfillment.process_fulfilling start'
+
+      Spree::Shipment.fulfilling.each do |shipment|
+        next if shipment.shipped?
+
+        tracking_info = remote_tracking_info(shipment)
+        log "Spree::Fulfillment.process_fulfilling: tracking_info #{tracking_info}"
+        next unless tracking_info
+
+        if tracking_info == :error
+          log 'Spree::Fulfillment.process_fulfilling: Could not retrieve' \
+            "tracking information for shipment #{shipment.id} (order ID: "\
+            "#{shipment.number})"
+          shipment.cancel
+        else
+          log 'Spree::Fulfillment.process_fulfilling: Tracking information: ' \
+            "#{tracking_info.inspect}"
+          shipment.attributes = {
+            shipped_at: tracking_info.ship_time,
+            tracking: "#{tracking_info.carrier}::#{tracking_info.tracking_number}"
+          }
+          shipment.ship!
+        end
+      end
+    end
+
+    def self.process_stock_levels
+      log 'Spree::Fulfillment.process_stock_levels start'
+
+      skus = Spree::Variant.pluck(:sku)
+      default_stock_location = Spree::StockLocation.find_by(name: 'default')
+
+      response = service.fetch_stock_levels(skus)
+
+      response.params['stock_levels'].each do |sku, stock|
+        variant = Spree::Variant.find_by(sku: sku)
+        variant.stock_items.
+          find_by(stock_location_id: default_stock_location.id).
+          set_count_on_hand(stock)
+        log "Spree::Fulfillment.process_stock_levels: variant #{variant.inspect} has a new stock level of #{stock}"
+      end
+    end
+
+    def self.remote_tracking_info(shipment)
+      response = service(shipment).fetch_tracking_data
+      return unless response
+
+      tracking_info = TrackingInfo.new(
+        response.params.dig('tracking_companies', shipment.number.to_s)&.first,
+        response.params.dig('tracking_numbers', shipment.number.to_s)&.first,
+        response.params.dig('shipping_date_times', shipment.number.to_s)&.first
+      )
+
+      unless tracking_info.carrier &&
+        tracking_info.tracking_number &&
+        tracking_info.ship_time
+        return :error
+      end
+
+      tracking_info.to_hash
+    end
+  end
+end

data/app/models/spree/shipment_decorator.rb

@@ -0,0 +1,87 @@
+Spree::Shipment.class_eval do
+  scope :fulfilling, -> { with_state('fulfilling') }
+  scope :fulfill_failed, -> { with_state('fulfill_failed') }
+
+  state_machines[:state] = nil # reset original state machine to start from scratch.
+
+  # This is a modified version of the original spree shipment state machine
+  # with the indicated changes.
+  state_machine initial: :pending, use_transactions: false do
+    event :ready do
+      transition from: :pending, to: :shipped, if: :can_transition_from_pending_to_shipped?
+      transition from: :pending, to: :ready, if: :can_transition_from_pending_to_ready?
+    end
+
+    event :pend do
+      transition from: :ready, to: :pending
+    end
+
+    event :ship do
+      transition from: [:ready, :canceled], to: :fulfilling # was to: :shipped
+      # new transition
+      transition from: :fulfilling, to: :shipped
+    end
+    after_transition to: :shipped, do: :after_ship
+
+    # new callback
+    before_transition to: :fulfilling, do: :before_fulfilling
+
+    event :cancel do
+      transition to: :canceled, from: [:pending, :ready]
+      # new transition
+      transition from: :fulfilling, to: :fulfill_failed
+    end
+    after_transition to: :canceled, do: :after_cancel
+
+    event :resume do
+      transition from: :canceled, to: :ready, if: :can_transition_from_canceled_to_ready?
+      transition from: :canceled, to: :pending
+    end
+    after_transition from: :canceled, to: [:pending, :ready, :shipped], do: :after_resume
+
+    after_transition do |shipment, transition|
+      shipment.state_changes.create!(
+        previous_state: transition.from,
+        next_state:     transition.to,
+        name:           'shipment'
+      )
+    end
+  end
+
+  # If there's an error submitting to the fulfillment service, we should halt
+  # the transition to 'fulfill' and stay in 'ready'.  That way transient errors
+  # will get rehandled.  If there are persistent errors, that should be treated
+  # as a bug.
+  def before_fulfilling
+    response = Spree::Fulfillment.fulfill(self) # throws :halt on error, which aborts transition
+
+    # Stop the transition to shipped if there was an error.
+    unless response.success?
+      if Spree::Fulfillment.config[:development_mode] &&
+          response.params['faultstring'] =~ /the SellerSKU for Item Id: \S+ is invalid/
+        Spree::Fulfillment.log 'Ignoring missing catalog item (test / dev setting - should not see this on prod)'
+      else
+        Spree::Fulfillment.log 'Abort - response was in error'
+        throw :halt
+      end
+    end
+  # TODO: Narrow down the catched exception
+  rescue => ex
+    Spree::Fulfillment.log "Spree::Shipment#before_fulfilling failed: #{ex.message}" \
+      "\n#{ex.backtrace}"
+    throw :halt
+  end
+
+  alias_method :orig_determine_state, :determine_state
+  # Determines the appropriate +state+ according to the following logic:
+  #
+  # canceled   if order is canceled
+  # pending    unless order is complete and +order.payment_state+ is +paid+
+  # shipped    if already shipped (ie. does not change the state)
+  # ready      all other cases
+  def determine_state(order)
+    return state if ['fulfilling', 'fulfill_failed', 'shipped'].include?(state)
+
+    orig_determine_state(order)
+  end
+end

data/lib/generators/solidus/fulfillment/install/install_generator.rb

@@ -0,0 +1,8 @@
+module Solidus
+  module Fulfillment
+    module Generators
+      class InstallGenerator < Rails::Generators::Base
+      end
+    end
+  end
+end

data/lib/solidus/fulfillment/amazon_fulfillment.rb

@@ -0,0 +1,189 @@
+require 'active_fulfillment'
+
+ActiveFulfillment::Service.logger = Rails.logger
+ActiveFulfillment::AmazonMarketplaceWebService.class_eval do
+  # Monkeypatch of the original parse_tracking_response to include the shipping date.
+  # Changed lines are marked.
+  def parse_tracking_response(document)
+    response = {
+      tracking_numbers: {},
+      tracking_companies: {},
+      tracking_urls: {},
+      shipping_date_times: {} # Additional key
+    }
+
+    tracking_numbers = document.css('FulfillmentShipmentPackage > member > TrackingNumber'.freeze)
+    if tracking_numbers.present?
+      order_id = document.at_css('FulfillmentOrder > SellerFulfillmentOrderId'.freeze).text.strip
+      response[:tracking_numbers][order_id] = tracking_numbers.map{ |t| t.text.strip }
+    end
+
+    tracking_companies = document.css('FulfillmentShipmentPackage > member > CarrierCode'.freeze)
+    if tracking_companies.present?
+      order_id = document.at_css('FulfillmentOrder > SellerFulfillmentOrderId'.freeze).text.strip
+      response[:tracking_companies][order_id] = tracking_companies.map{ |t| t.text.strip }
+    end
+
+    # Changes start here
+    shipping_date_times = document.css('FulfillmentShipment > member > ShippingDateTime'.freeze)
+    if shipping_date_times.present?
+      response[:shipping_date_times][order_id] = shipping_date_times.map { |t| t.text.strip }
+    end
+    # Changes end here
+
+    response[:response_status] = SUCCESS
+
+    Response.new(success?(response), message_from(response), response)
+  end
+end
+
+module Solidus
+  module Fulfillment
+    class AmazonFulfillment
+      def initialize(shipment = nil)
+        @shipment = shipment
+      end
+
+      # Runs inside a state_machine callback. So throwing :halt is how we abort things.
+      def fulfill
+        sleep 1 # avoid throttle from Amazon
+
+        response = remote.fulfill(order_id, address, line_items, options)
+        Spree::Fulfillment.log "Spree::AmazonFulfillment#fulfill: order_id: " \
+          "#{order_id}\naddress: #{address}\nline_items: #{line_items}\noptions: " \
+          "#{options}\nresponse: #{response.params}"
+
+        response
+      end
+
+      # Returns the tracking number if there is one, else :error if there's a
+      # problem with the shipment that will result in a permanent failure to
+      # fulfill, else nil.
+      def fetch_tracking_data
+        sleep 1 # avoid throttle from Amazon
+
+        response = begin
+          remote.fetch_tracking_data([order_id])
+        rescue => ex
+          Spree::Fulfillment.log 'Spree::AmazonFulfillment#fetch_tracking_data: Failed to get ' \
+            "tracking info for shipment #{@shipment.id} (order ID: #{order_id})"
+          Spree::Fulfillment.log "Spree::AmazonFulfillment#fetch_tracking_data: #{ex}"
+          Airbrake.notify(e) if defined?(Airbrake)
+
+          return nil
+        end
+
+        Spree::Fulfillment.log "Spree::AmazonFulfillment#fetch_tracking_data: #{response.params}"
+
+        response
+      end
+
+      # Returns the stock levels for the given skus
+      def fetch_stock_levels(skus)
+        sleep 1 # avoid throttle from Amazon
+
+        response = begin
+          remote.fetch_stock_levels(skus: skus)
+        rescue => ex
+          Spree::Fulfillment.log 'Spree::AmazonFulfillment#fetch_stock_levels: Failed to get ' \
+            "stock levels"
+          Spree::Fulfillment.log "Spree::AmazonFulfillment#fetch_stock_levels: #{ex}"
+          Airbrake.notify(e) if defined?(Airbrake)
+
+          return nil
+        end
+
+        Spree::Fulfillment.log "Spree::AmazonFulfillment#fetch_stock_levels: #{response.params}"
+
+        response
+      end
+
+      private
+
+      # For Amazon these are the API access key and secret.
+      def credentials
+        @credentials ||= {
+          login: Spree::Fulfillment.config[:api_key],
+          password: Spree::Fulfillment.config[:secret_key],
+          seller_id: Spree::Fulfillment.config[:seller_id]
+        }
+      end
+
+      def remote
+        @remote ||= ActiveFulfillment::Base.service('amazon_marketplace_web').new(credentials)
+      end
+
+      def order_id
+        @order_id ||= @shipment.number
+      end
+
+      def address
+        @address ||= begin
+          ship_address = @shipment.order.ship_address
+
+          {
+            name: "#{ship_address.firstname} #{ship_address.lastname}",
+            address1: ship_address.address1,
+            address2: ship_address.address2,
+            city: ship_address.city,
+            state: ship_address.state.abbr,
+            country: ship_address.state.country.iso,
+            zip: ship_address.zipcode
+          }
+        end
+      end
+
+      def max_quantity_failsafe(quantity)
+        return quantity unless Spree::Fulfillment.config[:max_quantity_failsafe]
+
+        [Spree::Fulfillment.config[:max_quantity_failsafe], quantity].min
+      end
+
+      def line_items
+        @line_items ||= begin
+          skus = @shipment.inventory_units.map do |inventory_unit|
+            sku = inventory_unit.variant.sku
+            raise "Missing sku for #{inventory_unit.variant}" if sku.blank?
+            sku
+          end.uniq
+
+          skus.map do |sku|
+            quantity = @shipment.inventory_units.select do |inventory_unit|
+              inventory_unit.variant.sku == sku
+            end.size
+
+            {
+              sku: sku,
+              quantity: max_quantity_failsafe(quantity)
+            }
+          end
+        end
+      end
+
+      def shipping_method
+        return @shipping_method if defined?(@shipping_method)
+
+        raw_shipping_method = @shipment.shipping_method
+        @shipping_method = 'Standard' unless raw_shipping_method
+        @shipping_method ||=
+          case raw_shipping_method.name.downcase
+          when /expedited/
+            'Expedited'
+          when /priority/
+            'Priority'
+          else
+            'Standard'
+          end
+      end
+
+      def options
+        @options ||= {
+          shipping_method: shipping_method,
+          order_date: @shipment.order.created_at,
+          comment: 'Thank you for your order.',
+          email: @shipment.order.email
+        }
+      end
+    end
+  end
+end

data/lib/solidus/fulfillment/engine.rb

@@ -0,0 +1,14 @@
+module Solidus
+  module Fulfillment
+    class Engine < Rails::Engine
+      isolate_namespace Spree
+      engine_name 'solidus_fulfillment'
+
+      config.to_prepare do
+        Dir.glob(File.join(__dir__, '../../../app/**/*_decorator*.rb')) do |c|
+          require_dependency(c)
+        end
+      end
+    end
+  end
+end

data/lib/solidus_fulfillment.rb

@@ -0,0 +1,2 @@
+require 'solidus_core'
+require 'solidus/fulfillment/engine'

data/lib/tasks/solidus_fulfillment.rake

@@ -0,0 +1,24 @@
+namespace :solidus_fulfillment do
+  desc "Handles shipments that are ready for or have completed fulfillment"
+  task process: :environment do
+    Rake::Task['solidus_fulfillment:process:ready'].invoke
+    Rake::Task['solidus_fulfillment:process:fulfilling'].invoke
+  end
+
+  namespace :process do
+    desc "Passes any shipments that are ready to the fulfillment service"
+    task ready: :environment do
+      Spree::Fulfillment.process_ready
+    end
+
+    desc "Gets tracking number and sends ship email when fulfillment house is done"
+    task fulfilling: :environment do
+      Spree::Fulfillment.process_fulfilling
+    end
+
+    desc "Updates the stock levels"
+    task stock_levels: :environment do
+      Spree::Fulfillment.process_stock_levels
+    end
+  end
+end

data/script/rails

@@ -0,0 +1,7 @@
+# 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_fulfillment/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'

data/solidus_fulfillment.gemspec

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'solidus_fulfillment'
+  s.version     = '2.0.0'
+  s.summary     = 'Solidus extension to do fulfillment processing via various services when a shipment becomes ready'
+  s.description = 'Solidus extension to do fulfillment processing via various services when a shipment becomes ready'
+
+  s.required_ruby_version     = '>= 2.2.7'
+
+  s.author   = 'Rémy Coutable'
+  s.email    = 'remy@rymai.me'
+  s.homepage = 'https://rubygems.org/gems/solidus_fulfillment'
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.require_path = 'lib'
+  s.requirements << 'none'
+
+  s.add_dependency 'solidus_core', '~> 2.1'
+  s.add_dependency 'active_fulfillment'
+
+#  s.add_development_dependency 'capybara', '~> 1.1.2'
+#  s.add_development_dependency 'coffee-rails'
+#  s.add_development_dependency 'factory_girl', '~> 2.6.4'
+#  s.add_development_dependency 'ffaker'
+#  s.add_development_dependency 'rspec-rails',  '~> 2.9'
+#  s.add_development_dependency 'sass-rails'
+#  s.add_development_dependency 'sqlite3'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,46 @@
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+require File.expand_path('../dummy/config/environment.rb',  __FILE__)
+
+require 'rspec/rails'
+require 'ffaker'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
+
+# Requires factories defined in spree_core
+require 'spree/core/testing_support/factories'
+require 'spree/core/testing_support/controller_requests'
+require 'spree/core/testing_support/authorization_helpers'
+require 'spree/core/url_helpers'
+
+RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+
+  # == URL Helpers
+  #
+  # Allows access to Spree's routes in specs:
+  #
+  # visit spree.admin_path
+  # current_path.should eql(spree.products_path)
+  config.include Spree::Core::UrlHelpers
+
+  # == Mock Framework
+  #
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  #
+  # config.mock_with :mocha
+  # config.mock_with :flexmock
+  # config.mock_with :rr
+  config.mock_with :rspec
+
+  # Remove this line if you're not using ActiveRecord or ActiveRecord fixtures
+  config.fixture_path = "#{::Rails.root}/spec/fixtures"
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, remove the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: solidus_fulfillment
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- Rémy Coutable
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: solidus_core
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: active_fulfillment
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Solidus extension to do fulfillment processing via various services when
+  a shipment becomes ready
+email: remy@rymai.me
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- Versionfile
+- app/models/spree/fulfillment.rb
+- app/models/spree/shipment_decorator.rb
+- lib/generators/solidus/fulfillment/install/install_generator.rb
+- lib/solidus/fulfillment/amazon_fulfillment.rb
+- lib/solidus/fulfillment/engine.rb
+- lib/solidus_fulfillment.rb
+- lib/tasks/solidus_fulfillment.rake
+- script/rails
+- solidus_fulfillment.gemspec
+- spec/spec_helper.rb
+homepage: https://rubygems.org/gems/solidus_fulfillment
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.2.7
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- none
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Solidus extension to do fulfillment processing via various services when
+  a shipment becomes ready
+test_files:
+- spec/spec_helper.rb