stall 0.2.0 → 0.3.1

data/lib/para/stall/inputs/variant_select_input.rb

@@ -0,0 +1,79 @@
+module Para
+  module Stall
+    module Inputs
+      class VariantSelectInput < SimpleForm::Inputs::Base
+        include VariantInputHelper
+
+        def input(wrapper_options = nil)
+          ensure_target_relation_present!
+
+          template.render partial: partial_path, locals: {
+            form: @builder,
+            model: model,
+            attribute_name: attribute_name,
+            foreign_key: foreign_key,
+            properties: properties,
+            variants_data: variants_data,
+            price_selector: price_selector
+          }
+        end
+
+        private
+
+        def price_selector
+          @price_selector ||= options[:price_selector] || '[data-sellable-price]'
+        end
+
+        def product
+          @product ||= options[:product]
+        end
+
+        def relation
+          @relation ||= options.fetch(:relation, :variants)
+        end
+
+        # Iterate on every variant to fetch available properties and values and
+        # build a VariantsPropertyConfig for each available one
+        #
+        def properties
+          @properties ||= variants.each_with_object({}) do |variant, hash|
+            variant.variant_property_values.each do |variant_property_value|
+              property = variant_property_value.property_value.property
+
+              unless hash[property]
+                hash[property] = VariantsPropertyConfig.new(
+                  product, property, variants
+                )
+              end
+            end
+          end.values
+        end
+
+        def variants
+          @variants ||= options.fetch(:variants) do
+            product.variants.select(&:published?)
+          end
+        end
+
+        def partial_path
+          options.fetch(:partial_path, 'para/stall/inputs/variant_select')
+        end
+
+        def foreign_key
+          @foreign_key ||= model.reflect_on_association(attribute_name).foreign_key
+        end
+
+        def variants_data
+          @variants_data ||= variants.map do |variant|
+            { id: variant.id, price: template.number_to_currency(variant.price) }.tap do |data|
+              properties.each do |property_config|
+                data[property_config.property.id] =
+                  property_config.property_value_for(variant).id
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/para/stall/inputs/variants_matrix_input.rb

@@ -0,0 +1,72 @@
+module Para
+  module Stall
+    module Inputs
+      class VariantsMatrixInput < SimpleForm::Inputs::Base
+        include VariantInputHelper
+
+        def initialize(*)
+          super
+          options[:label] = false
+        end
+
+        def input(wrapper_options = nil)
+          ensure_target_relation_present!
+
+          template.render partial: 'para/stall/inputs/variants_matrix', locals: {
+            form: @builder,
+            model: model,
+            attribute_name: attribute_name,
+            all_properties: all_properties,
+            properties: properties,
+            variants: variants,
+            require_all_properties: require_all_properties,
+            dom_identifier: dom_identifier,
+            variant_row_locals: variant_row_locals
+          }
+        end
+
+        private
+
+        def all_properties
+          @all_properties ||= Property.includes(:property_values).all.map do |property|
+            VariantsPropertyConfig.new(resource, property, unsorted_variants)
+          end
+        end
+
+        def properties
+          @properties ||= all_properties.select(&:active?)
+        end
+
+        def unsorted_variants
+          @unsorted_variants ||= resource.send(attribute_name)
+        end
+
+        def variants
+          @variants ||= unsorted_variants.sort_by(&method(:variant_sort_method))
+        end
+
+        def require_all_properties
+          options[:require_all_properties] || false
+        end
+
+        def dom_identifier
+          @dom_identifier ||= [
+            model.model_name.element,
+            resource.id || resource.object_id,
+            attribute_name
+          ].join('-')
+        end
+
+        def variant_row_locals
+          {
+            model: model,
+            attribute_name: attribute_name,
+            all_properties: all_properties,
+            properties: properties,
+            dom_identifier: dom_identifier
+          }
+        end
+      end
+    end
+  end
+end

data/lib/para/stall/routes.rb

@@ -0,0 +1,11 @@
+module Para
+  module Stall
+    class Routes < Para::Plugins::Routes
+      def draw
+        plugin :stall do
+          crud_component controller: '/para/stall/admin/carts'
+        end
+      end
+    end
+  end
+end

data/lib/para/stall/variants_property_config.rb

