attr_json 0.1.0

data/lib/attr_json/record.rb

@@ -0,0 +1,140 @@
+require 'attr_json/attribute_definition'
+require 'attr_json/attribute_definition/registry'
+require 'attr_json/type/container_attribute'
+
+module AttrJson
+  # The mix-in to provide AttrJson support to ActiveRecord::Base models.
+  # We call it `Record` instead of `ActiveRecord` to avoid confusing namespace
+  # shadowing errors, sorry!
+  #
+  # @example
+  #       class SomeModel < ActiveRecord::Base
+  #         include AttrJson::Record
+  #
+  #         attr_json :a_number, :integer
+  #       end
+  #
+  module Record
+    extend ActiveSupport::Concern
+
+    DEFAULT_CONTAINER_ATTRIBUTE = :json_attributes
+
+    included do
+      unless self < ActiveRecord::Base
+        raise TypeError, "AttrJson::Record can only be used with an ActiveRecord::Base model. #{self} does not appear to be one. Are you looking for ::AttrJson::Model?"
+      end
+
+      class_attribute :attr_json_registry, instance_accessor: false
+      self.attr_json_registry = AttrJson::AttributeDefinition::Registry.new
+
+      class_attribute :default_json_container_attribute, instance_acessor: false
+      self.default_json_container_attribute ||= DEFAULT_CONTAINER_ATTRIBUTE
+    end
+
+    class_methods do
+      # Type can be a symbol that will be looked up in `ActiveModel::Type.lookup`,
+      # or an ActiveModel:::Type::Value).
+      #
+      # @param name [Symbol,String] name of attribute
+      #
+      # @param type [ActiveModel::Type::Value] An instance of an ActiveModel::Type::Value (or subclass)
+      #
+      # @option options [Boolean] :array (false) Make this attribute an array of given type.
+      #
+      # @option options [Object] :default (nil) Default value, if a Proc object it will be #call'd
+      #   for default.
+      #
+      # @option options [String,Symbol] :store_key (nil) Serialize to JSON using
+      #   given store_key, rather than name as would be usual.
+      #
+      # @option options [Symbol,String] :container_attribute (self.default_json_container_attribute) The real
+      #   json(b) ActiveRecord attribute/column to serialize as a key in. Defaults to
+      #  `self.default_json_container_attribute`, which defaults to `:attr_jsons`
+      #
+      # @option options [Boolean] :validate (true) Create an ActiveRecord::Validations::AssociatedValidator so
+      #   validation errors on the attributes post up to self.
+      #
+      # @option options [Boolean] :rails_attribute (false) Create an actual ActiveRecord
+      #    `attribute` for name param. A Rails attribute isn't needed for our functionality,
+      #    but registering thusly will let the type be picked up by simple_form and
+      #    other tools that may look for it via Rails attribute APIs.
+      def attr_json(name, type, **options)
+        options = {
+          rails_attribute: false,
+          validate: true,
+          container_attribute: self.default_json_container_attribute
+        }.merge!(options)
+        options.assert_valid_keys(AttributeDefinition::VALID_OPTIONS + [:validate, :rails_attribute])
+        container_attribute = options[:container_attribute]
+
+        # TODO arg check container_attribute make sure it exists. Hard cause
+        # schema isn't loaded yet when class def is loaded. Maybe not.
+
+        # Want to lazily add an attribute cover to the json container attribute,
+        # only if it hasn't already been done. WARNING we are using internal
+        # Rails API here, but only way to do this lazily, which I thought was
+        # worth it. On the other hand, I think .attribute is idempotent, maybe we don't need it...
+        unless attributes_to_define_after_schema_loads[container_attribute.to_s] &&
+               attributes_to_define_after_schema_loads[container_attribute.to_s].first.is_a?(AttrJson::Type::ContainerAttribute)
+            attribute container_attribute.to_sym, AttrJson::Type::ContainerAttribute.new(self, container_attribute)
+        end
+
+        self.attr_json_registry = attr_json_registry.with(
+          AttributeDefinition.new(name.to_sym, type, options.except(:rails_attribute, :validate))
+        )
+
+        # By default, automatically validate nested models
+        if type.kind_of?(AttrJson::Type::Model) && options[:validate]
+          self.validates_with ActiveRecord::Validations::AssociatedValidator, attributes: [name.to_sym]
+        end
+
+        # We don't actually use this for anything, we provide our own covers. But registering
+        # it with usual system will let simple_form and maybe others find it.
+        if options[:rails_attribute]
+          self.attribute name.to_sym, self.attr_json_registry.fetch(name).type
+        end
+
+        _attr_jsons_module.module_eval do
+          define_method("#{name}=") do |value|
+            attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
+            # write_store_attribute copied from Rails store_accessor implementation.
+            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+
+            # special handling for nil, sorry, because if name key was previously
+            # not present, write_store_attribute by default will decide there was
+            # no change and refuse to make the change. TODO messy.
+            if value.nil? && !public_send(attribute_def.container_attribute).has_key?(attribute_def.store_key)
+               public_send :"#{attribute_def.container_attribute}_will_change!"
+               public_send(attribute_def.container_attribute)[attribute_def.store_key] = nil
+            else
+              # use of `write_store_attribute` is copied from Rails store_accessor implementation.
+              # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+              write_store_attribute(attribute_def.container_attribute, attribute_def.store_key, attribute_def.cast(value))
+            end
+          end
+
+          define_method("#{name}") do
+            attribute_def = self.class.attr_json_registry.fetch(name.to_sym)
+
+            # use of `read_store_attribute` is copied from Rails store_accessor implementation.
+            # https://github.com/rails/rails/blob/74c3e43fba458b9b863d27f0c45fd2d8dc603cbc/activerecord/lib/active_record/store.rb#L90-L96
+            read_store_attribute(attribute_def.container_attribute, attribute_def.store_key)
+          end
+        end
+      end
+
+      private
+
+      # Define an anonymous module and include it, so can still be easily
+      # overridden by concrete class. Design cribbed from ActiveRecord::Store
+      # https://github.com/rails/rails/blob/4590d7729e241cb7f66e018a2a9759cb3baa36e5/activerecord/lib/active_record/store.rb
+      def _attr_jsons_module # :nodoc:
+        @_attr_jsons_module ||= begin
+          mod = Module.new
+          include mod
+          mod
+        end
+      end
+    end
+  end
+end

