jsonb_accessor 0.4.0.beta → 1.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6eb9689dbf752a8e5759e0224838eab520fe7ced
-  data.tar.gz: 07132e8465d69d01909de02f544c5db202ff6e81
+  metadata.gz: c764a056e39fc6979212aac29a31384cb694a38b
+  data.tar.gz: 495df5a38ac759f3b07d718f818bddfbcb9449ec
 SHA512:
-  metadata.gz: 8e5131ee5b8d0c15ad6bb563261867678485a576622a2e6ddff8e710acbcee8ea15ca9a2a3eedf73495ad17600b9fe0e02347ef55c1efb671141cb57ec4fedb2
-  data.tar.gz: c7d9d78356a2d4f081c078bc843282da3918d6502153c6030cf1e85bc373f45e63cc6c6eb089520bcd331de9aba71af8038afe393d3a82b8b85767faba0cf5f0
+  metadata.gz: 8716e5c48b3122677518e20230d3d70c59b42eb9434ed4ebe8992f4ef9b797a4b9e2b2566960ed34a3a6cbf77baa785f0fe0853f9bf40198d9214360ced4bf8f
+  data.tar.gz: 90389c14a8b8aa3b27da14301897e5ee836c713456ed562421ef989d6b3c88407d211ff22cc79fd76be318735660bb9129e4ce6ccd9bd7b17bbe7444f346b2b8

data/.rubocop.yml

@@ -23,6 +23,8 @@ Metrics/MethodLength:
   Enabled: false
 Metrics/ModuleLength:
   Enabled: false
+Metrics/BlockLength:
+  Enabled: false
 Metrics/PerceivedComplexity:
   Enabled: false
 Style/AlignParameters:

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
-  - 2.2.4
-  - 2.3.0
+  - 2.2.5
+  - 2.3.1
 addons:
   postgresql: '9.4'
 before_install:
@@ -13,5 +13,4 @@ before_script:
   - bundle exec rake db:migrate
 cache: bundler
 gemfile:
-  - gemfiles/activerecord_4.2.4.gemfile
   - gemfiles/activerecord_5.0.0.gemfile

data/Appraisals

@@ -1,8 +1,3 @@
-appraise "activerecord-4.2.4" do
-  gemspec
-  gem "activerecord", "4.2.4"
-end
-
 appraise "activerecord-5.0.0" do
   gemspec
   gem "activerecord", "5.0.0"

data/README.md

@@ -1,19 +1,15 @@
 # JSONb Accessor
 
