axle_attributes 1.13.2

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

@@ -0,0 +1,17 @@
+module AxleAttributes::Serializations::Builder
+  class SerializeMany < Serialization
+    def index_type
+      :nested
+    end
+
+    def meta_attributes
+      if reflection.counter_cache_column
+        {
+          reflection.counter_cache_column => {type: :integer, index: true,  version: false, editable: false}
+        }
+      else
+        {}
+      end
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module AxleAttributes::Serializations::Builder
+  class SerializeOne < Serialization
+    def index_type
+      :object
+    end
+  end
+end

data/lib/axle_attributes/serializations/reflection.rb

@@ -0,0 +1,40 @@
+module AxleAttributes
+  module Serializations
+    class Reflection
+      attr_accessor :macro, :name, :options
+      def initialize(macro, name, options)
+        @macro      = macro
+        @name       = name.to_sym
+        @options    = options
+        @collection = macro == :serialize_many
+      end
+
+      def serialization_class
+        case macro
+        when :serialize_many
+          Serializations::SerializeMany
+        when :serialize_one
+          Serializations::SerializeOne
+        end
+      end
+
+      def storage_column
+        name
+      end
+
+      def counter_cache_column
+        unless options[:counter_cache] == false
+          "#{name}_count"
+        end
+      end
+
+      def klass
+        @klass ||= (options[:class_name] || name.to_s.classify).constantize
+      end
+
+      def collection?
+        @collection
+      end
+    end
+  end
+end

data/lib/axle_attributes/serializations/serialization.rb

@@ -0,0 +1,88 @@
+module AxleAttributes
+  module Serializations
+    class Serialization
+      attr_accessor :owner, :reflection
+      def initialize(owner, reflection)
+        @owner      = owner
+        @reflection = reflection
+        @collection = nil
+        @loaded     = false
+      end
+
+      def name
+        reflection.name
+      end
+
+      def writer(value)
+        raise "writer must be implemented"
+      end
+
+      def reader
+        target
+      end
+
+      def reader_was
+        if owner.changed_attributes.include?(name.to_s)
+          instantiate_target_with_self owner.changed_attributes[name.to_s]
+        else
+          target
+        end
+      end
+
+      def loaded?
+        @loaded
+      end
+
+      protected
+
+        def target=(value)
+          @target = value
+          target_with_serialization_instance(@target)
+          loaded!
+          owner[reflection.storage_column] = mutate_json_times!(value.as_json)
+        end
+
+        def mutate_json_times!(json)
+          Array.wrap(json).each do |attrs|
+            attrs.each do |k, v|
+              if v.acts_like?(:time) || v.acts_like?(:date)
+                attrs[k] = v.as_json
+              end
+            end
+          end
+
+          json
+        end
+
+        def target
+          unless loaded?
+            @target = load_target
+            loaded!
+          end
+
+          @target
+        end
+
+        def loaded!
+          @loaded = true
+        end
+
+        def load_target
+          instantiate_target_with_self owner[reflection.storage_column]
+        end
+
+        def instantiate_target_with_self(json)
+          target_with_serialization_instance instantiate_target(json)
+        end
+
+        def target_with_serialization_instance(target)
+          Array.wrap(target).each { |record| record.serialization_instance = self }
+          target
+        end
+
+        def instantiate_target(json)
+          raise "instantiate_target must be implemented"
+        end
+    end
+  end
+end

data/lib/axle_attributes/serializations/serialize_many.rb

@@ -0,0 +1,88 @@
+module AxleAttributes
+  module Serializations
+    class SerializeMany < Serialization
+      def writer(records)
+        return if records.nil? && owner[reflection.storage_column].nil?
+
+        records ||= []
+        records = records.map { |record| record.is_a?(Hash) ? reflection.klass.new(record) : record }
+
+        replace(records)
+      end
+
+      def replace(records)
+        delete(target - records)
+        concat(records)
+
+        target_changed!
+      end
+
+      def delete(records)
+        records.each { |record| delete_from_collection(record) }
+      end
+
+      def concat(records)
+        records.each { |record| add_to_collection(record) }
+      end
+
+      def attributes_writer(attributes_collection)
+        return if attributes_collection.empty?
+
+        if attributes_collection.is_a? Hash
+          attributes_collection = attributes_collection.values
+        end
+
+        attributes_collection.each do |attributes|
+          attributes = attributes.with_indifferent_access
+
+          if attributes['_destroy'] == '1'
+            target.delete_if { |record| record.id == attributes['id'] }
+          else
+            if existing = target.detect { |record| record.id == attributes['id'] }
+              existing.attributes = attributes
+            else
+              target << reflection.klass.new(attributes)
+            end
+          end
+        end
+
+        target_changed!
+      end
+
+      private
+
+        def target_changed!
+          self.target = target
+
+          if reflection.counter_cache_column
+            owner.send("#{reflection.counter_cache_column}=", target.size)
+          end
+        end
+
+        def instantiate_target(json)
+          json.nil? ? [] : json.map { |entry| reflection.klass.instantiate(entry['id'], entry) }
+        end
+
+        def delete_from_collection(record)
+          target.delete(record)
+        end
+
+        def add_to_collection(record)
+          if index = target.index(record)
+            current = target[index]
+            new_attributes = record.attributes.update('id' => current.id, 'created_at' => current.created_at)
+
+            current.attributes.each_key do |key|
+              unless new_attributes.key?(key)
+                current.send("#{key}=", reflection.klass.attributes[key].default)
+              end
+            end
+
+            current.attributes = new_attributes
+          else
+            target << record
+          end
+        end
+    end
+  end
+end

