shopify_product_taxonomy 1.0.0

data/lib/product_taxonomy/models/extended_attribute.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  class ExtendedAttribute < Attribute
+    class << self
+      def localizations
+        superclass.localizations # Extended attribute localizations are defined in the same place as attributes
+      end
+    end
+
+    validate :values_from_valid?
+
+    attr_reader :values_from
+
+    alias_method :base_attribute, :values_from
+
+    # @param name [String] The name of the attribute.
+    # @param handle [String] The handle of the attribute.
+    # @param description [String] The description of the attribute.
+    # @param friendly_id [String] The friendly ID of the attribute.
+    # @param values_from [Attribute, String] A resolved {Attribute} object. When resolving fails, pass the friendly ID
+    #   instead.
+    def initialize(name:, handle:, description:, friendly_id:, values_from:)
+      @values_from = values_from
+      values_from.add_extended_attribute(self) if values_from.is_a?(Attribute)
+      super(
+        id: values_from.try(:id),
+        name:,
+        handle:,
+        description:,
+        friendly_id:,
+        values: values_from.try(:values),
+        is_manually_sorted: values_from.try(:manually_sorted?) || false,
+      )
+    end
+
+    private
+
+    def values_from_valid?
+      errors.add(
+        :base_attribute,
+        :not_found,
+        message: "not found for friendly ID \"#{values_from}\"",
+      ) unless values_from.is_a?(Attribute)
+    end
+  end
+end

data/lib/product_taxonomy/models/integration_version.rb

