surus 0.3.2 → 0.4.0

data/lib/surus/json/model.rb

@@ -0,0 +1,17 @@
+module Surus
+  module JSON
+    module Model
+      def find_json(id, options={})
+        sql = RowQuery.new(where(id: id), options).to_sql
+        connection.select_value sql
+      end
+
+      def all_json(options={})
+        sql = ArrayAggQuery.new(scoped, options).to_sql
+        connection.select_value sql
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend Surus::JSON::Model

data/lib/surus/json/query.rb

@@ -0,0 +1,78 @@
+module Surus
+  module JSON
+    class Query
+      attr_reader :original_scope
+      attr_reader :options
+
+      def initialize(original_scope, options={})
+        @original_scope = original_scope
+        @options = options
+      end
+
+      private
+      def klass
+        original_scope.klass
+      end
+
+      def subquery_sql
+        select(columns.map(&:to_s).join(', ')).to_sql
+      end
+
+      def columns
+        selected_columns + association_columns
+      end
+
+      def table_columns
+        klass.columns
+      end
+
+      def selected_columns
+        if options.key? :columns
+          options[:columns]
+        else
+          table_columns.map(&:name)
+        end
+      end
+
+      def association_columns
+        included_associations_name_and_options.map do |association_name, association_options|
+          association = klass.reflect_on_association association_name
+          subquery = case association.source_macro
+          when :belongs_to
+            association_scope = BelongsToScopeBuilder.new(original_scope, association).scope
+            RowQuery.new(association_scope, association_options).to_sql
+          when :has_many
+            association_scope = HasManyScopeBuilder.new(original_scope, association).scope
+            ArrayAggQuery.new(association_scope, association_options).to_sql
+          when :has_and_belongs_to_many
+            association_scope = HasAndBelongsToManyScopeBuilder.new(original_scope, association).scope
+            ArrayAggQuery.new(association_scope, association_options).to_sql
+          end
+          "(#{subquery}) #{association_name}"
+        end
+      end
+
+      def included_associations_name_and_options
+        _include = options[:include]
+        if _include.nil?
+          {}
+        elsif _include.kind_of?(::Hash)
+          _include
+        elsif _include.kind_of?(::Array)
+          _include.each_with_object({}) do |e, hash|
+            if e.kind_of?(Hash)
+              hash.merge!(e)
+            else
+              hash[e] = {}
+            end
+          end
+        else
+          {_include => {}}
+        end
+      end
+
+      delegate :connection, :quoted_table_name, to: :klass
+      delegate :select, to: :original_scope
+    end
+  end
+end

data/lib/surus/json/row_query.rb

@@ -0,0 +1,9 @@
+module Surus
+  module JSON
+    class RowQuery < Query
+      def to_sql
+        "select row_to_json(t) from (#{subquery_sql}) t"
+      end
+    end
+  end
+end

data/lib/surus/version.rb

@@ -1,3 +1,3 @@
 module Surus
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/spec/array/decimal_serializer_spec.rb

@@ -7,17 +7,17 @@ describe Surus::Array::DecimalSerializer do
     [[BigDecimal("0.0")], "single element"],
     [[BigDecimal("1.0"), BigDecimal("2.0")], "multiple elements"],
     [[BigDecimal("-1.0"), BigDecimal("-2.0")], "negative element"],
-    [[BigDecimal("1232493289348929843.323422349274382923")], "high magnitude element"], 
+    [[BigDecimal("1232493289348929843.323422349274382923")], "high magnitude element"],
     [[BigDecimal("1.0"), BigDecimal("2.0"), BigDecimal("2.0")], "duplicated elements"],
     [[BigDecimal("1.0"), nil], "an element is nil"],
     [(10_000.times.map { |n| n * BigDecimal("1.13312") }).to_a, "huge array"]
   ]
-  
+
   round_trip_examples.each do |value, description|
     it "round trips when #{description}" do
       r = DecimalArrayRecord.create! :decimals => value
       r.reload
-      r.decimals.should == value
-    end    
+      expect(r.decimals).to eq(value)
+    end
   end
 end

data/spec/array/float_serializer_spec.rb

@@ -7,17 +7,17 @@ describe Surus::Array::FloatSerializer do
     [[0.0], "single element"],
     [[1.0, 2.0], "multiple elements"],
     [[-1.0, -2.0], "negative element"],
-    [[4.4325349e+45, 1.2324323e+77, 1.1242342e-57, 3e99], "high magnitude elements"], 
+    [[4.4325349e+45, 1.2324323e+77, 1.1242342e-57, 3e99], "high magnitude elements"],
     [[1.0, 2.0, 2.0, 2.0], "duplicated elements"],
     [[1.0, nil], "an element is nil"],
     [(10_000.times.map { |n| n * 1.0 }).to_a, "huge array"]
   ]
-  
+
   round_trip_examples.each do |value, description|
     it "round trips when #{description}" do
       r = FloatArrayRecord.create! :floats => value
       r.reload
-      r.floats.should == value
-    end    
+      expect(r.floats).to eq(value)
+    end
   end
 end

