datasource 0.0.1 → 0.0.2

data/lib/datasource/serializer.rb

@@ -0,0 +1,117 @@
+module Datasource
+  class Serializer
+    TemplatePart = Struct.new(:parent, :type, :value, :select) do
+      def initialize(parent, type = nil, value = nil)
+        super(parent, type, get_default_value(type, value), [])
+      end
+
+      def set_default_value(value = nil)
+        self.value = get_default_value(type, value)
+      end
+    private
+      def get_default_value(type, value)
+        case type
+        when :hash then {}
+        when :array then []
+        when :datasource then value
+        when nil then nil
+        else
+          fail "Unknown type #{type}"
+        end
+      end
+    end
+
+    class << self
+      attr_accessor :datasource_count, :template
+
+      def inherited(base)
+        base.datasource_count = 0
+        @cursor = base.template = nil
+      end
+
+      def with_new_cursor(type, value = nil, &block)
+        result = nil
+        new_cursor = TemplatePart.new(@cursor, type, value)
+        @cursor = @cursor.tap do
+          if template.nil?
+            self.template = @cursor = new_cursor
+          elsif @cursor.type == :datasource
+            @cursor = @cursor.parent
+            return with_new_cursor(type, value, &block)
+          elsif @cursor.type == :array
+            @cursor = new_cursor
+            @cursor.parent.push(@cursor)
+          elsif @cursor.type.nil?
+            # replace cursor
+            @cursor.type = type
+            @cursor.set_default_value(value)
+          else
+            fail "Invalid use of #{type}."
+          end
+          result = block.call
+        end
+        result
+      end
+
+      def hash(&block)
+        with_new_cursor(:hash, &block)
+      end
+
+      def key(name)
+        fail "Cannot use key outside hash." unless template && @cursor.type == :hash
+        @cursor = @cursor.tap do
+          @cursor = @cursor.value[name.to_s] = TemplatePart.new(@cursor)
+          yield
+        end
+      end
+
+      def array(&block)
+        with_new_cursor(:array, &block)
+      end
+
+      def datasource(ds)
+        self.datasource_count += 1
+        @cursor = with_new_cursor(:datasource, ds) { @cursor }
+      end
+
+      def attributes(*attributes)
+        attributes.each { |name| attribute name }
+      end
+
+      def attribute(name)
+        fail "No datasource selected - use \"select_datasource Klass\" first." unless template && @cursor.type == :datasource
+        @cursor.select << name
+      end
+    end
+
+    def initialize(*scopes)
+      @scopes = scopes
+      if @scopes.size != self.class.datasource_count
+        fail ArgumentError, "#{self.class.name} needs #{self.class.datasource_count} scopes, you provided #{@scopes.size}"
+      end
+    end
+
+    def as_json
+      parse_template_part(self.class.template)
+    end
+
+  private
+    def parse_template_part(part)
+      return nil unless part
+      case part.type
+      when :hash
+        {}.tap do |result|
+          part.value.each_pair do |k, v|
+            result[k] = parse_template_part(v)
+          end
+        end
+      when :array
+        part.value.map { |v| parse_template_part(v) }
+      when :datasource
+        part.value.new(@scopes.shift).select(*part.select).results
+      else
+        fail "Unknown type #{type}"
+      end
+    end
+  end
+end

data/lib/datasource.rb

@@ -1,8 +1,26 @@
+module Datasource
+  Error = Class.new(StandardError)
+  RecursionError = Class.new(StandardError)
+
+  def self.load(adapter = nil)
+    unless adapter
+      adapter = if defined? ActiveRecord
+        :activerecord
+      elsif defined? Sequel
+        :sequel
+      end
+    end
+
+    require 'datasource/adapters/active_record' if [:activerecord, :active_record].include?(adapter)
+    require 'datasource/adapters/sequel' if adapter == :sequel
+    require 'datasource/consumer_adapters/active_model_serializers' if defined? ActiveModel::Serializer
+  end
+end
+
 require 'datasource/base'
 
 require 'datasource/attributes/computed_attribute'
 require 'datasource/attributes/query_attribute'
+require 'datasource/attributes/loader'
 
-require 'datasource/adapters/active_record'
-
-require 'datasource/serializer/composite'
+require 'datasource/serializer'

data/lib/generators/datasource/install_generator.rb

@@ -0,0 +1,8 @@
+class Datasource::InstallGenerator < ::Rails::Generators::Base
+  source_root File.expand_path("../templates", __FILE__)
+  desc 'Creates a Datasource Rails initializer'
+
+  def create_serializer_file
+    template 'initializer.rb', 'config/initializers/datasource.rb'
+  end
+end

data/lib/generators/datasource/templates/initializer.rb