@@ -0,0 +1,296 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  # A single version of an integration, e.g. "shopify/2024-07".
+  #
+  # Includes:
+  # - The full names of categories in the integration's taxonomy.
+  # - The mapping rules for converting between the integration's taxonomy and Shopify's taxonomy.
+  class IntegrationVersion
+    INTEGRATIONS_PATH = File.expand_path("integrations", ProductTaxonomy.data_path)
+
+    class << self
+      # Generate all distribution files for all integration versions.
+      #
+      # @param output_path [String] The path to the output directory.
+      # @param logger [Logger] The logger to use for logging messages.
+      # @param current_shopify_version [String] The current version of the Shopify taxonomy.
+      # @param base_path [String] The path to the base directory containing integration versions.
+      def generate_all_distributions(output_path:, logger:, current_shopify_version: nil, base_path: INTEGRATIONS_PATH)
+        clear_shopify_integrations_directory(output_path:, logger:)
+        
+        integration_versions = load_all_from_source(current_shopify_version:, base_path:)
+        all_mappings = integration_versions.each_with_object([]) do |integration_version, all_mappings|
+          logger.info("Generating integration mappings for #{integration_version.name}/#{integration_version.version}")
+          integration_version.generate_distributions(output_path:)
+          all_mappings.concat(integration_version.to_json(direction: :both))
+        end
+        generate_all_mappings_file(mappings: all_mappings, current_shopify_version:, output_path:)
+      end
+
+      # Clear the Shopify integrations directory before generating new files.
+      #
+      # @param output_path [String] The path to the output directory.
+      # @param logger [Logger] The logger to use for logging messages.
+      def clear_shopify_integrations_directory(output_path:, logger:)
+        shopify_integrations_path = File.join(integrations_output_path(output_path), "shopify")
+        if Dir.exist?(shopify_integrations_path)
+          FileUtils.rm_rf(shopify_integrations_path)
+          FileUtils.mkdir_p(shopify_integrations_path)
+        end
+      end
+
+      # Load all integration versions from the source data directory.
+      #
+      # @return [Array<IntegrationVersion>]
+      def load_all_from_source(current_shopify_version: nil, base_path: INTEGRATIONS_PATH)
+        integrations_yaml = YAML.safe_load_file(File.expand_path("integrations.yml", base_path))
+        integrations_yaml.flat_map do |integration_yaml|
+          versions = integration_yaml["available_versions"].sort.map do |version_path|
+            load_from_source(
+              integration_path: File.expand_path(version_path, base_path),
+              current_shopify_version:,
+            )
+          end
+
+          resolve_to_shopify_mappings_chain(versions) if integration_yaml["name"] == "shopify"
+
+          versions
+        end
+      end
+
+      # Resolve a set of IntegrationVersion to_shopify mappings so that each one maps to the latest version of the
+      # Shopify taxonomy.
+      #
+      # @param versions [Array<IntegrationVersion>] The versions to resolve, ordered from oldest to newest.
+      def resolve_to_shopify_mappings_chain(versions)
+        versions.reverse.each_with_object([]) do |version, resolved_versions|
+          version.resolve_to_shopify_mappings(resolved_versions)
+          resolved_versions.prepend(version)
+        end
+      end
+
+      # Load an integration version from the provided source data directory.
+      #
+      # @param integration_path [String] The path to the integration version source data directory.
+      # @return [IntegrationVersion]
+      def load_from_source(integration_path:, current_shopify_version: nil)
+        full_names = YAML.safe_load_file(File.expand_path("full_names.yml", integration_path))
+        full_names_by_id = full_names.each_with_object({}) { |data, hash| hash[data["id"].to_s] = data }
+
+        from_shopify_mappings = MappingRule.load_rules_from_source(
+          integration_path:,
+          direction: :from_shopify,
+          full_names_by_id:,
+        )
+        to_shopify_mappings = MappingRule.load_rules_from_source(
+          integration_path:,
+          direction: :to_shopify,
+          full_names_by_id:,
+        )
+
+        integration_pathname = Pathname.new(integration_path)
+
+        new(
+          name: integration_pathname.parent.basename.to_s,
+          version: integration_pathname.basename.to_s,
+          full_names_by_id:,
+          from_shopify_mappings:,
+          to_shopify_mappings:,
+          current_shopify_version:,
+        )
+      end
+
+      # Generate a JSON file containing all mappings for all integration versions.
+      #
+      # @param mappings [Array<Hash>] The mappings to include in the file.
+      # @param version [String] The current version of the Shopify taxonomy.
+      # @param output_path [String] The path to the output directory.
+      def generate_all_mappings_file(mappings:, current_shopify_version:, output_path:)
+        File.write(
+          File.expand_path("all_mappings.json", integrations_output_path(output_path)),
+          JSON.pretty_generate(to_json(mappings:, current_shopify_version:)) + "\n",
+        )
+      end
+
+      # Generate a JSON representation for a given set of mappings and version of the Shopify taxonomy.
+      #
+      # @param version [String] The current version of the Shopify taxonomy.
+      # @param mappings [Array<Hash>] The mappings to include in the file.
+      # @return [Hash]
+      def to_json(current_shopify_version:, mappings:)
+        {
+          version: current_shopify_version,
+          mappings:,
+        }
+      end
+
+      # Generate the path to the integrations output directory.
+      #
+      # @param base_output_path [String] The base path to the output directory.
+      # @return [String]
+      def integrations_output_path(base_output_path)
+        File.expand_path("en/integrations", base_output_path)
+      end
+    end
+
+    attr_reader :name, :version, :from_shopify_mappings, :to_shopify_mappings, :full_names_by_id
+
+    # @param name [String] The name of the integration.
+    # @param version [String] The version of the integration.
+    # @param full_names_by_id [Hash<String, Hash>] A hash of full names by ID.
+    # @param current_shopify_version [String] The current version of the Shopify taxonomy.
+    # @param from_shopify_mappings [Array<MappingRule>] The mappings from the Shopify taxonomy to the integration's
+    #   taxonomy.
+    # @param to_shopify_mappings [Array<MappingRule>] The mappings from the integration's taxonomy to the Shopify
+    #   taxonomy.
+    def initialize(
+      name:,
+      version:,
+      full_names_by_id:,
+      current_shopify_version: nil,
+      from_shopify_mappings: nil,
+      to_shopify_mappings: nil
+    )
+      @name = name
+      @version = version
+      @full_names_by_id = full_names_by_id
+      @current_shopify_version = current_shopify_version
+      @from_shopify_mappings = from_shopify_mappings
+      @to_shopify_mappings = to_shopify_mappings
+      @to_json = {} # memoized by direction
+    end
+
+    # Generate all distribution files for the integration version.
+    #
+    # @param output_path [String] The path to the output directory.
+    def generate_distributions(output_path:)
+      generate_distribution(output_path:, direction: :from_shopify) if @from_shopify_mappings.present?
+      generate_distribution(output_path:, direction: :to_shopify) if @to_shopify_mappings.present?
+    end
+
+    # Generate JSON and TXT distribution files for a single direction of the integration version.
+    #
+    # @param output_path [String] The path to the output directory.
+    # @param direction [Symbol] The direction of the distribution file to generate (:from_shopify or :to_shopify).
+    def generate_distribution(output_path:, direction:)
+      output_dir = File.expand_path(@name, self.class.integrations_output_path(output_path))
+      FileUtils.mkdir_p(output_dir)
+
+      json = self.class.to_json(mappings: [to_json(direction:)], current_shopify_version: @current_shopify_version)
+      File.write(
+        File.expand_path("#{distribution_filename(direction:)}.json", output_dir),
+        JSON.pretty_generate(json) + "\n",
+      )
+      File.write(
+        File.expand_path("#{distribution_filename(direction:)}.txt", output_dir),
+        to_txt(direction:) + "\n",
+      )
+    end
+
+    # Resolve the output categories of to_shopify mappings to the current version of the Shopify taxonomy, taking into
+    # any mappings from later versions.
+    #
+    # @param next_integration_versions [Array<IntegrationVersion>] An array of Shopify integration versions coming
+    #   after the current version.
+    def resolve_to_shopify_mappings(next_integration_versions)
+      @to_shopify_mappings&.each do |mapping|
+        newer_mapping = next_integration_versions.flat_map(&:to_shopify_mappings).compact.find do |mapping_rule|
+          mapping_rule.input_category["id"] == mapping.output_category
+        end
+        mapping.output_category = newer_mapping&.output_category || Category.find_by(id: mapping.output_category)
+
+        next unless mapping.output_category.nil?
+
+        raise ArgumentError, "Failed to resolve Shopify mapping: " \
+          "\"#{mapping.input_category["id"]}\" to \"#{mapping.output_category}\" " \
+          "(input version: #{version})"
+      end
+    end
+
+    # For a mapping to an external taxonomy, get the IDs of external categories that are not mapped from Shopify.
+    #
+    # @return [Array<String>] IDs of external categories not mapped from the Shopify taxonomy. Empty if there are no
+    #   mappings from Shopify.
+    def unmapped_external_category_ids
+      return [] if @from_shopify_mappings.blank?
+
+      mappings_by_output_category_id = @from_shopify_mappings.index_by { _1.output_category["id"].to_s }
+      @full_names_by_id.keys - mappings_by_output_category_id.keys
+    end
+
+    # Generate a JSON representation of the integration version for a single direction.
+    #
+    # @param direction [Symbol] The direction of the distribution file to generate (:from_shopify or :to_shopify).
+    # @return [Hash, Array<Hash>, nil]
+    def to_json(direction:)
+      if @to_json.key?(direction)
+        @to_json[direction]
+      elsif direction == :both
+        [to_json(direction: :from_shopify), to_json(direction: :to_shopify)].compact
+      else
+        mappings = if direction == :from_shopify
+          @from_shopify_mappings&.sort_by { _1.input_category.id_parts }
+        else
+          @to_shopify_mappings
+        end
+
+        @to_json[direction] = if mappings.present?
+          {
+            input_taxonomy: input_name_and_version(direction:),
+            output_taxonomy: output_name_and_version(direction:),
+            rules: mappings.map(&:to_json),
+          }
+        end
+      end
+    end
+
+    # Generate a TXT representation of the integration version for a single direction.
+    #
+    # @param direction [Symbol] The direction of the distribution file to generate (:from_shopify or :to_shopify).
+    # @return [String]
+    def to_txt(direction:)
+      mappings = direction == :from_shopify ? @from_shopify_mappings : @to_shopify_mappings
+
+      header = <<~TXT
+        # Shopify Product Taxonomy - Mapping #{input_name_and_version(direction:)} to #{output_name_and_version(direction:)}
+        # Format:
+        # → {base taxonomy category name}
+        # ⇒ {mapped taxonomy category name}
+
+      TXT
+
+      visible_mappings = mappings.filter_map do |mapping|
+        next if @name == "shopify" && direction == :to_shopify && mapping.input_txt_equals_output_txt?
+
+        mapping.to_txt
+      end
+
+      header + visible_mappings.sort.join("\n").chomp
+    end
+
+    private
+
+    def distribution_filename(direction:)
+      "#{input_name_and_version(direction:)}_to_#{output_name_and_version(direction:)}"
+        .gsub("/", "_")
+        .gsub("-unstable", "")
+    end
+
+    def integration_name_and_version
+      "#{@name}/#{@version}"
+    end
+
+    def shopify_name_and_version
+      "shopify/#{@current_shopify_version}"
+    end
+
+    def input_name_and_version(direction:)
+      direction == :from_shopify ? shopify_name_and_version : integration_name_and_version
+    end
+
+    def output_name_and_version(direction:)
+      direction == :from_shopify ? integration_name_and_version : shopify_name_and_version
+    end
+  end
+end