-[![Gem Version](https://badge.fury.io/rb/jsonb_accessor.svg)](http://badge.fury.io/rb/jsonb_accessor) [![Build Status](https://travis-ci.org/devmynd/jsonb_accessor.svg)](https://travis-ci.org/devmynd/jsonb_accessor) 
+[![Gem Version](https://badge.fury.io/rb/jsonb_accessor.svg)](http://badge.fury.io/rb/jsonb_accessor) [![Build Status](https://travis-ci.org/devmynd/jsonb_accessor.svg)](https://travis-ci.org/devmynd/jsonb_accessor)
 
 Adds typed `jsonb` backed fields as first class citizens to your `ActiveRecord` models. This gem is similar in spirit to [HstoreAccessor](https://github.com/devmynd/hstore_accessor), but the `jsonb` column in PostgreSQL has a few distinct advantages, mostly around nested documents and support for collections.
 
 ## Table of Contents
 
 * [Installation](#installation)
-* [Rails 5](#rails-5)
 * [Usage](#usage)
-* [ActiveRecord Methods Generated for Fields](#activerecord-methods-generated-for-fields)
 * [Validations](#validations)
 * [Single-Table Inheritance](#single-table-inheritance)
-* [Scopes](#scopes)
-* [Migrations](#migrations)
 * [Dependencies](#dependencies)
 * [Development](#development)
 * [Contributing](#contributing)
@@ -30,10 +26,6 @@ And then execute:
 
     $ bundle install
 
-## Rails 5
-
-Version 0.4.X will run on Rails 5, but behavior around type coercion for array and other collection field types behaves differently. When you upgrade to 0.4.X make sure you do not depend on subtle type coercion rules.
-
 ## Usage
 
 First we must create a model which has a `jsonb` column available to store data into it:
@@ -54,82 +46,14 @@ We can then declare the `jsonb` fields we wish to expose via the accessor:
 class Product < ActiveRecord::Base
   jsonb_accessor(
     :options,
-    :count, # => value type
     title: :string,
     id_value: :value,
     external_id: :integer,
-    reviewed_at: :date_time
+    reviewed_at: :datetime
   )
 end
 ```
 
-JSONb Accessor accepts both untyped and typed key definitions. Untyped keys are treated as-is and no additional casting is performed. This allows the freedom of dynamic values alongside the power types, which is especially convenient when saving nested form attributes. Typed keys will be cast to their respective values using the same mechanism ActiveRecord uses to coerce standard attribute columns. It's as close to a real column as you can get and the goal is to keep it that way.
-
-All untyped keys must be defined prior to typed columns. You can declare a typed column with type `value` for explicit dynamic behavior. For reference, the `jsonb_accessor` macro is defined thusly.
-
-```ruby
-def jsonb_accessor(jsonb_attribute, *value_fields, **typed_fields)
-  ...
-end
-```
-
-There's quite a bit more to do do and document but we're excited to get this out there while we work on it some more.
-
-## ActiveRecord Methods Generated for Fields
-
-```ruby
-class Product < ActiveRecord::Base
-  jsonb_accessor :data, field: :string
-end
-```
-
-* `field`
-* `field=`
-* `field?`
-* `field_changed?`
-* `field_was`
-* `field_change`
-* `reset_field!`
-* `restore_field!`
-* `field_will_change!`
-
-### Supported Types
-
-Because the underlying storage mechanism is JSON, we attempt to abide by the limitations of what can be represented natively. We use [ActiveRecord::Type](https://github.com/rails/rails/blob/master/activerecord/lib/active_record/type.rb) for seralization, but any type defined in the [Postgres connection adapter](https://github.com/rails/rails/blob/master/activerecord/lib/active_record/connection_adapters/postgresql/oid.rb) will also be accepted. Beware of the impact of using complex Postgres column types such as inet, enum, hstore, etc... We plan to restrict which types are allowed in a future patch.
-
-The following types are explicitly supported.
-
-* big_integer
-* binary
-* boolean
-* date
-* date_time
-* decimal
-* float
-* integer
-* string
-* text
-* time
-* value
-
-
-Typed arrays are also supported by specifying `:type_array` (i.e. `:float_array`). `:array` is interpreted as an array of `value` types.
-
-Support for nested types is also available but experimental at this point. If you must, you may try something like this for nested objects.
-
-```ruby
-class Product < ActiveRecord::Base
-  jsonb_accessor(
-    :options,
-    nested_object: { key: :integer }
-  )
-end
-
-p = Product.new
-p.nested_object.key = "10"
-puts p.nested_object.key #=> 10
-```
-
 ## Validations
 
 Because this gem promotes attributes nested into the JSON column to first level attributes, most validations should just work. We still have to add some testing and support around this feature but feel free to try and leave us feedback if they're not working as expected.
@@ -208,7 +132,7 @@ end
 
 #### `<jsonb_field>_contains`
 
-**Description:** returns all records that contain matching attributes in the specified `jsonb` field. 
+**Description:** returns all records that contain matching attributes in the specified `jsonb` field.
 
 ```ruby
 product_1 = Product.create!(name: "foo", approved: true, reviewed_at: 3.days.ago)
@@ -218,143 +142,13 @@ product_3 = Product.create!(name: "foo", approved: false)
 Product.data_contains(name: "foo", approved: true) # => [product_1]
 ```
 
-**Note:** when including an array attribute, the stored array and the array used for the query do not need to match exactly. For example, when queried with `[1, 2]`, records that have arrays of `[2, 1, 3]` will be returned. 
-
-#### `with_<jsonb_defined_field>`
-
-**Description:** returns all records with the given value in the field. This is defined for all `jsonb_accessor` defined fields. It's a convenience method that allows you to do `Product.with_name("foo")` instead of `Product.data_contains(name: "foo")`.
-
-```ruby
-product_1 = Product.create!(name: "foo")
-product_2 = Product.create!(name: "bar")
-
-Product.with_name("foo") # => [product_1]
-```
-
-**Note:** when including an array attribute, the stored array and the array used for the query do not need to match exactly. For example, when queried with `[1, 2]`, records that have arrays of `[2, 1, 3]` will be returned. 
-
-### Integer, Big Integer, Decimal, and Float Scopes
-
-#### `<jsonb_defined_field>_gt`
-
-**Description:** returns all records with a value that is greater than the argument.
-
-```ruby
-product_1 = Product.create!(price: 10)
-product_2 = Product.create!(price: 11)
-
-Product.price_gt(10) # => [product_2]
-```
-
-#### `<jsonb_defined_field>_gte`
-
-**Description:** returns all records with a value that is greater than or equal to the argument.
-
-```ruby
-product_1 = Product.create!(price: 10)
-product_2 = Product.create!(price: 11)
-product_3 = Product.create!(price: 9)
-
-Product.price_gte(10) # => [product_1, product_2]
-```
-
-#### `<jsonb_defined_field>_lt`
-
-**Description:** returns all records with a value that is less than the argument.
-
-```ruby
-product_1 = Product.create!(price: 10)
-product_2 = Product.create!(price: 11)
-
-Product.price_lt(11) # => [product_1]
-```
-
-#### `<jsonb_defined_field>_lte`
-
-**Description:** returns all records with a value that is less than or equal to the argument.
-
-```ruby
-product_1 = Product.create!(price: 10)
-product_2 = Product.create!(price: 11)
-product_3 = Product.create!(price: 12)
-
-Product.price_lte(11) # => [product_1, product_2]
-```
-
-
-### Boolean Scopes
-
-#### `is_<jsonb_defined_field>`
-
-**Description:** returns all records where the value is `true`.
-
-```ruby
-product_1 = Product.create!(approved: true)
-product_2 = Product.create!(approved: false)
-
-Product.is_approved # => [product_1]
-```
-
-#### `not_<jsonb_defined_field>`
-
-**Description:** returns all records where the value is `false`.
-
-```ruby
-product_1 = Product.create!(approved: true)
-product_2 = Product.create!(approved: false)
-
-Product.not_approved # => [product_2]
-```
-
-### Date, DateTime Scopes
-
-#### `<jsonb_defined_field>_before`
-
-**Description:** returns all records where the value is before the argument. Also supports JSON string arguments.
-
-```ruby
-product_1 = Product.create!(reviewed_at: 3.days.ago)
-product_2 = Product.create!(reviewed_at: 5.days.ago)
-
-Product.reviewed_at_before(4.days.ago) # => [product_2]
-Product.reviewed_at_before(4.days.ago.to_json) # => [product_2]
-```
-
-#### `<jsonb_defined_field>_after`
-
-**Description:** returns all records where the value is after the argument. Also supports JSON string arguments.
-
-```ruby
-product_1 = Product.create!(reviewed_at: 3.days.from_now)
-product_2 = Product.create!(reviewed_at: 5.days.from_now)
-
-Product.reviewed_at_after(4.days.from_now) # => [product_2]
-Product.reviewed_at_after(4.days.from_now.to_json) # => [product_2]
-```
-
-### Array Scopes
-
-#### `<jsonb_defined_fields>_contains`
-
-**Description:** returns all records where the value is contained in the array field.
-
-```ruby
-product_1 = Product.create!(previous_prices: [3])
-product_2 = Product.create!(previous_prices: [4, 5, 6])
-
-Product.previous_prices_contains(5) # => [product_2]
-```
-
-## Migrations
-
-Coming soon...
-
-`jsonb` supports `GIN`, `GIST`, `btree` and `hash` indexes over `json` column. We have plans to add migrations helpers for generating these indexes for you.
+**Note:** when including an array attribute, the stored array and the array used for the query do not need to match exactly. For example, when queried with `[1, 2]`, records that have arrays of `[2, 1, 3]` will be returned.
 
 ## Dependencies
 
-- ActiveRecord 4.2
-- Postgres 9.4 (in order to use the [jsonb column type](http://www.postgresql.org/docs/9.4/static/datatype-json.html)).
+- ActiveRecord 5.0
+- Ruby >= 2.2.2
+- Postgres >= 9.4 (in order to use the [jsonb column type](http://www.postgresql.org/docs/9.4/static/datatype-json.html)).
 
 ## Development
 

data/Rakefile

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 require "rubygems"
 require "bundler/setup"
 require "bundler/gem_tasks"

data/bin/console

@@ -1,4 +1,5 @@
 #!/usr/bin/env ruby
+# frozen_string_literal: true
 # rubocop:disable Lint/UselessAssignment
 
 require "bundler/setup"
@@ -6,11 +7,8 @@ require "jsonb_accessor"
 require "rspec"
 require File.expand_path("../../spec/spec_helper.rb", __FILE__)
 
-ActiveRecord::Base.establish_connection(
-  adapter: "postgresql",
-  database: "jsonb_accessor",
-  username: "postgres"
-)
+dbconfig = YAML.load(File.open("db/config.yml"))
+ActiveRecord::Base.establish_connection(dbconfig["development"])
 
 x = Product.new
 

data/db/schema.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # This file is auto-generated from the current state of the database. Instead
 # of editing this file, please use the migrations feature of Active Record to
 # incrementally modify your database, and then regenerate this schema definition.

data/gemfiles/activerecord_5.0.0.gemfile.lock

@@ -1,8 +1,8 @@
 PATH
   remote: ../
   specs:
-    jsonb_accessor (0.4.0.beta)
-      activerecord (>= 4.2.1)
+    jsonb_accessor (1.0.0.beta)
+      activerecord (>= 5.0.0)
       pg (>= 0.18.1)
 
 GEM
@@ -38,8 +38,6 @@ GEM
       thor (>= 0.14.0)
     arel (7.1.4)
     ast (2.3.0)
-    astrolabe (1.3.1)
-      parser (~> 2.2)
     awesome_print (1.7.0)
     builder (3.2.2)
     coderay (1.1.1)
@@ -84,25 +82,25 @@ GEM
       thor (>= 0.18.1, < 2.0)
     rainbow (2.1.0)
     rake (10.5.0)
-    rspec (3.2.0)
-      rspec-core (~> 3.2.0)
-      rspec-expectations (~> 3.2.0)
-      rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.3)
-      rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.1)
+    rspec (3.5.0)
+      rspec-core (~> 3.5.0)
+      rspec-expectations (~> 3.5.0)
+      rspec-mocks (~> 3.5.0)
+    rspec-core (3.5.4)
+      rspec-support (~> 3.5.0)
+    rspec-expectations (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-mocks (3.2.1)
+      rspec-support (~> 3.5.0)
+    rspec-mocks (3.5.0)
       diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
-    rubocop (0.31.0)
-      astrolabe (~> 1.3)
-      parser (>= 2.2.2.1, < 3.0)
+      rspec-support (~> 3.5.0)
+    rspec-support (3.5.0)
+    rubocop (0.44.1)
+      parser (>= 2.3.1.1, < 3.0)
       powerpack (~> 0.1)
       rainbow (>= 1.99.1, < 3.0)
-      ruby-progressbar (~> 1.4)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (~> 1.0, >= 1.0.1)
     ruby-progressbar (1.8.1)
     shoulda-matchers (3.1.1)
       activesupport (>= 4.0.0)
@@ -115,13 +113,13 @@ GEM
     thread_safe (0.3.5)
     tzinfo (1.2.2)
       thread_safe (~> 0.1)
+    unicode-display_width (1.1.1)
     yard (0.9.5)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  actionpack
   activerecord (= 5.0.0)
   appraisal
   awesome_print
@@ -133,10 +131,10 @@ DEPENDENCIES
   pry-doc
   pry-nav
   rake (~> 10.0)
-  rspec (~> 3.2.0)
-  rubocop (= 0.31.0)
+  rspec (~> 3.2)
+  rubocop (~> 0.31)
   shoulda-matchers
   standalone_migrations
 
 BUNDLED WITH
-   1.11.2
+   1.13.5

data/jsonb_accessor.gemspec

@@ -20,10 +20,9 @@ Gem::Specification.new do |spec|
   spec.executables           = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths         = ["lib"]
 
-  spec.add_dependency "activerecord", ">= 4.2.1"
+  spec.add_dependency "activerecord", ">= 5.0.0"
   spec.add_dependency "pg", ">= 0.18.1"
 
-  spec.add_development_dependency "actionpack"
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "database_cleaner"
@@ -32,8 +31,8 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "pry-doc"
   spec.add_development_dependency "pry-nav"
   spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.2.0"
-  spec.add_development_dependency "rubocop", "0.31.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+  spec.add_development_dependency "rubocop", "~> 0.31"
   spec.add_development_dependency "shoulda-matchers"
   spec.add_development_dependency "standalone_migrations"
 end

data/lib/jsonb_accessor/macro.rb

@@ -1,174 +1,62 @@
+# frozen_string_literal: true
 module JsonbAccessor
   module Macro
     module ClassMethods
-      def jsonb_accessor(jsonb_attribute, *value_fields, **typed_fields)
-        fields_map = JsonbAccessor::FieldsMap.new(value_fields, typed_fields)
-        class_namespace = ClassBuilder.generate_class_namespace(name)
-        attribute_namespace = ClassBuilder.generate_attribute_namespace(jsonb_attribute, class_namespace)
-        nested_classes = ClassBuilder.generate_nested_classes(attribute_namespace, fields_map.nested_fields)
-        jsonb_attribute_initialization_method_name = "initialize_jsonb_attrs_for_#{jsonb_attribute}"
-        jsonb_attribute_scope_name = "#{jsonb_attribute}_contains"
-
-        singleton_class.send(:define_method, "#{jsonb_attribute}_classes") do
-          nested_classes
-        end
-
-        delegate "#{jsonb_attribute}_classes", to: :class
-
-        _initialize_jsonb_attrs(jsonb_attribute, fields_map, jsonb_attribute_initialization_method_name)
-        _create_jsonb_attribute_scope_name(jsonb_attribute, jsonb_attribute_scope_name)
-        _create_jsonb_scopes(jsonb_attribute, fields_map, jsonb_attribute_scope_name)
-        _create_jsonb_accessor_methods(jsonb_attribute, jsonb_attribute_initialization_method_name, fields_map)
-
-        _register_jsonb_classes_for_cleanup
-      end
-
-      private
-
-      def _register_jsonb_classes_for_cleanup
-        return unless ENV["RACK_ENV"] == "development"
-
-        class_name = CLASS_PREFIX + name
-        clean_up_proc = proc do
-          if JsonbAccessor.constants.any? { |c| c.to_s == class_name }
-            JsonbAccessor.send(:remove_const, class_name)
-          end
-        end
-
-        if ActiveRecord::VERSION::MAJOR == 5 && defined?(ActiveSupport::Reloader)
-          ActiveSupport::Reloader.to_complete(&clean_up_proc)
-        elsif defined?(ActionDispatch)
-          ActionDispatch::Reloader.to_cleanup(&clean_up_proc)
-        end
-      end
-
-      def _initialize_jsonb_attrs(jsonb_attribute, fields_map, jsonb_attribute_initialization_method_name)
-        define_method(jsonb_attribute_initialization_method_name) do
-          if has_attribute?(jsonb_attribute)
-            jsonb_attribute_hash = send(jsonb_attribute) || {}
-
-            fields_map.typed_fields.keys.each do |field|
-              write_attribute(field, jsonb_attribute_hash[field.to_s])
+      def jsonb_accessor(jsonb_attribute, field_types)
+        field_names = field_types.keys
+        names_and_store_keys = field_types.each_with_object({}) do |(name, type), mapping|
+          _type, options = Array(type)
+          mapping[name.to_s] = (options.try(:delete, :store_key) || name).to_s
+        end
+        # Defines virtual attributes for each jsonb field.
+        field_types.each do |name, type|
+          attribute name, *type
+        end
+
+        # Setters are in a module to allow users to override them and still be able to use `super`.
+        setters = Module.new do
+          # Overrides the setter created by `attribute` above to make sure the jsonb attribute is kept in sync.
+          names_and_store_keys.each do |name, store_key|
+            define_method("#{name}=") do |value|
+              super(value)
+              new_values = (public_send(jsonb_attribute) || {}).merge(store_key => public_send(name))
+              write_attribute(jsonb_attribute, new_values)
             end
-
-            fields_map.nested_fields.keys.each do |field|
-              send("#{field}=", jsonb_attribute_hash[field.to_s])
-            end
-
-            send(:clear_attribute_changes, fields_map.names)
-          end
-        end
-
-        after_initialize(jsonb_attribute_initialization_method_name.to_sym)
-      end
-
-      def _create_jsonb_attribute_scope_name(jsonb_attribute, jsonb_attribute_scope_name)
-        scope jsonb_attribute_scope_name, (lambda do |attributes|
-                                             query_options = new(attributes).send(jsonb_attribute)
-                                             fields = attributes.keys.map(&:to_s)
-                                             query_options.delete_if { |key, value| fields.exclude?(key) }
-                                             query_json = TypeHelper.type_cast_as_jsonb(query_options)
-                                             where("#{table_name}.#{jsonb_attribute} @> ?", query_json)
-                                           end)
-      end
-
-      def _create_jsonb_scopes(jsonb_attribute, fields_map, jsonb_attribute_scope_name)
-        __create_jsonb_standard_scopes(fields_map, jsonb_attribute_scope_name)
-        __create_jsonb_typed_scopes(jsonb_attribute, fields_map)
-      end
-
-      def __create_jsonb_standard_scopes(fields_map, jsonb_attribute_scope_name)
-        fields_map.names.each do |field|
-          scope "with_#{field}", -> (value) { send(jsonb_attribute_scope_name, field => value) }
-        end
-      end
-
-      def __create_jsonb_typed_scopes(jsonb_attribute, fields_map)
-        fields_map.typed_fields.each do |field, type|
-          case type
-          when :boolean
-            ___create_jsonb_boolean_scopes(field)
-          when :integer, :float, :decimal, :big_integer
-            ___create_jsonb_numeric_scopes(field, jsonb_attribute, type)
-          when :date_time, :date
-            ___create_jsonb_date_time_scopes(field, jsonb_attribute, type)
-          when /array/
-            ___create_jsonb_array_scopes(field)
           end
-        end
-      end
-
-      def ___create_jsonb_boolean_scopes(field)
-        scope "is_#{field}", -> { send("with_#{field}", true) }
-        scope "not_#{field}", -> { send("with_#{field}", false) }
-      end
-
-      def ___create_jsonb_numeric_scopes(field, jsonb_attribute, type)
-        safe_type = type.to_s.gsub("big_", "")
-        scope "__numeric_#{field}_comparator", -> (value, operator) { where("((#{table_name}.#{jsonb_attribute}) ->> ?)::#{safe_type} #{operator} ?", field, value) }
-        scope "#{field}_lt", -> (value) { send("__numeric_#{field}_comparator", value, "<") }
-        scope "#{field}_lte", -> (value) { send("__numeric_#{field}_comparator", value, "<=") }
-        scope "#{field}_gte", -> (value) { send("__numeric_#{field}_comparator", value, ">=") }
-        scope "#{field}_gt", -> (value) { send("__numeric_#{field}_comparator", value, ">") }
-      end
-
-      def ___create_jsonb_date_time_scopes(field, jsonb_attribute, type)
-        scope "__date_time_#{field}_comparator", -> (value, operator) { where("((#{table_name}.#{jsonb_attribute}) ->> ?)::timestamp #{operator} ?::timestamp", field, value.to_json) }
-        scope "#{field}_before", -> (value) { send("__date_time_#{field}_comparator", value, "<") }
-        scope "#{field}_after", -> (value) { send("__date_time_#{field}_comparator", value, ">") }
-      end
 
-      def ___create_jsonb_array_scopes(field)
-        scope "#{field}_contains", -> (value) { send("with_#{field}", [value]) }
-      end
-
-      def _create_jsonb_accessor_methods(jsonb_attribute, jsonb_attribute_initialization_method_name, fields_map)
-        jsonb_accessor_methods = Module.new do
+          # Overrides the jsonb attribute setter to make sure the jsonb fields are kept in sync.
           define_method("#{jsonb_attribute}=") do |value|
-            write_attribute(jsonb_attribute, value)
-            send(jsonb_attribute_initialization_method_name)
-          end
+            indifferent_value = value.try(:with_indifferent_access) || {}
+            value_with_store_keys = names_and_store_keys.each_with_object({}) do |(name, store_key), new_value|
+              new_value[store_key] = indifferent_value[name]
+            end
 
-          define_method(:reload) do |*args, &block|
-            super(*args, &block)
-            send(jsonb_attribute_initialization_method_name)
-            self
+            super(value_with_store_keys)
+
+            new_attributes = field_names.each_with_object({}) { |name, defaults| defaults[name] = nil }.merge(value || {})
+            new_attributes.each { |name, new_value| write_attribute(name, new_value) }
           end
         end
+        include setters
 
-        __create_jsonb_typed_field_setters(jsonb_attribute, jsonb_accessor_methods, fields_map)
-        __create_jsonb_nested_field_accessors(jsonb_attribute, jsonb_accessor_methods, fields_map)
-        include jsonb_accessor_methods
-      end
-
-      def __create_jsonb_typed_field_setters(jsonb_attribute, jsonb_accessor_methods, fields_map)
-        fields_map.typed_fields.each do |field, type|
-          attribute(field.to_s, TypeHelper.fetch(type))
-
-          jsonb_accessor_methods.instance_eval do
-            define_method("#{field}=") do |value, *args, &block|
-              super(value, *args, &block)
-              new_jsonb_value = (send(jsonb_attribute) || {}).merge(field => attributes[field.to_s])
-              write_attribute(jsonb_attribute, new_jsonb_value)
-            end
+        # Makes sure new objects have the appropriate values in their jsonb fields.
+        after_initialize do
+          jsonb_values = public_send(jsonb_attribute) || {}
+          jsonb_values.each do |store_key, value|
+            name = names_and_store_keys.key(store_key)
+            write_attribute(name, value)
           end
+          clear_changes_information if persisted?
         end
-      end
 
-      def __create_jsonb_nested_field_accessors(jsonb_attribute, jsonb_accessor_methods, fields_map)
-        fields_map.nested_fields.each do |field, nested_attributes|
-          attribute(field.to_s, TypeHelper.fetch(:value))
-          jsonb_accessor_methods.instance_eval do
-            define_method("#{field}=") do |value|
-              instance_class = send("#{jsonb_attribute}_classes")[field]
-              instance = cast_nested_field_value(value, instance_class, __method__)
-
-              new_jsonb_value = (send(jsonb_attribute) || {}).merge(field.to_s => instance.attributes)
-              write_attribute(jsonb_attribute, new_jsonb_value)
-              super(instance)
-            end
+        # <jsonb_attribute>_where scope
+        scope("#{jsonb_attribute}_where", lambda do |attributes|
+          store_key_attributes = attributes.each_with_object({}) do |(name, value), new_attributes|
+            store_key = names_and_store_keys[name.to_s]
+            new_attributes[store_key] = value
           end
-        end
+          jsonb_where(jsonb_attribute, store_key_attributes)
+        end)
       end
     end
   end

data/lib/jsonb_accessor/query_builder.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+module JsonbAccessor
+  GREATER_THAN = ">"
+  GREATER_THAN_OR_EQUAL_TO = ">="
+  LESS_THAN = "<"
+  LESS_THAN_OR_EQUAL_TO = "<="
+
+  NUMBER_OPERATORS_MAP = {
+    GREATER_THAN => GREATER_THAN,
+    "greater_than" => GREATER_THAN,
+    "gt" => GREATER_THAN,
+    GREATER_THAN_OR_EQUAL_TO => GREATER_THAN_OR_EQUAL_TO,
+    "greater_than_or_equal_to" => GREATER_THAN_OR_EQUAL_TO,
+    "gte" => GREATER_THAN_OR_EQUAL_TO,
+    LESS_THAN => LESS_THAN,
+    "less_than" => LESS_THAN,
+    "lt" => LESS_THAN,
+    LESS_THAN_OR_EQUAL_TO => LESS_THAN_OR_EQUAL_TO,
+    "less_than_or_equal_to" => LESS_THAN_OR_EQUAL_TO,
+    "lte" => LESS_THAN_OR_EQUAL_TO
+  }.freeze
+
+  NUMBER_OPERATORS = NUMBER_OPERATORS_MAP.keys.freeze
+
+  TIME_OPERATORS_MAP = {
+    "after" => GREATER_THAN,
+    "before" => LESS_THAN
+  }.freeze
+
+  TIME_OPERATORS = TIME_OPERATORS_MAP.keys.freeze
+
+  IS_NUMBER_QUERY_ARGUMENTS = lambda do |arg|
+    arg.is_a?(Hash) &&
+      arg.keys.map(&:to_s).all? { |key| JsonbAccessor::NUMBER_OPERATORS.include?(key) }
+  end
+
+  IS_TIME_QUERY_ARGUMENTS = lambda do |arg|
+    arg.is_a?(Hash) &&
+      arg.keys.map(&:to_s).all? { |key| JsonbAccessor::TIME_OPERATORS.include?(key) }
+  end
+
+  module QueryBuilder
+    extend ActiveSupport::Concern
+
+    included do
+      scope(:jsonb_contains,
+        -> (column_name, attributes) { where("#{table_name}.#{column_name} @> (?)::jsonb", attributes.to_json) })
+
+      scope(:jsonb_number_query, lambda do |column_name, field_name, given_operator, value|
+        operator = JsonbAccessor::NUMBER_OPERATORS_MAP.fetch(given_operator.to_s)
+        where("(#{table_name}.#{column_name} ->> ?)::float #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_time_query, lambda do |column_name, field_name, given_operator, value|
+        operator = JsonbAccessor::TIME_OPERATORS_MAP.fetch(given_operator.to_s)
+        where("(#{table_name}.#{column_name} ->> ?)::timestamp #{operator} ?", field_name, value)
+      end)
+
+      scope(:jsonb_where, lambda do |column_name, attributes|
+        query = all
+        contains_attributes = {}
+
+        attributes.each do |name, value|
+          case value
+          when IS_NUMBER_QUERY_ARGUMENTS
+            value.each { |operator, query_value| query = query.jsonb_number_query(column_name, name, operator, query_value) }
+          when IS_TIME_QUERY_ARGUMENTS
+            value.each { |operator, query_value| query = query.jsonb_time_query(column_name, name, operator, query_value) }
+          else
+            contains_attributes[name] = value
+          end
+        end
+
+        query.jsonb_contains(column_name, contains_attributes)
+      end)
+    end
+  end
+end

data/lib/jsonb_accessor/version.rb

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 module JsonbAccessor
-  VERSION = "0.4.0.beta"
+  VERSION = "1.0.0.beta"
 end

data/lib/jsonb_accessor.rb

@@ -1,14 +1,11 @@
+# frozen_string_literal: true
 require "active_record"
 
 require "active_record/connection_adapters/postgresql_adapter"
 
 require "jsonb_accessor/version"
-require "jsonb_accessor/fields_map"
-require "jsonb_accessor/helpers"
-require "jsonb_accessor/type_helper"
-require "jsonb_accessor/nested_base"
-require "jsonb_accessor/class_builder"
 require "jsonb_accessor/macro"
+require "jsonb_accessor/query_builder"
 
 module JsonbAccessor
   extend ActiveSupport::Concern
@@ -17,5 +14,5 @@ end
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Base.send(:include, JsonbAccessor)
-  ActiveRecord::Base.send(:include, JsonbAccessor::Helpers)
+  ActiveRecord::Base.send(:include, JsonbAccessor::QueryBuilder)
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonb_accessor
 version: !ruby/object:Gem::Version
-  version: 0.4.0.beta
+  version: 1.0.0.beta
 platform: ruby
 authors:
 - Michael Crismali
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-10-17 00:00:00.000000000 Z
+date: 2016-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.1
+        version: 5.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.1
+        version: 5.0.0
 - !ruby/object:Gem::Dependency
   name: pg
   requirement: !ruby/object:Gem::Requirement
@@ -40,20 +40,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.18.1
-- !ruby/object:Gem::Dependency
-  name: actionpack
-  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'
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -172,28 +158,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '3.2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.2.0
+        version: '3.2'
 - !ruby/object:Gem::Dependency
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.31.0
+        version: '0.31'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.31.0
+        version: '0.31'
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -247,18 +233,12 @@ files:
 - db/config.yml
 - db/migrate/20150407031737_set_up_testing_db.rb
 - db/schema.rb
-- gemfiles/activerecord_4.2.4.gemfile
-- gemfiles/activerecord_4.2.4.gemfile.lock
 - gemfiles/activerecord_5.0.0.gemfile
 - gemfiles/activerecord_5.0.0.gemfile.lock
 - jsonb_accessor.gemspec
 - lib/jsonb_accessor.rb
-- lib/jsonb_accessor/class_builder.rb
-- lib/jsonb_accessor/fields_map.rb
-- lib/jsonb_accessor/helpers.rb
 - lib/jsonb_accessor/macro.rb
-- lib/jsonb_accessor/nested_base.rb
-- lib/jsonb_accessor/type_helper.rb
+- lib/jsonb_accessor/query_builder.rb
 - lib/jsonb_accessor/version.rb
 homepage: https://github.com/devmynd/jsonb_accessor
 licenses:

data/gemfiles/activerecord_4.2.4.gemfile

@@ -1,8 +0,0 @@
-# This file was generated by Appraisal
-
-source "https://rubygems.org"
-
-gem "pg"
-gem "activerecord", "4.2.4"
-
-gemspec :path => "../"

data/gemfiles/activerecord_4.2.4.gemfile.lock

@@ -1,146 +0,0 @@
-PATH
-  remote: ../
-  specs:
-    jsonb_accessor (0.4.0.beta)
-      activerecord (>= 4.2.1)
-      pg (>= 0.18.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    actionpack (4.2.4)
-      actionview (= 4.2.4)
-      activesupport (= 4.2.4)
-      rack (~> 1.6)
-      rack-test (~> 0.6.2)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    actionview (4.2.4)
-      activesupport (= 4.2.4)
-      builder (~> 3.1)
-      erubis (~> 2.7.0)
-      rails-dom-testing (~> 1.0, >= 1.0.5)
-      rails-html-sanitizer (~> 1.0, >= 1.0.2)
-    activemodel (4.2.4)
-      activesupport (= 4.2.4)
-      builder (~> 3.1)
-    activerecord (4.2.4)
-      activemodel (= 4.2.4)
-      activesupport (= 4.2.4)
-      arel (~> 6.0)
-    activesupport (4.2.4)
-      i18n (~> 0.7)
-      json (~> 1.7, >= 1.7.7)
-      minitest (~> 5.1)
-      thread_safe (~> 0.3, >= 0.3.4)
-      tzinfo (~> 1.1)
-    appraisal (2.1.0)
-      bundler
-      rake
-      thor (>= 0.14.0)
-    arel (6.0.3)
-    ast (2.1.0)
-    astrolabe (1.3.1)
-      parser (~> 2.2)
-    awesome_print (1.6.1)
-    builder (3.2.2)
-    coderay (1.1.0)
-    database_cleaner (1.5.1)
-    diff-lcs (1.2.5)
-    erubis (2.7.0)
-    i18n (0.7.0)
-    json (1.8.3)
-    loofah (2.0.3)
-      nokogiri (>= 1.5.9)
-    method_source (0.8.2)
-    mini_portile (0.6.2)
-    minitest (5.8.1)
-    nokogiri (1.6.6.2)
-      mini_portile (~> 0.6.0)
-    parser (2.2.3.0)
-      ast (>= 1.1, < 3.0)
-    pg (0.18.4)
-    powerpack (0.1.1)
-    pry (0.10.3)
-      coderay (~> 1.1.0)
-      method_source (~> 0.8.1)
-      slop (~> 3.4)
-    pry-doc (0.8.0)
-      pry (~> 0.9)
-      yard (~> 0.8)
-    pry-nav (0.2.4)
-      pry (>= 0.9.10, < 0.11.0)
-    rack (1.6.4)
-    rack-test (0.6.3)
-      rack (>= 1.0)
-    rails-deprecated_sanitizer (1.0.3)
-      activesupport (>= 4.2.0.alpha)
-    rails-dom-testing (1.0.7)
-      activesupport (>= 4.2.0.beta, < 5.0)
-      nokogiri (~> 1.6.0)
-      rails-deprecated_sanitizer (>= 1.0.1)
-    rails-html-sanitizer (1.0.2)
-      loofah (~> 2.0)
-    railties (4.2.4)
-      actionpack (= 4.2.4)
-      activesupport (= 4.2.4)
-      rake (>= 0.8.7)
-      thor (>= 0.18.1, < 2.0)
-    rainbow (2.0.0)
-    rake (10.4.2)
-    rspec (3.2.0)
-      rspec-core (~> 3.2.0)
-      rspec-expectations (~> 3.2.0)
-      rspec-mocks (~> 3.2.0)
-    rspec-core (3.2.3)
-      rspec-support (~> 3.2.0)
-    rspec-expectations (3.2.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-mocks (3.2.1)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.2.0)
-    rspec-support (3.2.2)
-    rubocop (0.31.0)
-      astrolabe (~> 1.3)
-      parser (>= 2.2.2.1, < 3.0)
-      powerpack (~> 0.1)
-      rainbow (>= 1.99.1, < 3.0)
-      ruby-progressbar (~> 1.4)
-    ruby-progressbar (1.7.5)
-    shoulda-matchers (3.0.0)
-      activesupport (>= 4.0.0)
-    slop (3.6.0)
-    standalone_migrations (4.0.2)
-      activerecord (~> 4.2.0)
-      railties (~> 4.2.0)
-      rake (~> 10.0)
-    thor (0.19.1)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-    yard (0.8.7.6)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  actionpack
-  activerecord (= 4.2.4)
-  appraisal
-  awesome_print
-  bundler (~> 1.9)
-  database_cleaner
-  jsonb_accessor!
-  pg
-  pry
-  pry-doc
-  pry-nav
-  rake (~> 10.0)
-  rspec (~> 3.2.0)
-  rubocop (= 0.31.0)
-  shoulda-matchers
-  standalone_migrations
-
-BUNDLED WITH
-   1.11.2

data/lib/jsonb_accessor/class_builder.rb

@@ -1,101 +0,0 @@
-module JsonbAccessor
-  UnknownValue = Class.new(StandardError)
-  CLASS_PREFIX = "JA"
-
-  module ClassBuilder
-    class << self
-      def generate_class(namespace, new_class_name, attribute_definitions)
-        fields_map = JsonbAccessor::FieldsMap.new([], attribute_definitions)
-        klass = generate_new_class(new_class_name, fields_map, namespace)
-        nested_classes = generate_nested_classes(klass, fields_map.nested_fields)
-
-        define_class_methods(klass, nested_classes, new_class_name)
-        define_attributes_and_data_types(klass, fields_map)
-        define_typed_accessors(klass, fields_map)
-        define_nested_accessors(klass, fields_map)
-
-        klass
-      end
-
-      def generate_nested_classes(klass, nested_attributes)
-        nested_attributes.each_with_object({}) do |(attribute_name, nested_attrs), nested_classes|
-          nested_classes[attribute_name] = generate_class(klass, attribute_name, nested_attrs)
-        end
-      end
-
-      def generate_class_namespace(name)
-        class_name = CLASS_PREFIX + name.gsub(CONSTANT_SEPARATOR, "")
-        if JsonbAccessor.constants.any? { |c| c.to_s == class_name }
-          class_namespace = JsonbAccessor.const_get(class_name)
-        else
-          class_namespace = Module.new
-          JsonbAccessor.const_set(class_name, class_namespace)
-        end
-        class_namespace
-      end
-
-      def generate_attribute_namespace(attribute_name, class_namespace)
-        attribute_namespace = Module.new
-        name = generate_constant_name(attribute_name)
-        class_namespace.const_set(name, attribute_namespace)
-      end
-
-      private
-
-      def define_nested_accessors(klass, fields_map)
-        klass.class_eval do
-          fields_map.nested_fields.keys.each do |attribute_name|
-            attr_reader attribute_name
-
-            define_method("#{attribute_name}=") do |value|
-              instance_class = nested_classes[attribute_name]
-              instance = cast_nested_field_value(value, instance_class, __method__)
-
-              instance_variable_set("@#{attribute_name}", instance)
-              attributes[attribute_name] = instance.attributes
-              update_parent
-            end
-          end
-        end
-      end
-
-      def define_typed_accessors(klass, fields_map)
-        klass.class_eval do
-          fields_map.typed_fields.keys.each do |attribute_name|
-            define_method(attribute_name) { attributes[attribute_name] }
-
-            cast_method_name = ActiveRecord::VERSION::MAJOR == 5 ? :cast : :type_cast_from_user
-            define_method("#{attribute_name}=") do |value|
-              cast_value = attributes_and_data_types[attribute_name].public_send(cast_method_name, value)
-              attributes[attribute_name] = cast_value
-              update_parent
-            end
-          end
-        end
-      end
-
-      def define_attributes_and_data_types(klass, fields_map)
-        klass.send(:define_method, :attributes_and_data_types) do
-          @attributes_and_data_types ||= fields_map.typed_fields.each_with_object({}) do |(name, type), attrs_and_data_types|
-            attrs_and_data_types[name] = TypeHelper.fetch(type)
-          end
-        end
-      end
-
-      def define_class_methods(klass, nested_classes, attribute_name)
-        klass.singleton_class.send(:define_method, :nested_classes) { nested_classes }
-        klass.singleton_class.send(:define_method, :attribute_on_parent_name) { attribute_name }
-      end
-
-      def generate_new_class(new_class_name, fields_map, namespace)
-        klass = Class.new(NestedBase)
-        new_class_name_camelized = generate_constant_name(new_class_name)
-        namespace.const_set(new_class_name_camelized, klass)
-      end
-
-      def generate_constant_name(attribute_name)
-        "#{CLASS_PREFIX}#{attribute_name.to_s.camelize}"
-      end
-    end
-  end
-end

data/lib/jsonb_accessor/fields_map.rb

@@ -1,32 +0,0 @@
-module JsonbAccessor
-  class FieldsMap
-    attr_accessor :nested_fields, :typed_fields
-
-    def initialize(value_fields, typed_and_nested_fields)
-      grouped_fields = extract_typed_and_nested_fields(typed_and_nested_fields)
-      nested_fields, typed_fields = grouped_fields.values_at(:nested, :typed)
-
-      self.typed_fields = implicitly_typed_fields(value_fields).merge(typed_fields)
-      self.nested_fields = nested_fields
-    end
-
-    def names
-      typed_fields.keys + nested_fields.keys
-    end
-
-    private
-
-    def implicitly_typed_fields(value_fields)
-      value_fields.each_with_object({}) do |field_name, implicitly_typed_fields|
-        implicitly_typed_fields[field_name] = :value
-      end
-    end
-
-    def extract_typed_and_nested_fields(typed_and_nested_fields)
-      typed_and_nested_fields.each_with_object(nested: {}, typed: {}) do |(attribute_name, type_or_nested), grouped_attributes|
-        group = type_or_nested.is_a?(Hash) ? grouped_attributes[:nested] : grouped_attributes[:typed]
-        group[attribute_name] = type_or_nested
-      end
-    end
-  end
-end

data/lib/jsonb_accessor/helpers.rb

@@ -1,19 +0,0 @@
-module JsonbAccessor
-  module Helpers
-    def cast_nested_field_value(value, klass, method_name)
-      case value
-      when klass
-        instance = klass.new(value.attributes)
-      when Hash
-        instance = klass.new(value)
-      when nil
-        instance = klass.new
-      else
-        raise UnknownValue, "unable to set value '#{value}' is not a hash, `nil`, or an instance of #{klass} in #{method_name}"
-      end
-
-      instance.parent = self
-      instance
-    end
-  end
-end

data/lib/jsonb_accessor/nested_base.rb

@@ -1,35 +0,0 @@
-module JsonbAccessor
-  class NestedBase
-    include Helpers
-
-    attr_accessor :attributes, :parent
-    alias_method :to_h, :attributes
-
-    delegate :[], to: :attributes
-    delegate :nested_classes, :attribute_on_parent_name, to: :class
-
-    def initialize(attributes = {})
-      self.attributes = {}.with_indifferent_access
-
-      nested_classes.keys.each do |key|
-        send("#{key}=", nil)
-      end
-
-      attributes.each do |name, value|
-        send("#{name}=", value)
-      end
-    end
-
-    def update_parent
-      parent.send("#{attribute_on_parent_name}=", self) if parent
-    end
-
-    def []=(key, value)
-      send("#{key}=", value)
-    end
-
-    def ==(suspect)
-      self.class == suspect.class && attributes == suspect.attributes
-    end
-  end
-end

data/lib/jsonb_accessor/type_helper.rb

@@ -1,68 +0,0 @@
-module JsonbAccessor
-  CONSTANT_SEPARATOR = "::"
-  module TypeHelper
-    ARRAY_MATCHER = /_array\z/
-    UnknownType = Class.new(StandardError)
-
-    class << self
-      def fetch(type)
-        case type
-        when :array
-          new_array(value)
-        when ARRAY_MATCHER
-          fetch_active_record_array_type(type)
-        when :value
-          value
-        else
-          fetch_active_record_type(type)
-        end
-      end
-
-      def type_cast_as_jsonb(suspect)
-        user_cast_method_name, db_case_method_name = ActiveRecord::VERSION::MAJOR == 5 ? [:cast, :serialize] : [:type_cast_from_user, :type_cast_for_database]
-        type_cast_hash = jsonb.public_send(user_cast_method_name, suspect)
-        jsonb.public_send(db_case_method_name, type_cast_hash)
-      end
-
-      private
-
-      def jsonb
-        @jsonb ||= fetch(:jsonb)
-      end
-
-      def fetch_active_record_array_type(type)
-        subtype = type.to_s.sub(ARRAY_MATCHER, "")
-        new_array(fetch_active_record_type(subtype))
-      end
-
-      def fetch_active_record_type(type)
-        class_name = type.to_s.camelize
-        klass = value_descendants.find do |ar_type|
-          ar_type.to_s.split(CONSTANT_SEPARATOR).last == class_name
-        end
-
-        if klass
-          klass.new
-        else
-          raise JsonbAccessor::TypeHelper::UnknownType
-        end
-      end
-
-      def value_descendants
-        grouped_types = ActiveRecord::Type::Value.descendants.group_by do |ar_type|
-          !!ar_type.to_s.match(ActiveRecord::ConnectionAdapters::PostgreSQL::OID.to_s)
-        end
-
-        grouped_types[true] + grouped_types[false]
-      end
-
-      def value
-        ActiveRecord::Type::Value.new
-      end
-
-      def new_array(subtype)
-        ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array.new(subtype)
-      end
-    end
-  end
-end