axle_attributes 1.13.2

data/lib/axle_attributes/has_attributes/json_reader.rb

@@ -0,0 +1,87 @@
+module AxleAttributes
+  module HasAttributes
+    class JsonReader
+      # json = {
+      #   {
+      #     "location": {
+      #       "street": {"type": "string"},
+      #       "city": {"type": "string", "readonly": true}
+      #     }
+      #     "group2": {
+      #     },
+      #     ...
+      #   },
+      #   "contacts": {
+      #     "type": "serialize_many",
+      #     "attributes": {
+      #       "first_name": {"type": "string"},
+      #       "professional_title": {"type": "string"}
+      #     }
+      #   }
+      # }
+      #
+      # AxleAttributes::HasAttributes::JsonReader.read_definitions(Widget, json)
+      #
+      def self.read_definitions(model, json, options = {})
+        new(model, options).read_definitions(json)
+      end
+
+      attr_reader :model
+      attr_reader :reader_options
+      def initialize(model, reader_options = {})
+        @model            = model
+        @reader_options   = reader_options
+      end
+
+      def read_definitions(json)
+        json = ActiveSupport::JSON.decode(json) unless json.is_a?(Hash)
+
+        json.each do |namespace, options|
+          if options['type']
+            read_serialization namespace, options
+          else
+            read_definition_group options
+          end
+        end
+      end
+
+      private
+
+        def read_definition_group(definitions)
+          definitions.each do |attribute_name, options|
+            model.has_attribute attribute_name, normalize_options(options)
+          end
+        end
+
+        SERIALIZATION_TYPES = %w(serialize_one serialize_many)
+        def read_serialization(serialization_name, options)
+          raise "unknown serialization #{options['type']}" unless SERIALIZATION_TYPES.include?(options['type'])
+          serialization_type        = options['type']
+          serialization_attributes  = options['attributes']
+
+          child_model = (options['class_name'] || serialization_name.classify).constantize
+          AxleAttributes::HasAttributes::JsonReader.read_definitions(child_model, {serialization_type => serialization_attributes}, reader_options)
+          reflection = model.send(serialization_type, serialization_name.to_sym, options.slice('class_name').symbolize_keys!)
+        end
+
+        SYMBOL_OPTIONS = [:type, :format, :index, :mmdb_name]
+        def normalize_options(options)
+          options.symbolize_keys!
+
+          SYMBOL_OPTIONS.each do |option_name|
+            if (value = options[option_name]).is_a?(String)
+              options[option_name] = value.to_sym
+            end
+          end
+
+          options.reverse_merge! default_options
+
+          options
+        end
+
+        def default_options
+          @default_options ||= (reader_options[:defaults] || {})
+        end
+    end
+  end
+end

data/lib/axle_attributes/model.rb

@@ -0,0 +1,34 @@
+module AxleAttributes
+  module Model
+    extend ActiveSupport::Concern
+
+    included do
+      unless include?(ElasticRecord::Model)
+        include ElasticRecord::Model
+      end
+
+      include AxleAttributes::HasAttributes
+      self.has_attribute_definition_class = '::AxleAttributes::ParentDefinition'
+      add_core_axle_attributes! unless self.name.demodulize == 'Base'
+
+      include AxleAttributes::Provided
+      include AxleAttributes::Segmented
+      include AxleAttributes::Serializations
+      include AxleAttributes::Versioned
+      include AxleAttributes::Validations
+    end
+
+    module ClassMethods
+      def inherited(child)
+        super
+        child.add_core_axle_attributes!
+      end
+
+      def add_core_axle_attributes!
+        has_attribute(:created_at, type: :time, index: true, editable: false) unless attributes['created_at']
+        has_attribute(:updated_at, type: :time, index: true, editable: false) unless attributes['updated_at']
+        has_attribute(:segment_id, type: :integer, index: true, editable: false) unless attributes['segment_id']
+      end
+    end
+  end
+end

data/lib/axle_attributes/null_definition.rb

@@ -0,0 +1,11 @@
+module AxleAttributes
+  class NullDefinition < ::AxleAttributes::Definition
+    def type
+      :null
+    end
+
+    def ==(other)
+      self.class == other.class && self.model == other.model && self.name == other.name
+    end
+  end
+end

data/lib/axle_attributes/parent_definition.rb