data/lib/product_taxonomy/models/mapping_rule.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  # A mapping rule for converting between the integration's taxonomy and Shopify's taxonomy.
+  class MappingRule
+    class << self
+      # Load mapping rules from the provided source data directory for a single direction.
+      #
+      # @param integration_path [String] The path to the integration version source data directory.
+      # @param direction [Symbol] The direction of the mapping rules to load (:from_shopify or :to_shopify).
+      # @param full_names_by_id [Hash<String, Hash>] A hash of full names by ID.
+      # @return [Array<MappingRule>, nil]
+      def load_rules_from_source(integration_path:, direction:, full_names_by_id:)
+        file_path = File.expand_path("mappings/#{direction}.yml", integration_path)
+        return unless File.exist?(file_path)
+
+        data = YAML.safe_load_file(file_path)
+        raise ArgumentError, "Mapping rules file does not contain a hash: #{file_path}" unless data.is_a?(Hash)
+        raise ArgumentError, "Mapping rules file does not have a `rules` key: #{file_path}" unless data.key?("rules")
+        unless data["rules"].is_a?(Array)
+          raise ArgumentError, "Mapping rules file `rules` value is not an array: #{file_path}"
+        end
+
+        data["rules"].map do |rule|
+          input_id = rule.dig("input", "product_category_id")&.to_s
+          output_id = rule.dig("output", "product_category_id")&.first&.to_s
+
+          raise ArgumentError, "Invalid mapping rule: #{rule}" if input_id.nil? || output_id.nil?
+
+          is_to_shopify = direction == :to_shopify
+          input_category = is_to_shopify ? full_names_by_id[input_id] : Category.find_by(id: input_id)
+          # We set output_category to be the raw output ID if is_to_shopify is true, with an expectation that it will
+          # be resolved to a `Category` before the rule is serialized to JSON or TXT.
+          # See `IntegrationVersion#resolve_to_shopify_mappings`.
+          output_category = is_to_shopify ? output_id : full_names_by_id[output_id]
+
+          raise ArgumentError, "Input category not found for mapping rule: #{rule}" unless input_category
+          raise ArgumentError, "Output category not found for mapping rule: #{rule}" unless output_category
+
+          new(input_category:, output_category:)
+        rescue TypeError, NoMethodError
+          raise ArgumentError, "Invalid mapping rule: #{rule}"
+        end
+      end
+    end
+
+    attr_reader :input_category
+    attr_accessor :output_category
+
+    def initialize(input_category:, output_category:)
+      @input_category = input_category
+      @output_category = output_category
+    end
+
+    # Generate a JSON representation of the mapping rule.
+    #
+    # @return [Hash]
+    def to_json
+      {
+        input: {
+          category: category_json(@input_category),
+        },
+        output: {
+          category: [category_json(@output_category)],
+        },
+      }
+    end
+
+    # Generate a TXT representation of the mapping rule.
+    #
+    # @return [String]
+    def to_txt
+      <<~TXT
+        → #{category_txt(@input_category)}
+        ⇒ #{category_txt(@output_category)}
+      TXT
+    end
+
+    # Whether the input and output categories have the same full name.
+    #
+    # @return [Boolean]
+    def input_txt_equals_output_txt?
+      category_txt(@input_category) == category_txt(@output_category)
+    end
+
+    private
+
+    def category_json(category)
+      if category.is_a?(Hash)
+        {
+          id: category["id"].to_s,
+          full_name: category["full_name"],
+        }
+      elsif category.is_a?(Category)
+        {
+          id: category.gid,
+          full_name: category.full_name,
+        }
+      else
+        raise ArgumentError, "Mapping rule category not resolved. Raw value: #{category}"
+      end
+    end
+
+    def category_txt(category)
+      if category.is_a?(Hash)
+        category["full_name"]
+      elsif category.is_a?(Category)
+        category.full_name
+      else
+        raise ArgumentError, "Mapping rule category not resolved. Raw value: #{category}"
+      end
+    end
+  end
+end

