Creating an extension

This guide requires an update!
Getting Started
Let's build a simple extension. Suppose we want the ability to mark certain products as being on sale. We'd like to be able to set a sale price on a product and show products that are on sale on a separate products page. This is a great example of how an extension can be used to build on the solid Spree foundation.
Before we start, let's make sure we have Spree CLI installed by running:
1
gem install spree_cmd
Copied!
So let's start by generating the extension. Run the following command from a directory of your choice outside of our Spree application:
1
spree extension simple_sales
Copied!
This creates a spree_simple_sales directory with several additional files and directories. After generating the extension make sure you change to its directory:
1
cd spree_simple_sales
Copied!
Adding a Sale Price to Variants
The first thing we need to do is create a migration that adds a sale_price column to variants.
We can do this with the following command:
1
bundle exec rails g migration add_sale_price_to_spree_variants sale_price:decimal
Copied!
Because we are dealing with prices, we need to now edit the generated migration to ensure the correct precision and scale. Edit the file db/migrate/XXXXXXXXXXX_add_sale_price_to_spree_variants.rb so that it contains the following:
1
class AddSalePriceToSpreeVariants < SpreeExtension::Migration
2
  def change
3
    add_column :spree_variants, :sale_price, :decimal, precision: 8, scale: 2
4
  end