data/lib/axle_attributes/serializations/serialize_one.rb

@@ -0,0 +1,34 @@
+module AxleAttributes
+  module Serializations
+    class SerializeOne < Serialization
+      def writer(record_or_hash)
+        if record_or_hash.is_a?(Hash)
+          if target
+            target.attributes = record_or_hash
+            record = target
+          else
+            record = reflection.klass.new(record_or_hash)
+          end
+        else
+          record = record_or_hash
+        end
+
+        self.target = record
+      end
+
+      def attributes_writer(attributes)
+        attributes = attributes.with_indifferent_access
+        writer(attributes['_destroy'] == '1' ? nil : attributes)
+      end
+
+      private
+
+        def instantiate_target(json)
+          if json
+            reflection.klass.instantiate json['id'], json
+          end
+        end
+
+    end
+  end
+end

data/lib/axle_attributes/serialized_child.rb

@@ -0,0 +1,58 @@
+require 'securerandom'
+
+module AxleAttributes
+  module SerializedChild
+    extend ActiveSupport::Concern
+
+    included do
+      include SuperstoreOverrides
+      alias :eql? :==
+
+      include AxleAttributes::Versioned
+      include AxleAttributes::HasAttributes
+      self.has_attribute_definition_class = '::AxleAttributes::ChildDefinition'
+      has_attribute :id, type: :string, index: true, editable: false, version: true
+      has_attribute :created_at, type: :time, index: true, editable: false
+
+      attr_accessor :serialization_instance
+
+      include AxleAttributes::Provided
+      include AxleAttributes::Validations
+    end
+
+    module SuperstoreOverrides
+      def initialize(*args)
+        super
+        @attributes['created_at'] ||= Time.current
+      end
+
+      def attributes=(params)
+        params.each do |attr, value|
+          self.public_send("#{attr}=", value) if respond_to?("#{attr}=")
+        end
+      end
+
+      def ==(other)
+        super || hash == other.hash
+      end
+
+      def attributes
+        result = super
+        result.select! { |attr, value| !value.nil? && self.class.attributes[attr] }
+        result
+      end
+    end
+
+    def hash
+      id.hash
+    end
+
+    def versioned_attributes
+      attributes.keep_if { |key, value| self.class.attributes[key].versioned? }
+    end
+
+    def as_search
+      attributes.keep_if { |key, value| self.class.attributes[key].indexed? }
+    end
+  end
+end

data/lib/axle_attributes/validations.rb

@@ -0,0 +1,29 @@
+module AxleAttributes
+  module Validations
+    extend ActiveSupport::Concern
+
+    included do
+      validate :validate_formats
+    end
+
+    private
+
+      def validate_formats
+        each_provided_definition do |definition|
+          value = send(definition.name)
+          if value.present? && error = definition.validate(value)
+            errors.add(definition.name, error)
+          end
+        end
+      end
+
+      def each_provided_definition
+        provided_set.each do |attr|
+          if definition = self.class.attributes[attr]
+            yield definition
+          end
+        end
+      end
+
+  end
+end

data/lib/axle_attributes/versioned.rb

@@ -0,0 +1,21 @@
+module AxleAttributes
+  module Versioned
+    extend ActiveSupport::Concern
+
+    included do
+      class_attribute :versioned_attributes, instance_accessor: false
+      self.versioned_attributes = Set.new
+    end
+
+    module ClassMethods
+      def inherited(child)
+        child.versioned_attributes = versioned_attributes.dup
+        super
+      end
+
+      def add_versioned_attribute(*attributes)
+        attributes.each { |attribute| versioned_attributes << attribute.to_s }
+      end
+    end
+  end
+end

data/test/dummy/README.rdoc

@@ -0,0 +1,6 @@
+== README
+
+Running tests
+
+rake db:create
+rake

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Dummy::Application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or vendor/assets/javascripts of plugins, if any, can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/sstephenson/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/test/dummy/app/assets/stylesheets/application.css

@@ -0,0 +1,13 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or vendor/assets/stylesheets of plugins, if any, can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the top of the
+ * compiled file, but it's generally better to create a new file per style scope.
+ *
+ *= require_self
+ *= require_tree .
+ */

data/test/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  # Prevent CSRF attacks by raising an exception.
+  # For APIs, you may want to use :null_session instead.
+  protect_from_forgery with: :exception
+end