pg_serializable 0.1.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 618fc576fe1ec96d02b3b6745406aaa0921297a3
-  data.tar.gz: 10fcb8a2866501c48f4126cbbb907f76c64c3b26
+  metadata.gz: fc026e950ca7cd42a452b17f7ea42e69513298ff
+  data.tar.gz: de6db447af2b2ba0f845dffeb29efd02c130089a
 SHA512:
-  metadata.gz: c252b339e93bb7e0f544e3bdc80639086a6c2378df48a1d6c7fbf8646c45774048bd0aae5f6177f9485fd7235c7bdedb3ee9c6cd785903b1d044960188ade606
-  data.tar.gz: 0f4d3bd51fcb1255f54cd206477eba8eeeeaddc1bc33194fb5538406233a291d499990f5854f2833fa7599eeff5fe6e694c52c706701c6ec73f39d388bb433d2
+  metadata.gz: 11102ebb57aa4da829575d9b7bc70d94a9fcf670175aaaa9089868d3df011c11f23e63f5e4c12ef85276532e1b76f2aaec1a0f004ee0e3a3052cb140c9a700be
+  data.tar.gz: 0ea08435b36bda86588c0ed4c771e3e879c5d4ababd309b0c8f0969b6c269c25d2f001bdc16f33b80b40424376a33955d03438c13c57da98fda19a837a2837d8

data/Gemfile.lock

@@ -0,0 +1,58 @@
+PATH
+  remote: .
+  specs:
+    pg_serializable (1.0.0)
+      activerecord (~> 5.2)
+      activesupport (~> 5.2)
+      oj (~> 3.6)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activemodel (5.2.1)
+      activesupport (= 5.2.1)
+    activerecord (5.2.1)
+      activemodel (= 5.2.1)
+      activesupport (= 5.2.1)
+      arel (>= 9.0)
+    activesupport (5.2.1)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+    arel (9.0.0)
+    concurrent-ruby (1.0.5)
+    diff-lcs (1.3)
+    i18n (1.1.1)
+      concurrent-ruby (~> 1.0)
+    minitest (5.11.3)
+    oj (3.6.11)
+    rake (10.5.0)
+    rspec (3.8.0)
+      rspec-core (~> 3.8.0)
+      rspec-expectations (~> 3.8.0)
+      rspec-mocks (~> 3.8.0)
+    rspec-core (3.8.0)
+      rspec-support (~> 3.8.0)
+    rspec-expectations (3.8.2)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-mocks (3.8.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.8.0)
+    rspec-support (3.8.0)
+    thread_safe (0.3.6)
+    tzinfo (1.2.5)
+      thread_safe (~> 0.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.16)
+  pg_serializable!
+  rake (~> 10.0)
+  rspec (~> 3.0)
+
+BUNDLED WITH
+   1.16.5

data/README.md

@@ -4,6 +4,58 @@ This is experimental.
 
 Serialize json directly from postgres (9.4+).
 
+## Why?
+Models:
+```ruby
+class Product < ApplicationRecord
+  has_many :categories_products
+  has_many :categories, through: :categories_products
+  has_many :variations
+  belongs_to :label
+end
+class Variation < ApplicationRecord
+  belongs_to :product
+  belongs_to :color
+end
+class Color < ApplicationRecord
+  has_many :variations
+end
+class Label < ApplicationRecord
+  has_many :products
+end
+class Category < ApplicationRecord
+  has_many :categories_products
+  has_many :products, through: :categories_products
+end
+```
+
+Using Jbuilder+ActiveRecord:
+```ruby
+class Api::ProductsController < ApplicationController
+  def index
+    @products = Product.limit(200)
+                       .order(updated_at: :desc)
+                       .includes(:categories, :label, variations: :color)
+    render 'api/products/index.json.jbuilder'
+  end
+end
+```
+```shell
+Completed 200 OK in 2521ms (Views: 2431.8ms | ActiveRecord: 45.7ms)
+```
+
+Using PgSerializable:
+```ruby
+class Api::ProductsController < ApplicationController
+  def index
+    render json: Product.limit(200).order(updated_at: :desc).json
+  end
+end
+```
+```shell
+Completed 200 OK in 89ms (Views: 0.1ms | ActiveRecord: 78.9ms)
+```
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -30,8 +82,10 @@ class Product < ApplicationRecord
   include PgSerializable
 
   serializable do
