active_model_serializers_pg 0.0.5 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fb040d4836aa84e29ba59590ac8bc4373528e31e5186cec1168538d52384fd0
-  data.tar.gz: a2ef8e881e358597aeb30145a73cbfdff5b7ed663d1c614ba5a40cbceba9d772
+  metadata.gz: '0692a6200c2d79a0704f65112f64c150bca435c24f82409c6b7e327ecb8e5a62'
+  data.tar.gz: c4a9b76cb7e6f5f896ddacf01fd6d4ae2c7e0b43f14692f3877a0afaec024953
 SHA512:
-  metadata.gz: 30889a0c217b98a0a79296379fd7c399b414b223a3568133e796ef605ae938d013957052c939c65bed5a75fed3e64d08025bc83729a92d620d3fdb905aca13dd
-  data.tar.gz: 7ff699ff57696cece4ed3f54a2f3d8583f1d2bd2089f65ab842972d9c22c9a2a86360c20e4bd0e043f2532db8f54c332804e3038c3d65f35c3af6be4f297a56e
+  metadata.gz: fda8dad0da5f0b7e877e348b7b42494b74b6378e9a84977e276f3cbe1595a259eaef4a2d708747d1d6b307f24b5c4f6949c3e7aec6210670030e2b52cf2a9a9c
+  data.tar.gz: a81b5904a40a60a482bd3745f289c9a9c774a73b2bc2ce1c3ed26efb518e21318270ad7b401338e34dadb537793cb5ea67d845942ee936f6df25bb4d64a4e488

data/README.md

@@ -31,6 +31,13 @@ Or install it yourself as:
 
     gem install active_model_serializers_pg
 
+### Migrations
+
+This gem depends on a SQL function to dasherize hstore/json/jsonb columns, so you must add its migration to your project and run it, like this:
+
+    rails g active_model_serializers_pg
+    rake db:migrate
+
 ## Usage
 
 You can enable in-Postgres serialization for everything by putting this in a Rails initializer:
@@ -52,8 +59,10 @@ Here are some other details we support:
 - `belongs_to`, `has_one`, and `has_many` associations.
 - If you serialize an `enum` you get the string values, not integers.
 - You can serialize an `alias`'d association.
+- You can serialize an `alias_attribute`'d column.
 - We preserve SQL ordering from a model's `default_scope`.
 - We preserve SQL ordering attached to an association.
+- When dasherizing we also dasherize json/jsonb/hstore contents (like standard AMS).
 
 ### Methods in Serializers and Models
 
@@ -110,7 +119,7 @@ To work on active\_model\_serializers\_pg locally, follow these steps:
  4. Run `bundle exec rake db:create`, this will create the test database.
  5. Run `bundle exec rake db:migrate`, this will set up the database tables required
     by the test.
- 6. Run `bundle exec rake test:all` to run tests against all supported versions of Active Record (currently 5.0.x, 5.1.x, 5.2.x).
+ 6. Run `bundle exec rake test:all` to run tests against all supported versions of Active Record (currently 5.0.x, 5.1.x, 5.2.x, 6.0.x).
     You can also say `BUNDLE_GEMFILE=gemfiles/Gemfile.activerecord-5.2.x bundle exec rspec spec` to run against a specific version (and select specific tests).
 
 Commands for building/releasing/installing:

data/Rakefile

@@ -72,9 +72,17 @@ namespace :db do
   task :migrate => :load_db_settings do
     ActiveRecord::Base.establish_connection
 
+    ActiveRecord::Base.connection.execute "CREATE EXTENSION hstore"
+
     ActiveRecord::Base.connection.create_table :people, force: true do |t|
       t.string   "first_name"
       t.string   "last_name"
+      t.json     "options"
+      t.jsonb    "prefs"
+      t.hstore   "settings"
+      t.json     "selfies", array: true
+      t.jsonb    "portraits", array: true
+      t.hstore   "landscapes", array: true
       t.datetime "created_at"
       t.datetime "updated_at"
     end
@@ -131,6 +139,8 @@ namespace :db do
       t.datetime "updated_at"
     end
 
+    ActiveRecord::Base.connection.execute File.read(File.expand_path('../lib/generators/active_record/templates/jsonb_dasherize.sql', __FILE__))
+
     puts 'Database migrated'
   end
 end
@@ -141,7 +151,7 @@ namespace :test do
     # Escape current bundler environment
     Bundler.with_clean_env do
       # Currently only supports Active Record v5.0-v5.2
