solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/store_credit.rb

@@ -15,7 +15,7 @@ class Spree::StoreCredit < Spree::Base
   belongs_to :user, class_name: Spree::UserClassHandle.new
   belongs_to :created_by, class_name: Spree::UserClassHandle.new
   belongs_to :category, class_name: "Spree::StoreCreditCategory"
-  belongs_to :credit_type, class_name: 'Spree::StoreCreditType', :foreign_key => 'type_id'
+  belongs_to :credit_type, class_name: 'Spree::StoreCreditType', foreign_key: 'type_id'
   has_many :store_credit_events
 
   validates_presence_of :user_id, :category_id, :type_id, :created_by_id, :currency
@@ -44,7 +44,7 @@ class Spree::StoreCredit < Spree::Base
     amount - amount_used - amount_authorized
   end
 
-  def authorize(amount, order_currency, options={})
+  def authorize(amount, order_currency, options = {})
     authorization_code = options[:action_authorization_code]
     if authorization_code
       if store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
@@ -62,7 +62,7 @@ class Spree::StoreCredit < Spree::Base
         action_originator: options[:action_originator],
         action_authorization_code: authorization_code,
 
-        amount_authorized: self.amount_authorized + amount,
+        amount_authorized: amount_authorized + amount
       })
       authorization_code
     else
@@ -77,10 +77,10 @@ class Spree::StoreCredit < Spree::Base
     elsif currency != order_currency
       errors.add(:base, Spree.t('store_credit.currency_mismatch'))
     end
-    return errors.blank?
+    errors.blank?
   end
 
-  def capture(amount, authorization_code, order_currency, options={})
+  def capture(amount, authorization_code, order_currency, options = {})
     return false unless authorize(amount, order_currency, action_authorization_code: authorization_code)
     auth_event = store_credit_events.find_by!(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
 
@@ -95,8 +95,8 @@ class Spree::StoreCredit < Spree::Base
           action_originator: options[:action_originator],
           action_authorization_code: authorization_code,
 
-          amount_used: self.amount_used + amount,
-          amount_authorized: self.amount_authorized - auth_event.amount,
+          amount_used: amount_used + amount,
+          amount_authorized: amount_authorized - auth_event.amount
         })
         authorization_code
       end
@@ -106,15 +106,15 @@ class Spree::StoreCredit < Spree::Base
     end
   end
 
-  def void(authorization_code, options={})
+  def void(authorization_code, options = {})
     if auth_event = store_credit_events.find_by(action: AUTHORIZE_ACTION, authorization_code: authorization_code)
-      self.update_attributes!({
+      update_attributes!({
         action: VOID_ACTION,
         action_amount: auth_event.amount,
         action_authorization_code: authorization_code,
         action_originator: options[:action_originator],
 
-        amount_authorized: amount_authorized - auth_event.amount,
+        amount_authorized: amount_authorized - auth_event.amount
       })
       true
     else
@@ -123,11 +123,11 @@ class Spree::StoreCredit < Spree::Base
     end
   end
 
-  def credit(amount, authorization_code, order_currency, options={})
+  def credit(amount, authorization_code, order_currency, options = {})
     # Find the amount related to this authorization_code in order to add the store credit back
     capture_event = store_credit_events.find_by(action: CAPTURE_ACTION, authorization_code: authorization_code)
 
-    if currency != order_currency  # sanity check to make sure the order currency hasn't changed since the auth
+    if currency != order_currency # sanity check to make sure the order currency hasn't changed since the auth
       errors.add(:base, Spree.t('store_credit.currency_mismatch'))
       false
     elsif capture_event && amount <= capture_event.amount
@@ -135,7 +135,7 @@ class Spree::StoreCredit < Spree::Base
         action: CREDIT_ACTION,
         action_amount: amount,
         action_originator: options[:action_originator],
-        action_authorization_code: authorization_code,
+        action_authorization_code: authorization_code
       }
       create_credit_record(amount, action_attributes)
       true
@@ -162,7 +162,7 @@ class Spree::StoreCredit < Spree::Base
   end
 
   def generate_authorization_code
-    "#{self.id}-SC-#{Time.current.utc.strftime("%Y%m%d%H%M%S%6N")}"
+    "#{id}-SC-#{Time.current.utc.strftime('%Y%m%d%H%M%S%6N')}"
   end
 
   def editable?
@@ -208,7 +208,7 @@ class Spree::StoreCredit < Spree::Base
 
   private
 
-  def create_credit_record(amount, action_attributes={})
+  def create_credit_record(amount, action_attributes = {})
     # Setting credit_to_new_allocation to true will create a new allocation anytime #credit is called
     # If it is not set, it will update the store credit's amount in place
     credit = if Spree::Config[:credit_to_new_allocation]
@@ -225,17 +225,17 @@ class Spree::StoreCredit < Spree::Base
   def create_credit_record_params(amount)
     {
       amount: amount,
-      user_id: self.user_id,
-      category_id: self.category_id,
-      created_by_id: self.created_by_id,
-      currency: self.currency,
-      type_id: self.type_id,
-      memo: credit_allocation_memo,
+      user_id: user_id,
+      category_id: category_id,
+      created_by_id: created_by_id,
+      currency: currency,
+      type_id: type_id,
+      memo: credit_allocation_memo
     }
   end
 
   def credit_allocation_memo
-    Spree.t("store_credit.credit_allocation_memo", id: self.id)
+    Spree.t("store_credit.credit_allocation_memo", id: id)
   end
 
   def store_event
@@ -252,7 +252,7 @@ class Spree::StoreCredit < Spree::Base
       authorization_code: action_authorization_code || event.authorization_code || generate_authorization_code,
       user_total_amount: user.total_available_store_credit,
       originator: action_originator,
-      update_reason: update_reason,
+      update_reason: update_reason
     })
   end
 
