jsonb_accessor 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9aa4a83990520b8f0190a339f1973ead1de118c2
-  data.tar.gz: e12959b405e89178e7bbacbad07948c822db635e
+  metadata.gz: b3280838fd8b45ffea5fd3892240799bbb6785f7
+  data.tar.gz: 561e28860a5d43e25afc95ef79473480d2cc368e
 SHA512:
-  metadata.gz: c3a2da61536078ceef74ce35eb35f9645443389304710cb801fbbb49ff6aa534b738e89c4d29454361ff8916dbe0ac71b600ee697ee9b43c5f1c2fb84bb24d81
-  data.tar.gz: b8e45b17608b058ecc56c721b32785097422503f24aeddd0dc44243a0d041f6fa55ad812c34f862eea1b38a7f4ca373a37768e82d6615ea15eb9430f0798ca3a
+  metadata.gz: 080851d0cc5ea02c5d443a65473d97fd588de21c24011bbb65ab1ec7a96bdbc74b9b44298234d322dc942f8adf7ee775fb0d2fdb336cdb59455ec3f6d9a72e52
+  data.tar.gz: 1430c66ba53b9a01ce052043fbb49e75a1f90233f27de85a77e619eaa04e397853aeb7c82a5f2f1e8a0cf5f2ebe1f859e6680b9fc7161b160389c3b0366986b5

data/.rubocop.yml

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

data/Appraisals

@@ -1,3 +1,7 @@
 appraise "activerecord-4.2.1" do
   gem "activerecord", "4.2.1"
 end
+
+appraise "activerecord-4.2.2" do
+  gem "activerecord", "4.2.2"
+end

data/README.md

@@ -1,10 +1,21 @@
 # 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.
 