-    attributes :name, :id
-    attribute :name, label: :test_name
+    default do
+      attributes :name, :id
+      attribute :name, label: :test_name
+    end
   end
 end
 ```
@@ -87,23 +141,68 @@ attribute :name, label: :different_name
 Wrap attributes in custom sql
 ```ruby
 serializable do
-  attributes :id
-  attribute :active, label: :deleted { |v| "NOT #{v}" }
+  default do
+    attributes :id
+    attribute :active, label: :deleted { |v| "NOT #{v}" }
+  end
 end
 ```
+```sql
+SELECT
+  COALESCE(json_agg(
+    json_build_object('id', a0.id, 'deleted', NOT a0.active)
+  ), '[]'::json)
+FROM (
+  SELECT "products".*
+  FROM "products"
+  ORDER BY "products"."updated_at" DESC
+  LIMIT 2
+) a0
+```
 ```json
 [
   {
     "id": 503,
-    "deleted": true
+    "deleted": false
   },
   {
     "id": 502,
-    "deleted": true
+    "deleted": false
   }
 ]
 ```
+### Traits
+
+```ruby
+serializable do
+  default do
+    attributes :id, :name
+  end
+
+  trait :simple do
+    attributes :id
+  end
+end
+```
 
+```ruby
+render json: Product.limit(10).json(trait: :simple)
+```
+
+```json
+[
+  { "id": 1 },
+  { "id": 2 },
+  { "id": 3 },
+  { "id": 4 },
+  { "id": 5 },
+  { "id": 6 },
+  { "id": 7 },
+  { "id": 8 },
+  { "id": 9 },
+  { "id": 10 }
+]
+```
 
 ### Associations
 Supported associations:
@@ -115,8 +214,10 @@ Supported associations:
 #### belongs_to
 ```ruby
 serializable do
-  attributes :id, :name
-  belongs_to: :label
+  default do
+    attributes :id, :name
+    belongs_to: :label
+  end
 end
 ```
 ```json
@@ -143,21 +244,27 @@ Works for nested relationships
 ```ruby
 class Product < ApplicationRecord
   serializable do
-    attributes :id, :name
-    has_many: :variations
+    default do
+      attributes :id, :name
+      has_many: :variations
+    end
   end
 end
 
 class Variation < ApplicationRecord
   serializable do
-    attributes :id, :hex
-    belongs_to: :color
+    default do
+      attributes :id, :name
+      belongs_to: :color
+    end
   end
 end
 
 class Color < ApplicationRecord
   serializable do
-    attributes :id, :hex
+    default do
+      attributes :id, :hex
+    end
   end
 end
 ```
@@ -215,14 +322,18 @@ class Product < ApplicationRecord
   has_many :categories, through: :categories_products
 
   serializable do
-    attributes :id
-    has_many :categories
+    default do
+      attributes :id
+      has_many :categories
+    end
   end
 end
 
 class Category < ApplicationRecord
   serializable do
