datasource 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 617cef0cb48d4953a9da29c7476ef583c5d7487e
+  data.tar.gz: bf76cef2be532f75c71729dbf3fa11fa4022ea37
+SHA512:
+  metadata.gz: 3d4738bb6e26eae45f63df27fdfe52a7725d49d1e20569eace2af7d71314e20529f3a29fb913979b1f88f960f337418319b2f2dd88ef978ed57d8d72cda5688e
+  data.tar.gz: 3079481e54532538dd4aeb9df57ec2abe0f412f62369caf91ec3ebe16ab5106036321f3070d02be015972a81da9f6bb087de997f38610ba94c843e9cd4425e95

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) <year> <copyright holders>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+# Datasource

data/Rakefile

@@ -0,0 +1,8 @@
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'test'
+end
+
+desc "Run tests"
+task :default => :test

data/lib/datasource/adapters/active_record.rb

@@ -0,0 +1,126 @@
+require 'set'
+
+ActiveRecord::Calculations
+module ActiveRecord
+  module Calculations
+    def pluck_hash(*column_names)
+      column_names.map! do |column_name|
+        if column_name.is_a?(Symbol) && attribute_alias?(column_name)
+          attribute_alias(column_name)
+        else
+          column_name.to_s
+        end
+      end
+
+      if has_include?(column_names.first)
+        construct_relation_for_association_calculations.pluck(*column_names)
+      else
+        relation = spawn
+        relation.select_values = column_names.map { |cn|
+          columns_hash.key?(cn) ? arel_table[cn] : cn
+        }
+        result = klass.connection.select_all(relation.arel, nil, bind_values)
+        columns = result.columns.map do |key|
+          klass.column_types.fetch(key) {
+            result.column_types.fetch(key) { result.identity_type }
+          }
+        end
+
+        result.rows.map do |values|
+          {}.tap do |hash|
+            values.zip(columns, result.columns).each do |v|
+              single_attr_hash = { v[2] => v[0] }
+              hash[v[2]] = v[1].type_cast klass.initialize_attributes(single_attr_hash).values.first
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+module Datasource
+  module Adapters
+    module ActiveRecord
+      ID_KEY = "id"
+
+      def to_query(scope)
+        ActiveRecord::Base.uncached do
+          scope.select(*get_select_values(scope)).to_sql
+        end
+      end
+
+      def get_rows(scope)
+        scope.pluck_hash(*get_select_values(scope))
+      end
+
+      def included_datasource_rows(att, datasource_data, rows)
+        ds_select = datasource_data[:select]
+        unless ds_select.include?(att[:foreign_key])
+          ds_select += [att[:foreign_key]]
+        end
+        ds_scope = datasource_data[:scope]
+        column = "#{ds_scope.klass.table_name}.#{att[:foreign_key]}"
+        ds_scope = ds_scope.where("#{column} IN (?)",
+            rows.map { |row| row[att[:id_key]] })
+        grouped_results = att[:klass].new(ds_scope)
+        .select(ds_select)
+        .results.group_by do |row|
+          row[att[:foreign_key]]
+        end
+        unless datasource_data[:select].include?(att[:foreign_key])
+          grouped_results.each_pair do |k, rows|
+            rows.each do |row|
+              row.delete(att[:foreign_key])
+            end
+          end
+        end
+        grouped_results
+      end
+
+      def get_select_values(scope)
+        select_values = Set.new
+        select_values.add("#{scope.klass.table_name}.#{self.class.adapter::ID_KEY}")
+
+        self.class._attributes.each do |att|
+          if attribute_exposed?(att[:name])
+            if att[:klass] == nil
+              select_values.add("#{scope.klass.table_name}.#{att[:name]}")
+            elsif att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+              att[:klass]._depends.keys.map(&:to_s).each do |name|
+                next if name == scope.klass.table_name
+                ensure_table_join!(scope, name, att)
+              end
+              att[:klass]._depends.each_pair do |table, names|
+                Array(names).each do |name|
+                  select_values.add("#{table}.#{name}")
+                end
+                # TODO: handle depends on virtual attribute
+              end
+            elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
+              select_values.add("(#{att[:klass].new.select_value}) as #{att[:name]}")
+              att[:klass]._depends.each do |name|
+                next if name == scope.klass.table_name
+                ensure_table_join!(scope, name, att)
+              end
+            end
+          end
+        end
+        select_values.to_a
+      end
+
+      def ensure_table_join!(scope, name, att)
+        join_value = scope.joins_values.find do |value|
+          if value.is_a?(Symbol)
+            value.to_s == att[:name]
+          elsif value.is_a?(String)
+            if value =~ /join (\w+)/i
+              $1 == att[:name]
+            end
+          end
+        end
+        raise "Given scope does not join on #{name}, but it is required by #{att[:name]}" unless join_value
+      end
+    end
+  end
+end