-**This gem is under heavy development. Please use cautiously and help us with feedback by opening issues for defects and feature requests. The current API is subject to change.**
+## Table of Contents
+
+* [Installation](#installation)
+* [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)
 
 ## Installation
 
@@ -42,7 +53,7 @@ class Product < ActiveRecord::Base
     title: :string,
     id_value: :value,
     external_id: :integer,
-    reviewed_at: :datetime
+    reviewed_at: :date_time
   )
 end
 ```
@@ -79,28 +90,40 @@ end
 
 ### Supported Types
 
-The following types are supported, including typed collections:
-
-```
-:array,
-:boolean,
-:boolean_array,
-:date,
-:date_array,
-:datetime,
-:datetime_array,
-:decimal,
-:decimal_array,
-:float,
-:float_array,
-:integer,
-:integer_array,
-:string,
-:string_array,
-:time,
-:time_array,
-:value
-```
+The following types are supported:
+
+* big_integer
+* binary
+* bit
+* bit_varying
+* boolean
+* bytea
+* cidr
+* date
+* date_time
+* decimal
+* decimal_without_scale
+* enum
+* float
+* hstore
+* inet
+* integer
+* json
+* jsonb
+* money
+* point
+* range
+* specialized_string
+* string
+* text
+* time
+* unsigned_integer
+* uuid
+* value
+* vector
+* xml
+
+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.
 
@@ -123,11 +146,214 @@ Because this gem promotes attributes nested into the JSON column to first level
 
 ## Single-Table Inheritance
 
-You can use it for STI in the same spirit as [hstore_accessor, which is documented here.](https://github.com/devmynd/hstore_accessor#single-table-inheritance).
+One of the big issues with `ActiveRecord` single-table inheritance (STI)
+is sparse columns.  Essentially, as sub-types of the original table
+diverge further from their parent more columns are left empty in a given
+table.  Postgres' `jsonb` type provides part of the solution in that
+the values in an `jsonb` column does not impose a structure - different
+rows can have different values.
+
+We set up our table with an `jsonb` field:
+
+```ruby
+# db/migration/<timestamp>_create_players_table.rb
+class CreateVehiclesTable < ActiveRecord::Migration
+  def change
+    create_table :vehicles do |t|
+      t.string :make
+      t.string :model
+      t.integer :model_year
+      t.string :type
+      t.jsonb :data
+    end
+  end
+end
+```
+
+And for our models:
+
+```ruby
+# app/models/vehicle.rb
+class Vehicle < ActiveRecord::Base
+end
+
+# app/models/vehicles/automobile.rb
+class Automobile < Vehicle
+  jsonb_accessor :data,
+    axle_count: :integer,
+    weight: :float
+end
+
+# app/models/vehicles/airplane.rb
+class Airplane < Vehicle
+  jsonb_accessor :data,
+    engine_type: :string,
+    safety_rating: :integer
+end
+```
+
+From here any attributes specific to any sub-class can be stored in the
+`jsonb` column avoiding sparse data.  Indices can also be created on
+individual fields in an `jsonb` column.
+
+This approach was originally concieved by Joe Hirn in [this blog
+post](http://www.devmynd.com/blog/2013-3-single-table-inheritance-hstore-lovely-combination).
 
 ## Scopes
 
-Coming soon...
+JsonbAccessor currently supports several scopes. Let's say we have a class that looks like this:
+
+```ruby
+class Product < ActiveRecord::Base
+  jsonb_accessor :data,
+    approved: :boolean,
+    name: :string,
+    price: :integer,
+    previous_prices: :integer_array,
+    reviewed_at: :date_time
+end
+```
+
+### General Scopes
+
+#### `<jsonb_field>_contains`
+
+**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)
+product_2 = Product.create!(name: "bar", approved: true)
+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
 

data/bin/console

@@ -12,10 +12,6 @@ ActiveRecord::Base.establish_connection(
   username: "postgres"
 )
 
-class Product < ActiveRecord::Base
-  jsonb_accessor :options, title: :string, foo: { bar: { baz: :string } }
-end
-
 x = Product.new
 
 Pry.start

data/gemfiles/activerecord_4.2.1.gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../
   specs:
-    jsonb_accessor (0.1.0)
+    jsonb_accessor (0.3.0)
       activerecord (>= 4.2.1)
       pg
 
@@ -57,10 +57,10 @@ GEM
     minitest (5.5.1)
     nokogiri (1.6.6.2)
       mini_portile (~> 0.6.0)
-    parser (2.2.0.3)
+    parser (2.2.2.5)
       ast (>= 1.1, < 3.0)
     pg (0.18.1)
-    powerpack (0.1.0)
+    powerpack (0.1.1)
     pry (0.10.1)
       coderay (~> 1.1.0)
       method_source (~> 0.8.1)
@@ -101,9 +101,9 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.2.0)
     rspec-support (3.2.2)
-    rubocop (0.30.0)
+    rubocop (0.31.0)
       astrolabe (~> 1.3)
-      parser (>= 2.2.0.1, < 3.0)
+      parser (>= 2.2.2.1, < 3.0)
       powerpack (~> 0.1)
       rainbow (>= 1.99.1, < 3.0)
       ruby-progressbar (~> 1.4)
@@ -125,6 +125,7 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  actionpack (~> 4.2.1)
   activerecord (= 4.2.1)
   appraisal
   awesome_print
@@ -136,6 +137,6 @@ DEPENDENCIES
   pry-nav
   rake (~> 10.0)
   rspec (~> 3.2.0)
-  rubocop
+  rubocop (= 0.31.0)
   shoulda-matchers
   standalone_migrations

data/gemfiles/activerecord_4.2.2.gemfile

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

data/gemfiles/activerecord_4.2.2.gemfile.lock

@@ -0,0 +1,143 @@
+PATH
+  remote: ../
+  specs:
+    jsonb_accessor (0.3.0)
+      activerecord (>= 4.2.1)
+      pg
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    actionpack (4.2.2)
+      actionview (= 4.2.2)
+      activesupport (= 4.2.2)
+      rack (~> 1.6)
+      rack-test (~> 0.6.2)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    actionview (4.2.2)
+      activesupport (= 4.2.2)
+      builder (~> 3.1)
+      erubis (~> 2.7.0)
+      rails-dom-testing (~> 1.0, >= 1.0.5)
+      rails-html-sanitizer (~> 1.0, >= 1.0.1)
+    activemodel (4.2.2)
+      activesupport (= 4.2.2)
+      builder (~> 3.1)
+    activerecord (4.2.2)
+      activemodel (= 4.2.2)
+      activesupport (= 4.2.2)
+      arel (~> 6.0)
+    activesupport (4.2.2)
+      i18n (~> 0.7)
+      json (~> 1.7, >= 1.7.7)
+      minitest (~> 5.1)
+      thread_safe (~> 0.3, >= 0.3.4)
+      tzinfo (~> 1.1)
+    appraisal (2.0.1)
+      activesupport (>= 3.2.21)
+      bundler
+      rake
+      thor (>= 0.14.0)
+    arel (6.0.0)
+    ast (2.0.0)
+    astrolabe (1.3.0)
+      parser (>= 2.2.0.pre.3, < 3.0)
+    awesome_print (1.6.1)
+    builder (3.2.2)
+    coderay (1.1.0)
+    database_cleaner (1.4.1)
+    diff-lcs (1.2.5)
+    erubis (2.7.0)
+    i18n (0.7.0)
+    json (1.8.3)
+    loofah (2.0.2)
+      nokogiri (>= 1.5.9)
+    method_source (0.8.2)
+    mini_portile (0.6.2)
+    minitest (5.7.0)
+    nokogiri (1.6.6.2)
+      mini_portile (~> 0.6.0)
+    parser (2.3.0.pre.2)
+      ast (>= 1.1, < 3.0)
+    pg (0.18.2)
+    powerpack (0.1.1)
+    pry (0.10.1)
+      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.2)
+    rack-test (0.6.3)
+      rack (>= 1.0)
+    rails-deprecated_sanitizer (1.0.3)
+      activesupport (>= 4.2.0.alpha)
+    rails-dom-testing (1.0.6)
+      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.2)
+      actionpack (= 4.2.2)
+      activesupport (= 4.2.2)
+      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 (2.8.0)
+      activesupport (>= 3.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 (~> 4.2.1)
+  activerecord (= 4.2.2)
+  appraisal
+  awesome_print
+  bundler (~> 1.9)
+  database_cleaner
+  jsonb_accessor!
+  pry
+  pry-doc
+  pry-nav
+  rake (~> 10.0)
+  rspec (~> 3.2.0)
+  rubocop (= 0.31.0)
+  shoulda-matchers
+  standalone_migrations

data/jsonb_accessor.gemspec

@@ -22,6 +22,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "activerecord", ">= 4.2.1"
   spec.add_dependency "pg"
 
+  spec.add_development_dependency "actionpack", "~> 4.2.1"
   spec.add_development_dependency "appraisal"
   spec.add_development_dependency "bundler", "~> 1.9"
   spec.add_development_dependency "database_cleaner"
@@ -31,7 +32,7 @@ Gem::Specification.new do |spec|
   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"
+  spec.add_development_dependency "rubocop", "0.31.0"
   spec.add_development_dependency "shoulda-matchers"
   spec.add_development_dependency "standalone_migrations"
 end

data/lib/jsonb_accessor.rb

@@ -3,6 +3,8 @@ 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"
@@ -15,4 +17,5 @@ end
 
 ActiveSupport.on_load(:active_record) do
   ActiveRecord::Base.send(:include, JsonbAccessor)
+  ActiveRecord::Base.send(:include, JsonbAccessor::Helpers)
 end

data/lib/jsonb_accessor/class_builder.rb

@@ -1,76 +1,100 @@
 module JsonbAccessor
   UnknownValue = Class.new(StandardError)
+  CLASS_PREFIX = "JA"
 
   module ClassBuilder
     class << self
       def generate_class(namespace, new_class_name, attribute_definitions)
-        grouped_attributes = group_attributes(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)
 
-        klass = Class.new(NestedBase)
-        namespace.const_set(new_class_name.to_s.camelize, klass)
-        nested_classes = generate_nested_classes(klass, grouped_attributes[:nested])
+        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.class_eval do
-          singleton_class.send(:define_method, :nested_classes) { nested_classes }
-          singleton_class.send(:define_method, :attribute_on_parent_name) { new_class_name }
+        klass
+      end
 
-          define_method(:attributes_and_data_types) do
-            @attributes_and_data_types ||= grouped_attributes[:typed].each_with_object({}) do |(name, type), attrs_and_data_types|
-              attrs_and_data_types[name] = TypeHelper.fetch(type)
-            end
-          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
 
-          grouped_attributes[:typed].keys.each do |attribute_name|
-            define_method(attribute_name) { attributes[attribute_name] }
+      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
 
-            define_method("#{attribute_name}=") do |value|
-              cast_value = attributes_and_data_types[attribute_name].type_cast_from_user(value)
-              attributes[attribute_name] = cast_value
-              update_parent
-            end
-          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
 
-          grouped_attributes[:nested].keys.each do |attribute_name|
+      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__)
 
-              case value
-              when instance_class
-                instance = instance_class.new(value.attributes)
-              when Hash
-                instance = instance_class.new(value)
-              when nil
-                instance = instance_class.new
-              else
-                raise UnknownValue, "unable to set value '#{value}' is not a hash, `nil`, or an instance of #{instance_class} in #{__method__}"
-              end
-
-              instance.parent = self
               instance_variable_set("@#{attribute_name}", instance)
               attributes[attribute_name] = instance.attributes
               update_parent
             end
           end
         end
-        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)
+      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] }
+
+            define_method("#{attribute_name}=") do |value|
+              cast_value = attributes_and_data_types[attribute_name].type_cast_from_user(value)
+              attributes[attribute_name] = cast_value
+              update_parent
+            end
+          end
         end
       end
 
-      private
-
-      def group_attributes(attributes)
-        attributes.each_with_object(nested: {}, typed: {}) do |(name, type_or_nested), grouped_attributes|
-          group = type_or_nested.is_a?(Hash) ? grouped_attributes[:nested] : grouped_attributes[:typed]
-          group[name] = type_or_nested
+      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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,19 @@
+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/macro.rb

@@ -1,61 +1,112 @@
 module JsonbAccessor
   module Macro
-    class << self
-      def group_attributes(value_fields, typed_fields)
-        value_fields_hash = process_value_fields(value_fields)
+    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"
 
-        typed_fields.each_with_object(nested: {}, typed: value_fields_hash) 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
+        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
 
-      def process_value_fields(value_fields)
-        value_fields.each_with_object({}) do |value_field, hash_for_value_fields|
-          hash_for_value_fields[value_field] = :value
+      private
+
+      def _register_jsonb_classes_for_cleanup
+        if defined?(ActionDispatch) && ENV["RACK_ENV"] == "development"
+          class_name = CLASS_PREFIX + name
+          ActionDispatch::Reloader.to_cleanup do
+            if JsonbAccessor.constants.any? { |c| c.to_s == class_name }
+              JsonbAccessor.send(:remove_const, class_name)
+            end
+          end
         end
       end
 
-      def build_class_namespace(class_name)
-        class_name = class_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)
+      def _initialize_jsonb_attrs(jsonb_attribute, fields_map, jsonb_attribute_initialization_method_name)
+        define_method(jsonb_attribute_initialization_method_name) do
+          jsonb_attribute_hash = send(jsonb_attribute) || {}
+          fields_map.names.each do |field|
+            send("#{field}=", jsonb_attribute_hash[field.to_s])
+          end
         end
-        class_namespace
+        after_initialize(jsonb_attribute_initialization_method_name)
       end
-    end
 
-    module ClassMethods
-      def jsonb_accessor(jsonb_attribute, *value_fields, **typed_fields)
-        all_fields = Macro.group_attributes(value_fields, typed_fields)
-        nested_fields, typed_fields = all_fields.values_at(:nested, :typed)
+      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
 
-        class_namespace = Macro.build_class_namespace(name)
-        attribute_namespace = Module.new
-        class_namespace.const_set(jsonb_attribute.to_s.camelize, attribute_namespace)
+      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
 
-        nested_classes = ClassBuilder.generate_nested_classes(attribute_namespace, nested_fields)
+      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
 
-        singleton_class.send(:define_method, "#{jsonb_attribute}_classes") do
-          nested_classes
+      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
 
-        delegate "#{jsonb_attribute}_classes", to: :class
+      def ___create_jsonb_boolean_scopes(field)
+        scope "is_#{field}", -> { send("with_#{field}", true) }
+        scope "not_#{field}", -> { send("with_#{field}", false) }
+      end
 
-        jsonb_attribute_initialization_method_name = "initialize_jsonb_attrs_for_#{jsonb_attribute}"
+      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
 
-        define_method(jsonb_attribute_initialization_method_name) do
-          jsonb_attribute_hash = send(jsonb_attribute) || {}
-          (typed_fields.keys + nested_fields.keys).each do |field|
-            send("#{field}=", jsonb_attribute_hash[field.to_s])
-          end
-        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
 
-        after_initialize(jsonb_attribute_initialization_method_name)
+      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
           define_method("#{jsonb_attribute}=") do |value|
             write_attribute(jsonb_attribute, value)
@@ -69,7 +120,13 @@ module JsonbAccessor
           end
         end
 
-        typed_fields.each do |field, type|
+        __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
@@ -80,34 +137,22 @@ module JsonbAccessor
             end
           end
         end
+      end
 
-        nested_fields.each do |field, nested_attributes|
+      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 = nested_classes[field]
-
-              case value
-              when instance_class
-                instance = instance_class.new(value.attributes)
-              when Hash
-                instance = instance_class.new(value)
-              when nil
-                instance = instance_class.new
-              else
-                raise UnknownValue, "unable to set value '#{value}' is not a hash, `nil`, or an instance of #{instance_class} in #{__method__}"
-              end
-
-              instance.parent = self
+              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
           end
         end
-
-        include jsonb_accessor_methods
       end
     end
   end

data/lib/jsonb_accessor/nested_base.rb

@@ -1,5 +1,7 @@
 module JsonbAccessor
   class NestedBase
+    include Helpers
+
     attr_accessor :attributes, :parent
     alias_method :to_h, :attributes
 

data/lib/jsonb_accessor/type_helper.rb

@@ -18,8 +18,17 @@ module JsonbAccessor
         end
       end
 
+      def type_cast_as_jsonb(suspect)
+        type_cast_hash = jsonb.type_cast_from_user(suspect)
+        jsonb.type_cast_for_database(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))

data/lib/jsonb_accessor/version.rb

@@ -1,3 +1,3 @@
 module JsonbAccessor
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jsonb_accessor
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Michael Crismali
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-04-17 00:00:00.000000000 Z
+date: 2015-06-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,6 +39,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.2.1
 - !ruby/object:Gem::Dependency
   name: appraisal
   requirement: !ruby/object:Gem::Requirement
@@ -169,16 +183,16 @@ dependencies:
   name: rubocop
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.31.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - '='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.31.0
 - !ruby/object:Gem::Dependency
   name: shoulda-matchers
   requirement: !ruby/object:Gem::Requirement
@@ -234,9 +248,13 @@ files:
 - docker-compose.yml
 - gemfiles/activerecord_4.2.1.gemfile
 - gemfiles/activerecord_4.2.1.gemfile.lock
+- gemfiles/activerecord_4.2.2.gemfile
+- gemfiles/activerecord_4.2.2.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