axle_attributes 1.13.2

data/lib/axle_attributes/definition/callbacks.rb

@@ -0,0 +1,34 @@
+module AxleAttributes
+  class Definition
+    # Adds support for +setup+ and +teardown+ callbacks.
+    # These callbacks serve as a replacement to overwriting the
+    # <tt>#setup</tt> and <tt>#teardown</tt> methods of your TestCase.
+    #
+    #   class ExampleTest < ActiveSupport::TestCase
+    #     setup do
+    #       # ...
+    #     end
+    #   end
+    module Callbacks
+
+      extend ActiveSupport::Concern
+
+      included do
+        include ActiveSupport::Callbacks
+        define_callbacks :setup
+      end
+
+      module ClassMethods
+        # Add a callback, which runs before <tt>TestCase#setup</tt>.
+        def setup(*args, &block)
+          set_callback(:setup, :before, *args, &block)
+        end
+      end
+
+      def before_setup # :nodoc:
+        super
+        run_callbacks :setup
+      end
+    end
+  end
+end

data/lib/axle_attributes/definition/customization.rb

@@ -0,0 +1,51 @@
+module AxleAttributes
+  class Definition
+    module Customization
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cached_customizations
+        self.cached_customizations = {}
+      end
+
+      module ClassMethods
+        def cached_customization_for(namespace)
+          cached_customizations[namespace] ||= AttributeCustomization.namespace_cache_for(namespace).read
+        end
+      end
+
+      def customization
+        self.class.cached_customization_for(namespace)[name]
+      end
+
+      def display_name
+        read_customization(:display_name) || name.titlecase.gsub('.', ' ')
+      end
+
+      def description
+        read_customization :description
+      end
+
+      def notes
+        read_customization :notes
+      end
+
+      def editable_customization
+        value = customization.try(:editable)
+        value.nil? ? true : value
+      end
+
+      def deprecated_on
+        read_customization :deprecated_on
+      end
+
+      def deprecated?
+        deprecated_on.present?
+      end
+
+      def read_customization(property)
+        customization.try(property).presence
+      end
+    end
+  end
+end

data/lib/axle_attributes/definition/formatted.rb

@@ -0,0 +1,57 @@
+module AxleAttributes
+  class Definition
+    module Formatted
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :formatters
+        self.formatters = {}
+
+        setup do
+          setup_method_override!
+          formatter.try(:setup!, self)
+        end
+      end
+
+      def analyzer_mapping
+        if mapping = formatter.try(:analyzer_mapping)
+          mapping
+        else
+          super
+        end
+      end
+
+      def instructions
+        fetch_format_property(:instructions)
+      end
+
+      def standardize(value)
+        formatter.try(:standardize, self, value) || value
+      end
+
+      def validate(value)
+        formatter.try :validate, self, value
+      end
+
+      def formatter
+        formatters[format]
+      end
+
+      private
+
+        def fetch_format_property(property)
+          read_customization(property) || formatter.try(property, self)
+        end
+
+        def setup_method_override!
+          if formatter.respond_to?(:standardize)
+            definition = self
+            model.send :define_method, "#{name}=" do |value|
+              super definition.standardize(value)
+            end
+          end
+        end
+
+    end
+  end
+end

data/lib/axle_attributes/definition/indexed.rb

@@ -0,0 +1,41 @@
+module AxleAttributes
+  class Definition
+    module Indexed
+      def index
+        options[:index]
+      end
+
+      ANALYZERS = [:snowball, :proper_noun, :simple]
+      def analyzer_mapping
+        {type: 'string', analyzer: index} if ANALYZERS.include?(index)
+      end
+
+      INDEXES_BY_TYPE = {
+        array:    {type: "string", index: "not_analyzed", doc_values: true},
+        boolean:  {type: "boolean", doc_values: true},
+        float:    {type: "double", doc_values: true},
+        integer:  {type: "long", doc_values: true},
+        json:     {type: "boolean"},
+        string:   {type: 'string', index_analyzer: 'keyword', search_analyzer: 'standard'},
+        text:     {type: 'string', index_analyzer: 'keyword', search_analyzer: 'standard'},
+        time:     {type: "date", format: "dateOptionalTime", doc_values: true},
+        date:     {type: "date", format: "date", doc_values: true}
+      }
+      def index_mapping
+        return unless index
+
+        if mapping = analyzer_mapping
+          multi_field_index(name, mapping)
+        elsif index == true
+          INDEXES_BY_TYPE[type] || (raise "unknown index type #{type.inspect} for #{name}")
+        elsif index.is_a?(Hash)
+          index
+        end
+      end
+
+      def multi_field_index(field, analyzer_mapping)
+        {type: "multi_field", fields: {field => {type: "string", index: "not_analyzed", doc_values: true}, analyzed: analyzer_mapping}}
+      end
+    end
+  end
+end