@@ -0,0 +1,11 @@
+Datasource.load(:activerecord)
+
+if defined? ActiveModel::Serializer
+  if ActiveModel::Serializer.respond_to?(:config)
+    ActiveModel::Serializer.config.array_serializer = Datasource::ArrayAMS
+  else
+    ActiveModel::Serializer.setup do |config|
+      config.array_serializer = Datasource::ArrayAMS
+    end
+  end
+end

data/test/active_record_helper.rb

@@ -8,3 +8,16 @@ def clean_db
   ActiveRecord::Base.connection.execute("DELETE FROM blogs")
   ActiveRecord::Base.connection.execute("DELETE FROM sqlite_sequence")
 end
+
+def assert_query_count(count)
+  old_logger = ActiveRecord::Base.logger
+  logger = StringIO.new
+  ActiveRecord::Base.logger = Logger.new(logger)
+  begin
+    yield
+  ensure
+    ActiveRecord::Base.logger = old_logger
+    # puts logger.string
+  end
+  assert_equal count, logger.string.lines.count
+end

data/test/schema.rb

@@ -16,18 +16,4 @@ ActiveRecord::Schema.define(:version => 0) do
   end
 end
 
-class Blog < ActiveRecord::Base
-  self.table_name = "blogs"
-  has_many :posts
-end
-
-class Post < ActiveRecord::Base
-  self.table_name = "posts"
-  belongs_to :blog
-  has_many :comments
-end
-
-class Comment < ActiveRecord::Base
-  self.table_name = "comments"
-  belongs_to :post
-end
+ActiveRecord::Base.send :include, Datasource::Adapters::ActiveRecord::Model

data/test/test_helper.rb

@@ -5,8 +5,10 @@ require 'minitest/autorun'
 require 'active_support/all'
 require 'active_record'
 require 'datasource'
+require 'active_model_serializers'
+require 'pry'
+
+Datasource.load(:activerecord)
 
 # Load support files
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# ActiveRecord::Base.logger = Logger.new STDOUT

data/test/test_loader.rb

@@ -0,0 +1,79 @@
+require 'test_helper'
+require 'active_record_helper'
+
+class LoaderTest < ActiveSupport::TestCase
+  class Comment < ActiveRecord::Base
+    self.table_name = "comments"
+    belongs_to :post
+  end
+
+  class Post < ActiveRecord::Base
+    self.table_name = "posts"
+    has_many :comments
+
+    datasource_module do
+      loader :newest_comment, group_by: :post_id, one: true do |post_ids|
+        Comment.for_serializer.where(post_id: post_ids)
+          .group("post_id")
+          .having("id = MAX(id)")
+          .datasource_select(:post_id)
+      end
+
+      loader :newest_comment_text, array_to_hash: true do |post_ids|
+        Comment.where(post_id: post_ids)
+          .group("post_id")
+          .having("id = MAX(id)")
+          .pluck("post_id, comment")
+      end
+
+      loader :ordered_comments, group_by: :post_id do |post_ids|
+        Comment.for_serializer(CommentSerializer).where(post_id: post_ids)
+          .order("post_id, id desc")
+          .datasource_select(:post_id)
+      end
+
+      computed :newest_comment, loaders: :newest_comment
+      computed :newest_comment_text, loaders: :newest_comment_text
+      computed :ordered_comments, loaders: :ordered_comments
+    end
+
+    def name_initials
+      return unless author_first_name && author_last_name
+      author_first_name[0].upcase + author_last_name[0].upcase
+    end
+  end
+
+  class CommentSerializer < ActiveModel::Serializer
+    attributes :id, :comment
+  end
+
+  class PostSerializer < ActiveModel::Serializer
+    attributes :id, :title, :newest_comment, :newest_comment_text, :ordered_comments
+
+    def newest_comment
+      CommentSerializer.new(object.loaded_values[:newest_comment]).as_json
+    end
+
+    def newest_comment_text
+      object.loaded_values[:newest_comment_text]
+    end
+
+    def ordered_comments
+      Datasource::ArrayAMS.new(object.loaded_values[:ordered_comments]).as_json
+    end
+  end
+
+  def test_loader
+    post = Post.create! title: "First Post"
+    2.times { |i| post.comments.create! comment: "Comment #{i+1}" }
+
+    assert_query_count(4) do
+      assert_equal Datasource::ArrayAMS.new(Post.all).as_json,
+        [{:id=>1, :title=>"First Post", :newest_comment=>{"comment"=>{:id=>2, :comment=>"Comment 2"}}, :newest_comment_text=>"Comment 2", :ordered_comments=>[{:id=>2, :comment=>"Comment 2"}, {:id=>1, :comment=>"Comment 1"}]}]
+    end
+  end
+
+  def teardown
+    clean_db
+  end
+end

