Migrate dump_attributes command to new tool (#566)

### TL;DR

Migrated command to dump attributes to YAML from deprecated tool version to new one.


### What changed?
- Added new `dump_attributes` CLI command
- Migrated `DumpAttributesCommand`
- Implemented `DataSerializer` for attributes that handles both base and extended attributes
- Base attributes are sorted by ID, while extended attributes maintain their addition order

### How to test?
Run the CLI command: `bin/product_taxonomy dump_attributes`

Sample output:
```
❯ bin/product_taxonomy dump_attributes
Dumping attributes...
Updated `/Users/danielgross/product-taxonomy/data/attributes.yml`
Completed in 1.07 seconds
```

Author: danielpgross

dev/lib/product_taxonomy.rb

@@ -32,6 +32,7 @@ def data_path = DATA_PATH
 require_relative "product_taxonomy/models/serializers/category/docs/search_serializer"
 require_relative "product_taxonomy/models/serializers/category/dist/json_serializer"
 require_relative "product_taxonomy/models/serializers/category/dist/txt_serializer"
+require_relative "product_taxonomy/models/serializers/attribute/data/data_serializer"
 require_relative "product_taxonomy/models/serializers/attribute/data/localizations_serializer"
 require_relative "product_taxonomy/models/serializers/attribute/docs/base_and_extended_serializer"
 require_relative "product_taxonomy/models/serializers/attribute/docs/reversed_serializer"
@@ -47,5 +48,6 @@ def data_path = DATA_PATH
 require_relative "product_taxonomy/commands/generate_docs_command"
 require_relative "product_taxonomy/commands/generate_release_command"
 require_relative "product_taxonomy/commands/dump_categories_command"
+require_relative "product_taxonomy/commands/dump_attributes_command"
 require_relative "product_taxonomy/commands/sync_en_localizations_command"
 require_relative "product_taxonomy/commands/add_category_command"

dev/lib/product_taxonomy/cli.rb

@@ -46,6 +46,11 @@ def dump_categories
       DumpCategoriesCommand.new(options).run
     end
 
+    desc "dump_attributes", "Dump attributes to YAML file"
+    def dump_attributes
+      DumpAttributesCommand.new(options).run
+    end
+
     desc "sync_en_localizations", "Sync English localizations for categories, attributes, and values"
     option :targets, type: :string, desc: "List of targets to sync. Valid targets are: categories, attributes, values"
     def sync_en_localizations

dev/lib/product_taxonomy/commands/dump_attributes_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  class DumpAttributesCommand < Command
+    def execute
+      logger.info("Dumping attributes...")
+
+      load_taxonomy
+
+      path = File.expand_path("attributes.yml", ProductTaxonomy.data_path)
+      FileUtils.mkdir_p(File.dirname(path))
+
+      data = Serializers::Attribute::Data::DataSerializer.serialize_all
+      File.write(path, YAML.dump(data, line_width: -1))
+
+      logger.info("Updated `#{path}`")
+    end
+  end
+end

dev/lib/product_taxonomy/models/serializers/attribute/data/data_serializer.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Data
+        module DataSerializer
+          class << self
+            def serialize_all
+              # Base attributes are sorted by ID, extended attributes are sorted by the order they were added
+              extended_attributes, base_attributes = ProductTaxonomy::Attribute.all.partition(&:extended?)
+              base_attributes.sort_by!(&:id)
+
+              {
+                "base_attributes" => base_attributes.map { serialize(_1) },
+                "extended_attributes" => extended_attributes.map { serialize(_1) },
+              }
+            end
+
+            # @param [Attribute] attribute
+            # @return [Hash]
+            def serialize(attribute)
+              if attribute.extended?
+                {
+                  "name" => attribute.name,
+                  "handle" => attribute.handle,
+                  "description" => attribute.description,
+                  "friendly_id" => attribute.friendly_id,
+                  "values_from" => attribute.values_from.friendly_id,
+                }
+              else
+                {
+                  "id" => attribute.id,
+                  "name" => attribute.name,
+                  "description" => attribute.description,
+                  "friendly_id" => attribute.friendly_id,
+                  "handle" => attribute.handle,
+                  "sorting" => attribute.manually_sorted? ? "custom" : nil,
+                  "values" => attribute.sorted_values.map(&:friendly_id),
+                }.compact
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

dev/test/commands/dump_attributes_command_test.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "tmpdir"
+
+module ProductTaxonomy
+  class DumpAttributesCommandTest < TestCase
+    setup do
+      @tmp_base_path = Dir.mktmpdir
+      @real_base_path = File.expand_path("..", ProductTaxonomy.data_path)
+
+      FileUtils.mkdir_p(File.expand_path("data", @tmp_base_path))
+      ProductTaxonomy.stubs(:data_path).returns(File.expand_path("data", @tmp_base_path))
+
+      Command.any_instance.stubs(:load_taxonomy)
+    end
+
+    teardown do
+      FileUtils.remove_entry(@tmp_base_path)
+    end
+
+    test "execute dumps attributes to YAML file" do
+      mock_data = { "test" => "data" }
+      Serializers::Attribute::Data::DataSerializer.stubs(:serialize_all)
+        .returns(mock_data)
+
+      command = DumpAttributesCommand.new({})
+      command.execute
+
+      expected_path = File.expand_path("data/attributes.yml", @tmp_base_path)
+      assert File.exist?(expected_path)
+      assert_equal "---\ntest: data\n", File.read(expected_path)
+    end
+  end
+end

dev/test/models/serializers/attribute/data/data_serializer_test.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Data
+        class DataSerializerTest < TestCase
+          setup do
+            @value = ProductTaxonomy::Value.new(
+              id: 1,
+              name: "Black",
+              friendly_id: "color__black",
+              handle: "color__black",
+            )
+
+            @base_attribute = ProductTaxonomy::Attribute.new(
+              id: 1,
+              name: "Color",
+              description: "Defines the primary color or pattern, such as blue or striped",
+              friendly_id: "color",
+              handle: "color",
+              values: [@value],
+            )
+
+            @extended_attribute = ProductTaxonomy::ExtendedAttribute.new(
+              name: "Clothing Color",
+              description: "Color of the clothing",
+              friendly_id: "clothing_color",
+              handle: "clothing_color",
+              values_from: @base_attribute
+            )
+
+            ProductTaxonomy::Value.add(@value)
+            ProductTaxonomy::Attribute.add(@base_attribute)
+            ProductTaxonomy::Attribute.add(@extended_attribute)
+          end
+
+          test "serialize returns the expected data structure for base attribute" do
+            expected = {
+              "id" => 1,
+              "name" => "Color",
+              "description" => "Defines the primary color or pattern, such as blue or striped",
+              "friendly_id" => "color",
+              "handle" => "color",
+              "values" => ["color__black"]
+            }
+
+            assert_equal expected, DataSerializer.serialize(@base_attribute)
+          end
+
+          test "serialize returns the expected data structure for extended attribute" do
+            expected = {
+              "name" => "Clothing Color",
+              "handle" => "clothing_color",
+              "description" => "Color of the clothing",
+              "friendly_id" => "clothing_color",
+              "values_from" => "color"
+            }
+
+            assert_equal expected, DataSerializer.serialize(@extended_attribute)
+          end
+
+          test "serialize_all returns all attributes in data format" do
+            expected = {
+              "base_attributes" => [{
+                "id" => 1,
+                "name" => "Color",
+                "description" => "Defines the primary color or pattern, such as blue or striped",
+                "friendly_id" => "color",
+                "handle" => "color",
+                "values" => ["color__black"]
+              }],
+              "extended_attributes" => [{
+                "name" => "Clothing Color",
+                "handle" => "clothing_color",
+                "description" => "Color of the clothing",
+                "friendly_id" => "clothing_color",
+                "values_from" => "color"
+              }]
+            }
+
+            assert_equal expected, DataSerializer.serialize_all
+          end
+
+          test "serialize includes sorting field when attribute is manually sorted" do
+            @base_attribute = ProductTaxonomy::Attribute.new(
+              id: 2,
+              name: "Size",
+              description: "Defines the size of the product",
+              friendly_id: "size",
+              handle: "size",
+              values: [@value],
+              is_manually_sorted: true
+            )
+            ProductTaxonomy::Attribute.add(@base_attribute)
+
+            expected = {
+              "id" => 2,
+              "name" => "Size",
+              "description" => "Defines the size of the product",
+              "friendly_id" => "size",
+              "handle" => "size",
+              "sorting" => "custom",
+              "values" => ["color__black"]
+            }
+
+            assert_equal expected, DataSerializer.serialize(@base_attribute)
+          end
+
+          test "serialize_all sorts base attributes by ID" do
+            second_base_attribute = ProductTaxonomy::Attribute.new(
+              id: 2,
+              name: "Size",
+              description: "Defines the size of the product",
+              friendly_id: "size",
+              handle: "size",
+              values: []
+            )
+            third_base_attribute = ProductTaxonomy::Attribute.new(
+              id: 3,
+              name: "Material",
+              description: "Defines the material of the product",
+              friendly_id: "material",
+              handle: "material",
+              values: []
+            )
+            # Add attributes in random order to ensure sorting is by ID
+            ProductTaxonomy::Attribute.add(third_base_attribute)
+            ProductTaxonomy::Attribute.add(second_base_attribute)
+
+            result = DataSerializer.serialize_all
+            base_attributes = result["base_attributes"]
+
+            assert_equal 3, base_attributes.length
+            assert_equal "color", base_attributes[0]["friendly_id"]
+            assert_equal "size", base_attributes[1]["friendly_id"]
+            assert_equal "material", base_attributes[2]["friendly_id"]
+          end
+
+          test "serialize_all preserves extended attributes order" do
+            second_extended_attribute = ProductTaxonomy::ExtendedAttribute.new(
+              name: "Shoe Color",
+              description: "Color of the shoe",
+              friendly_id: "shoe_color",
+              handle: "shoe_color",
+              values_from: @base_attribute
+            )
+            third_extended_attribute = ProductTaxonomy::ExtendedAttribute.new(
+              name: "Accessory Color",
+              description: "Color of the accessory",
+              friendly_id: "accessory_color",
+              handle: "accessory_color",
+              values_from: @base_attribute
+            )
+            # Add extended attributes in specific order
+            ProductTaxonomy::Attribute.add(second_extended_attribute)
+            ProductTaxonomy::Attribute.add(third_extended_attribute)
+
+            result = DataSerializer.serialize_all
+            extended_attributes = result["extended_attributes"]
+
+            assert_equal 3, extended_attributes.length
+            assert_equal "clothing_color", extended_attributes[0]["friendly_id"]
+            assert_equal "shoe_color", extended_attributes[1]["friendly_id"]
+            assert_equal "accessory_color", extended_attributes[2]["friendly_id"]
+          end
+        end
+      end
+    end
+  end
+end