@@ -283,7 +283,7 @@ class Spree::StoreCredit < Spree::Base
   end
 
   def associate_credit_type
-    unless self.type_id
+    unless type_id
       credit_type_name = category.try(:non_expiring?) ? Spree.t("store_credit.non_expiring") : Spree.t("store_credit.expiring")
       self.credit_type = Spree::StoreCreditType.find_by_name(credit_type_name)
     end

data/app/models/spree/store_credit_category.rb

@@ -5,7 +5,7 @@ class Spree::StoreCreditCategory < Spree::Base
   class_attribute :reimbursement_category_name
   self.reimbursement_category_name = Spree.t("store_credit_category.default")
 
-  def self.reimbursement_category(reimbursement)
+  def self.reimbursement_category(_reimbursement)
     Spree::StoreCreditCategory.find_by(name: reimbursement_category_name) ||
       Spree::StoreCreditCategory.first
   end
@@ -13,5 +13,4 @@ class Spree::StoreCreditCategory < Spree::Base
   def non_expiring?
     self.class.non_expiring_credit_types.include? name
   end
-
 end

data/app/models/spree/tax/item_adjuster.rb

@@ -0,0 +1,37 @@
+module Spree
+  module Tax
+    # Adjust a single taxable item (line item or shipment)
+    class ItemAdjuster
+      attr_reader :item, :order
+
+      include TaxHelpers
+
+      # @param [Spree::LineItem,Spree::Shipment] item to adjust
+      # @param [Hash] options like already known tax rates for the order's zone
+      def initialize(item, options = {})
+        @item = item
+        @order = @item.order
+        # set instance variable so `TaxRate.match` is only called when necessary
+        @rates_for_order_zone = options[:rates_for_order_zone]
+        @rates_for_default_zone = options[:rates_for_default_zone]
+        @order_tax_zone = options[:order_tax_zone]
+        @skip_destroy_adjustments = options[:skip_destroy_adjustments]
+      end
+
+      # Deletes all existing tax adjustments and creates new adjustments for all
+      # (geographically and category-wise) applicable tax rates.
+      #
+      # Creating the adjustments will also run the ItemAdjustments class and
+      # persist all taxation and promotion totals on the item.
+      #
+      # @return [Array<Spree::Adjustment>] newly created adjustments
+      def adjust!
+        return unless order_tax_zone(order)
+        # Using .destroy_all to make sure callbacks fire
+        item.adjustments.tax.destroy_all unless @skip_destroy_adjustments
+
+        rates_for_item(item).map { |rate| rate.adjust(order_tax_zone(order), item) }
+      end
+    end
+  end
+end