-    attributes :name, :id
+    default do
+      attributes :name, :id
+    end
   end
 end
 ```
@@ -260,6 +371,106 @@ end
 #### has_one
 TODO: write examples
 
+### Association Traits
+Models:
+```ruby
+class Product < ApplicationRecord
+  has_many :variations
+
+  serializable do
+    default do
+      attributes :id, :name
+    end
+
+    trait :with_variations do
+      attributes :id
+      has_many :variations, trait: :for_products
+    end
+  end
+end
+
+class Variation < ApplicationRecord
+  serializable do
+    default do
+      attributes :id
+      belongs_to: :color
+    end
+
+    trait :for_products do
+      attributes :id
+    end
+  end
+end
+```
+
+Controller:
+```ruby
+render json: Product.limit(3).json(trait: :with_variations)
+```
+
+```json
+[
+   {
+      "id":1,
+      "variations":[
+
+      ]
+   },
+   {
+      "id":2,
+      "variations":[
+         {
+            "id":5
+         },
+         {
+            "id":4
+         },
+         {
+            "id":3
+         },
+         {
+            "id":2
+         },
+         {
+            "id":1
+         }
+      ]
+   },
+   {
+      "id":3,
+      "variations":[
+         {
+            "id":14
+         },
+         {
+            "id":13
+         },
+         {
+            "id":12
+         },
+         {
+            "id":11
+         },
+         {
+            "id":10
+         },
+         {
+            "id":9
+         },
+         {
+            "id":8
+         },
+         {
+            "id":7
+         },
+         {
+            "id":6
+         }
+      ]
+   }
+]
+```
+
 ## Development
 
 TODO

data/lib/pg_serializable.rb

@@ -1,47 +1,58 @@
+require 'oj'
 require 'active_support/concern'
-
-require 'pg_serializable/version'
 require 'pg_serializable/errors'
-require 'pg_serializable/aliaser'
+require 'pg_serializable/visitable'
 require 'pg_serializable/nodes'
-require 'pg_serializable/serializer'
+require 'pg_serializable/trait_manager'
+require 'pg_serializable/trait'
+require 'pg_serializable/visitors'
+
+module ActiveRecord
+  class Relation
+    include PgSerializable::Visitable
+
+    def json(trait: :default)
+      to_pg_json accept(PgSerializable::Visitors::Json.new, trait: trait)
+    end
+  end
+end
 
 module PgSerializable
   extend ActiveSupport::Concern
+
   included do
-    def json
-      ActiveRecord::Base.connection.select_one(
-        self.class.where(id: id).limit(1).as_json_object.to_sql
-      )['json_build_object']
+    include Visitable
+
+    def json(trait: :default)
+      self.class.to_pg_json accept(PgSerializable::Visitors::Json.new, trait: trait)
     end
   end
 
   class_methods do
-    def json
-      ActiveRecord::Base.connection.select_one(
-        serializer.as_json_array(pg_scope, Aliaser.new).to_sql
-      )['coalesce']
+    def json(trait: :default)
+      to_pg_json accept(PgSerializable::Visitors::Json.new, trait: trait)
     end
 
-    def as_json_array(table_alias = Aliaser.new)
-      serializer.as_json_array(pg_scope, table_alias)
+    def serializable(&blk)
+      trait_manager.instance_eval &blk
+      validate_traits!
     end
 
-    def as_json_object(table_alias = Aliaser.new)
-      serializer.as_json_object(pg_scope, table_alias)
+    def trait_manager
+      @trait_manager ||= TraitManager.new(self)
     end
 
-    def serializable(&blk)
-      serializer.instance_eval &blk
-      serializer.check_for_cycles!
+    def accept visitor, **kwargs
+      visitor.visit self, **kwargs
     end
 
-    def serializer
-      @serializer ||= Serializer.new(self)
+    def to_pg_json(scope)
+      res = scope.as_json.first
+      ::Oj.dump(res['coalesce'] || res['json_build_object'])
     end
 
-    def pg_scope
-      respond_to?(:to_sql) ? self : all
-    end
+    private
+
+    delegate :validate_traits!, to: :trait_manager
   end
 end

data/lib/pg_serializable/errors.rb

@@ -1,6 +1,5 @@
 module PgSerializable
-  class Serializer
-    class AttributeError < ::StandardError;end
-    class AssociationError < ::StandardError;end
-  end
+  class AttributeError < ::StandardError;end
+  class AssociationError < ::StandardError;end
+  class UnknownAttributeError < ::StandardError;end
 end

data/lib/pg_serializable/nodes.rb

@@ -6,3 +6,8 @@ require 'pg_serializable/nodes/coalesce'
 require 'pg_serializable/nodes/json_agg'
 require 'pg_serializable/nodes/json_array'
 require 'pg_serializable/nodes/json_build_object'
+
+module PgSerializable
+  module Nodes
+  end
+end

data/lib/pg_serializable/nodes/association.rb

@@ -1,13 +1,14 @@
 module PgSerializable
   module Nodes
     class Association < Base
-      attr_reader :klass, :name
+      attr_reader :klass, :name, :trait, :type, :label
 
-      def initialize(klass, name, type, label: nil)
+      def initialize(klass, name, type, label: nil, trait: :default)
         @name = name
         @klass = klass
         @type = type
         @label = label || name
+        @trait = trait
       end
 
       def to_sql(outer_alias, aliaser)
@@ -18,43 +19,6 @@ module PgSerializable
         @target ||= association.klass
       end
 
-      private
-
-      def value(outer_alias, aliaser)
-        next_alias = aliaser.next!
-        self.send(@type, outer_alias, next_alias, aliaser)
-      end
-
-      def has_many(outer_alias, next_alias, aliaser)
-        return has_many_through(outer_alias, next_alias, aliaser) if association.through_reflection?
-        target.as_json_array(aliaser).where("#{next_alias}.#{primary_key}=#{outer_alias}.#{foreign_key}").to_sql
-      end
-
-      def has_many_through(outer_alias, next_alias, aliaser)
-        through = association.through_reflection
-        source = association.source_reflection
-        # NOTE: this will fail if the source table shares the same foreign key as your join table
-        #       i.e. products and categories have a join table but categories has a product_id column
-        association
-          .klass
-          .select("#{source.table_name}.*, #{through.table_name}.#{source.join_foreign_key}, #{through.table_name}.#{through.join_primary_key}")
-          .joins(through.name)
-          .as_json_array(aliaser)
-          .where("#{next_alias}.#{through.join_primary_key}=#{outer_alias}.#{foreign_key}")
-          .to_sql
-      end
-
-      def has_one(outer_alias, next_alias, aliaser)
-        subquery_alias = "#{next_alias[0]}#{next_alias[1]}#{next_alias[0]}" # avoid alias collision
-        target.select("DISTINCT ON (#{primary_key}) #{subquery_alias}.*").from(
-          "#{target.table_name} #{subquery_alias}"
-        ).as_json_object(aliaser).where("#{next_alias}.#{primary_key}=#{outer_alias}.#{foreign_key}").to_sql
-      end
-
-      def belongs_to(outer_alias, next_alias, aliaser)
-        target.as_json_object(aliaser).where("#{next_alias}.#{primary_key}=#{outer_alias}.#{foreign_key}").to_sql
-      end
-
       def association
         @association ||= @klass.reflect_on_association(@name)
       end

data/lib/pg_serializable/nodes/attribute.rb

@@ -1,25 +1,14 @@
 module PgSerializable
   module Nodes
     class Attribute < Base
-      def initialize(column_name, label: nil, &prc)
+      attr_reader :column_name, :klass, :label, :prc
+
+      def initialize(klass, column_name, label: nil, &prc)
+        @klass = klass
         @column_name = column_name
         @label = label || column_name
         @prc = prc if block_given?
       end
-
-      def to_sql(table_alias=nil)
-        [key, value(table_alias)].join(',')
-      end
-
-      private
-      def key
-        "\'#{@label}\'"
-      end
-
-      def value(tbl)
-        val = "#{tbl && "#{tbl}."}#{@column_name}"
-        @prc ? @prc.call(val) : val
-      end
     end
   end
 end

data/lib/pg_serializable/trait.rb

@@ -0,0 +1,32 @@
+module PgSerializable
+  class Trait
+    attr_reader :klass, :attribute_nodes
+
+    def initialize(klass)
+      @klass = klass
+      @attribute_nodes = []
+    end
+
+    def attributes(*attrs)
+      attrs.each do |attribute|
+        @attribute_nodes << Nodes::Attribute.new(klass, attribute)
+      end
+    end
+
+    def attribute(column_name, label: nil, &blk)
+      @attribute_nodes << Nodes::Attribute.new(klass, column_name, label: label, &blk)
+    end
+
+    def has_many(association, label: nil, trait: :default)
+      @attribute_nodes << Nodes::Association.new(klass, association, :has_many, label: label, trait: trait)
+    end
+
+    def belongs_to(association, label: nil, trait: :default)
+      @attribute_nodes << Nodes::Association.new(klass, association, :belongs_to, label: label, trait: trait)
+    end
+
+    def has_one(association, label: nil, trait: :default)
+      @attribute_nodes << Nodes::Association.new(klass, association, :has_one, label: label, trait: trait)
+    end
+  end
+end

data/lib/pg_serializable/trait_manager.rb

@@ -0,0 +1,32 @@
+module PgSerializable
+  class TraitManager
+    include PgSerializable::Visitable
+
+    attr_reader :klass, :traits
+
+    def initialize(klass)
+      @klass = klass
+      @traits = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def default(&blk)
+      default_trait = PgSerializable::Trait.new(klass)
+      default_trait.instance_eval &blk
+      @traits[:default] = default_trait
+    end
+
+    def trait(trait_name, &blk)
+      trait_instance = PgSerializable::Trait.new(klass)
+      trait_instance.instance_eval &blk
+      @traits[trait_name] = trait_instance
+    end
+
+    def get_trait(trait)
+      @traits[trait]
+    end
+
+    def validate_traits!
+      accept(PgSerializable::Visitors::Validation.new)
+    end
+  end
+end

data/lib/pg_serializable/version.rb

@@ -1,3 +1,3 @@
 module PgSerializable
-  VERSION = "0.1.1"
+  VERSION = "1.0.0"
 end

data/lib/pg_serializable/visitable.rb

@@ -0,0 +1,7 @@
+module PgSerializable
+  module Visitable
+    def accept visitor, **kwargs
+      visitor.visit self, **kwargs
+    end
+  end
+end

data/lib/pg_serializable/visitors.rb

@@ -0,0 +1,8 @@
+require 'pg_serializable/visitors/base'
+require 'pg_serializable/visitors/validation'
+require 'pg_serializable/visitors/json'
+
+module PgSerializable
+  module Visitors
+  end
+end

data/lib/pg_serializable/visitors/base.rb

@@ -0,0 +1,89 @@
+module PgSerializable
+  module Visitors
+    class Base
+      def visit(subject, **kwargs)
+        send(visit_method_for(subject), subject, **kwargs)
+      end
+
+      def visit_method_for(subject)
+        case subject
+        when record? then :visit_record
+        when class? then :visit_class
+        when relation? then :visit_relation
+        when trait_manager? then :visit_trait_manager
+        when trait? then :visit_trait
+        when node? then :visit_node
+        else :visit_other
+        end
+      end
+
+      # activerecord
+
+      def visit_record(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      def visit_class(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      def visit_scope(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      # pg_serializable
+
+      def visit_trait_manager(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      def visit_trait(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      def visit_node(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      # everything else
+
+      def visit_other(subject, **kwargs)
+        raise NotImplementedError.new
+      end
+
+      private
+
+      def record?
+        ->(x) { x.is_a? ApplicationRecord }
+      end
+
+      def class?
+        ->(x) { x.is_a? Class }
+      end
+
+      def relation?
+        ->(x) { x.is_a? ActiveRecord::Relation }
+      end
+
+      def trait_manager?
+        ->(x) { x.is_a? PgSerializable::TraitManager }
+      end
+
+      def trait?
+        ->(x) { x.is_a? PgSerializable::Trait }
+      end
+
+      def node?
+        ->(x) { x.is_a? PgSerializable::Nodes::Base }
+      end
+
+      def attribute?
+        ->(x) { x.is_a? PgSerializable::Nodes::Attribute }
+      end
+
+      def association?
+        ->(x) { x.is_a? PgSerializable::Nodes::Association }
+      end
+    end
+  end
+end

data/lib/pg_serializable/visitors/json.rb

@@ -0,0 +1,137 @@
+module PgSerializable
+  module Visitors
+    class Json < Base
+      def visit_record(subject, trait: :default)
+        table_alias = next_alias!
+
+        klass = subject.class
+        select_sql = json_build_object(visit(klass.trait_manager, trait: trait, table_alias: table_alias)).to_sql
+        from_sql = klass.where(id: subject.id).limit(1).to_sql
+
+        klass.select(select_sql).from("#{as(from_sql, table_alias)}")
+      end
+
+      def visit_relation(subject, table_alias: nil, trait: :default)
+        table_alias ||= next_alias!
+
+        klass = subject.klass
+        select_sql = coalesce(json_agg(json_build_object(visit(klass.trait_manager, trait: trait, table_alias: table_alias)))).to_sql
+        from_sql = subject.to_sql
+
+        klass.select(select_sql).from("#{as(from_sql, table_alias)}")
+      end
+
+      def visit_class(subject, trait: :default, **kwargs)
+        visit(subject.all, trait: trait, **kwargs)
+      end
+
+      def visit_trait_manager(subject, trait: :default, **kwargs)
+        visit subject.get_trait(trait), **kwargs
+      end
+
+      def visit_trait(subject, **kwargs)
+        subject.attribute_nodes.map { |attribute| visit attribute, **kwargs }.join(', ')
+      end
+
+      def visit_node(subject, **kwargs)
+        case subject
+        when attribute? then visit_attribute subject, **kwargs
+        when association? then visit_association subject, **kwargs
+        else raise UnknownAttributeError.new
+        end
+      end
+
+      def visit_attribute(subject, table_alias: nil)
+        table_alias ||= alias_tracker
+        key = "\'#{subject.label}\'"
+        val = "\"#{table_alias}\".\"#{subject.prc ? subject.prc.call(column_name) : subject.column_name}\""
+        "#{key}, #{val}"
+      end
+
+      def visit_association(subject, **kwargs)
+        send("visit_#{subject.type}", subject, **kwargs)
+      end
+
+      def visit_belongs_to(subject, table_alias:, **kwargs)
+        current_alias = next_alias!
+        klass = subject.target
+        select_sql = json_build_object(visit(klass.trait_manager, trait: subject.trait, table_alias: current_alias)).to_sql
+        query = klass.select(select_sql).from("#{klass.table_name} #{current_alias}")
+                .where("#{current_alias}.#{subject.primary_key}=#{table_alias}.#{subject.foreign_key}").to_sql
+        "\'#{subject.label}\', (#{query})"
+      end
+
+      def visit_has_many(subject, table_alias:, **kwargs)
+        return visit_has_many_through(subject, table_alias: table_alias, **kwargs) if subject.association.through_reflection?
+
+        current_alias = next_alias!
+        klass = subject.target
+        select_sql = coalesce(json_agg(json_build_object(visit(klass.trait_manager, trait: subject.trait, table_alias: current_alias)))).to_sql
+
+        query = klass.select(select_sql).from("#{klass.table_name} #{current_alias}")
+                .where("#{current_alias}.#{subject.primary_key}=#{table_alias}.#{subject.foreign_key}").to_sql
+
+        "\'#{subject.label}\', (#{query})"
+      end
+
+      def visit_has_many_through(subject, table_alias:, **kwargs)
+        current_alias = next_alias!
+
+        association = subject.association
+        through = association.through_reflection
+        source = association.source_reflection
+
+        query = visit(association
+          .klass
+          .select("#{source.table_name}.*, #{through.table_name}.#{source.join_foreign_key}, #{through.table_name}.#{through.join_primary_key}")
+          .joins(through.name), table_alias: current_alias)
+          .where("#{current_alias}.#{through.join_primary_key}=#{table_alias}.#{subject.foreign_key}")
+          .to_sql
+
+        "\'#{subject.label}\', (#{query})"
+      end
+
+      def visit_has_one(subject, table_alias:, **kwargs)
+        current_alias = next_alias!
+        subquery_alias = next_alias!
+        klass = subject.target
+
+        select_sql = json_build_object(visit(klass.trait_manager, trait: subject.trait, table_alias: current_alias)).to_sql
+        from_sql = klass
+          .select("DISTINCT ON (#{subject.primary_key}) #{subquery_alias}.*")
+          .from("#{klass.table_name} #{subquery_alias}")
+
+        query = klass.select(select_sql).from("#{as(from_sql, current_alias)}")
+          .where("#{current_alias}.#{subject.primary_key}=#{table_alias}.#{subject.foreign_key}").to_sql
+
+        "\'#{subject.label}\', (#{query})"
+      end
+
+      private
+
+      def alias_tracker
+        @alias ||= 'a0'
+      end
+
+      def next_alias!
+        alias_tracker.next!.dup
+      end
+
+      def as(sql, table_alias)
+        PgSerializable::Nodes::As.new(sql, table_alias)
+      end
+
+      def json_build_object(sql)
+        PgSerializable::Nodes::JsonBuildObject.new(sql)
+      end
+
+      def json_agg(sql)
+        PgSerializable::Nodes::JsonAgg.new(sql)
+      end
+
+      def coalesce(sql)
+        PgSerializable::Nodes::Coalesce.new(sql, PgSerializable::Nodes::JsonArray.new)
+      end
+    end
+  end
+end

data/lib/pg_serializable/visitors/validation.rb

@@ -0,0 +1,68 @@
+module PgSerializable
+  module Visitors
+    class Validation < Base
+      def visit_class(subject, **kwargs)
+        visit subject.trait_manager
+      end
+
+      def visit_trait_manager(subject, **kwargs)
+        subject.traits.each do |_, value|
+          visit value
+        end
+      end
+
+      def visit_trait(subject, **kwargs)
+        subject.attribute_nodes.each { |attribute_node| visit attribute_node }
+        ensure_no_cycles!(subject)
+      end
+
+      def visit_node(subject, **kwargs)
+        if subject.is_a? PgSerializable::Nodes::Attribute
+          visit_attribute_node(subject, **kwargs)
+        elsif subject.is_a? PgSerializable::Nodes::Association
+          visit_association_node(subject, **kwargs)
+        else
+          raise UnknownAttributeError.new('validation visitor called with unknow node type')
+        end
+      end
+
+      def visit_attribute_node(subject, **kwargs)
+        klass = subject.klass
+        column_name = subject.column_name
+        unless klass.column_names.include? column_name.to_s
+          raise PgSerializable::AttributeError.new("column `#{column_name}` doesn't exist for class #{klass}")
+        end
+      end
+
+      def visit_association_node(subject, **kwargs)
+        klass = subject.klass
+        name = subject.name
+        if klass.reflect_on_association(name).nil?
+          raise PgSerializable::AssociationError.new("association `#{name.to_s}` doesn't exist for class #{klass}")
+        end
+        if subject.target.trait_manager.get_trait(subject.trait).nil?
+          raise PgSerializable::AssociationError.new("trait `#{subect.trait}` doesn't exist for class #{subject.target}")
+        end
+      end
+
+      private
+
+      def ensure_no_cycles!(trait)
+        @root_klass = trait.klass
+        check_for_cycles(trait)
+      end
+
+      def check_for_cycles(subject)
+        case subject
+        when trait? then subject.attribute_nodes.each { |node| check_for_cycles(node) }
+        when association?
+          if subject.target == @root_klass
+            raise PgSerializable::AssociationError.new("class #{@root_klass} contains a cycle in nested association #{subject.klass}")
+          end
+          associated_trait = subject.target.trait_manager.get_trait subject.trait
+          check_for_cycles(associated_trait)
+        end
+      end
+    end
+  end
+end