data/lib/axle_attributes/definition/mappings.rb

@@ -0,0 +1,48 @@
+module AxleAttributes
+  class Definition
+    module Mappings
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :cached_attribute_mappings
+        self.cached_attribute_mappings = {}
+      end
+
+      module ClassMethods
+        def cached_attribute_mappings_for(namespace)
+          cached_attribute_mappings[namespace] ||= AttributeMapping.cached_mapping_for(namespace).read
+        end
+      end
+
+      def to_options
+        mappings.map do |k, v|
+          [v, k]
+        end
+      end
+
+      def mappings
+        if @mappings
+          @mappings
+        elsif mapping_model && mapping_model.respond_to?(:cached_mapping)
+          mapping_model.cached_mapping
+        else
+          self.class.cached_attribute_mappings_for(namespace)[name] || {}
+        end
+      end
+
+      def mappings=(val)
+        @mappings = val
+      end
+
+      def mapping_records
+        AttributeMapping.where(namespace: namespace, attribute_name: name)
+      end
+
+      def mapping_model
+        if options[:mapping_model]
+          @mapping_model ||= options[:mapping_model].constantize
+        end
+      end
+    end
+  end
+end

data/lib/axle_attributes/dumper.rb

@@ -0,0 +1,54 @@
+require 'csv'
+
+module AxleAttributes
+  class Dumper
+    attr_reader :model
+    def initialize(model)
+      @model  = model
+    end
+
+    def dump_internal
+      dump(model.attribute_set, ["Attribute", "Display Name", "Type", "Deprecation", "Legacy Name", "Mapping", "Description", "Note"]) do |definition|
+        [
+          definition.canonical_name,
+          definition.display_name,
+          definition.type,
+          definition.deprecated_on ? definition.deprecated_on.to_s('%Y/%m/%d') : nil,
+          definition.options[:mmdb_name],
+          mapping_display(definition),
+          definition.description,
+          definition.notes
+        ]
+      end
+    end
+
+    def dump_public(attribute_set)
+      dump(attribute_set, ["Attribute", "Display Name", "Type", "Description"]) do |definition|
+        [
+          definition.canonical_name,
+          definition.display_name,
+          definition.type,
+          definition.description
+        ]
+      end
+    end
+
+    def dump(attribute_set, headers)
+      CSV.generate(headers: headers, write_headers: true) do |csv|
+        attribute_set.sort.each do |attribute_name|
+          definition = model.attributes[attribute_name]
+          csv << yield(definition) if definition
+        end
+      end
+    end
+
+    def mapping_display(definition)
+      if mapping_model = definition.mapping_model
+        "#{mapping_model.model_name.plural}.#{mapping_model.natural_key}" if mapping_model.respond_to?(:natural_key)
+      elsif definition.mappings.any?
+        "attribute_mappings"
+      end
+    end
+
+  end
+end

data/lib/axle_attributes/engine.rb

@@ -0,0 +1,4 @@
+module AxleAttributes
+  class Engine < ::Rails::Engine
+  end
+end

data/lib/axle_attributes/format.rb