data/app/models/spree/tax/order_adjuster.rb

@@ -0,0 +1,38 @@
+module Spree
+  module Tax
+    # Add tax adjustments to all line items and shipments in an order
+    class OrderAdjuster
+      attr_reader :order
+
+      include TaxHelpers
+
+      # @param [Spree::Order] order to be adjusted
+      def initialize(order)
+        @order = order
+      end
+
+      # Creates tax adjustments for all taxable items (shipments and line items)
+      # in the given order.
+      def adjust!
+        return unless order_tax_zone(order)
+
+        order.all_adjustments.tax.destroy_all
+
+        (order.line_items + order.shipments).each do |item|
+          ItemAdjuster.new(item, order_wide_options).adjust!
+        end
+      end
+
+      private
+
+      def order_wide_options
+        {
+          rates_for_order_zone: rates_for_order_zone(order),
+          rates_for_default_zone: rates_for_default_zone,
+          order_tax_zone: order_tax_zone(order),
+          skip_destroy_adjustments: true
+        }
+      end
+    end
+  end
+end

data/app/models/spree/tax/shipping_rate_taxer.rb

@@ -0,0 +1,31 @@
+module Spree
+  module Tax
+    # Used to build shipping rate taxes
+    class ShippingRateTaxer
+      include TaxHelpers
+
+      # Build shipping rate taxes for a shipping rate
+      # Modifies the passed-in shipping rate with associated shipping rate taxes.
+      # @param [Spree::ShippingRate] shipping_rate The shipping rate to add taxes to.
+      #   This parameter will be modified.
+      # @return [Spree::ShippingRate] The shipping rate with associated tax objects
+      def tax(shipping_rate)
+        tax_rates_for_shipping_rate(shipping_rate).each do |tax_rate|
+          shipping_rate.taxes.build(
+            amount: tax_rate.compute_amount(shipping_rate),
+            tax_rate: tax_rate
+          )
+        end
+        shipping_rate
+      end
+
+      private
+
+      def tax_rates_for_shipping_rate(shipping_rate)
+        applicable_rates(shipping_rate.order).select do |tax_rate|
+          tax_rate.tax_category == shipping_rate.tax_category
+        end
+      end
+    end
+  end
+end

data/app/models/spree/tax/tax_helpers.rb

@@ -0,0 +1,49 @@
+module Spree
+  module Tax
+    module TaxHelpers
+      private
+
+      # Imagine with me this scenario:
+      # You are living in Spain and you have a store which ships to France.
+      # Spain is therefore your default tax rate.
+      # When you ship to Spain, you want the Spanish rate to apply.
+      # When you ship to France, you want the French rate to apply.
+      #
+      # Normally, Spree would notice that you have two potentially applicable
+      # tax rates for one particular item.
+      # When you ship to Spain, only the Spanish one will apply.
+      # When you ship to France, you'll see a Spanish refund AND a French tax.
+      # This little bit of code at the end stops the Spanish refund from appearing.
+      #
+      # For further discussion, see https://github.com/spree/spree/issues/4397 and https://github.com/spree/spree/issues/4327.
+      def applicable_rates(order)
+        order_zone_tax_categories = rates_for_order_zone(order).map(&:tax_category)
+        default_rates_with_unmatched_tax_category = rates_for_default_zone.to_a.delete_if do |default_rate|
+          order_zone_tax_categories.include?(default_rate.tax_category)
+        end
+
+        (rates_for_order_zone(order) + default_rates_with_unmatched_tax_category).uniq
+      end
+
+      def rates_for_order_zone(order)
+        @rates_for_order_zone ||= Spree::TaxRate.for_zone(order_tax_zone(order))
+      end
+
+      def rates_for_default_zone
+        @rates_for_default_zone ||= Spree::TaxRate.for_zone(Spree::Zone.default_tax)
+      end
+
+      def order_tax_zone(order)
+        @order_tax_zone ||= order.tax_zone
+      end
+
+      def sum_of_included_tax_rates(item)
+        rates_for_item(item).map(&:amount).sum
+      end
+
+      def rates_for_item(item)
+        applicable_rates(item.order).select { |rate| rate.tax_category == item.tax_category }
+      end
+    end
+  end
+end