data/lib/datasource/attributes/computed_attribute.rb

@@ -0,0 +1,41 @@
+module Datasource
+  module Attributes
+    class ComputedAttribute
+      class << self
+        attr_accessor :_depends
+
+        def inherited(base)
+          base._depends = (_depends || {}).dup # TODO: deep dup?
+        end
+
+        def depends(*args)
+          args.each do |dep|
+            _depends.deep_merge!(dep)
+            dep.values.each do |names|
+              Array(names).each do |name|
+                define_method(name) do
+                  @depend_values[name.to_s]
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def initialize(depend_values)
+        @depend_values = depend_values
+      end
+    end
+  end
+
+  class Datasource::Base
+    def self.computed_attribute(name, deps, &block)
+      klass = Class.new(Attributes::ComputedAttribute) do
+        depends deps
+
+        define_method(:value, &block)
+      end
+      attribute name, klass
+    end
+  end
+end

data/lib/datasource/attributes/query_attribute.rb

@@ -0,0 +1,28 @@
+module Datasource
+  module Attributes
+    class QueryAttribute
+      class << self
+        attr_accessor :_depends
+
+        def inherited(base)
+          base._depends = (_depends || []).dup
+        end
+
+        def depends(*args)
+          self._depends += args.map(&:to_s)
+        end
+      end
+    end
+  end
+
+  class Datasource::Base
+    def self.query_attribute(name, deps, &block)
+      klass = Class.new(Attributes::QueryAttribute) do
+        depends deps
+
+        define_method(:select_value, &block)
+      end
+      attribute name, klass
+    end
+  end
+end

data/lib/datasource/base.rb

@@ -0,0 +1,99 @@
+module Datasource
+  class Base
+    class << self
+      attr_accessor :_attributes, :_virtual_attributes, :_associations
+      attr_accessor :adapter
+
+      def inherited(base)
+        base._attributes = (_attributes || []).dup
+        @adapter ||= Datasource::Adapters::ActiveRecord
+        self.send :include, @adapter
+      end
+
+      def attributes(*attrs)
+        attrs.each { |name| attribute(name) }
+      end
+
+      def attribute(name, klass = nil)
+        @_attributes.push name: name.to_s, klass: klass
+      end
+
+      def includes_many(name, klass, foreign_key)
+        @_attributes.push name: name.to_s, klass: klass, foreign_key: foreign_key.to_s, id_key: self::ID_KEY
+      end
+    end
+
+    def initialize(scope)
+      @scope = scope
+      @expose_attributes = []
+      @datasource_data = {}
+    end
+
+    def select(*names)
+      names = names.flat_map do |name|
+        if name.kind_of?(Hash)
+          # datasource data
+          name.each_pair do |k, v|
+            @datasource_data[k.to_s] = v
+          end
+          name.keys
+        else
+          name
+        end
+      end
+      @expose_attributes = (@expose_attributes + names.map(&:to_s)).uniq
+      self
+    end
+
+    def attribute_exposed?(name)
+      @expose_attributes.include?(name)
+    end
+
+    def to_query
+      to_query(@scope)
+    end
+
+    def results
+      rows = get_rows(@scope)
+
+      attribute_map = self.class._attributes.inject({}) do |hash, att|
+        hash[att[:name]] = att
+        hash
+      end
+
+      computed_expose_attributes = []
+      datasources = {}
+
+      @expose_attributes.each do |name|
+        att = attribute_map[name]
+        klass = att[:klass]
+        next unless klass
+
+        if klass.ancestors.include?(Attributes::ComputedAttribute)
+          computed_expose_attributes.push(att)
+        elsif klass.ancestors.include?(Base)
+          datasources[att] =
+            included_datasource_rows(att, @datasource_data[att[:name]], rows)
+        end
+      end
+
+      # TODO: field names...
+      rows.each do |row|
+        computed_expose_attributes.each do |att|
+          klass = att[:klass]
+          if klass
+            row[att[:name]] = klass.new(row).value
+          end
+        end
+        datasources.each_pair do |att, rows|
+          row[att[:name]] = Array(rows[row[att[:id_key]]])
+        end
+        row.delete_if do |key, value|
+          !attribute_exposed?(key)
+        end
+      end
+
+      rows
+    end
+  end
+end