data/pg_serializable.gemspec

@@ -38,4 +38,5 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "activesupport", "~> 5.2"
   spec.add_runtime_dependency "activerecord", "~> 5.2"
+  spec.add_runtime_dependency "oj", "~> 3.6"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: pg_serializable
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 1.0.0
 platform: ruby
 authors:
 - matthewjf
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-10-03 00:00:00.000000000 Z
+date: 2018-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
 description: serializes rails models from postgres (9.5+)
 email:
 - matthewjf@gmail.com
@@ -92,13 +106,13 @@ files:
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
+- Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
 - bin/console
 - bin/setup
 - lib/pg_serializable.rb
-- lib/pg_serializable/aliaser.rb
 - lib/pg_serializable/errors.rb
 - lib/pg_serializable/nodes.rb
 - lib/pg_serializable/nodes/as.rb
@@ -109,8 +123,14 @@ files:
 - lib/pg_serializable/nodes/json_agg.rb
 - lib/pg_serializable/nodes/json_array.rb
 - lib/pg_serializable/nodes/json_build_object.rb
-- lib/pg_serializable/serializer.rb
+- lib/pg_serializable/trait.rb
+- lib/pg_serializable/trait_manager.rb
 - lib/pg_serializable/version.rb
+- lib/pg_serializable/visitable.rb
+- lib/pg_serializable/visitors.rb
+- lib/pg_serializable/visitors/base.rb
+- lib/pg_serializable/visitors/json.rb
+- lib/pg_serializable/visitors/validation.rb
 - pg_serializable.gemspec
 homepage: https://github.com/matthewjf/pg_serializable
 licenses:

