shopify_product_taxonomy 1.0.0

data/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

data/lib/product_taxonomy/models/serializers/attribute/data/localizations_serializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Data
+        module LocalizationsSerializer
+          class << self
+            def serialize_all
+              attributes = ProductTaxonomy::Attribute.all
+
+              {
+                "en" => {
+                  "attributes" => attributes.sort_by(&:friendly_id).reduce({}) { _1.merge!(serialize(_2)) },
+                },
+              }
+            end
+
+            # @param [Attribute] attribute
+            # @return [Hash]
+            def serialize(attribute)
+              {
+                attribute.friendly_id => {
+                  "name" => attribute.name,
+                  "description" => attribute.description,
+                },
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/attribute/dist/json_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Dist
+        class JsonSerializer
+          class << self
+            def serialize_all(version:, locale: "en")
+              {
+                "version" => version,
+                "attributes" => ProductTaxonomy::Attribute.sorted_base_attributes.map { serialize(_1, locale:) },
+              }
+            end
+
+            # @param attribute [Attribute]
+            # @param locale [String] The locale to use for localized attributes.
+            # @return [Hash]
+            def serialize(attribute, locale: "en")
+              {
+                "id" => attribute.gid,
+                "name" => attribute.name(locale:),
+                "handle" => attribute.handle,
+                "description" => attribute.description(locale:),
+                "extended_attributes" => attribute.extended_attributes.sort_by(&:name).map do |ext_attr|
+                  {
+                    "name" => ext_attr.name(locale:),
+                    "handle" => ext_attr.handle,
+                  }
+                end,
+                "values" => attribute.sorted_values(locale:).map do |value|
+                  Serializers::Value::Dist::JsonSerializer.serialize(value, locale:)
+                end,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/attribute/dist/txt_serializer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Dist
+        class TxtSerializer
+          class << self
+            def serialize_all(version:, locale: "en", padding: longest_gid_length)
+              header = <<~HEADER
+                # Shopify Product Taxonomy - Attributes: #{version}
+                # Format: {GID} : {Attribute name}
+
+              HEADER
+
+              attributes_txt = ProductTaxonomy::Attribute
+                .sorted_base_attributes
+                .map { serialize(_1, padding:, locale:) }
+                .join("\n")
+
+              header + attributes_txt
+            end
+
+            # @param attribute [Attribute]
+            # @param padding [Integer] The padding to use for the GID.
+            # @param locale [String] The locale to use for localized attributes.
+            # @return [String]
+            def serialize(attribute, padding: 0, locale: "en")
+              "#{attribute.gid.ljust(padding)} : #{attribute.name(locale:)}"
+            end
+
+            private
+
+            def longest_gid_length
+              ProductTaxonomy::Attribute.all.filter_map { _1.extended? ? nil : _1.gid.length }.max
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/attribute/docs/base_and_extended_serializer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Docs
+        module BaseAndExtendedSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Attribute.sorted_base_attributes.flat_map do |attribute|
+                extended_attributes = attribute.extended_attributes.sort_by(&:name).map do |extended_attribute|
+                  serialize(extended_attribute)
+                end
+                extended_attributes + [serialize(attribute)]
+              end
+            end
+
+            # @param [Attribute] attribute
+            # @return [Hash]
+            def serialize(attribute)
+              result = {
+                "id" => attribute.gid,
+                "name" => attribute.extended? ? attribute.base_attribute.name : attribute.name,
+                "handle" => attribute.handle,
+                "extended_name" => attribute.extended? ? attribute.name : nil,
+                "values" => attribute.values.map do |value|
+                  {
+                    "id" => value.gid,
+                    "name" => value.name,
+                  }
+                end,
+              }
+              result.delete("extended_name") unless attribute.extended?
+              result
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/attribute/docs/reversed_serializer.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Docs
+        module ReversedSerializer
+          class << self
+            def serialize_all
+              attributes_to_categories = ProductTaxonomy::Category.all.each_with_object({}) do |category, hash|
+                category.attributes.each do |attribute|
+                  hash[attribute] ||= []
+                  hash[attribute] << category
+                end
+              end
+
+              serialized_attributes = ProductTaxonomy::Attribute.all.sort_by(&:name).map do |attribute|
+                serialize(attribute, attributes_to_categories[attribute])
+              end
+
+              {
+                "attributes" => serialized_attributes,
+              }
+            end
+
+            # @param [Attribute] attribute The attribute to serialize.
+            # @param [Array<Category>] attribute_categories The categories that the attribute belongs to.
+            # @return [Hash] The serialized attribute.
+            def serialize(attribute, attribute_categories)
+              attribute_categories ||= []
+              {
+                "id" => attribute.gid,
+                "handle" => attribute.handle,
+                "name" => attribute.name,
+                "base_name" => attribute.extended? ? attribute.base_attribute.name : nil,
+                "categories" => attribute_categories.sort_by(&:full_name).map do |category|
+                  {
+                    "id" => category.gid,
+                    "full_name" => category.full_name,
+                  }
+                end,
+                "values" => attribute.sorted_values.map do |value|
+                  {
+                    "id" => value.gid,
+                    "name" => value.name,
+                  }
+                end,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/attribute/docs/search_serializer.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Attribute
+      module Docs
+        module SearchSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Attribute.all.sort_by(&:name).map do |attribute|
+                serialize(attribute)
+              end
+            end
+
+            # @param [Attribute] attribute
+            # @return [Hash]
+            def serialize(attribute)
+              {
+                "searchIdentifier" => attribute.handle,
+                "title" => attribute.name,
+                "url" => "?attributeHandle=#{attribute.handle}",
+                "attribute" => {
+                  "handle" => attribute.handle,
+                },
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/data/data_serializer.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Data
+        module DataSerializer
+          class << self
+            def serialize_all(root = nil)
+              categories = root ? root.descendants_and_self : ProductTaxonomy::Category.all_depth_first
+              categories.sort_by(&:id_parts).flat_map { serialize(_1) }
+            end
+
+            # @param [Category] category
+            # @return [Hash]
+            def serialize(category)
+              {
+                "id" => category.id,
+                "name" => category.name,
+                "children" => category.children.sort_by(&:id_parts).map(&:id),
+                "attributes" => AlphanumericSorter.sort(category.attributes.map(&:friendly_id), other_last: true),
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/data/full_names_serializer.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Data
+        module FullNamesSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Category.all.sort_by(&:full_name).map { serialize(_1) }
+            end
+
+            # @param [Category] category
+            # @return [Hash]
+            def serialize(category)
+              {
+                "id" => category.id,
+                "full_name" => category.full_name,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/data/localizations_serializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Data
+        module LocalizationsSerializer
+          class << self
+            def serialize_all
+              categories = ProductTaxonomy::Category.all_depth_first
+
+              {
+                "en" => {
+                  "categories" => categories.sort_by(&:id_parts).reduce({}) { _1.merge!(serialize(_2)) },
+                },
+              }
+            end
+
+            # @param [Category] category
+            # @return [Hash]
+            def serialize(category)
+              {
+                category.id => {
+                  "name" => category.name,
+                  "context" => category.full_name,
+                },
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/dist/json_serializer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Dist
+        module JsonSerializer
+          class << self
+            def serialize_all(version:, locale: "en")
+              {
+                "version" => version,
+                "verticals" => ProductTaxonomy::Category.verticals.map do |vertical|
+                  {
+                    "name" => vertical.name(locale:),
+                    "prefix" => vertical.id,
+                    "categories" => vertical.descendants_and_self.map { |category| serialize(category, locale:) },
+                  }
+                end,
+              }
+            end
+
+            # @param category [Category]
+            # @param locale [String] The locale to use for localization.
+            # @return [Hash]
+            def serialize(category, locale: "en")
+              {
+                "id" => category.gid,
+                "level" => category.level,
+                "name" => category.name(locale:),
+                "full_name" => category.full_name(locale:),
+                "parent_id" => category.parent&.gid,
+                "attributes" => category.attributes.map do |attr|
+                  {
+                    "id" => attr.gid,
+                    "name" => attr.name(locale:),
+                    "handle" => attr.handle,
+                    "description" => attr.description(locale:),
+                    "extended" => attr.is_a?(ExtendedAttribute),
+                  }
+                end,
+                "children" => category.children.map do |child|
+                  {
+                    "id" => child.gid,
+                    "name" => child.name(locale:),
+                  }
+                end,
+                "ancestors" => category.ancestors.map do |ancestor|
+                  {
+                    "id" => ancestor.gid,
+                    "name" => ancestor.name(locale:),
+                  }
+                end,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/dist/txt_serializer.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Dist
+        module TxtSerializer
+          class << self
+            def serialize_all(version:, locale: "en", padding: longest_gid_length)
+              header = <<~HEADER
+                # Shopify Product Taxonomy - Categories: #{version}
+                # Format: {GID} : {Ancestor name} > ... > {Category name}
+
+              HEADER
+
+              categories_txt = ProductTaxonomy::Category
+                .all_depth_first
+                .map { |category| serialize(category, padding:, locale:) }
+                .join("\n")
+
+              header + categories_txt
+            end
+
+            # @param category [Category]
+            # @param padding [Integer] The padding to use for the GID.
+            # @param locale [String] The locale to use for localization.
+            # @return [String]
+            def serialize(category, padding:, locale: "en")
+              "#{category.gid.ljust(padding)} : #{category.full_name(locale:)}"
+            end
+
+            private
+
+            def longest_gid_length
+              ProductTaxonomy::Category.all.max_by { |c| c.gid.length }.gid.length
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/docs/search_serializer.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Docs
+        module SearchSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Category.all_depth_first.flat_map { serialize(_1) }
+            end
+
+            # @param [Category] category
+            # @return [Hash]
+            def serialize(category)
+              {
+                "searchIdentifier" => category.gid,
+                "title" => category.full_name,
+                "url" => "?categoryId=#{CGI.escapeURIComponent(category.gid)}",
+                "category" => {
+                  "id" => category.gid,
+                  "name" => category.name,
+                  "fully_qualified_type" => category.full_name,
+                  "depth" => category.level,
+                },
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/category/docs/siblings_serializer.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Category
+      module Docs
+        module SiblingsSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Category.all_depth_first.each_with_object({}) do |category, groups|
+                parent_id = category.parent&.gid.presence || "root"
+                sibling = serialize(category)
+
+                groups[category.level] ||= {}
+                groups[category.level][parent_id] ||= []
+                groups[category.level][parent_id] << sibling
+              end
+            end
+
+            # @param [Category] category
+            # @return [Hash]
+            def serialize(category)
+              {
+                "id" => category.gid,
+                "name" => category.name,
+                "fully_qualified_type" => category.full_name,
+                "depth" => category.level,
+                "parent_id" => category.parent&.gid.presence || "root",
+                "node_type" => category.root? ? "root" : "leaf",
+                "ancestor_ids" => category.ancestors.map(&:gid).join(","),
+                "attribute_handles" => category.attributes.map(&:handle).join(","),
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/value/data/data_serializer.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Value
+      module Data
+        module DataSerializer
+          class << self
+            def serialize_all
+              ProductTaxonomy::Value.all.sort_by(&:id).map { serialize(_1) }
+            end
+
+            # @param [Value] value
+            # @return [Hash]
+            def serialize(value)
+              {
+                "id" => value.id,
+                "name" => value.name,
+                "friendly_id" => value.friendly_id,
+                "handle" => value.handle,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/value/data/localizations_serializer.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Value
+      module Data
+        module LocalizationsSerializer
+          class << self
+            def serialize_all
+              values = ProductTaxonomy::Value.all
+
+              {
+                "en" => {
+                  "values" => values.sort_by(&:friendly_id).reduce({}) { _1.merge!(serialize(_2)) },
+                },
+              }
+            end
+
+            # @param [Value] value
+            # @return [Hash]
+            def serialize(value)
+              {
+                value.friendly_id => {
+                  "name" => value.name,
+                  "context" => value.primary_attribute.name,
+                },
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/serializers/value/dist/json_serializer.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Serializers
+    module Value
+      module Dist
+        class JsonSerializer
+          class << self
+            def serialize_all(version:, locale: "en")
+              {
+                "version" => version,
+                "values" => ProductTaxonomy::Value.all_values_sorted.map { serialize(_1, locale:) },
+              }
+            end
+
+            # @param value [Value]
+            # @param locale [String] The locale to use for localization.
+            # @return [Hash]
+            def serialize(value, locale: "en")
+              {
+                "id" => value.gid,
+                "name" => value.name(locale:),
+                "handle" => value.handle,
+              }
+            end
+          end
+        end
+      end
+    end
+  end
+end