-      %w(5.0.x 5.1.x 5.2.x).each do |version|
+      %w(5.0.x 5.1.x 5.2.x 6.0.x).each do |version|
         sh "BUNDLE_GEMFILE='gemfiles/Gemfile.activerecord-#{version}' bundle install --quiet"
         sh "BUNDLE_GEMFILE='gemfiles/Gemfile.activerecord-#{version}' bundle exec rspec spec"
       end

data/active_model_serializers_pg.gemspec

@@ -19,12 +19,14 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_runtime_dependency     'active_model_serializers', '~> 0.10.8'
-  spec.add_runtime_dependency     'activerecord', '~> 5.0'
+  spec.add_runtime_dependency     'activerecord', '>= 5.0'
 
   spec.add_development_dependency 'bundler', '~> 1.3'
   spec.add_development_dependency 'actionpack', '> 4.0'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'rspec-rails'
+  spec.add_development_dependency 'generator_spec'
   spec.add_development_dependency 'bourne', '~> 1.3.0'
   spec.add_development_dependency 'database_cleaner'
   spec.add_development_dependency 'dotenv'

data/gemfiles/Gemfile.activerecord-5.0.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.0.0"
+gem "rails", "~>5.0.0"

data/gemfiles/Gemfile.activerecord-5.1.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.1.0"
+gem "rails", "~>5.1.0"

data/gemfiles/Gemfile.activerecord-5.2.x

@@ -2,4 +2,4 @@ source "https://rubygems.org"
 
 gemspec :path => '..'
 
-gem "activerecord", "~>5.2.0"
+gem "rails", "~>5.2.0"

data/gemfiles/Gemfile.activerecord-6.0.x

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gemspec :path => '..'
+
+gem "rails", "~>6.0.0"

data/lib/active_model_serializers/adapter/json_api_pg.rb

@@ -77,7 +77,7 @@ module ActiveModelSerializers
       end
 
       def self.warn_about_collection_serializer
-          msg = "You are using an ordinary AMS CollectionSerializer with the json_api_pg adapter, which probably means Rails is pointlessly loading all your ActiveRecord instances *and* running the build JSON-building query in Postgres."
+          msg = "You are using an ordinary AMS CollectionSerializer with the json_api_pg adapter, which probably means Rails is pointlessly loading all your ActiveRecord instances *and* running the JSON-building query in Postgres."
           if Object.const_defined? 'Rails'
             Rails.logger.warn msg
           else
@@ -105,8 +105,8 @@ end
 # i.e. how you got here, not how you'd leave:
 # "Reflection" seems to be the internal ActiveRecord lingo
 # for a belongs_to or has_many relationship.
-# (The public documentation calls these "associations",
-# I think think older versions of Rails even used that internally,
+# (The public documentation calls these "associations".
+# I think older versions of Rails even used that internally,
 # but nowadays the method names use "reflection".)
 class JsonThing
   attr_reader :ar_class, :full_name, :name, :serializer, :serializer_options, :json_key, :json_type, :reflection, :parent, :cte_name, :jbs_name
@@ -141,28 +141,10 @@ class JsonThing
     JsonThing.new(refl.klass, "#{full_name}.#{reflection_name}", nil, serializer_options, refl, self)
   end
 
-  # Gets the attributes (i.e. scalar fields) on the AR class
-  # as a Set of symbols.
-  # TODO: tests
-	def declared_attributes
-    @declared_attributes ||= Set.new(@ar_class.attribute_types.keys.map(&:to_sym))
-  end
-
   def enum?(field)
     @ar_class.attribute_types[field.to_s].is_a? ActiveRecord::Enum::EnumType
   end
 
-  # Gets the reflections (aka associations) of the AR class
-  # as a Hash from symbol to a subclass of ActiveRecord::Reflection.
-  # TODO: tests
-  def declared_reflections
-    @declared_reflections ||= Hash[
-      @ar_class.reflections.map{|k, v|
-        [k.to_sym, v]
-      }
-    ]
-  end
-
   # Checks for alias_attribute and gets to the real attribute name.
   def unaliased(field_name)
     ret = field_name
@@ -191,6 +173,20 @@ class JsonThing
     (@sql_methods[field] ||= _sql_method(field))[0]
   end
 