data/lib/pg_serializable/aliaser.rb

@@ -1,15 +0,0 @@
-module PgSerializable
-  class Aliaser
-    def initialize(current=nil)
-      @current = current || 'a0'
-    end
-
-    def next!
-      @current = @current.next
-    end
-
-    def to_s
-      @current
-    end
-  end
-end

data/lib/pg_serializable/serializer.rb

@@ -1,102 +0,0 @@
-module PgSerializable
-  class Serializer
-    attr_reader :klass
-
-    def initialize(klass)
-      @klass = klass
-      @attributes = []
-    end
-
-    def attributes(*attrs)
-      attrs.each do |attribute|
-        @attributes << Nodes::Attribute.new(attribute) if column_exists?(attribute)
-      end
-    end
-
-    def attribute(column_name, label: nil, &blk)
-      @attributes << Nodes::Attribute.new(column_name, label: label, &blk) if column_exists?(column_name)
-    end
-
-    def has_many(association, label: nil)
-      @attributes << Nodes::Association.new(klass, association, :has_many, label: label) if association_exists?(association)
-    end
-
-    def belongs_to(association, label: nil)
-      @attributes << Nodes::Association.new(klass, association, :belongs_to, label: label) if association_exists?(association)
-    end
-
-    def has_one(association, label: nil)
-      @attributes << Nodes::Association.new(klass, association, :has_one, label: label) if association_exists?(association)
-    end
-
-    def as_json_array(skope, aliaser)
-      @aliaser = aliaser
-      @table_alias = @aliaser.to_s
-      query(json_agg.to_sql, skope)
-    end
-
-    def as_json_object(skope, aliaser)
-      @aliaser = aliaser
-      @table_alias = @aliaser.to_s
-      query(json_build_object.to_sql, skope)
-    end
-
-    def check_for_cycles!(klass=self.klass)
-      @attributes.each do |attribute|
-        next unless attribute.is_a?(Nodes::Association)
-        target_klass = attribute.target
-        raise AssociationError.new("serializers contain a cycle, check class `#{attribute.klass}` for association `:#{attribute.name}`") if target_klass == klass
-        target_klass.serializer.check_for_cycles!(self.klass)
-      end
-    end
-
-    private
-
-    def query(select_sql, from_scope)
-      klass
-        .unscoped
-        .select(select_sql)
-        .from(Nodes::As.new(from_scope, @table_alias).to_sql)
-    end
-
-    def build_attributes
-      res = []
-      @attributes.each do |attribute|
-        if attribute.is_a?(Nodes::Attribute)
-          res << attribute.to_sql(@table_alias)
-        elsif attribute.is_a?(Nodes::Association)
-          res << attribute.to_sql(@table_alias, @aliaser)
-        else
-          raise 'unknown attribute type'
-        end
-      end
-      res.join(',')
-    end
-
-    def json_build_object
-      Nodes::JsonBuildObject.new(build_attributes)
-    end
-
-    def json_agg
-      Nodes::Coalesce.new(Nodes::JsonAgg.new(json_build_object), Nodes::JsonArray.new)
-    end
-
-    def table_alias
-      @table_alias
-    end
-
-    def association(name)
-      klass.reflect_on_association(name)
-    end
-
-    def column_exists?(column_name)
-      raise AttributeError.new("`#{column_name.to_s}` column doesn't exist for table #{klass.table_name}") unless klass.column_names.include? column_name.to_s
-      true
-    end
-
-    def association_exists?(name)
-      raise AssociationError.new("`#{name.to_s}` association doesn't exist for table #{klass.table_name}") if klass.reflect_on_association(name).nil?
-      true
-    end
-  end
-end