data/lib/product_taxonomy/models/mixins/formatted_validation_errors.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module FormattedValidationErrors
+    def validate!(...)
+      super # Calls original ActiveModel::Validations#validate!
+    rescue ActiveModel::ValidationError
+      id_field_name = self.is_a?(Category) ? :id : :friendly_id
+      id_value = self.send(id_field_name)
+
+      formatted_error_details = self.errors.map do |error|
+        attribute = error.attribute # Raw attribute name, e.g., :friendly_id
+        message = error.message     # Just the message part, e.g., "can't be blank"
+        prefix = "  • "
+
+        prefix + (attribute == :base ? message : "#{attribute} #{message}")
+      end.join("\n")
+
+      raise ActiveModel::ValidationError.new(self), "Validation failed for #{self.class.name.demodulize.downcase} " \
+        "with #{id_field_name}=`#{id_value}`:\n#{formatted_error_details}"
+    end
+  end
+end

data/lib/product_taxonomy/models/mixins/indexed.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  # Mixin providing indexing for a model, using hashes to support fast uniqueness checks and lookups by field value.
+  module Indexed
+    NotFoundError = Class.new(StandardError)
+
+    class << self
+      # Keep track of which model class used "extend Indexed" so that the model can be subclassed while still storing
+      # model objects in a shared index on the superclass.
+      def extended(indexed_model_class)
+        indexed_model_class.instance_variable_set(:@is_indexed, true)
+      end
+    end
+
+    # Validator that checks for uniqueness of a field value across all models in a given index.
+    class UniquenessValidator < ActiveModel::EachValidator
+      def validate_each(record, attribute, value)
+        if record.class.duplicate?(model: record, field: attribute)
+          record.errors.add(attribute, :taken, message: "\"#{value}\" has already been used")
+        end
+      end
+    end
+
+    # Add a model to the index.
+    #
+    # @param model [Object] The model to add to the index.
+    def add(model)
+      hashed_models.keys.each do |field|
+        hashed_models[field][model.send(field)] ||= []
+        hashed_models[field][model.send(field)] << model
+      end
+    end
+
+    # Convenience method to create a model, validate it, and add it to the index. If the model is not valid, raise an
+    # error.
+    #
+    # @param args [Array] The arguments to pass to the model's constructor.
+    # @return [Object] The created model.
+    def create_validate_and_add!(...)
+      model = new(...)
+      model.validate!(:create)
+      add(model)
+      model
+    end
+
+    # Check if a field value is a duplicate of an existing model. A model is considered to be a duplicate if it was
+    # added after the first model with that value.
+    #
+    # @param model [Object] The model to check for uniqueness.
+    # @param field [Symbol] The field to check for uniqueness.
+    # @return [Boolean] Whether the value is unique.
+    def duplicate?(model:, field:)
+      raise ArgumentError, "Field not hashed: #{field}" unless hashed_models.key?(field)
+
+      existing_models = hashed_models[field][model.send(field)]
+      return false if existing_models.nil?
+
+      existing_models.first != model
+    end
+
+    # Find a model by field value. Returns the first matching record or nil. Only works for fields marked unique.
+    #
+    # @param conditions [Hash] Hash of field-value pairs to search by
+    # @return [Object, nil] The matching model or nil if not found
+    def find_by(**conditions)
+      field, value = conditions.first
+      raise ArgumentError, "Field not hashed: #{field}" unless hashed_models.key?(field)
+
+      hashed_models[field][value]&.first
+    end
+
+    # Find a model by field value. Returns the first matching record or raises an error if not found. Only works for
+    # fields marked unique.
+    #
+    # @param conditions [Hash] Hash of field-value pairs to search by
+    # @return [Object] The matching model
+    def find_by!(**conditions)
+      record = find_by(**conditions)
+      return record if record
+
+      field, value = conditions.first
+      field = field.to_s.humanize(capitalize: false, keep_id_suffix: true)
+      raise NotFoundError, "#{self.name.demodulize} with #{field} \"#{value}\" not found"
+    end
+
+    # Get the hash of models indexed by a given field. Only works for fields marked unique.
+    #
+    # @param field [Symbol] The field to get the hash for.
+    # @return [Hash] The hash of models indexed by the given field.
+    def hashed_by(field)
+      raise ArgumentError, "Field not hashed: #{field}" unless hashed_models.key?(field)
+
+      hashed_models[field]
+    end
+
+    # Get all models in the index.
+    #
+    # @return [Array<Object>] All models in the index.
+    def all
+      hashed_models.first[1].values.flatten
+    end
+
+    # Get the number of models in the index.
+    #
+    # @return [Integer] The number of models in the index.
+    def size
+      all.size
+    end
+
+    # Get the hash of hash of models, indexed by fields marked unique.
+    #
+    # @return [Hash] The hash of hash of models indexed by the fields marked unique.
+    def hashed_models
+      # If we're a subclass of the model class that originally extended Indexed, use the parent class' hashed_models.
+      return superclass.hashed_models unless @is_indexed
+
+      @hashed_models ||= unique_fields.each_with_object({}) do |field, hash|
+        hash[field] = {}
+      end
+    end
+
+    private
+
+    def unique_fields
+      _validators.select do |_, validators|
+        validators.any? do |validator|
+          validator.is_a?(UniquenessValidator)
+        end
+      end.keys
+    end
+  end
+end