5
end
Copied!
 We're not inheriting directly from ActiveRecord::Migration, instead we're using [SpreeExtension::Migration](https://github.com/spree-contrib/spree_extension/blob/master/lib/spree_extension/migration.rb) to support multiple Rails versions.
Adding Our Extension to the Spree Application
Before we continue development of our extension, let's add it to the Spree application.
Within the my_store application directory, add the following line to the bottom of our Gemfile:
1
gem 'spree_simple_sales', path: '../spree_simple_sales'
Copied!
You may have to adjust the path somewhat depending on where you created the extension. You want this to be the path relative to the location of the my_store application.
Once you have added the gem, it's time to bundle:
1
bundle install
Copied!
Finally, let's run the spree_simple_sales install generator to copy over the migration we just created (answer yes if prompted to run migrations):
1
# context: Your Spree store's app root (i.e. Rails.root); not the extension's root path.
2
bundle exec rails g spree_simple_sales:install
Copied!
Adding a Controller Action to HomeController
Now we need to extend Spree::HomeController and add an action that selects "on sale" products.
 Note for the sake of this example that `Spree::HomeController` is only included in spree_frontend so you need to make it a dependency on your extensions *.gemspec file.
Make sure you are in the spree_simple_sales root directory and run the following command to create the directory structure for our controller decorator:
1
mkdir -p app/controllers/spree_simple_sales/spree
Copied!
Next, create a new file in the directory we just created called home_controller_decorator.rb and add the following content to it:
1
module SpreeSimpleSales
2
  module Spree
3
    module HomeControllerDecorator
4
      def sale
5
        @products = ::Spree::Product.joins(:variants_including_master).where('spree_variants.sale_price is not null').distinct
6
      end
7
    end
8
  end
9
end
10
​
11
Spree::HomeController.prepend SpreeSimpleSales::Spree::HomeControllerDecorator
Copied!
This will select just the products that have a variant with a sale_price set.
We also need to add a route to this action in our config/routes.rb file. Let's do this now. Update the routes file to contain the following:
1
Spree::Core::Engine.routes.draw do
2
  get "/sale" => "home#sale"
3
end
Copied!
Viewing On Sale Products
Setting the Sale Price for a Variant
Now that our variants have the attribute sale_price available to them, let's update the sample data so we have at least one product that is on sale in our application. We will need to do this in the rails console for the time being, as we have no admin interface to set sale prices for variants. So, in order to do this, first open up the rails console:
1
bundle exec rails c
Copied!
Now, follow the steps I take in selecting a product and updating its master variant to have a sale price. Note, you may not be editing the exact same product as I am, but this is not important. We just need one "on sale" product to display on the sales page.
1
> product = Spree::Product.first
2
=> #<Spree::Product id: 107377505, name: "Spree Bag", description: "Lorem ipsum dolor sit amet, consectetuer adipiscing...", available_on: "2013-02-13 18:30:16", deleted_at: nil, permalink: "spree-bag", meta_description: nil, meta_keywords: nil, tax_category_id: 25484906, shipping_category_id: nil, count_on_hand: 10, created_at: "2013-02-13 18:30:16", updated_at: "2013-02-13 18:30:16", on_demand: false>
3
​
4
> variant = product.master
5
=> #<Spree::Variant id: 833839126, sku: "SPR-00012", weight: nil, height: nil, width: nil, depth: nil, deleted_at: nil, is_master: true, product_id: 107377505, count_on_hand: 10, cost_price: #<BigDecimal:7f8dda5eebf0,'0.21E2',9(36)>, position: nil, lock_version: 0, on_demand: false, cost_currency: nil, sale_price: nil>
6
​
7
> variant.sale_price = 8.00
8
=> 8.0
9
​
10
> variant.save
11
=> true
Copied!
Decorating Variants
Let's fix our extension so that it uses the sale_price when it is present.
First, create the required directory structure for our new decorator:
1
mkdir -p app/models/spree_simple_sales/spree
Copied!
Next, create the file app/models/spree_simple_sales/spree/variant_decorator.rb and add the following content to it:
1
module SpreeSimpleSales
2
  module Spree
3
    module VariantDecorator
4
      def price_in(currency)
5
        return super unless sale_price.present?
6
        ::Spree::Price.new(variant_id: self.id, amount: self.sale_price, currency: currency)
7
      end
8
    end
9
  end
10
end
11
​
12
Spree::Variant.prepend SpreeSimpleSales::Spree::VariantDecorator
Copied!
If there is a sale_price present on the product's master variant, we return that price. Otherwise, we call the original implementation of price_in (using return super).
Testing Our Decorator
It's always a good idea to test your code. We should be extra careful to write tests for our Variant decorator since we are modifying core Spree functionality. Let's write a couple of simple unit tests for variant_decorator.rb
Generating the Test App
An extension is not a full Rails application, so we need something to test our extension against. By running the Spree test_app rake task, we can generate a barebones Spree application within our spec directory to run our tests against.
We can do this with the following command from the root directory of our extension:
1
bundle exec rake test_app
Copied!
After this command completes, you should be able to run rspec and see the following output:
1
No examples found.
2
​
3
Finished in 0.00005 seconds
4
0 examples, 0 failures
Copied!
Great! We're ready to start adding some tests. Let's replicate the extension's directory structure in our spec directory by running the following command
1
mkdir -p spec/models/spree
Copied!
Now, let's create a new file in this directory called variant_decorator_spec.rb and add the following tests to it:
1
require 'spec_helper'
2
​
3
describe Spree::Variant do
4
  describe "#price_in" do
5
    it "returns the sale price if it is present" do
6
      variant = create(:variant, sale_price: 8.00)
7
      expected = Spree::Price.new(variant_id: variant.id, currency: "USD", amount: variant.sale_price)
8
​
9
      result = variant.price_in("USD")
10
​
11
      expect(result.variant_id).to eq(expected.variant_id)
12
      expect(result.amount.to_f).to eq(expected.amount.to_f)
13
      expect(result.currency).to eq(expected.currency)
14
    end
15
​
16
    it "returns the normal price if it is not on sale" do
17
      variant = create(:variant, price: 15.00)
18
      expected = Spree::Price.new(variant_id: variant.id, currency: "USD", amount: variant.price)
19
​
20
      result = variant.price_in("USD")
21
​
22
      expect(result.variant_id).to eq(expected.variant_id)
23
      expect(result.amount.to_f).to eq(expected.amount.to_f)
24
      expect(result.currency).to eq(expected.currency)
25
    end
26
  end
27
end
Copied!
These specs test that the price_in method we overrode in our VariantDecorator returns the correct price both when the sale price is present and when it is not.
Summary
In this tutorial, you learned how to both install extensions and create your own. A lot of core Spree development concepts were covered and you gained exposure to some of the Spree internals.

🎁Extensions - Previous

Extensions

Next - 🌏Deployment

AWS

Last modified 3mo ago

Copy link

Edit on GitHub

Contents

Getting Started

Adding a Sale Price to Variants

Adding Our Extension to the Spree Application

Adding a Controller Action to HomeController

Viewing On Sale Products

Setting the Sale Price for a Variant

Decorating Variants

Testing Our Decorator

Generating the Test App

Summary