attr_json 0.1.0

data/lib/attr_json/record/query_scopes.rb

@@ -0,0 +1,35 @@
+require 'attr_json/record/query_builder'
+
+module AttrJson
+  module Record
+    # Adds query-ing scopes into a AttrJson::Record, based
+    # on postgres jsonb.
+    #
+    # Has to be mixed into something that also is a AttrJson::Record please!
+    #
+    # @example
+    #      class MyRecord < ActiveRecord::Base
+    #        include AttrJson::Record
+    #        include AttrJson::Record::QueryScopes
+    #
+    #        attr_json :a_string, :string
+    #      end
+    #
+    #      some_model.jsonb_contains(a_string: "foo").first
+    #
+    # See more in {file:README} docs.
+    module QueryScopes
+      extend ActiveSupport::Concern
+
+      included do
+        unless self < AttrJson::Record
+          raise TypeError, "AttrJson::Record::QueryScopes can only be included in a AttrJson::Record"
+        end
+
+        scope(:jsonb_contains, lambda do |attributes|
+          QueryBuilder.new(self, attributes).contains_relation
+        end)
+      end
+    end
+  end
+end

data/lib/attr_json/type/array.rb

@@ -0,0 +1,55 @@
+module AttrJson
+  module Type
+    # You can wrap any ActiveModel::Type in one of these, and it's magically
+    # a type representing an Array of those things, always returning
+    # an array of those things on cast, serialize, and deserialize.
+    #
+    # Meant for use with AttrJson::Record and AttrJson::Model, may or
+    # may not do something useful or without exceptions in other contexts.
+    #
+    #     AttrJson::Type::Array.new(base_type)
+    class Array < ::ActiveModel::Type::Value
+      attr_reader :base_type
+      def initialize(base_type)
+        @base_type = base_type
+      end
+
+      def type
+        @type ||= "array_of_#{base_type.type}".to_sym
+      end
+
+      def cast(value)
+        convert_to_array(value).collect { |v| base_type.cast(v) }
+      end
+
+      def serialize(value)
+        convert_to_array(value).collect { |v| base_type.serialize(v) }
+      end
+
+      def deserialize(value)
+        convert_to_array(value).collect { |v| base_type.deserialize(v) }
+      end
+
+      # This is used only by our own keypath-chaining query stuff.
+      def value_for_contains_query(key_path_arr, value)
+        [
+          if key_path_arr.present?
+            base_type.value_for_contains_query(key_path_arr, value)
+          else
+            base_type.serialize(base_type.cast value)
+          end
+        ]
+      end
+
+      protected
+      def convert_to_array(value)
+        if value.kind_of?(Hash)
+          [value]
+        else
+          Array(value)
+        end
+      end
+
+    end
+  end
+end

data/lib/attr_json/type/container_attribute.rb

@@ -0,0 +1,56 @@
+module AttrJson
+  module Type
+    # A type that gets applied to the AR container/store jsonb attribute,
+    # to do serialization/deserialization/cast using declared attr_jsons, to
+    # json-able values, before calling super to original json-type, which will
+    # actually serialize/deserialize the json.
+    class ContainerAttribute < (if Gem.loaded_specs["activerecord"].version.release >= Gem::Version.new('5.2')
+      ActiveRecord::Type::Json
+    else
+      ActiveRecord::Type::Internal::AbstractJson
+    end)
+      attr_reader :model, :container_attribute
+      def initialize(model, container_attribute)
+        @model = model
+        @container_attribute = container_attribute.to_s
+      end
+      def cast(v)
+        # this seems to be rarely/never called by AR, not sure where if ever.
+        h = super || {}
+        model.attr_json_registry.definitions.each do |attr_def|
+          next unless container_attribute.to_s == attr_def.container_attribute.to_s
+
+          if h.has_key?(attr_def.store_key)
+            h[attr_def.store_key] = attr_def.cast(h[attr_def.store_key])
+          elsif attr_def.has_default?
+            h[attr_def.store_key] = attr_def.provide_default!
+          end
+        end
+        h
+      end
+      def serialize(v)
+        if v.nil?
+          return super
+        end
+
+        super(v.collect do |key, value|
+          attr_def = model.attr_json_registry.store_key_lookup(container_attribute, key)
+          [key, attr_def ? attr_def.serialize(value) : value]
+        end.to_h)
+      end
+      def deserialize(v)
+        h = super || {}
+        model.attr_json_registry.definitions.each do |attr_def|
+          next unless container_attribute.to_s == attr_def.container_attribute.to_s
+
+          if h.has_key?(attr_def.store_key)
+            h[attr_def.store_key] = attr_def.deserialize(h[attr_def.store_key])
+          elsif attr_def.has_default?
+            h[attr_def.store_key] = attr_def.provide_default!
+          end
+        end
+        h
+      end
+    end
+  end
+end