data/lib/attr_json/record/dirty.rb

@@ -0,0 +1,281 @@
+module AttrJson
+  module Record
+    # This only works in Rails 5.1+, and only uses the 'new style' dirty
+    # tracking methods, available in Rails 5.1+.
+    #
+    # Add into an ActiveRecord object with AttrJson::Record,
+    # to track dirty changes to attr_jsons, off the attr_json_changes
+    # object.
+    #
+    #     some_model.attr_json_changes.saved_changes
+    #     some_model.attr_json_changes.json_attr_before_last_save
+    #
+    # All methods ordinarily in ActiveRecord::Attributes::Dirty should be available,
+    # including synthetic attribute-specific ones like `will_save_change_to_attribute_name?`.
+    # By default, they _only_ report changes from json attributes.
+    # To have a merged list also including ordinary AR changes, add on `merged`:
+    #
+    #     some_model.attr_json_changes.merged.saved_changes
+    #     some_model.attr_json_changes.merged.ordinary_attr_before_last_save
+    #
+    # Complex nested models will show up in changes as the cast models. If you want
+    # the raw json instead, use `as_json`:
+    #
+    #     some_model.attr_json_changes.as_json.saved_changes
+    #
+    # You can combine as_json and merged if you like:
+    #
+    #     some_model.attr_json_changes.as_json.merged.saved_changes
+    #
+    # See more in [separate documentation guide](../../../doc_src/dirty_tracking.md)
+    #
+    # See what methods are available off of the object returned by {attr_json_changes}
+    # in {Dirty::Implementation} -- should be the AR dirty-tracking methods you expect.
+    module Dirty
+      def attr_json_changes
+        Implementation.new(self)
+      end
+
+
+      class Implementation
+        # The attribute_method stuff is copied from ActiveRecord::Dirty,
+        # to give you all the same synthetic per-attribute methods.
+        # We make it work with overridden #matched_attribute_method below.
+        include ActiveModel::AttributeMethods
+
+        # Attribute methods for "changed in last call to save?"
+        attribute_method_affix(prefix: "saved_change_to_", suffix: "?")
+        attribute_method_prefix("saved_change_to_")
+        attribute_method_suffix("_before_last_save")
+
+        # Attribute methods for "will change if I call save?"
+        attribute_method_affix(prefix: "will_save_change_to_", suffix: "?")
+        attribute_method_suffix("_change_to_be_saved", "_in_database")
+
+        attr_reader :model
+
+        def initialize(model, merged: false, merge_containers: false, as_json: false)
+          @model = model
+          @merged = !!merged
+          @merge_containers = !!merge_containers
+          @as_json = !!as_json
+        end
+
+        # return a copy with `merged` attribute true, so dirty tracking
+        # will include ordinary AR attributes too, and you can do things like:
+        #
+        #     model.attr_json_changes.merged.saved_change_to_attribute?(ordinary_or_attr_json)
+        #
+        # By default, the json container attributes are included too. If you
+        # instead want our dirty tracking to pretend they don't exist:
+        #
+        #     model.attr_json_changes.merged(containers: false).etc
+        #
+        def merged(containers: true)
+          self.class.new(model, merged: true, merge_containers: containers,
+            as_json: as_json?)
+        end
+
+        # return a copy with as_json parameter set to true, so change diffs
+        # will be the json structures serialized, not the cast models.
+        # for 'primitive' types will be the same, but for AttrJson::Models
+        # very different.
+        def as_json
+          self.class.new(model, as_json: true,
+            merged: merged?,
+            merge_containers: merge_containers?)
+        end
+
+        # should we handle ordinary AR attributes too in one merged
+        # change tracker?
+        def merged?
+          @merged
+        end
+
+        # if we're `merged?` and `merge_containers?` is **false**, we
+        # _omit_ our json container attributes from our dirty tracking.
+        # only has meaning if `merged?` is true. Defaults to true.
+        def merge_containers?
+          @merge_containers
+        end
+
+        def as_json?
+          @as_json
+        end
+
+
+        def saved_change_to_attribute(attr_name)
+          attribute_def = registry[attr_name.to_sym]
+          if ! attribute_def
+            if merged? && (merge_containers? || ! registry.container_attributes.include?(attr_name.to_s))
+              return model.saved_change_to_attribute(attr_name)
+            else
+              return nil
+            end
+          end
+
+          json_container = attribute_def.container_attribute
+
+          (before_container, after_container) = model.saved_change_to_attribute(json_container)
+
+          formatted_before_after(
+            before_container.try(:[], attribute_def.store_key),
+            after_container.try(:[], attribute_def.store_key),
+            attribute_def)
+        end
+
+        def attribute_before_last_save(attr_name)
+          saved_change = saved_change_to_attribute(attr_name)
+          return nil if saved_change.nil?
+
+          saved_change[0]
+        end
+
+        def saved_change_to_attribute?(attr_name)
+          return nil unless registry[attr_name.to_sym] || merged? && (merge_containers? || ! registry.container_attributes.include?(attr_name.to_s))
+          ! saved_change_to_attribute(attr_name).nil?
+        end
+
+        def saved_changes
+          saved_changes = model.saved_changes
+          return {} if saved_changes == {}
+
+          json_attr_changes = registry.definitions.collect do |definition|
+            if container_change = saved_changes[definition.container_attribute]
+              old_v = container_change[0][definition.store_key]
+              new_v = container_change[1][definition.store_key]
+              if old_v != new_v
+                [ definition.name.to_s, formatted_before_after(old_v, new_v, definition) ]
+              end
+            end
+          end.compact.to_h
+
+          prepared_changes(json_attr_changes, saved_changes)
+        end
+
+        def saved_changes?
+          saved_changes.present?
+        end
+
+
+        def attribute_in_database(attr_name)
+          to_be_saved = attribute_change_to_be_saved(attr_name)
+          if to_be_saved.nil?
+            if merged? && (merge_containers? || ! registry.container_attributes.include?(attr_name.to_s))
+              return model.attribute_change_to_be_saved(attr_name)
+            else
+              return nil
+            end
+          end
+
+          to_be_saved[0]
+        end
+
+        def attribute_change_to_be_saved(attr_name)
+          attribute_def = registry[attr_name.to_sym]
+          if ! attribute_def
+            if merged? && (merge_containers? || ! registry.container_attributes.include?(attr_name.to_s))
+              return model.attribute_change_to_be_saved(attr_name)
+            else
+              return nil
+            end
+          end
+
+          json_container = attribute_def.container_attribute
+
+          (before_container, after_container) = model.attribute_change_to_be_saved(json_container)
+
+          formatted_before_after(
+            before_container.try(:[], attribute_def.store_key),
+            after_container.try(:[], attribute_def.store_key),
+            attribute_def
+          )
+        end
+
+        def will_save_change_to_attribute?(attr_name)
+          return nil unless registry[attr_name.to_sym] || merged? && (merge_containers? || ! registry.container_attributes.include?(attr_name.to_s))
+          ! attribute_change_to_be_saved(attr_name).nil?
+        end
+
+        def changes_to_save
+          changes_to_save = model.changes_to_save
+
+          return {} if changes_to_save == {}
+
+          json_attr_changes = registry.definitions.collect do |definition|
+            if container_change = changes_to_save[definition.container_attribute]
+              old_v = container_change[0][definition.store_key]
+              new_v = container_change[1][definition.store_key]
+              if old_v != new_v
+                [ definition.name.to_s, formatted_before_after(old_v, new_v, definition) ]
+              end
+            end
+          end.compact.to_h
+
+          prepared_changes(json_attr_changes, changes_to_save)
+        end
+
+        def has_changes_to_save?
+          changes_to_save.present?
+        end
+
+        def changed_attribute_names_to_save
+          changes_to_save.keys
+        end
+
+        def attributes_in_database
+          changes_to_save.transform_values(&:first)
+        end
+
+        private
+
+        # returns an array of before and after, possibly formatted with as_json.
+        # if both before and after are nil, returns nil.
+        def formatted_before_after(before_v, after_v, attribute_def)
+          return nil if before_v.nil? && after_v.nil?
+
+          if as_json?
+            before_v = attribute_def.type.serialize(before_v) unless before_v.nil?
+            after_v = attribute_def.type.serialize(after_v) unless after_v.nil?
+          end
+
+          [
+            before_v,
+            after_v
+          ]
+
+        end
+
+        # Takes a hash of _our_ attr_json changes, and possibly
+        # merges them into the hash of all changes from the parent record,
+        # depending on values of `merged?` and `merge_containers?`.
+        def prepared_changes(json_attr_changes, all_changes)
+          if merged?
+            all_changes.merge(json_attr_changes).tap do |merged|
+              unless merge_containers?
+                merged.except!(*registry.container_attributes)
+              end
+            end
+          else
+            json_attr_changes
+          end
+        end
+
+        def registry
+          model.class.attr_json_registry
+        end
+
+        # Override from ActiveModel::AttributeMethods
+        # to not require class-static define_attribute, but instead dynamically
+        # find it from currently declared attributes.
+        # https://github.com/rails/rails/blob/6aa5cf03ea8232180ffbbae4c130b051f813c670/activemodel/lib/active_model/attribute_methods.rb#L463-L468
+        def matched_attribute_method(method_name)
+          matches = self.class.send(:attribute_method_matchers_matching, method_name)
+          matches.detect do |match|
+            registry.has_attribute?(match.attr_name)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/attr_json/record/query_builder.rb