@@ -0,0 +1,78 @@
+module Para
+  module Stall
+    class VariantsPropertyConfig
+      attr_reader :resource, :property, :variants
+
+      def initialize(resource, property, variants)
+        @resource = resource
+        @property = property
+        @variants = variants
+      end
+
+      def options
+        property.property_values.map do |property_value|
+          [
+            property_value.value,
+            property_value.id,
+            selected: property_value_used?(property_value),
+            data: { name: property_value.value }
+          ]
+        end
+      end
+
+      def active?
+        variants.any? do |variant|
+          variant.variant_property_values.any? do |variant_property_value|
+            variant_property_value.property_value.try(:property) == property
+          end
+        end
+      end
+
+      def current_value
+        @current_value ||= property.property_values.find do |property_value|
+          property_value_used?(property_value)
+        end
+      end
+
+      def available_options
+        @available_options ||= property.property_values.each_with_object([]) do |property_value, ary|
+          if property_value_used?(property_value)
+            ary << [property_value.value, property_value.id]
+          end
+        end
+      end
+
+      def property_value_for(variant)
+        variant_property_value_for(variant).try(:property_value)
+      end
+
+      def variant_property_value_for(variant)
+        variant_property_value = variant.variant_property_values.find do |variant_property_value|
+          variant_property_value.property_value.try(:property) == property
+        end
+      end
+
+      def variant_property_value_or_build_for(variant)
+        variant_property_value_for(variant) || variant.variant_property_values.build
+      end
+
+      private
+
+      def variant_model
+        @variant_model ||= resource.class.reflect_on_association(relation).klass
+      end
+
+      def reflection
+        @reflection ||= variant_model.reflect_on_association(property.name)
+      end
+
+      def property_value_used?(property_value)
+        variants.any? do |variant|
+          variant.variant_property_values.any? do |variant_property_value|
+            variant_property_value.property_value == property_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/stall.rb

@@ -6,11 +6,15 @@ require 'haml-rails'
 require 'simple_form'
 require 'country_select'
 require 'cocoon'
+require 'deep_merge/rails_compat'
+require 'para'
 
 require 'stall/rails/routing_mapper'
 require 'stall/rails/currency_helper'
 require 'stall/engine'
 
+require 'para/stall'
+
 module Stall
   extend ActiveSupport::Autoload
 
@@ -19,6 +23,11 @@ module Stall
   autoload :Addresses
   autoload :Priceable
   autoload :Payable
+  autoload :Shippable
+  autoload :Adjustable
+  autoload :DefaultCurrencyManager
+  autoload :ReferenceManager
+  autoload :TotalPricesManager
 
   autoload :Checkout
   autoload :Shipping
@@ -26,6 +35,7 @@ module Stall
 
   autoload :Routes
   autoload :CartHelper
+  autoload :ArchivedPaidCartHelper
   autoload :Config
   autoload :Utils
 

data/lib/stall/addressable.rb

@@ -6,67 +6,19 @@ module Stall
     extend ActiveSupport::Concern
 
     included do
-      has_many :address_ownerships, as: :addressable, dependent: :destroy,
-                                    inverse_of: :addressable
-
-      has_many :addresses, through: :address_ownerships
-      accepts_nested_attributes_for :address_ownerships, allow_destroy: true
+      has_one :shipping_address, as: :addressable,
+                                 class_name: 'ShippingAddress',
+                                 dependent: :destroy,
+                                 inverse_of: :addressable
+      accepts_nested_attributes_for :shipping_address, allow_destroy: true
+
+      has_one :billing_address, as: :addressable,
+                                class_name: 'BillingAddress',
+                                dependent: :destroy,
+                                inverse_of: :addressable
+      accepts_nested_attributes_for :billing_address, allow_destroy: true
 
       attr_accessor :use_another_address_for_billing
     end
-
-    def address_ownership_for(type)
-      address_ownerships.find do |ownership|
-        ownership.public_send(type)
-      end if [:shipping, :billing].include?(type.to_sym)
-    end
-
-    # Provide billing and shipping address fetching and assigning shortcuts by
-    # using the address ownerships
-    #
-    [:shipping, :billing].each do |type|
-      instance_variable_name = :"@#{ type }_address"
-
-      define_method(:"#{ type }_address=") do |address|
-        ownership = address_ownership_for(type) || address_ownerships.build(type => true)
-        ownership.address = address
-        instance_variable_set(instance_variable_name, address)
-      end
-
-      define_method(:"build_#{ type }_address") do |attributes = {}|
-        if (ownership = address_ownership_for(type))
-          ownership.send(:"#{ type }=", false)
-        end
-
-        ownership = address_ownerships.build(type => true)
-        address = ownership.build_address(attributes)
-        instance_variable_set(instance_variable_name, address)
-      end
-
-      define_method(:"#{ type }_address") do
-        if (address = instance_variable_get(instance_variable_name))
-          return address
-        end
-
-        if (ownership = address_ownership_for(type))
-          instance_variable_set(instance_variable_name, ownership.address)
-        end
-      end
-
-      define_method(:"#{ type }_address_attributes=") do |attributes|
-        attributes.delete(:id)
-
-        ownership = address_ownership_for(type) || address_ownerships.build(type => true)
-        address = ownership.address || ownership.build_address
-        address.assign_attributes(attributes)
-        instance_variable_set(instance_variable_name, address)
-      end
-
-      define_method(:"mark_address_ownership_as_#{ type }") do |ownership|
-        ownership.send(:"mark_as_#{ type }").tap do
-          instance_variable_set(instance_variable_name, ownership.address)
-        end
-      end
-    end
   end
 end