data/lib/attr_json/type/model.rb

@@ -0,0 +1,77 @@
+module AttrJson
+  module Type
+    # An ActiveModel::Type representing a particular AttrJson::Model
+    # class, supporting casting, serialization, and deserialization from/to
+    # JSON-able serializable hashes.
+    #
+    # You create one with AttrJson::Model::Type.new(attr_json_model_class),
+    # but normally that's only done in AttrJson::Model.to_type, there isn't
+    # an anticipated need to create from any other place.
+    class Model < ::ActiveModel::Type::Value
+      attr_accessor :model
+      def initialize(model)
+        #TODO type check, it really better be a AttrJson::Model. maybe?
+        @model = model
+      end
+
+      def type
+        model.to_param.underscore.to_sym
+      end
+
+      def cast(v)
+        if v.nil?
+          # important to stay nil instead of empty object, because they
+          # are different things.
+          v
+        elsif v.kind_of? model
+          v
+        elsif v.respond_to?(:to_hash)
+          # to_hash is actually the 'implicit' conversion, it really is a hash
+          # even though it isn't is_a?(Hash), try to_hash first before to_h,
+          # the explicit conversion.
+          model.new_from_serializable(v.to_hash)
+        elsif v.respond_to?(:to_h)
+          # TODO Maybe we ought not to do this on #to_h?
+          model.new_from_serializable(v.to_h)
+        else
+          # Bad input? Most existing ActiveModel::Types seem to decide
+          # either nil, or a base value like the empty string. They don't
+          # raise. So we won't either, just nil.
+          nil
+        end
+      end
+
+      def serialize(v)
+        if v.nil?
+          nil
+        elsif v.kind_of?(model)
+          v.serializable_hash
+        else
+          cast(v).serializable_hash
+        end
+      end
+
+      def deserialize(v)
+        cast(v)
+      end
+
+      # these guys are definitely mutable, so we need this.
+      def changed_in_place?(raw_old_value, new_value)
+        serialize(new_value) != raw_old_value
+      end
+
+      # This is used only by our own keypath-chaining query stuff.
+      def value_for_contains_query(key_path_arr, value)
+        first_key, rest_keys = key_path_arr.first, key_path_arr[1..-1]
+        attr_def = model.attr_json_registry.fetch(first_key)
+        {
+          attr_def.store_key => if rest_keys.present?
+            attr_def.type.value_for_contains_query(rest_keys, value)
+          else
+            attr_def.serialize(attr_def.cast value)
+          end
+        }
+      end
+    end
+  end
+end

data/lib/attr_json/version.rb

@@ -0,0 +1,3 @@
+module AttrJson
+  VERSION = "0.1.0"
+end

data/playground_models.rb