@@ -0,0 +1,84 @@
+module AttrJson
+  module Record
+    # Implementation class called by #jsonb_contains scope method. Ordinarily
+    # you don't need to use it yourself, but you can.
+    class QueryBuilder
+      attr_reader :relation, :input_attributes
+      def initialize(relation, input_attributes)
+        @relation = relation
+        @input_attributes = input_attributes
+      end
+
+      def contains_relation
+        result_relation = relation
+
+        group_attributes_by_container.each do |container_attribute, attributes|
+          param_hash = {}
+
+          attributes.each do |key, value|
+            add_to_param_hash!(param_hash, key, value)
+          end
+          result_relation = result_relation.where("#{relation.table_name}.#{container_attribute} @> (?)::jsonb", param_hash.to_json)
+        end
+
+        result_relation
+      end
+
+      protected
+
+      def merge_param_hash!(original, new)
+        original.deep_merge!(new) do |key, old_val, new_val|
+          if old_val.is_a?(Array) && old_val.first.is_a?(Hash) && new_val.is_a?(Array) && new_val.first.is_a?(Hash)
+            [merge_param_hash!(old_val.first, new_val.first)]
+          elsif old_val.is_a?(Hash) && new_val.is_a?(Hash)
+            merge_param_hash!(old_val, new_val)
+          else
+            new_val
+          end
+        end
+      end
+
+
+      def add_to_param_hash!(param_hash, key_path_str, value)
+        key_path = key_path_str.to_s.split(".")
+        first_key, rest_keys = key_path.first, key_path[1..-1]
+        attr_def = relation.attr_json_registry.fetch(first_key)
+
+        value = if rest_keys.present?
+          attr_def.type.value_for_contains_query(rest_keys, value)
+        else
+          attr_def.serialize(attr_def.cast value)
+        end
+
+        if value.kind_of?(Hash)
+          param_hash[attr_def.store_key] ||= {}
+          merge_param_hash!(param_hash[attr_def.store_key], value)
+        else
+          param_hash[attr_def.store_key] = value
+        end
+
+        # it's a mutator not functional don't you forget it.
+        return nil
+      end
+
+      # returns a hash with keys container attributes, values hashes of attributes
+      # belonging to that container attribute.
+      def group_attributes_by_container
+        @group_attributes_by_container ||= begin
+          hash_by_container_attribute = {}
+
+          input_attributes.each do |key_path, value|
+            key = key_path.to_s.split(".").first
+            attr_def = relation.attr_json_registry.fetch(key)
+            container_attribute = attr_def.container_attribute
+
+            hash_by_container_attribute[container_attribute] ||= {}
+            hash_by_container_attribute[container_attribute][key_path] = value
+          end
+
+          hash_by_container_attribute
+        end
+      end
+    end
+  end
+end