data/lib/datasource/serializer/composite.rb

@@ -0,0 +1,119 @@
+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/lib/datasource.rb

@@ -0,0 +1,8 @@
+require 'datasource/base'
+
+require 'datasource/attributes/computed_attribute'
+require 'datasource/attributes/query_attribute'
+
+require 'datasource/adapters/active_record'
+
+require 'datasource/serializer/composite'

data/test/active_record_helper.rb

@@ -0,0 +1,10 @@
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+ActiveRecord::Migration.verbose = false
+load "schema.rb"
+
+def clean_db
+  ActiveRecord::Base.connection.execute("DELETE FROM comments")
+  ActiveRecord::Base.connection.execute("DELETE FROM posts")
+  ActiveRecord::Base.connection.execute("DELETE FROM blogs")
+  ActiveRecord::Base.connection.execute("DELETE FROM sqlite_sequence")
+end

data/test/schema.rb

@@ -0,0 +1,33 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :blogs, :force => true do |t|
+    t.string :title
+  end
+
+  create_table :posts, :force => true do |t|
+    t.integer :blog_id
+    t.string :title
+    t.string :author_first_name
+    t.string :author_last_name
+  end
+
+  create_table :comments, :force => true do |t|
+    t.integer :post_id
+    t.text :comment
+  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

data/test/test_datasource.rb

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

data/test/test_helper.rb

@@ -0,0 +1,12 @@
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+require 'minitest/autorun'
+require 'active_support/all'
+require 'active_record'
+require 'datasource'
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+# ActiveRecord::Base.logger = Logger.new STDOUT

data/test/test_serializer_composite.rb

@@ -0,0 +1,48 @@
+require 'test_helper'
+require 'active_record_helper'
+require 'pry'
+
+class PostsDatasource < Datasource::Base
+  attributes :id, :title, :blog_id
+end
+
+class BlogsDatasource < Datasource::Base
+  attributes :id, :title
+  includes_many :posts, PostsDatasource, :blog_id
+end
+
+class BlogsAndPostsSerializer < Datasource::Serializer::Composite
+  hash do
+    key :blogs do
+      datasource BlogsDatasource
+      attributes :id, :title,
+        posts: { select: [ :id ], scope: Post.all }
+    end
+
+    key :posts do
+      datasource PostsDatasource
+      attributes :id, :title
+    end
+  end
+end
+
+class SerializerCompositeTest < ActiveSupport::TestCase
+  # SELECT blogs.id, blogs.title FROM "blogs"
+  # SELECT posts.id, posts.blog_id FROM "posts"  WHERE (posts.blog_id IN (1,2))
+  # SELECT posts.id, posts.title FROM "posts"
+  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"
+
+    serializer = BlogsAndPostsSerializer.new(Blog.all, Post.all)
+
+    assert_equal({"blogs"=>[{"id"=>1, "title"=>"Blog 1", "posts"=>[{"id"=>1}, {"id"=>2}]}, {"id"=>2, "title"=>"Blog 2", "posts"=>[]}], "posts"=>[{"id"=>1, "title"=>"Post 1"}, {"id"=>2, "title"=>"Post 2"}]},
+      serializer.as_json)
+  end
+
+  def teardown
+    clean_db
+  end
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: datasource
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jan Berdajs
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+description: 
+email:
+- mrbrdo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/datasource.rb
+- lib/datasource/adapters/active_record.rb
+- lib/datasource/attributes/computed_attribute.rb
+- lib/datasource/attributes/query_attribute.rb
+- lib/datasource/base.rb
+- lib/datasource/serializer/composite.rb
+- test/active_record_helper.rb
+- test/schema.rb
+- test/test_datasource.rb
+- test/test_helper.rb
+- test/test_serializer_composite.rb
+homepage: https://github.com/mrbrdo/datasource
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+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