@@ -0,0 +1,74 @@
+module AxleAttributes
+  class Format
+    class_attribute :phone_regex
+    self.phone_regex = /\A\(\d{3}\) \d{3}-\d{4}\z/
+
+    class_attribute :url_regex
+    self.url_regex = /\A(https?:\/\/)([-a-z0-9]+\.[-.a-z0-9:]+)(\/[^\s]+)?\z/
+
+    class_attribute :zip_regex
+    self.zip_regex = /\A\d{5}\z/
+
+    class_attribute :postal_code_regex
+    self.postal_code_regex = /\A(\d{5}(-\d{4})?|[A-Z0-9]{6})\z/
+
+    class << self
+      PHONEWORDS = {"A"=>"2", "B"=>"2", "C"=>"2", "D"=>"3", "E"=>"3", "F"=>"3", "G"=>"4", "H"=>"4", "I"=>"4", "J"=>"5",
+                    "K"=>"5", "L"=>"5", "M"=>"6", "N"=>"6", "O"=>"6", "P"=>"7", "Q"=>"7", "R"=>"7", "S"=>"7", "T"=>"8",
+                    "U"=>"8", "V"=>"8", "W"=>"9", "X"=>"9", "Y"=>"9", "Z"=>"9"}
+
+      def standardize_phone(phone)
+        standardize phone, self.phone_regex do
+          standardized = phone.chars.map { |char| PHONEWORDS[char.upcase] || char }.join('')
+
+          standardized.gsub!(/\D/, '')
+
+          if standardized.size == 10
+            standardized.gsub!(/(\d{3})(\d{3})(\d{4})/, "(\\1) \\2-\\3")
+            standardized
+          elsif standardized.size == 11 && standardized[0] == '1'
+            standardized.gsub!(/1(\d{3})(\d{3})(\d{4})/, "(\\1) \\2-\\3")
+            standardized
+          end
+        end
+      end
+
+      def standardize_postal_code(postal_code)
+        standardize postal_code, postal_code_regex do
+          standardized = postal_code.remove(/[^\-[:alnum:]]/)
+          case standardized.length
+          when 6 then standardized.upcase!
+          when 9 then standardized.sub!(/\A(\d{5})(\d{4})\z/, '\\1-\\2')
+          end
+
+          standardized
+        end
+      end
+
+      def standardize_url(website)
+        standardize website, self.url_regex do
+          if website =~ /^(\w*):\/\//
+            scheme, _, resource = website.partition("://")
+            scheme.downcase!
+          else
+            scheme = "http"
+            resource = website
+          end
+          resource.strip!
+
+          host, slash, path = resource.partition("/")
+          host.downcase!
+          path.gsub! ' ', '%20'
+
+          path.empty? ? "#{scheme}://#{host}" : "#{scheme}://#{host}/#{path}"
+        end
+      end
+
+      def standardize(value, regex)
+        return value if value.blank? || value =~ regex
+        standardized = yield(value)
+        standardized =~ regex ? standardized : value
+      end
+    end
+  end
+end

data/lib/axle_attributes/has_attributes.rb

@@ -0,0 +1,104 @@
+require 'axle_attributes/has_attributes/json_reader'
+require 'open-uri'
+
+module AxleAttributes
+  module HasAttributes
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :has_attribute_definition_class
+      self.has_attribute_definition_class = '::AxleAttributes::Definition'
+    end
+
+    module ClassMethods
+      def inherited(child)
+        child.attribute_set = attribute_set.dup
+        child.attributes = attributes.dup
+        super
+      end
+
+      # Example:
+      #   has_attributes(
+      #     color: {type: :string, index: true, version: true},
+      #     weight: {type: :integer, version: true}
+      #   )
+      def has_attributes(definitions, default_options = {})
+        definitions.each do |name, options|
+          has_attribute name, default_options.merge(options)
+        end
+      end
+
+      def has_attribute(name, options = {})
+        name = name.to_s
+        definition = attribute_definition_class.new(self, name, options)
+        add_attribute_definition(name, definition)
+        definition.setup!
+      end
+
+      def add_attribute_definition(name, definition)
+        attributes[name] = definition
+        attribute_set << name
+      end
+
+      def has_mappings(mappings_hash)
+        mappings_hash.each do |name, mappings|
+          has_mapping name, mappings
+        end
+      end
+
+      def has_mapping(name, mappings)
+        if mappings.is_a?(Array)
+          mappings = Hash[mappings.map { |v| [v, v.humanize] }]
+        end
+
+        attributes[name.to_s].mappings = mappings
+      end
+
+      def attributes_file_root
+        @attributes_file_root ||= Rails.root.join('db', 'attributes')
+      end
+
+      def attributes_file_root=(pathname)
+        pathname = Pathname.new(pathname) unless pathname.is_a?(Pathname)
+        @attributes_file_root = pathname
+      end
+
+      def has_attributes_file(filename, options = {})
+        options[:defaults] ||= {}
+        options[:defaults][:filename] = filename
+        AxleAttributes::HasAttributes::JsonReader.read_definitions(self, read_attributes_file(filename), options)
+      end
+
+      def attributes
+        @attributes ||= {}
+      end
+
+      def attributes=(attributes)
+        @attributes = attributes
+      end
+
+      def attribute_set
+        @attribute_set ||= Set.new
+      end
+
+      def attribute_set=(attribute_set)
+        @attribute_set = attribute_set
+      end
+
+      def attribute_definition_class
+        @attribute_definition_class ||= has_attribute_definition_class.constantize
+      end
+
+      private
+
+        def read_attributes_file(filename)
+          attributes_file_pathname(filename).read
+        end
+
+        def attributes_file_pathname(filename)
+          attributes_file_root.join("#{filename}.json")
+        end
+
+    end
+  end
+end