@@ -0,0 +1,101 @@
+# required by our bin/console, nothing but something to play with.
+
+require 'attr_json'
+class TestModel
+  include AttrJson::Model
+
+  attr_json :str, :string
+  attr_json :int, :integer
+end
+
+class LangAndValue
+  include AttrJson::Model
+
+  attr_json :lang, :string, default: "en"
+  attr_json :value, :string
+
+  # Yes, you can use ordinary validations... I think. If not, soon.
+end
+
+class SomeLabels
+  include AttrJson::Model
+
+  attr_json :hello, LangAndValue.to_type, array: true
+  attr_json :goodbye, LangAndValue.to_type, array: true
+end
+
+
+class MyModel2 < ActiveRecord::Base
+  self.table_name = "products"
+   include AttrJson::Record
+   include AttrJson::Record::QueryScopes
+
+   # use any ActiveModel::Type types: string, integer, decimal (BigDecimal),
+   # float, datetime, boolean.
+   attr_json :my_string, :string
+   attr_json :my_integer, :integer
+   attr_json :my_datetime, :datetime
+
+   # You can have an _array_ of those things too.
+   attr_json :int_array, :integer, array: true
+
+   #and/or defaults
+   #attr_json :int_with_default, :integer, default: 100
+
+  attr_json :special_string, :string, store_key: "__my_string"
+
+  attr_json :lang_and_value, LangAndValue.to_type
+  # YES, you can even have an array of them
+  attr_json :lang_and_value_array, LangAndValue.to_type, array: true
+
+  attr_json :my_labels, SomeLabels.to_type
+end
+
+class MyEmbeddedModel
+  include AttrJson::Model
+
+  attr_json :str, :string
+end
+
+class MyModel < ActiveRecord::Base
+  self.table_name = "products"
+
+  include AttrJson::Record
+  include AttrJson::Record::Dirty
+
+  attr_json :str, :string
+  attr_json :str_array, :string, array: true
+  attr_json :array_of_models, MyEmbeddedModel.to_type, array: true
+end
+
+class StaticProduct < ActiveRecord::Base
+  self.table_name = "products"
+  belongs_to :product_category
+end
+
+class Product < StaticProduct
+  include AttrJson::Record
+  include AttrJson::Record::QueryScopes
+  include AttrJson::Record::Dirty
+
+  attr_json :title, :string
+  attr_json :rank, :integer
+  attr_json :made_at, :datetime
+  attr_json :time, :time
+  attr_json :date, :date
+  attr_json :dec, :decimal
+  attr_json :int_array, :integer, array: true
+  attr_json :model, TestModel.to_type
+
+  #jsonb_accessor :options, title: :string, rank: :integer, made_at: :datetime
+end
+
+
+
+
+class ProductCategory < ActiveRecord::Base
+  include AttrJson::Record
+
+  #jsonb_accessor :options, title: :string
+  has_many :products
+end

metadata

@@ -0,0 +1,177 @@
+--- !ruby/object:Gem::Specification
+name: attr_json
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jonathan Rochkind
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-04-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.0.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: yard-activesupport-concern
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: |-
+  ActiveRecord attributes stored serialized in a json column, super smooth.
+  For Rails 5.0, 5.1, or 5.2. Typed and cast like Active Record. Supporting nested models,
+  dirty tracking, some querying (with postgres jsonb contains), and working smoothy with form builders.
+
+  Use your database as a typed object store via ActiveRecord, in the same models right next to
+  ordinary ActiveRecord column-backed attributes and associations. Your json-serialized attr_json
+  attributes use as much of the existing ActiveRecord architecture as we can.
+email:
+- jonathan@dnil.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- ".yardopts"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rake
+- bin/rspec
+- bin/setup
+- config.ru
+- doc_src/dirty_tracking.md
+- doc_src/forms.md
+- json_attribute.gemspec
+- lib/attr_json.rb
+- lib/attr_json/attribute_definition.rb
+- lib/attr_json/attribute_definition/registry.rb
+- lib/attr_json/model.rb
+- lib/attr_json/model/cocoon_compat.rb
+- lib/attr_json/nested_attributes.rb
+- lib/attr_json/nested_attributes/builder.rb
+- lib/attr_json/nested_attributes/multiparameter_attribute_writer.rb
+- lib/attr_json/nested_attributes/writer.rb
+- lib/attr_json/record.rb
+- lib/attr_json/record/dirty.rb
+- lib/attr_json/record/query_builder.rb
+- lib/attr_json/record/query_scopes.rb
+- lib/attr_json/type/array.rb
+- lib/attr_json/type/container_attribute.rb
+- lib/attr_json/type/model.rb
+- lib/attr_json/version.rb
+- playground_models.rb
+homepage: https://github.com/jrochkind/attr_json
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/jrochkind/attr_json
+  source_code_uri: https://github.com/jrochkind/attr_json
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.13
+signing_key: 
+specification_version: 4
+summary: ActiveRecord attributes stored serialized in a json column, super smooth.
+test_files: []