data/app/models/spree/tax/tax_location.rb

@@ -0,0 +1,33 @@
+module Spree
+  module Tax
+    # A class exclusively used as a drop-in replacement for a default tax address.
+    # It responds to `:country_id` and `:state_id`.
+    #
+    # @attr_reader [Integer] country_id the ID of a Spree::Country object
+    # @attr_reader [Integer] state_id the ID of a Spree::State object
+    class TaxLocation
+      attr_reader :country_id, :state_id
+
+      # Create a new TaxLocation object
+      #
+      # @see Spree::Zone.for_address
+      #
+      # @param [Spree::Country] country a Spree::Country object, default: nil
+      # @param [Spree::State] state a Spree::State object, default: nil
+      #
+      # @return [Spree::Tax::TaxLocation] a Spree::Tax::TaxLocation object
+      def initialize(country: nil, state: nil)
+        @country_id = country && country.id
+        @state_id = state && state.id
+      end
+
+      def ==(other)
+        state_id == other.state_id && country_id == other.country_id
+      end
+
+      def empty?
+        country_id.nil? && state_id.nil?
+      end
+    end
+  end
+end

data/app/models/spree/tax_category.rb

@@ -13,7 +13,7 @@ module Spree
 
     def ensure_one_default
       if is_default
-        Spree::TaxCategory.where(is_default: true).where.not(id: self.id).update_all(is_default: false, updated_at: Time.current)
+        Spree::TaxCategory.where(is_default: true).where.not(id: id).update_all(is_default: false, updated_at: Time.current)
       end
     end
   end

data/app/models/spree/tax_rate.rb

@@ -22,90 +22,17 @@ module Spree
     belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
 
     has_many :adjustments, as: :source
+    has_many :shipping_rate_taxes, class_name: "Spree::ShippingRateTax"
 
     validates :amount, presence: true, numericality: true
     validates :tax_category_id, presence: true
     validates_with DefaultTaxZoneValidator
 
-    scope :by_zone, ->(zone) { where(zone_id: zone) }
+    # Finds all tax rates whose zones match a given address
+    scope :for_address, ->(address) { joins(:zone).merge(Spree::Zone.for_address(address)) }
 
-    # Gets the array of TaxRates appropriate for the specified order
-    def self.match(order_tax_zone)
-      return [] unless order_tax_zone
-      rates = includes(zone: { zone_members: :zoneable }).load.select do |rate|
-        # Why "potentially"?
-        # Go see the documentation for that method.
-        rate.potentially_applicable?(order_tax_zone)
-      end
-
-      # Imagine with me this scenario:
-      # You are living in Spain and you have a store which ships to France.
-      # Spain is therefore your default tax rate.
-      # When you ship to Spain, you want the Spanish rate to apply.
-      # When you ship to France, you want the French rate to apply.
-      #
-      # Normally, Spree would notice that you have two potentially applicable
-      # tax rates for one particular item.
-      # When you ship to Spain, only the Spanish one will apply.
-      # When you ship to France, you'll see a Spanish refund AND a French tax.
-      # This little bit of code at the end stops the Spanish refund from appearing.
-      #
-      # For further discussion, see https://github.com/spree/spree/issues/4397 and https://github.com/spree/spree/issues/4327.
-
-      remaining_rates = rates.dup
-      rates.each do |rate|
-        if rate.included_in_price?
-          if remaining_rates.any?{|r| r != rate && r.tax_category == rate.tax_category }
-            remaining_rates.delete(rate)
-          end
-        end
-      end
-
-      remaining_rates
-    end
-
-    # Pre-tax amounts must be stored so that we can calculate
-    # correct rate amounts in the future. For example:
-    # https://github.com/spree/spree/issues/4318#issuecomment-34723428
-    def self.store_pre_tax_amount(item, rates)
-      pre_tax_amount = case item
-        when Spree::LineItem then item.discounted_amount
-        when Spree::Shipment then item.discounted_cost
-        end
-
-      included_rates = rates.select(&:included_in_price)
-      if included_rates.any?
-        pre_tax_amount /= (1 + included_rates.map(&:amount).sum)
-      end
-
-      item.update_column(:pre_tax_amount, pre_tax_amount.round(2))
-    end
-
-    # This method is best described by the documentation on #potentially_applicable?
-    def self.adjust(order_tax_zone, items)
-      rates = self.match(order_tax_zone)
-      tax_categories = rates.map(&:tax_category)
-      relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
-      relevant_items.group_by { |item| item.class.name }.each do |class_name, items|
-        Spree::Adjustment.where(adjustable_type: class_name, adjustable_id: items.map(&:id)).tax.destroy_all
-      end
-      relevant_items.each do |item|
-        relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
-        store_pre_tax_amount(item, relevant_rates)
-        relevant_rates.each do |rate|
-          rate.adjust(order_tax_zone, item)
-        end
-      end
-      non_relevant_items.each do |item|
-        if item.adjustments.tax.present?
-          item.adjustments.tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
-          item.update_columns pre_tax_amount: 0
-        end
-      end
-    end
-
-    # Tax rates can *potentially* be applicable to an order.
-    # We do not know if they are/aren't until we attempt to apply these rates to
+    # Finds geographically matching tax rates for a tax zone.
+    # We do not know if they are/aren't applicable until we attempt to apply these rates to
     # the items contained within the Order itself.
     # For instance, if a rate passes the criteria outlined in this method,
     # but then has a tax category that doesn't match against any of the line items