data/test/test_scope.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+require 'active_record_helper'
+
+class ScopeTest < ActiveSupport::TestCase
+  class Post < ActiveRecord::Base
+    belongs_to :blog
+
+    datasource_module do
+      query :author_name do
+        "posts.author_first_name || ' ' || posts.author_last_name"
+      end
+    end
+  end
+
+  class PostSerializer < ActiveModel::Serializer
+    attributes :id, :title, :author_name
+  end
+
+  def test_first
+    Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
+    post = Post.for_serializer.first
+
+    assert_equal("The Post", post.title)
+    assert_equal("John Doe", post.author_name)
+    assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
+  end
+
+  def test_find
+    post = Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
+    post = Post.for_serializer.find(post.id)
+
+    assert_equal("The Post", post.title)
+    assert_equal("John Doe", post.author_name)
+    assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
+  end
+
+  def test_each
+    post = Post.create! title: "The Post", author_first_name: "John", author_last_name: "Doe", blog_id: 10
+
+    Post.for_serializer.each do |post|
+      assert_equal("The Post", post.title)
+      assert_equal("John Doe", post.author_name)
+      assert_raises(ActiveModel::MissingAttributeError) { post.blog_id }
+    end
+  end
+
+  def teardown
+    clean_db
+  end
+end

data/test/test_serializer.rb

@@ -0,0 +1,52 @@
+require 'test_helper'
+require 'active_record_helper'
+
+class SerializerTest < ActiveSupport::TestCase
+  class Post < ActiveRecord::Base
+    belongs_to :blog
+
+    datasource_module do
+      query :author_name do
+        "posts.author_first_name || ' ' || posts.author_last_name"
+      end
+    end
+  end
+
+  class Blog < ActiveRecord::Base
+    has_many :posts
+  end
+
+  class BlogSerializer < ActiveModel::Serializer
+    attributes :id, :title
+
+    has_many :posts
+  end
+
+  class PostSerializer < ActiveModel::Serializer
+    attributes :id, :title, :author_name
+  end
+
+  def test_blogs_and_posts_serializer
+    blog = Blog.create! title: "Blog 1"
+    blog.posts.create! title: "Post 1", author_first_name: "John", author_last_name: "Doe"
+    blog.posts.create! title: "Post 2", author_first_name: "Maria", author_last_name: "Doe"
+    blog = Blog.create! title: "Blog 2"
+
+    expected_result = [
+      {:id =>1, :title =>"Blog 1", :posts =>[
+        {:id =>1, :title =>"Post 1", :author_name =>"John Doe"},
+        {:id =>2, :title =>"Post 2", :author_name =>"Maria Doe"}
+      ]},
+      {:id =>2, :title =>"Blog 2", :posts =>[]}
+    ]
+
+    assert_query_count(2) do
+      serializer = Datasource::ArrayAMS.new(Blog.all)
+      assert_equal(expected_result, serializer.as_json)
+    end
+  end
+
+  def teardown
+    clean_db
+  end
+end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Jan Berdajs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-08 00:00:00.000000000 Z
+date: 2014-12-09 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -17,7 +31,7 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '4'
-  type: :runtime
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -38,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
 description: 
 email:
 - mrbrdo@gmail.com
@@ -50,15 +78,21 @@ files:
 - Rakefile
 - lib/datasource.rb
 - lib/datasource/adapters/active_record.rb
+- lib/datasource/adapters/sequel.rb
 - lib/datasource/attributes/computed_attribute.rb
+- lib/datasource/attributes/loader.rb
 - lib/datasource/attributes/query_attribute.rb
 - lib/datasource/base.rb
-- lib/datasource/serializer/composite.rb
+- lib/datasource/consumer_adapters/active_model_serializers.rb
+- lib/datasource/serializer.rb
+- lib/generators/datasource/install_generator.rb
+- lib/generators/datasource/templates/initializer.rb
 - test/active_record_helper.rb
 - test/schema.rb
-- test/test_datasource.rb
 - test/test_helper.rb
-- test/test_serializer_composite.rb
+- test/test_loader.rb
+- test/test_scope.rb
+- test/test_serializer.rb
 homepage: https://github.com/mrbrdo/datasource
 licenses:
 - MIT
@@ -86,6 +120,8 @@ summary: Ruby library for creating data source objects from database data
 test_files:
 - test/active_record_helper.rb
 - test/schema.rb
-- test/test_datasource.rb
 - test/test_helper.rb
-- test/test_serializer_composite.rb
+- test/test_loader.rb
+- test/test_scope.rb
+- test/test_serializer.rb
+has_rdoc: 

data/lib/datasource/serializer/composite.rb

