Migrate add_attribute command to new tool (#581)

danielpgross · web-flow · commit bc9c03e947e1 · 2025-02-27T17:06:49.000-05:00
### TL;DR

Migrated command to add new base and extended attributes to the taxonomy from deprecated tool version to new one.

### What changed?
- Migrated `AddAttributeCommand` to create new attributes with values, with support for creating both base attributes (with new values) and extended attributes (inheriting values from base attributes)
- Implemented `next_id` method in `Attribute` model to auto-generate IDs for new attributes

### How to test?

Add a new base attribute with values:
```
bin/product_taxonomy add_attribute "Alternative color" "Another type of color" --values "Blue,Yellow,Green"
```

Add an extended attribute by extending the base attribute:
```
bin/product_taxonomy add_attribute "Extended color" "An extended type of color" --base_attribute_friendly_id "alternative_color"
```

Sample run:
```
❯ bin/product_taxonomy add_attribute "Alternative color" "Another type of color" --values "Blue,Yellow,Green"
Created base attribute `Alternative color` with friendly_id=`alternative_color`
Dumping attributes...
Updated `/Users/danielgross/product-taxonomy/data/attributes.yml`
Dumping values...
Updated `/Users/danielgross/product-taxonomy/data/values.yml`
Syncing EN localizations
Syncing attributes...
Wrote attributes localizations to /Users/danielgross/product-taxonomy/data/localizations/attributes/en.yml
Syncing values...
Wrote values localizations to /Users/danielgross/product-taxonomy/data/localizations/values/en.yml
Version: unstable
Generating sibling groups...
Generating category search index...
Generating attributes...
Generating mappings...
Generating attributes with categories...
Generating attribute with categories search index...
Completed in 2.96 seconds
```
diff --git a/dev/lib/product_taxonomy.rb b/dev/lib/product_taxonomy.rb
@@ -53,4 +53,5 @@ def data_path = DATA_PATH
 require_relative "product_taxonomy/commands/dump_values_command"
 require_relative "product_taxonomy/commands/sync_en_localizations_command"
 require_relative "product_taxonomy/commands/add_category_command"
+require_relative "product_taxonomy/commands/add_attribute_command"
 require_relative "product_taxonomy/commands/add_value_command"
diff --git a/dev/lib/product_taxonomy/cli.rb b/dev/lib/product_taxonomy/cli.rb
@@ -68,6 +68,13 @@ def add_category(name, parent_id)
       AddCategoryCommand.new(options.merge(name:, parent_id:)).run
     end
 
+    desc "add_attribute NAME DESCRIPTION", "Add a new attribute to the taxonomy with NAME and DESCRIPTION"
+    option :values, type: :string, desc: "A comma separated list of values to add to the attribute"
+    option :base_attribute_friendly_id, type: :string, desc: "Create an extended attribute by extending the attribute with this friendly ID"
+    def add_attribute(name, description)
+      AddAttributeCommand.new(options.merge(name:, description:)).run
+    end
+
     desc "add_value NAME ATTRIBUTE_FRIENDLY_ID", "Add a new value with NAME to the primary attribute with ATTRIBUTE_FRIENDLY_ID"
     def add_value(name, attribute_friendly_id)
       AddValueCommand.new(options.merge(name:, attribute_friendly_id:)).run
diff --git a/dev/lib/product_taxonomy/commands/add_attribute_command.rb b/dev/lib/product_taxonomy/commands/add_attribute_command.rb
@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  class AddAttributeCommand < Command
+    def initialize(options)
+      super
+      load_taxonomy
+      @name = options[:name]
+      @description = options[:description]
+      @values = options[:values]
+      @base_attribute_friendly_id = options[:base_attribute_friendly_id]
+    end
+
+    def execute
+      if @base_attribute_friendly_id
+        create_extended_attribute!
+      else
+        create_base_attribute_with_values!
+      end
+      update_data_files!
+    end
+
+    private
+
+    def create_base_attribute_with_values!
+      raise "Values must be provided when creating a base attribute" if value_names.empty?
+
+      @attribute = Attribute.create_validate_and_add!(
+        id: Attribute.next_id,
+        name: @name,
+        description: @description,
+        friendly_id:,
+        handle:,
+        values: find_or_create_values,
+      )
+      logger.info("Created base attribute `#{@attribute.name}` with friendly_id=`#{@attribute.friendly_id}`")
+    end
+
+    def create_extended_attribute!
+      raise "Values should not be provided when creating an extended attribute" if value_names.any?
+
+      @attribute = ExtendedAttribute.create_validate_and_add!(
+        name: @name,
+        description: @description,
+        friendly_id:,
+        handle:,
+        values_from: Attribute.find_by(friendly_id: @base_attribute_friendly_id) || @base_attribute_friendly_id,
+      )
+      logger.info("Created extended attribute `#{@attribute.name}` with friendly_id=`#{@attribute.friendly_id}`")
+    end
+
+    def update_data_files!
+      DumpAttributesCommand.new({}).execute
+      DumpValuesCommand.new({}).execute
+      SyncEnLocalizationsCommand.new(targets: "attributes,values").execute
+      GenerateDocsCommand.new({}).execute
+    end
+
+    def friendly_id
+      @friendly_id ||= IdentifierFormatter.format_friendly_id(@name)
+    end
+
+    def handle
+      @handle ||= IdentifierFormatter.format_handle(friendly_id)
+    end
+
+    def value_names
+      @values&.split(",")&.map(&:strip) || []
+    end
+
+    def find_or_create_values
+      value_names.map do |value_name|
+        value_friendly_id = IdentifierFormatter.format_friendly_id("#{friendly_id}__#{value_name}")
+        existing_value = Value.find_by(friendly_id: value_friendly_id)
+        next existing_value if existing_value
+
+        Value.create_validate_and_add!(
+          id: Value.next_id,
+          name: value_name,
+          friendly_id: value_friendly_id,
+          handle: IdentifierFormatter.format_handle(value_friendly_id),
+        )
+      end
+    end
+  end
+end
diff --git a/dev/lib/product_taxonomy/models/attribute.rb b/dev/lib/product_taxonomy/models/attribute.rb
@@ -42,6 +42,11 @@ def sorted_base_attributes
         all.reject(&:extended?).sort_by(&:name)
       end
 
+      # Get the next ID for a newly created attribute.
+      #
+      # @return [Integer] The next ID.
+      def next_id = (all.max_by(&:id)&.id || 0) + 1
+
       private
 
       def attribute_from(attribute_data)
diff --git a/dev/test/commands/add_attribute_command_test.rb b/dev/test/commands/add_attribute_command_test.rb
@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module ProductTaxonomy
+  class AddAttributeCommandTest < TestCase
+    setup do
+      @base_attribute = Attribute.new(
+        id: 1,
+        name: "Color",
+        description: "Defines the primary color or pattern",
+        friendly_id: "color",
+        handle: "color",
+        values: [
+          Value.new(
+            id: 1,
+            name: "Black",
+            friendly_id: "color__black",
+            handle: "color__black",
+          ),
+        ],
+      )
+
+      Attribute.add(@base_attribute)
+      Value.add(@base_attribute.values.first)
+
+      AddAttributeCommand.any_instance.stubs(:load_taxonomy)
+      DumpAttributesCommand.any_instance.stubs(:load_taxonomy)
+      DumpValuesCommand.any_instance.stubs(:load_taxonomy)
+      SyncEnLocalizationsCommand.any_instance.stubs(:load_taxonomy)
+      GenerateDocsCommand.any_instance.stubs(:load_taxonomy)
+    end
+
+    test "execute successfully adds a new base attribute with values" do
+      DumpAttributesCommand.any_instance.expects(:execute).once
+      DumpValuesCommand.any_instance.expects(:execute).once
+      SyncEnLocalizationsCommand.any_instance.expects(:execute).once
+      GenerateDocsCommand.any_instance.expects(:execute).once
+
+      AddAttributeCommand.new(
+        name: "Size",
+        description: "Product size information",
+        values: "Small, Medium, Large",
+      ).execute
+
+      new_attribute = Attribute.find_by(friendly_id: "size")
+      assert_not_nil new_attribute
+      assert_equal 2, new_attribute.id # Since id 1 already exists
+      assert_equal "Size", new_attribute.name
+      assert_equal "Product size information", new_attribute.description
+      assert_equal "size", new_attribute.friendly_id
+      assert_equal "size", new_attribute.handle
+
+      assert_equal 3, new_attribute.values.size
+      value_names = new_attribute.values.map(&:name)
+      assert_includes value_names, "Small"
+      assert_includes value_names, "Medium"
+      assert_includes value_names, "Large"
+
+      value_friendly_ids = new_attribute.values.map(&:friendly_id)
+      assert_includes value_friendly_ids, "size__small"
+      assert_includes value_friendly_ids, "size__medium"
+      assert_includes value_friendly_ids, "size__large"
+    end
+
+    test "execute successfully adds an extended attribute" do
+      DumpAttributesCommand.any_instance.expects(:execute).once
+      DumpValuesCommand.any_instance.expects(:execute).once
+      SyncEnLocalizationsCommand.any_instance.expects(:execute).once
+      GenerateDocsCommand.any_instance.expects(:execute).once
+
+      AddAttributeCommand.new(
+        name: "Clothing Color",
+        description: "Color of clothing items",
+        base_attribute_friendly_id: "color",
+      ).execute
+
+      new_attribute = Attribute.find_by(friendly_id: "clothing_color")
+      assert_not_nil new_attribute
+      assert_instance_of ExtendedAttribute, new_attribute
+      assert_equal "Clothing Color", new_attribute.name
+      assert_equal "Color of clothing items", new_attribute.description
+      assert_equal "clothing_color", new_attribute.friendly_id
+      assert_equal "clothing-color", new_attribute.handle
+
+      assert_equal @base_attribute, new_attribute.base_attribute
+
+      assert_equal @base_attribute.values.size, new_attribute.values.size
+      assert_equal @base_attribute.values.first.name, new_attribute.values.first.name
+    end
+
+    test "execute raises error when creating base attribute without values" do
+      assert_raises(RuntimeError) do
+        AddAttributeCommand.new(
+          name: "Material",
+          description: "Product material information",
+          values: "",
+        ).execute
+      end
+    end
+
+    test "execute raises error when creating extended attribute with values" do
+      assert_raises(RuntimeError) do
+        AddAttributeCommand.new(
+          name: "Clothing Color",
+          description: "Color of clothing items",
+          base_attribute_friendly_id: "color",
+          values: "Red, Blue",
+        ).execute
+      end
+    end
+
+    test "execute raises error when base attribute for extended attribute doesn't exist" do
+      assert_raises(ActiveModel::ValidationError) do
+        AddAttributeCommand.new(
+          name: "Clothing Material",
+          description: "Material of clothing items",
+          base_attribute_friendly_id: "nonexistent",
+        ).execute
+      end
+    end
+
+    test "execute raises error when attribute with same friendly_id already exists" do
+      assert_raises(ActiveModel::ValidationError) do
+        AddAttributeCommand.new(
+          name: "Color", # This will generate the same friendly_id as @base_attribute
+          description: "Another color attribute",
+          values: "Red, Blue",
+        ).execute
+      end
+    end
+
+    test "execute creates values with correct friendly_ids and handles" do
+      DumpAttributesCommand.any_instance.stubs(:execute)
+      DumpValuesCommand.any_instance.stubs(:execute)
+      SyncEnLocalizationsCommand.any_instance.stubs(:execute)
+      GenerateDocsCommand.any_instance.stubs(:execute)
+
+      AddAttributeCommand.new(
+        name: "Material Type",
+        description: "Type of material used",
+        values: "Cotton, Polyester",
+      ).execute
+
+      new_attribute = Attribute.find_by(friendly_id: "material_type")
+      assert_not_nil new_attribute
+
+      cotton_value = new_attribute.values.find { |v| v.name == "Cotton" }
+      assert_not_nil cotton_value
+      assert_equal "material_type__cotton", cotton_value.friendly_id
+      assert_equal "material-type__cotton", cotton_value.handle
+
+      polyester_value = new_attribute.values.find { |v| v.name == "Polyester" }
+      assert_not_nil polyester_value
+      assert_equal "material_type__polyester", polyester_value.friendly_id
+      assert_equal "material-type__polyester", polyester_value.handle
+    end
+
+    test "execute reuses existing values with same friendly_id" do
+      existing_value = Value.new(
+        id: 2,
+        name: "Existing Cotton",
+        friendly_id: "material_type__cotton",
+        handle: "material_type__cotton",
+      )
+      Value.add(existing_value)
+
+      DumpAttributesCommand.any_instance.stubs(:execute)
+      DumpValuesCommand.any_instance.stubs(:execute)
+      SyncEnLocalizationsCommand.any_instance.stubs(:execute)
+      GenerateDocsCommand.any_instance.stubs(:execute)
+
+      AddAttributeCommand.new(
+        name: "Material Type",
+        description: "Type of material used",
+        values: "Cotton, Polyester",
+      ).execute
+
+      new_attribute = Attribute.find_by(friendly_id: "material_type")
+      assert_not_nil new_attribute
+
+      cotton_value = new_attribute.values.find { |v| v.friendly_id == "material_type__cotton" }
+      assert_not_nil cotton_value
+      assert_equal existing_value, cotton_value
+      assert_equal "Existing Cotton", cotton_value.name # Name from existing value
+
+      polyester_value = new_attribute.values.find { |v| v.name == "Polyester" }
+      assert_not_nil polyester_value
+      assert_equal "material_type__polyester", polyester_value.friendly_id
+    end
+
+    test "execute updates data files after creating attribute" do
+      DumpAttributesCommand.any_instance.expects(:execute).once
+      DumpValuesCommand.any_instance.expects(:execute).once
+      SyncEnLocalizationsCommand.expects(:new).with(targets: "attributes,values").returns(stub(execute: true))
+      GenerateDocsCommand.any_instance.expects(:execute).once
+
+      AddAttributeCommand.new(
+        name: "Size",
+        description: "Product size information",
+        values: "Small, Medium, Large",
+      ).execute
+    end
+  end
+end
diff --git a/dev/test/models/attribute_test.rb b/dev/test/models/attribute_test.rb
@@ -349,6 +349,38 @@ class AttributeTest < TestCase
       refute @attribute.extended?
     end
 
+    test "next_id returns 1 when there are no attributes" do
+      Attribute.reset
+      assert_equal 1, Attribute.next_id
+    end
+
+    test "next_id returns max id + 1 when there are attributes" do
+      Attribute.reset
+
+      attribute1 = Attribute.new(
+        id: 5,
+        name: "Size",
+        description: "Defines the size of the product",
+        friendly_id: "size",
+        handle: "size",
+        values: [@value],
+      )
+
+      attribute2 = Attribute.new(
+        id: 10,
+        name: "Material",
+        description: "Defines the material of the product",
+        friendly_id: "material",
+        handle: "material",
+        values: [@value],
+      )
+
+      Attribute.add(attribute1)
+      Attribute.add(attribute2)
+
+      assert_equal 11, Attribute.next_id
+    end
+
     private
 
     def stub_localizations