@@ -144,11 +71,20 @@ module Spree
     # Under no circumstances should negative adjustments be applied for the Spanish tax rates.
     #
     # Those rates should never come into play at all and only the French rates should apply.
-    def potentially_applicable?(order_tax_zone)
-      # If the rate's zone *contains* the order's tax zone, then it's applicable.
-      self.zone.contains?(order_tax_zone) ||
-      # The rate is a VAT and its zone contains the default zone, then it's applicable.
-      (self.included_in_price? && self.zone.contains?(Spree::Zone.default_tax))
+    scope :for_zone, ->(zone) { where(zone_id: Spree::Zone.with_shared_members(zone).pluck(:id)) }
+    scope :included_in_price, -> { where(included_in_price: true) }
+
+    # Create tax adjustments for some items that have the same tax zone.
+    #
+    # @deprecated Please use Spree::Tax::OrderAdjuster or Spree::Tax::ItemAdjuster instead.
+    #
+    # @param [Spree::Zone] order_tax_zone is the smalles applicable zone to the order's tax address
+    # @param [Array<Spree::LineItem,Spree::Shipment>] items to be adjusted
+    def self.adjust(order_tax_zone, items)
+      ActiveSupport::Deprecation.warn("Please use Spree::Tax::OrderAdjuster or Spree::Tax::ItemAdjuster instead", caller)
+      items.map do |item|
+        Spree::Tax::ItemAdjuster.new(item, rates_for_order_zone: for_zone(order_tax_zone)).adjust!
+      end
     end
 
     # Creates necessary tax adjustments for the order.
@@ -156,44 +92,43 @@ module Spree
       amount = compute_amount(item)
       return if amount == 0
 
-      included = included_in_price && default_zone_or_zone_match?(order_tax_zone)
-
-      if amount < 0
-        label = Spree.t(:refund) + ' ' + create_label
-      end
+      included = included_in_price && amount > 0
 