@@ -0,0 +1,37 @@
+module AxleAttributes
+  class ParentDefinition < ::AxleAttributes::Definition
+    setup do
+      setup_storage!
+      setup_index!
+      setup_versioning!
+    end
+
+    private
+
+      def setup_storage!
+        if type
+          storage_options = case type
+            when :text
+              {type: :string}
+            else
+              options.slice(:type, :default)
+            end
+
+          model.attribute(name, storage_options)
+        end
+      end
+
+      def setup_index!
+        if mapping = index_mapping
+          model.elastic_index.mapping[:properties].merge!(name => mapping)
+        end
+      end
+
+      def setup_versioning!
+        if versioned?
+          model.add_versioned_attribute name
+        end
+      end
+
+  end
+end

data/lib/axle_attributes/provided.rb

@@ -0,0 +1,67 @@
+module AxleAttributes
+  module Provided
+    extend ActiveSupport::Concern
+    include ActiveModel::AttributeMethods
+
+    included do
+      attribute_method_suffix '_provided?'
+    end
+
+    module ClassMethods
+      def tracking_disabled?
+        Thread.current[:disable_provided_tracking]
+      end
+
+      def without_provided_tracking
+        Thread.current[:disable_provided_tracking] = true
+        yield
+      ensure
+        Thread.current[:disable_provided_tracking] = false
+      end
+    end
+
+    def provided
+      provided_set.to_a
+    end
+
+    def provided_set
+      @provided_set ||= Set.new
+    end
+
+    def provided?(attr)
+      provided_set.include? attr
+    end
+
+    def save(*)
+      if status = super
+        provided_set.clear
+      end
+      status
+    end
+
+    # Attempts to <tt>save!</tt> the record and clears changed attributes if successful.
+    def save!(*)
+      super.tap do
+        provided_set.clear
+      end
+    end
+
+    # <tt>reload</tt> the record and clears changed attributes.
+    def reload(*)
+      super.tap do
+        provided_set.clear
+      end
+    end
+
+    private
+      def attribute_provided?(attr)
+        provided_set.include?(attr)
+      end
+
+      def write_attribute(attr, value)
+        provided_set << attr.to_s unless self.class.tracking_disabled?
+
+        super(attr, value)
+      end
+  end
+end

data/lib/axle_attributes/regex.rb

@@ -0,0 +1,4 @@
+module AxleAttributes
+  class Regex
+  end
+end

data/lib/axle_attributes/segmented.rb

@@ -0,0 +1,30 @@
+require 'digest'
+
+module AxleAttributes
+  module Segmented
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :max_segment
+      self.max_segment = 1024
+
+      before_create do
+        regenerate_segment_id unless segment_id
+      end
+    end
+
+    module ClassMethods
+      def segment_range
+        0..(max_segment-1)
+      end
+    end
+
+    def generate_segment_id
+      Digest::MD5.digest(id.to_s).unpack("L")[0] % max_segment
+    end
+
+    def regenerate_segment_id
+      self.segment_id = generate_segment_id
+    end
+  end
+end

data/lib/axle_attributes/serializations.rb