+  # Returns the primary key column as a string,
+  # but if there is a "#{primary_key}__sql" method,
+  # then call that and return it instead.
+  # We use this for the id reported in the jsonapi output,
+  # but not for foreign key relationships.
+  def primary_key_attr
+    pk = primary_key
+    if has_sql_method?(pk)
+      sql_method(pk)
+    else
+      pk
+    end
+  end
+
   private
 
   # This needs to be globally unique within the SQL query,
@@ -210,7 +206,7 @@ class JsonThing
     end
   end
 
-  # Each thing has bother a `cte_foo` CTE and a `jbs_foo` CTE.
+  # Each thing has both a `cte_foo` CTE and a `jbs_foo` CTE.
   # (jbs stands for "JSONBs" and is meant to take 3 chars like `cte`.)
   # The former is just the relevant records,
   # and the second builds the JSON object for each record.
@@ -376,6 +372,15 @@ end
 class JsonApiPgSql
   attr_reader :base_serializer, :base_relation
 
+  def self.json_column_type
+    # These classes may not exist, depending on the Rails version:
+    @@json_column_type = if Rails::VERSION::STRING >= '5.2'
+                           'ActiveRecord::Type::Json'
+                         else
+                           'ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Json'
+                         end.constantize
+  end
+
   def initialize(base_serializer, base_relation, instance_options, options)
     @base_relation = base_relation
     @instance_options = instance_options
@@ -452,14 +457,58 @@ class JsonApiPgSql
     elsif resource.has_sql_method?(field)
       resource.sql_method(field)
     else
-      %Q{"#{resource.table_name}"."#{resource.unaliased(field)}"}
+      field = resource.unaliased(field)
+      # Standard AMS dasherizes json/jsonb/hstore columns,
+      # so we have to do the same:
+      if ActiveModelSerializers.config.key_transform == :dash
+        cl = resource.ar_class.attribute_types[field.to_s]
+        if column_is_jsonb? cl
+          %Q{jsonb_dasherize("#{resource.table_name}"."#{field}")}
+        elsif column_is_jsonb_array? cl
+          # TODO: Could be faster:
+          # If we made the jsonb_dasherize function smarter so it could handle jsonb[],
+          # we wouldn't have to build a json object from the array then cast to jsonb[].
+          %Q{jsonb_dasherize(array_to_json("#{resource.table_name}"."#{field}")::jsonb)}
+        elsif column_is_castable_to_jsonb? cl
+          # Fortunately we can cast hstore to jsonb,
+          # which gives us a solution that works whether or not the hstore extension is installed.
+          # Defining an hstore_dasherize function would work only if the extension were present.
+          %Q{jsonb_dasherize("#{resource.table_name}"."#{field}"::jsonb)}
+        elsif column_is_castable_to_jsonb_array? cl
+          # TODO: Could be faster (see above):
+          %Q{jsonb_dasherize(array_to_json("#{resource.table_name}"."#{field}"::jsonb[])::jsonb)}
+        else
+          %Q{"#{resource.table_name}"."#{field}"}
+        end
+      else
+        %Q{"#{resource.table_name}"."#{field}"}
+      end
     end
   end
 