-      self.adjustments.create!({
-        :adjustable => item,
-        :amount => amount,
-        :order_id => item.order_id,
-        :label => label || create_label,
-        :included => included
+      adjustments.create!({
+        adjustable: item,
+        amount: amount,
+        order_id: item.order_id,
+        label: adjustment_label(amount),
+        included: included
       })
     end
 
     # This method is used by Adjustment#update to recalculate the cost.
     def compute_amount(item)
-      if included_in_price && !default_zone_or_zone_match?(item.order.tax_zone)
-        # In this case, it's a refund.
-        calculator.compute(item) * - 1
-      else
-        calculator.compute(item)
-      end
-    end
-
-    def default_zone_or_zone_match?(order_tax_zone)
-      Zone.default_tax.try!(:contains?, order_tax_zone) || self.zone.contains?(order_tax_zone)
+      calculator.compute(item)
     end
 
     private
 
-      def create_label
-        label = ""
-        label << (name.present? ? name : tax_category.name) + " "
-        label << (show_rate_in_label? ? "#{amount * 100}%" : "")
-        label << " (#{Spree.t(:included_in_price)})" if included_in_price?
-        label
-      end
+    def adjustment_label(amount)
+      Spree.t translation_key(amount),
+              scope: "adjustment_labels.tax_rates",
+              name: name.presence || tax_category.name,
+              amount: amount_for_adjustment_label
+    end
 
+    def amount_for_adjustment_label
+      ActiveSupport::NumberHelper::NumberToPercentageConverter.convert(
+        amount * 100,
+        locale: I18n.locale
+      )
+    end
+
+    def translation_key(amount)
+      key = included_in_price? ? "vat" : "sales_tax"
+      key += "_refund" if amount < 0
+      key += "_with_rate" if show_rate_in_label?
+      key.to_sym
+    end
   end
 end

data/app/models/spree/taxon.rb

@@ -13,6 +13,8 @@ module Spree
     has_many :promotion_rules, through: :promotion_rule_taxons
 
     before_create :set_permalink
+    before_update :set_permalink
+    after_update :update_child_permalinks, if: :permalink_changed?
 
     validates :name, presence: true
     validates :meta_keywords, length: { maximum: 255 }
@@ -47,7 +49,7 @@ module Spree
     # @return [String] meta_title if set otherwise a string containing the
     #   root name and taxon name
     def seo_title
-      unless meta_title.blank?
+      if meta_title.present?
         meta_title
       else
         root? ? name : "#{root.name} - #{name}"
@@ -57,11 +59,22 @@ module Spree
     # Sets this taxons permalink to a valid url encoded string based on its
     # name and its parents permalink (if present.)
     def set_permalink
-      if parent.present?
-        self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
-      else
-        self.permalink = name.to_url if permalink.blank?
-      end
+      permalink_tail = permalink.split('/').last if permalink.present?
+      permalink_tail ||= name.to_url
+      self.permalink_part = permalink_tail
+    end
+
+    # Update the permalink for this taxon and all children (if necessary)
+    def update_permalinks
+      set_permalink
+
+      # This will trigger update_child_permalinks if permalink has changed
+      save!
+    end
+
+    # Update the permalinks for all children
+    def update_child_permalinks
+      children.each(&:update_permalinks)
     end
 
     # @return [String] this taxon's permalink
@@ -72,16 +85,15 @@ module Spree
     # @return [ActiveRecord::Relation<Spree::Product>] the active products the
     #   belong to this taxon
     def active_products
-      products.active
+      products.not_deleted.available
     end
 
     # @return [String] this taxon's ancestors names followed by its own name,
     #   separated by arrows
     def pretty_name
-      ancestor_chain = self.ancestors.inject("") do |name, ancestor|
-        name += "#{ancestor.name} -> "
-      end
-      ancestor_chain + "#{name}"
+      ancestor_chain = ancestors.map(&:name)
+      ancestor_chain << name
+      ancestor_chain.join(" -> ")
     end
 
     # @see https://github.com/spree/spree/issues/3390
@@ -92,7 +104,19 @@ module Spree
       #
       # NOTE: no :position column needed - awesom_nested_set doesn't handle the
       # reordering if you bring your own :order_column.
-      move_to_child_with_index(parent, idx.to_i) unless self.new_record?
+      move_to_child_with_index(parent, idx.to_i) unless new_record?
+    end
+
+    def permalink_part
+      permalink.split('/').last
+    end
+
+    def permalink_part=(value)
+      if parent.present?
+        self.permalink = "#{parent.permalink}/#{value}"
+      else
+        self.permalink = value
+      end
     end
 
     private

data/app/models/spree/taxonomy.rb

@@ -12,16 +12,16 @@ module Spree
     default_scope -> { order(:position) }
 
     private
-      def set_name
-        if root
-          root.update_columns(
-            name: name,
-            updated_at: Time.current,
-          )
-        else
-          self.root = Taxon.create!(taxonomy_id: id, name: name)
-        end
-      end
 
+    def set_name
+      if root
+        root.update_columns(
+          name: name,
+          updated_at: Time.current
+        )
+      else
+        self.root = Taxon.create!(taxonomy_id: id, name: name)
+      end
+    end
   end
 end