data/lib/product_taxonomy/models/mixins/localized.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module ProductTaxonomy
+  module Localized
+    def localizations
+      return @localizations if @localizations
+
+      localization_path = File.expand_path(
+        "localizations/#{localizations_humanized_model_name}/*.yml",
+        ProductTaxonomy.data_path,
+      )
+      @localizations = Dir.glob(localization_path).each_with_object({}) do |file, localizations|
+        locale = File.basename(file, ".yml")
+        localizations[locale] = YAML.safe_load_file(file).dig(locale, localizations_humanized_model_name)
+      end
+    end
+
+    # Validate that all localizations are present for the given locales. If no locales are provided, all locales
+    # will be validated.
+    #
+    # @param locales [Array<String>, nil] The locales to validate. If nil, all locales will be validated.
+    def validate_localizations!(locales = nil)
+      model_keys = all.map { |model| model.send(@localizations_keyed_by).to_s }
+      locales_to_validate = locales || localizations.keys
+      locales_to_validate.each do |locale|
+        missing_localization_keys = model_keys.reject { |key| localizations.dig(locale, key, "name") }
+        next if missing_localization_keys.empty?
+
+        raise ArgumentError, "Missing or incomplete localizations for the following keys in " \
+          "localizations/#{localizations_humanized_model_name}/#{locale}.yml: #{missing_localization_keys.join(", ")}"
+      end
+    end
+
+    private
+
+    # Define methods that return localized attributes by fetching from localization YAML files. Values for the `en`
+    # locale come directly from the model's attributes.
+    #
+    # For example, if the class localizes `name` and `description` attributes keyed by `friendly_id`:
+    #
+    #   localized_attr_reader :name, :description, keyed_by: :friendly_id
+    #
+    # This will generate the following methods:
+    #
+    #   name(locale: "en")
+    #   description(locale: "en")
+    def localized_attr_reader(*attrs, keyed_by: :friendly_id)
+      if @localizations_keyed_by.present? && @localizations_keyed_by != keyed_by
+        raise ArgumentError, "Cannot localize attributes with different keyed_by values"
+      end
+
+      @localizations_keyed_by = keyed_by
+      attrs.each do |attr|
+        define_method(attr) do |locale: "en"|
+          raw_value = instance_variable_get("@#{attr}")
+
+          if locale == "en"
+            raw_value
+          else
+            self.class.localizations.dig(locale, send(keyed_by).to_s, attr.to_s) || raw_value
+          end
+        end
+      end
+    end
+
+    def localizations_humanized_model_name
+      name.demodulize.humanize.downcase.pluralize
+    end
+  end
+end