+  def column_is_jsonb?(column_class)
+    column_class.is_a? ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb
+  end
+
+  def column_is_jsonb_array?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) and
+      column_class.subtype.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Jsonb)
+  end
+
+  def column_is_castable_to_jsonb?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Hstore) or
+      column_class.is_a?(self.class.json_column_type)
+  end
+
+  def column_is_castable_to_jsonb_array?(column_class)
+    column_class.is_a?(ActiveRecord::ConnectionAdapters::PostgreSQL::OID::Array) and
+      column_is_castable_to_jsonb?(column_class.subtype)
+  end
+
   def select_resource_relationship_links(resource, reflection)
     reflection.links.map {|link_name, link_parts|
       <<~EOQ
-        '#{link_name}', CONCAT(#{link_parts.join(%Q{, "#{resource.parent.table_name}"."#{resource.parent.primary_key}", })})
+        '#{link_name}', CONCAT(#{link_parts.join(%Q{, "#{resource.parent.table_name}"."#{resource.parent.primary_key_attr}", })})
       EOQ
     }.join(",\n")
   end
@@ -510,12 +559,8 @@ class JsonApiPgSql
           # or from the class's default scope.
           # TODO: preserve the whole custom relation, not just ordering
           p = refl.ar_class.new
-          ordering = nil
-          ActiveSupport::Deprecation.silence do
-            # TODO: Calling `orders` prints deprecation warnings, so find another way:
-            ordering = p.send(refl.name).orders
-            ordering = child_resource.ar_class.default_scoped.orders if ordering.empty?
-          end
+          ordering = p.send(refl.name).arel.orders
+          ordering = child_resource.ar_class.default_scoped.arel.orders if ordering.empty?
           ordering = ordering.map{|o|
             case o
             # TODO: The gsub is pretty awful....
@@ -530,7 +575,7 @@ class JsonApiPgSql
           ordering = "ORDER BY #{ordering}" if ordering
           <<~EOQ
             LEFT OUTER JOIN LATERAL (
-              SELECT  coalesce(jsonb_agg(jsonb_build_object('id', rel."#{child_resource.primary_key}"::text,
+              SELECT  coalesce(jsonb_agg(jsonb_build_object('id', rel."#{child_resource.primary_key_attr}"::text,
                                                             'type', '#{child_resource.json_type}') #{ordering}), '[]') AS j
               FROM    "#{child_resource.table_name}" rel
               WHERE   rel."#{child_resource.foreign_key}" = "#{resource.table_name}"."#{resource.primary_key}"
@@ -543,7 +588,7 @@ class JsonApiPgSql
           when ActiveRecord::Relation
             rel = refl.reflection_sql
             sql = rel.select(<<~EOQ).to_sql
-              coalesce(jsonb_agg(jsonb_build_object('id', "#{child_resource.table_name}"."#{child_resource.primary_key}"::text,
+              coalesce(jsonb_agg(jsonb_build_object('id', "#{child_resource.table_name}"."#{child_resource.primary_key_attr}"::text,
                                                     'type', '#{child_resource.json_type}')), '[]') AS j
             EOQ
             <<~EOQ
@@ -556,7 +601,7 @@ class JsonApiPgSql
       elsif refl.has_one?
         <<~EOQ
           LEFT OUTER JOIN LATERAL (
-            SELECT  jsonb_build_object('id', rel."#{child_resource.primary_key}"::text,
+            SELECT  jsonb_build_object('id', rel."#{child_resource.primary_key_attr}"::text,
                                       'type', '#{child_resource.json_type}') AS j
             FROM    "#{child_resource.table_name}" rel
             WHERE   rel."#{child_resource.foreign_key}" = "#{resource.table_name}"."#{resource.primary_key}"
@@ -593,8 +638,6 @@ class JsonApiPgSql
 
   # See note in _jbs_name method for why we split each thing into two CTEs.
   def include_cte(resource)
-    # Sometimes options[:fields] has plural keys and sometimes singular,
-    # so try both:
     parent = resource.parent
     <<~EOQ
       SELECT  DISTINCT ON ("#{resource.table_name}"."#{resource.primary_key}")
@@ -674,7 +717,7 @@ class JsonApiPgSql
   def select_resource(resource)
     fields = fields_for(resource)
     <<~EOQ
-      jsonb_build_object('id', "#{resource.table_name}"."#{resource.primary_key}"::text,
+      jsonb_build_object('id', "#{resource.table_name}"."#{resource.primary_key_attr}"::text,
                          'type', '#{resource.json_type}',
                          'attributes', #{select_resource_attributes(resource)}
                          #{maybe_select_resource_relationships(resource)})

data/lib/active_model_serializers_pg/version.rb

@@ -1,3 +1,3 @@
 module ActiveModelSerializersPg
-  VERSION = '0.0.5'
+  VERSION = '0.2.0'
 end

data/lib/generators/active_model_serializers_pg/active_model_serializers_pg_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators'
+
+module ActiveModelSerializersPg
+  module Generators
+    class ActiveModelSerializersPgGenerator < Rails::Generators::NamedBase
+      Rails::Generators::ResourceHelpers
+
+      # The ORM generator assumes you're passing a name argument,
+      # but we don't need one, so we give it a default value:
+      argument :name, type: :string, default: "ignored"
+      source_root File.expand_path("../templates", __FILE__)
+
+      namespace :active_model_serializers_pg
+      hook_for :orm, required: true, name: "ignored"
+
+      desc "Creates an active_model_serialiers_pg database migration"
+
+    end
+  end
+end

data/lib/generators/active_record/active_model_serializers_pg_generator.rb

@@ -0,0 +1,43 @@
+require 'rails/generators/active_record'
+
+module ActiveRecord
+  module Generators
+    class ActiveModelSerializersPgGenerator < ActiveRecord::Generators::Base
+      argument :name, type: :string, default: "ignored"
+      source_root File.expand_path("../templates", __FILE__)
+
+      def write_migration
+        migration_template "migration.rb", "#{migration_path}/ams_pg_create_dasherize_functions.rb"
+      end
+
+      private
+
+      def read_sql(funcname)
+        File.read(File.join(File.expand_path('../templates', __FILE__), "#{funcname}.sql"))
+      end
+
+      def migration_exists?(table_name)
+        Dir.glob("#{File.join destination_root, migration_path}/[0-9]*_*.rb").grep(/\d+_ams_pg_create_dasherize_functions.rb$/).first
+      end
+
+      def migration_path
+        if Rails.version >= '5.0.3'
+          db_migrate_path
+        else
+          @migration_path ||= File.join "db", "migrate"
+        end
+      end
+
+      def migration_version
+        if Rails.version.start_with? '5'
+          "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
+        end
+      end
+
+      def jsonb_dasherize
+        read_sql('jsonb_dasherize')
+      end
+
+    end
+  end
+end

data/lib/generators/active_record/templates/jsonb_dasherize.sql

@@ -0,0 +1,32 @@
+CREATE FUNCTION jsonb_dasherize(j jsonb)
+RETURNS jsonb
+IMMUTABLE
+AS
+$$
+DECLARE
+t text;
+ret jsonb;
+BEGIN
+  t := jsonb_typeof(j);
+  IF t = 'object' THEN
+    SELECT  COALESCE(jsonb_object_agg(replace(lower(regexp_replace(k, '([A-Z])', '_\1', 'g')), '_', '-'), jsonb_dasherize(v)), '{}')
+    INTO    ret
+    FROM    jsonb_each(j) AS t(k, v);
+    RETURN ret;
+  ELSIF t = 'array' THEN
+    SELECT  COALESCE(jsonb_agg(jsonb_dasherize(elem)), '[]')
+    INTO    ret
+    FROM    jsonb_array_elements(j) AS t(elem);
+    RETURN ret;
+  ELSIF t IS NULL THEN
+    -- This should never happen internally
+    -- (thankfully, lest jsonb_set return NULL and destroy everything),
+    -- but only from a passed-in NULL.
+    RETURN NULL;
+  ELSE
+    -- string/number/null:
+    RETURN j;
+  END IF;
+END;
+$$
+LANGUAGE plpgsql;

data/lib/generators/active_record/templates/migration.rb

@@ -0,0 +1,11 @@
+class AmsPgCreateDasherizeFunctions < ActiveRecord::Migration<%= migration_version %>
+
+  def up
+    execute %q{<%= jsonb_dasherize %>}
+  end
+
+  def down
+    execute "DROP FUNCTION jsonb_dasherize(jsonb)"
+  end
+
+end

data/spec/generators/main_generator_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+require 'generators/active_model_serializers_pg/active_model_serializers_pg_generator'
+
+describe ActiveModelSerializersPg::Generators::ActiveModelSerializersPgGenerator, type: :generator do
+  destination File.expand_path "../../../tmp", __FILE__
+
+  before :each do
+    prepare_destination
+  end
+
+  it "creates the migration file" do
+    run_generator
+    expect(destination_root).to have_structure {
+      directory "db" do
+        directory "migrate" do
+          migration "ams_pg_create_dasherize_functions" do
+            contains "class AmsPgCreateDasherizeFunctions"
+          end
+        end
+      end
+    }
+  end
+end

data/spec/serializer_spec.rb

@@ -209,6 +209,65 @@ describe 'ArraySerializer' do
     end
   end
 
+  context 'with dasherized json columns' do
+    let(:relation)   { Person.all }
+    let(:controller) { PeopleController.new }
+    let(:person)     {
+      Person.create first_name: 'Test',
+                    last_name: 'User',
+                    options:    { 'foo_foo': 'baz', barBar: [{ 'jar_jar': 'binks' }] },
+                    prefs:      { 'foo_foo': 'baz', barBar: [{ 'jar_jar': 'binks' }] },
+                    settings:   { 'foo_foo': 'bar' },
+                    selfies:    [ { 'photo_resolution': '200x200' } ],
+                    portraits:  [ { 'photo_resolution': '150x200' } ],
+                    landscapes: [ { 'photo_resolution': '200x150' } ]
+    }
+    let(:options)    { { each_serializer: PersonWithJsonSerializer } }
+
+    before do
+      @old_key_setting = ActiveModelSerializers.config.key_transform
+      ActiveModelSerializers.config.key_transform = :dash
+    end
+
+    after do
+      ActiveModelSerializers.config.key_transform = @old_key_setting
+    end
+
+    it 'generates the proper json output' do
+      json_expected = {
+        data: [
+          {
+            id: person.id.to_s,
+            type: 'people',
+            attributes: {
+              prefs: {
+                'bar-bar': [{ 'jar-jar' => 'binks'}],
+                'foo-foo' => 'baz',
+              },
+              options: {
+                'bar-bar': [{ 'jar-jar' => 'binks'}],
+                'foo-foo' => 'baz',
+              },
+              selfies: [
+                { 'photo-resolution' => '200x200' },
+              ],
+              settings: {
+                'foo-foo' => 'bar'
+              },
+              portraits: [
+                { 'photo-resolution' => '150x200' },
+              ],
+              landscapes: [
+                { 'photo-resolution' => '200x150' },
+              ],
+            },
+          }
+        ]
+      }.to_json
+      expect(json_data).to eq json_expected
+    end
+  end
+
   context 'with aliased association' do
     let(:relation)   { Tag.first }
     let(:controller) { TagsController.new }

data/spec/spec_helper.rb

@@ -1,11 +1,12 @@
-require 'active_record'
-require 'action_controller'
+require 'rails/all'
 require 'rspec'
+require 'rspec/rails'
 require 'bourne'
 require 'database_cleaner'
 require 'active_model_serializers'
 require 'action_controller/serialization'
 require 'active_model_serializers_pg'
+require 'generator_spec'
 if ENV['TEST_UNPATCHED_AMS']
   ActiveModelSerializers.config.adapter = :json_api
 else
@@ -24,6 +25,17 @@ end
 require 'dotenv'
 Dotenv.load
 
+# Need this or Rails.application is nil just below:
+module TestApp
+  class Application < ::Rails::Application
+    config.root = File.dirname(__FILE__)
+  end
+end
+
+# Need this line or `hook_for` in our generators is ignored,
+# so our migration generator doesn't run:
+Rails.application.load_generators
+
 ActiveRecord::Base.establish_connection(ENV['DATABASE_URL'])
 
 class TestController < ActionController::Base
@@ -56,6 +68,16 @@ class PersonSerializer < ActiveModel::Serializer
   end
 end
 
+class PersonWithJsonSerializer < ActiveModel::Serializer
+  attributes :id,
+    :options,     # json
+    :prefs,       # jsonb
+    :settings,    # hstore
+    :selfies,     # json[]
+    :portraits,   # jsonb[]
+    :landscapes   # hstore[]
+end
+
 class Note < ActiveRecord::Base
   has_many :tags
   has_many :sorted_tags

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_model_serializers_pg
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Paul A. Jungwirth
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-22 00:00:00.000000000 Z
+date: 2021-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: active_model_serializers
@@ -28,14 +28,14 @@ dependencies:
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
         version: '5.0'
 - !ruby/object:Gem::Dependency
@@ -94,6 +94,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  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: generator_spec
+  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: bourne
   requirement: !ruby/object:Gem::Requirement
@@ -168,10 +196,16 @@ files:
 - gemfiles/Gemfile.activerecord-5.0.x
 - gemfiles/Gemfile.activerecord-5.1.x
 - gemfiles/Gemfile.activerecord-5.2.x
+- gemfiles/Gemfile.activerecord-6.0.x
 - lib/active_model_serializers/adapter/json_api_pg.rb
 - lib/active_model_serializers_pg.rb
 - lib/active_model_serializers_pg/collection_serializer.rb
 - lib/active_model_serializers_pg/version.rb
+- lib/generators/active_model_serializers_pg/active_model_serializers_pg_generator.rb
+- lib/generators/active_record/active_model_serializers_pg_generator.rb
+- lib/generators/active_record/templates/jsonb_dasherize.sql
+- lib/generators/active_record/templates/migration.rb
+- spec/generators/main_generator_spec.rb
 - spec/serializer_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/pjungwir/active_model_serializers_pg
@@ -193,10 +227,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.1
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Harness the power of PostgreSQL when crafting JSON reponses
 test_files:
+- spec/generators/main_generator_spec.rb
 - spec/serializer_spec.rb
 - spec/spec_helper.rb