data/lib/stall/addresses.rb

@@ -3,6 +3,7 @@ module Stall
     extend ActiveSupport::Autoload
 
     autoload :CopierBase
+    autoload :Copy
     autoload :CopySourceToTarget
     autoload :PrefillTargetFromSource
   end

data/lib/stall/addresses/copier_base.rb

@@ -16,7 +16,9 @@ module Stall
 
       def duplicate_attributes(model)
         model.attributes.dup.tap do |attributes|
-          attributes.delete('id')
+          %w(id type addressable_id addressable_type created_at updated_at).each do |key|
+            attributes.delete(key)
+          end
         end
       end
     end

data/lib/stall/addresses/copy.rb

@@ -0,0 +1,10 @@
+# Allows copying
+module Stall
+  module Addresses
+    class Copy < Stall::Addresses::CopierBase
+      def copy
+        target.assign_attributes(duplicate_attributes(source))
+      end
+    end
+  end
+end

data/lib/stall/addresses/copy_source_to_target.rb

@@ -8,36 +8,22 @@ module Stall
       end
 
       def copy
-        copy_shipping_address
-        copy_billing_address
+        copy_address(:shipping)
+        copy_address(:billing)
       end
 
       private
 
-      def copy_shipping_address
-        # Update or create target's shipping address with source's shipping
-        # address attributes
-        if target.shipping_address
-          target.shipping_address.assign_attributes(duplicate_attributes(source.shipping_address))
-        else
-          target.build_shipping_address(duplicate_attributes(source.shipping_address))
-        end
-      end
+      # Update or create target address with source attributes
+      #
+      def copy_address(type)
+        address = target.send(:"#{ type }_address") || target.send(:"build_#{ type }_address")
 
-      def copy_billing_address
-        # If the source uses the same address for shipping and billing, we
-        # reproduce this behavior ont the target
-        if source.shipping_address == source.billing_address
-          shipping_ownership = target.address_ownership_for(:shipping)
-          target.mark_address_ownership_as_billing(shipping_ownership)
-        # If the source has a separate billing address, we update or create the
-        # target's billing address with the source's one attributes
+        if (source_address = source.send(:"#{ type }_address"))
+          attributes = duplicate_attributes(source_address)
+          address.assign_attributes(attributes)
         else
-          if target.billing_address
-            target.billing_address.assign_attributes(duplicate_attributes(source.billing_address))
-          else
-            target.build_billing_address(duplicate_attributes(source.billing_address))
-          end
+          address.try(:mark_for_destruction)
         end
       end
     end

data/lib/stall/addresses/prefill_target_from_source.rb

@@ -2,26 +2,18 @@ module Stall
   module Addresses
     class PrefillTargetFromSource < Stall::Addresses::CopierBase
       def copy
-        prefill_shipping_address
-        prefill_billing_address
+        prefill_address(:shipping)
+        prefill_address(:billing)
       end
 
       private
 
-      def prefill_shipping_address
-        if source.shipping_address && !target.shipping_address
-          target.build_shipping_address(duplicate_attributes(source.shipping_address))
-        elsif !target.shipping_address
-          target.build_shipping_address
-        end
-      end
-
-      def prefill_billing_address
-        if source.billing_address && !target.billing_address
-          target.build_billing_address(duplicate_attributes(source.billing_address))
-        elsif !target.billing_address || target.billing_address == target.shipping_address
-          target.address_ownership_for(:shipping).billing = false
-          target.build_billing_address
+      def prefill_address(type)
+        if source.send("#{ type }_address") && !target.send("#{ type }_address")
+          attributes = duplicate_attributes(source.send("#{ type }_address"))
+          target.send("build_#{ type }_address", attributes)
+        elsif !target.send("#{ type }_address")
+          target.send("build_#{ type }_address")
         end
       end
     end