data/spec/array/integer_serializer_spec.rb

@@ -11,12 +11,12 @@ describe Surus::Array::IntegerSerializer do
     [[1, nil], "an element is nil"],
     [(1..10_000).to_a, "huge array"]
   ]
-  
+
   round_trip_examples.each do |value, description|
     it "round trips when #{description}" do
       r = IntegerArrayRecord.create! :integers => value
       r.reload
-      r.integers.should == value
-    end    
+      expect(r.integers).to eq(value)
+    end
   end
 end

data/spec/array/text_serializer_spec.rb

@@ -18,12 +18,12 @@ describe Surus::Array::TextSerializer do
     [[%q~foo \\ / " ; ' ( ) {}bar \\'~, "bar"], "an element many special characters"],
     [("aaa".."zzz").to_a, "huge array"]
   ]
-  
+
   round_trip_examples.each do |value, description|
     it "round trips when #{description}" do
       r = TextArrayRecord.create! :texts => value
       r.reload
-      r.texts.should == value
-    end    
+      expect(r.texts).to eq(value)
+    end
   end
 end

data/spec/database_structure.sql

@@ -36,9 +36,59 @@ CREATE TABLE float_array_records(
 
 
 
-DROP TABLE IF EXISTS float_array_records;
+DROP TABLE IF EXISTS decimal_array_records;
 
 CREATE TABLE decimal_array_records(
   id serial PRIMARY KEY,
   decimals decimal[]
+);
+
+
+
+DROP TABLE IF EXISTS users CASCADE;
+
+CREATE TABLE users(
+  id serial PRIMARY KEY,
+  name varchar NOT NULL,
+  email varchar NOT NULL
+);
+
+
+
+DROP TABLE IF EXISTS forums CASCADE;
+
+CREATE TABLE forums(
+  id serial PRIMARY KEY,
+  name varchar NOT NULL
+);
+
+
+
+DROP TABLE IF EXISTS posts CASCADE;
+
+CREATE TABLE posts(
+  id serial PRIMARY KEY,
+  forum_id integer NOT NULL REFERENCES forums,
+  author_id integer NOT NULL REFERENCES users,
+  subject varchar NOT NULL,
+  body varchar NOT NULL
+);
+
+
+
+DROP TABLE IF EXISTS tags CASCADE;
+
+CREATE TABLE tags(
+  id serial PRIMARY KEY,
+  name varchar NOT NULL UNIQUE
+);
+
+
+
+DROP TABLE IF EXISTS posts_tags CASCADE;
+
+CREATE TABLE posts_tags(
+  post_id integer NOT NULL REFERENCES posts,
+  tag_id integer NOT NULL REFERENCES tags,
+  PRIMARY KEY (post_id, tag_id)
 );

data/spec/factories.rb

@@ -0,0 +1,21 @@
+FactoryGirl.define do
+  factory :forum do
+    name { Faker::Lorem.sentence }
+  end
+
+  factory :post do
+    forum
+    author
+    subject { Faker::Lorem.sentence  }
+    body { Faker::Lorem.paragraph }
+  end
+
+  factory :tag do
+    sequence(:name) { |n| "#{Faker::Lorem.word} - #{n}" }
+  end
+
+  factory :user, aliases: [:author] do
+    name { Faker::Internet.user_name }
+    email { Faker::Internet.email }
+  end
+end

data/spec/hstore/serializer_spec.rb

@@ -8,7 +8,7 @@ describe Surus::Hstore::Serializer do
     [{"foo" => "bar", "baz" => "quz"}, "multiple key/value pairs"],
     [{"foo" => nil}, "value is nil"],
   ]
-  
+
   [
     ['"', 'double quote (")'],
     ["'", "single quote (')"],
@@ -22,13 +22,13 @@ describe Surus::Hstore::Serializer do
     round_trip_examples << [{"foo#{value}foo" => "bar"}, "key with #{description} in middle"]
     round_trip_examples << [{"foo#{value}" => "bar"}, "key with #{description} at end"]
     round_trip_examples << [{value => "bar"}, "key is #{description}"]
-    
+
     round_trip_examples << [{"foo" => "#{value}bar"}, "value with #{description} at beginning"]
     round_trip_examples << [{"foo" => "bar#{value}bar"}, "value with #{description} in middle"]
     round_trip_examples << [{"foo" => "bar#{value}"}, "value with #{description} at end"]
     round_trip_examples << [{"foo" => value}, "value is #{description}"]
   end
-  
+
   [
     [:foo, "symbol"],
     [0, "integer 0"],
@@ -55,12 +55,12 @@ describe Surus::Hstore::Serializer do
     round_trip_examples << [{value => "bar"}, "key is #{description}"]
     round_trip_examples << [{value => value}, "key and value are each #{description}"]
   end
-  
+
   round_trip_examples.each do |value, description|
     it "round trips when #{description}" do
       r = HstoreRecord.create! :properties => value
       r.reload
-      r.properties.should == value
-    end  
+      expect(r.properties).to eq(value)
+    end
   end
 end

data/spec/json/json_spec.rb

@@ -0,0 +1,153 @@
+require 'spec_helper'
+require 'oj'
+ActiveRecord::Base.include_root_in_json = false
+
+describe 'json' do
+  describe 'find_json' do
+    context 'with only id parameter' do
+      it 'is entire row as json' do
+        user = FactoryGirl.create :user
+        to_json = Oj.load user.to_json
+        find_json = Oj.load User.find_json(user.id)
+        expect(find_json).to eq(to_json)
+      end
+    end
+
+    context 'with columns parameter' do
+      it 'is selected row columns as json' do
+        user = FactoryGirl.create :user
+        to_json = Oj.load user.to_json only: [:id, :name]
+        find_json = Oj.load User.find_json(user.id, columns: [:id, :name])
+        expect(find_json).to eq(to_json)
+      end
+    end
+
+    context 'with includes option' do
+      it 'includes entire belongs_to object' do
+        post = FactoryGirl.create :post
+        to_json = Oj.load post.to_json(include: :author)
+        find_json = Oj.load Post.find_json(post.id, include: :author)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'filters by belongs_to conditions' do
+        post = FactoryGirl.create :post
+        find_json = Oj.load Post.find_json(post.id, include: :forum_with_impossible_conditions)
+        expect(find_json.fetch('forum_with_impossible_conditions')).to be_nil
+      end
+
+      it 'includes multiple entire belongs_to objects' do
+        post = FactoryGirl.create :post
+        to_json = Oj.load post.to_json(include: [:author, :forum])
+        find_json = Oj.load Post.find_json(post.id, include: [:author, :forum])
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes only selected columns of belongs_to object' do
+        post = FactoryGirl.create :post
+        to_json = Oj.load post.to_json(include: {author: {only: [:id, :name]}})
+        find_json = Oj.load Post.find_json(post.id, include: {author: {columns: [:id, :name]}})
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes entire has_many association' do
+        user = FactoryGirl.create :user
+        posts = FactoryGirl.create_list :post, 2, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: :posts)
+        find_json = Oj.load User.find_json(user.id, include: :posts)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'preserves has_many order' do
+        user = FactoryGirl.create :user
+        posts = FactoryGirl.create_list :post, 2, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: :posts_with_order)
+        find_json = Oj.load User.find_json(user.id, include: :posts_with_order)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'filters by has_many conditions' do
+        user = FactoryGirl.create :user
+        FactoryGirl.create :post, author: user, subject: 'foo'
+        FactoryGirl.create :post, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: :posts_with_conditions)
+        find_json = Oj.load User.find_json(user.id, include: :posts_with_conditions)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes only select columns of has_many association' do
+        user = FactoryGirl.create :user
+        posts = FactoryGirl.create_list :post, 2, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: {posts: {only: [:id, :subject]}})
+        find_json = Oj.load User.find_json(user.id, include: {posts: {columns: [:id, :subject]}})
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes empty array for empty has_many association' do
+        user = FactoryGirl.create :user
+        to_json = Oj.load user.to_json(include: :posts)
+        find_json = Oj.load User.find_json(user.id, include: :posts)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes entire has_and_belongs_to_many association' do
+        post = FactoryGirl.create :post
+        tag = FactoryGirl.create :tag
+        post.tags << tag
+        to_json = Oj.load post.to_json(include: :tags)
+        find_json = Oj.load Post.find_json(post.id, include: :tags)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'excludes other has_and_belongs_to_many association records' do
+        post = FactoryGirl.create :post
+        tag = FactoryGirl.create :tag
+        post.tags << tag
+        other_post = FactoryGirl.create :post
+        other_tag = FactoryGirl.create :tag
+        other_post.tags << other_tag
+        to_json = Oj.load post.to_json(include: :tags)
+        find_json = Oj.load Post.find_json(post.id, include: :tags)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes empty array for empty has_and_belongs_to_many' do
+        post = FactoryGirl.create :post
+        to_json = Oj.load post.to_json(include: :tags)
+        find_json = Oj.load Post.find_json(post.id, include: :tags)
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes nested associations' do
+        user = FactoryGirl.create :user
+        post = FactoryGirl.create :post, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: {posts: {include: :forum}})
+        find_json = Oj.load User.find_json(user.id, include: {posts: {include: :forum}})
+        expect(find_json).to eq(to_json)
+      end
+
+      it 'includes nested associations with columns' do
+        user = FactoryGirl.create :user
+        post = FactoryGirl.create :post, author: user
+        user.reload
+        to_json = Oj.load user.to_json(include: {posts: {only: [:id], include: :forum}})
+        find_json = Oj.load User.find_json(user.id, include: {posts: {columns: [:id], include: :forum}})
+        expect(find_json).to eq(to_json)
+      end
+    end
+  end
+
+  describe 'all_json' do
+    it 'is all rows as array' do
+      users = FactoryGirl.create_list :user, 3
+      to_json = Oj.load users.to_json
+      all_json = Oj.load User.all_json
+      expect(all_json).to eq(to_json)
+    end
+  end
+end