@@ -0,0 +1,147 @@
+module AxleAttributes
+  module Serializations
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Autoload
+
+    autoload :Reflection,       'axle_attributes/serializations/reflection'
+    autoload :Serialization,    'axle_attributes/serializations/serialization'
+    autoload :SerializeMany,    'axle_attributes/serializations/serialize_many'
+    autoload :SerializeOne,     'axle_attributes/serializations/serialize_one'
+
+    module Builder
+      autoload :Serialization,  'axle_attributes/serializations/builder/serialization'
+      autoload :SerializeMany,  'axle_attributes/serializations/builder/serialize_many'
+      autoload :SerializeOne,   'axle_attributes/serializations/builder/serialize_one'
+    end
+
+    included do
+      class_attribute :serialization_reflections
+      self.serialization_reflections = {}
+
+      validate :validate_serialized_objects
+
+      after_save { child_serialization_cache.clear }
+    end
+
+    module ClassMethods
+      # serialize_many serializes a collection of objects into a single column.
+      #
+      # === Example
+      #
+      # class Factory
+      #   serialize_many :widgets
+      # end
+      #
+      # This adds the following:
+      #   <tt>factory.widgets_count</tt> - A counter cache of the number of widgets
+      #   <tt>factory.widgets_updated_at</tt> - The last time a widget was modifed
+      #   <tt>factory.widgets</tt> - A collection of widgets
+      #
+      # == Options
+      # [:class_name]
+      #   The name of the class to instantiate the serialized objects as.
+      def serialize_many(name, options = {})
+        reflection = AxleAttributes::Serializations::Reflection.new(:serialize_many, name, options)
+        AxleAttributes::Serializations::Builder::SerializeMany.new(self, reflection).build!
+        reflection
+      end
+
+      # serialize_one serializes an object into a single column.
+      #
+      # === Example
+      #
+      # class Factory
+      #   serialize_one :manager
+      # end
+      #
+      # This adds the following:
+      #   <tt>factory.manager</tt> - Read the manager.
+      #   <tt>factory.manager=(value)</tt> - Write the manager.
+      #
+      # == Options
+      # [:class_name]
+      #   The name of the class to instantiate the serialized objects as.
+      def serialize_one(name, options = {})
+        reflection = AxleAttributes::Serializations::Reflection.new(:serialize_one, name, options)
+        AxleAttributes::Serializations::Builder::SerializeOne.new(self, reflection).build!
+        reflection
+      end
+
+      def serialized_many?(name)
+        serialization_reflections[name.to_sym].try :collection?
+      end
+
+      def generated_serialized_object_methods
+        @generated_serialized_object_methods ||= begin
+          mod = const_set(:GeneratedSerializedObjectMethods, Module.new)
+          include mod
+          mod
+        end
+      end
+    end
+
+    # Returns the searches_many instance for the given name, instantiating it if it doesn't already exist
+    def child_serialization(name)
+      serialization = child_serialization_instance_get(name)
+
+      if serialization.nil?
+        reflection = serialization_reflections[name]
+        serialization = reflection.serialization_class.new(self, reflection)
+        child_serialization_instance_set(name, serialization)
+      end
+
+      serialization
+    end
+
+    def reload
+      super
+      child_serialization_cache.clear
+    end
+
+    def validate_serialized_objects
+      child_serialization_cache.each do |name, serialization|
+        next unless serialization.loaded?
+
+        validation_method = serialization.reflection.collection? ? :validate_collection_serialization : :validate_single_serialization
+        send(validation_method, serialization)
+      end
+    end
+
+    def validate_collection_serialization(serialization)
+      serialization.reader.each do |record|
+        if record.invalid?
+          record.errors.each do |attribute, message|
+            attribute = "#{serialization.name}.#{attribute}"
+            errors[attribute] << message
+            errors[attribute].uniq!
+          end
+        end
+      end
+    end
+
+    def validate_single_serialization(serialization)
+      record = serialization.reader
+
+      if record && record.invalid?
+        record.errors.each do |attribute, message|
+          attribute = "#{serialization.name}.#{attribute}"
+          errors[attribute] << message
+        end
+      end
+    end
+
+    private
+
+      def child_serialization_cache
+        @child_serialization_cache ||= {}
+      end
+
+      def child_serialization_instance_get(name)
+        child_serialization_cache[name.to_sym]
+      end
+
+      def child_serialization_instance_set(name, serialization)
+        child_serialization_cache[name.to_sym] = serialization
+      end
+  end
+end

data/lib/axle_attributes/serializations/builder/serialization.rb

@@ -0,0 +1,83 @@
+module AxleAttributes::Serializations::Builder
+  class Serialization
+    attr_accessor :model, :reflection
+    def initialize(model, reflection)
+      @model = model
+      @reflection = reflection
+    end
+
+    def build!
+      model.serialization_reflections = model.serialization_reflections.merge(reflection.name => reflection)
+
+      define_attributes
+      define_writer
+      define_reader
+    end
+
+    def define_attributes
+      model.attribute_definition_class.new(model, reflection.storage_column, type: :json, index: false, version: true).setup!
+
+      model.has_attributes(meta_attributes)
+
+      setup_definitions_on_parent
+    end
+
+    def mixin
+      model.generated_serialized_object_methods
+    end
+
+    def define_writer
+      name = reflection.name
+
+      mixin.redefine_method "#{name}=" do |records|
+        child_serialization(name).writer(records)
+      end
+
+      mixin.redefine_method "#{name}_attributes=" do |attrs|
+        child_serialization(name).attributes_writer(attrs)
+      end
+    end
+
+    def define_reader
+      name = reflection.name
+
+      mixin.redefine_method(name) do
+        child_serialization(name).reader
+      end
+
+      mixin.redefine_method("#{name}_was") do
+        child_serialization(name).reader_was
+      end
+    end
+
+    def setup_definitions_on_parent
+      serialized_index_mapping = {
+        type: index_type,
+        properties: {}
+      }
+
+      reflection.klass.attributes.each_value do |definition|
+        definition.nested_path = reflection.name.to_s if reflection.collection?
+
+        model.add_attribute_definition("#{reflection.name}.#{definition.name}", definition)
+
+        if mapping = definition.index_mapping
+          serialized_index_mapping[:properties][definition.name] = mapping
+        end
+      end
+
+      model.elastic_index.mapping[:properties].merge!(reflection.name.to_s => serialized_index_mapping)
+    end
+
+    protected
+
+      def index_type
+        raise "index_type must be implemented"
+      end
+
+      def meta_attributes
+        {}
+      end
+
+  end
+end