@@ -1,119 +0,0 @@
-module Datasource
-  module Serializer
-    class Composite
-      TemplatePart = Struct.new(:parent, :type, :value, :select) do
-        def initialize(parent, type = nil, value = nil)
-          super(parent, type, get_default_value(type, value), [])
-        end
-
-        def set_default_value(value = nil)
-          self.value = get_default_value(type, value)
-        end
-      private
-        def get_default_value(type, value)
-          case type
-          when :hash then {}
-          when :array then []
-          when :datasource then value
-          when nil then nil
-          else
-            fail "Unknown type #{type}"
-          end
-        end
-      end
-
-      class << self
-        attr_accessor :datasource_count, :template
-
-        def inherited(base)
-          base.datasource_count = 0
-          @cursor = base.template = nil
-        end
-
-        def with_new_cursor(type, value = nil, &block)
-          result = nil
-          new_cursor = TemplatePart.new(@cursor, type, value)
-          @cursor = @cursor.tap do
-            if template.nil?
-              self.template = @cursor = new_cursor
-            elsif @cursor.type == :datasource
-              @cursor = @cursor.parent
-              return with_new_cursor(type, value, &block)
-            elsif @cursor.type == :array
-              @cursor = new_cursor
-              @cursor.parent.push(@cursor)
-            elsif @cursor.type.nil?
-              # replace cursor
-              @cursor.type = type
-              @cursor.set_default_value(value)
-            else
-              fail "Invalid use of #{type}."
-            end
-            result = block.call
-          end
-          result
-        end
-
-        def hash(&block)
-          with_new_cursor(:hash, &block)
-        end
-
-        def key(name)
-          fail "Cannot use key outside hash." unless @cursor.type == :hash
-          @cursor = @cursor.tap do
-            @cursor = @cursor.value[name.to_s] = TemplatePart.new(@cursor)
-            yield
-          end
-        end
-
-        def array(&block)
-          with_new_cursor(:array, &block)
-        end
-
-        def datasource(ds)
-          self.datasource_count += 1
-          @cursor = with_new_cursor(:datasource, ds) { @cursor }
-        end
-
-        def attributes(*attributes)
-          attributes.each { |name| attribute name }
-        end
-
-        def attribute(name)
-          fail "No datasource selected - use \"select_datasource Klass\" first." unless @cursor.type == :datasource
-          @cursor.select << name
-        end
-      end
-
-      def initialize(*scopes)
-        @scopes = scopes
-        if @scopes.size != self.class.datasource_count
-          fail ArgumentError, "#{self.class.name} needs #{@scopes.size} scopes, you provided #{self.class.datasource_count}"
-        end
-      end
-
-      def as_json
-        parse_template_part(self.class.template)
-      end
-
-    private
-      def parse_template_part(part)
-        return nil unless part
-        case part.type
-        when :hash
-          {}.tap do |result|
-            part.value.each_pair do |k, v|
-              result[k] = parse_template_part(v)
-            end
-          end
-        when :array
-          part.value.map { |v| parse_template_part(v) }
-        when :datasource
-          part.value.new(@scopes.shift).select(*part.select).results
-        else
-          fail "Unknown type #{type}"
-        end
-      end
-    end
-  end
-end

data/test/test_datasource.rb

@@ -1,47 +0,0 @@
-require 'test_helper'
-require 'active_record_helper'
-require 'pry'
-
-class PostsDatasource < Datasource::Base
-  attributes :id, :title, :blog_id
-
-  computed_attribute :author, posts: [ :author_first_name, :author_last_name ] do
-    { "name" => "#{author_first_name} #{author_last_name}" }
-  end
-
-  query_attribute :author_name, :posts do
-    "posts.author_first_name || ' ' || posts.author_last_name"
-  end
-end
-
-class BlogsDatasource < Datasource::Base
-  attributes :id
-
-  includes_many :posts, PostsDatasource, :blog_id
-end
-
-class DatasourceTest < ActiveSupport::TestCase
-  def test_basic
-    blog = Blog.create! title: "Blog 1"
-    blog.posts.create! title: "Post 1", author_first_name: "John", author_last_name: "Doe"
-
-    ds = PostsDatasource.new(Post.all)
-
-    assert_equal [{"id"=>1, "title"=>"Post 1", "author_name"=>"John Doe", "author"=>{"name"=>"John Doe"}}],
-      ds.select(:id, :title, :author, :author_name).results
-  end
-
-  def test_assoc
-    blog = Blog.create! title: "Blog 1"
-    blog.posts.create! title: "Post 1", author_first_name: "John", author_last_name: "Doe"
-
-    ds = BlogsDatasource.new(Blog.all)
-
-    assert_equal [{"id"=>1, "posts"=>[{"id"=>1, "author_name"=>"John Doe"}]}],
-      ds.select(:id, posts: { scope: Post.all, select: [:id, :author_name] }).results
-  end
-
-  def teardown
-    clean_db
-  end
-end