datasource 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 89a34ecb59d8f4183295c43b4badd33aca5f5e62
-  data.tar.gz: b408320273ce49236bd022d7db00c1fce06bdfd5
+  metadata.gz: 50befc547d1d02c68a29f7a73b5a75ae3038ee16
+  data.tar.gz: a0866c2dfbfa920696d27d2f83ef4252088c5fe7
 SHA512:
-  metadata.gz: 0db668df6f4ae71223655a544d59b805e6bdd2694ab540f37dacc7962700d427799f00308d0cdf03a180a7e45f7d3891ff795e73def10c180bf9df5d92942df3
-  data.tar.gz: c69ae3fe12467516c7f24d090e7240a398e9e7d341dd82a1c54b459c57dd4fb2f9c796a6180a85e02fc304ea45bbf96361579af3249974df4fd73cc0a02dd997
+  metadata.gz: 1d628e4fc124ece6b97cd373438009a27b37d78f13bc18fbef0fcdc410d1c47fdff43f174feef8f06de694141271950c05449c1da8644c8cf3d150fb22edfcd0
+  data.tar.gz: f334b8022a8db68d276d22168aaf4e296de0dd9a496c6df22a0a59323a87a2332f0141fa69a4806430f6e9312cfdf983ec560154c7cc07f0eb7d479858a68b56

data/README.md

@@ -1,8 +1,10 @@
 # Datasource
 
+**Make sure you are reading the README corresponding to the version your are using**
+
 Automatically preload your ORM records for your serializer.
 
-## Install
+#### Install
 
 Add to Gemfile
 
@@ -10,9 +12,12 @@ Add to Gemfile
 gem 'datasource'
 ```
 
-And `bundle install`.
+```
+bundle install
+rails g datasource:install
+```
 
-Run install generator:
+#### Upgrade
 
 ```
 rails g datasource:install
@@ -27,25 +32,18 @@ rails g datasource:install
 
 - active_model_serializers
 
-## Basic Usage
-
-### Attributes
-You don't have to do anything special.
-
-```ruby
-class UserSerializer < ActiveModel::Serializer
-  attributes :id, :email
-end
-```
-
-But you get an optimized query for free:
+## Simple Mode
 
-```sql
-SELECT id, email FROM users
-```
+Datasource is configured to run in Simple mode by default, which makes it easier
+to start with, but disables some advanced optimizations. See
+[Advanced mode](https://github.com/mrbrdo/datasource/wiki/Advanced-mode) for more
+information after you understand Simple mode.
 
 ### Associations
-You don't have to do anything special.
+
+The most noticable magic effect of using Datasource in Simple mode (Advanced mode
+has other benefits) is that associations will automatically be preloaded using a
+single query.
 
 ```ruby
 class PostSerializer < ActiveModel::Serializer
@@ -57,45 +55,13 @@ class UserSerializer < ActiveModel::Serializer
   has_many :posts
 end
 ```
-
-But you get automatic association preloading ("includes") with optimized queries for free:
-
 ```sql
-SELECT id FROM users
-SELECT id, title, user_id FROM posts WHERE id IN (?)
+SELECT users.* FROM users
+SELECT posts.* FROM posts WHERE id IN (?)
 ```
 
-### Model Methods / Virtual Attributes
-You need to use `computed` in a `datasource_module` block to specify what a method depends on. It can depend on database columns, other computed attributes or loaders.
-
-```ruby
-class User < ActiveRecord::Base
-  datasource_module do
-    computed :first_name_initial, :first_name
-    computed :both_initials, :first_name, :last_name
-  end
-
-  # method can be in model
-  def first_name_initial
-    first_name[0].upcase
-  end
-end
-
-class UserSerializer < ActiveModel::Serializer
-  attributes :first_name_initial, :last_name_initial
-
-  # method can also be in serializer
-  def both_initials
-    object.last_name[0].upcase + object.last_name[0].upcase
-  end
-end
-```
-
-```sql
-SELECT first_name, last_name FROM users
-```
-
-You will be reminded with an exception if you forget to do this.
+This means you **do not** need to call `includes` yourself. It will be done
+automatically by Datasource.
 
 ### Show action
 
@@ -128,8 +94,6 @@ class UsersController < ApplicationController
 end
 ```
 
-## Advanced Usage
-
 ### Query attribute
 
 You can specify a SQL fragment for `SELECT` and use that as an attribute on your
@@ -150,7 +114,7 @@ end
 ```
 
 ```sql
-SELECT users.id, (users.first_name || ' ' || users.last_name) AS full_name FROM users
+SELECT users.*, (users.first_name || ' ' || users.last_name) AS full_name FROM users
 ```
 
 Note: If you need data from another table, use a join in a loader (see below).
@@ -161,8 +125,13 @@ You might want to have some more complex preloading logic. In that case you can
 A loader will receive ids of the records, and needs to return a hash.
 The key of the hash must be the id of the record for which the value is.
 
-A loader will only be executed if a computed attribute depends on it. If an attribute depends
-on multiple loaders, pass an array of loaders like so `computed :attr, loaders: [:loader1, :loader2]`.
+A loader will only be executed if a computed attribute depends on it. See
+[Advanced mode](https://github.com/mrbrdo/datasource/wiki/Advanced-mode) for
+information about computed attributes (but this works the same way in Simple mode).
+A more simple alternative to loader which doesn't require computed attributes is to use
+[Loaded](#loaded).
+If an attribute depends on multiple loaders, pass an array of loaders like
+so `computed :attr, loaders: [:loader1, :loader2]`.
 
 Be careful that if your hash does not contain a value for the object ID, the loaded value
 will be nil. However you can use the `default` option for such cases (see below example).
@@ -191,7 +160,7 @@ end
 ```
 
 ```sql
-SELECT users.id FROM users
+SELECT users.* FROM users
 SELECT user_id, COUNT(id) FROM posts WHERE user_id IN (?)
 ```
 
@@ -227,8 +196,8 @@ end
 
 ### Loaded
 
-Loaded is the same as loader, but it also creates a computed attribute and defines
-a method with the same name on your model.
+Loaded is the same as loader, but it automatically creates a computed attribute
+and defines a method with the same name on your model.
 
 Here is the previous example with `loaded` instead of `loader`:
 
@@ -265,10 +234,10 @@ class User < ActiveRecord::Base
         .group(:user_id)
         .pluck("user_id, COUNT(id)")
     end
+  end
 
-    def post_count
-      posts.count
-    end
+  def post_count
+    posts.count
   end
 end
 
@@ -279,3 +248,17 @@ end
 User.first.post_count # <- your method will be called
 
 ```
+
+## Getting Help
+
+If you find a bug, please report an [Issue](https://github.com/mrbrdo/datasource/issues/new).
+
+If you have a question, you can also open an Issue.
+
+## Contributing
+
+1. Fork it ( https://github.com/mrbrdo/datasource/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/lib/datasource/adapters/active_record.rb

@@ -136,22 +136,20 @@ module Datasource
         end
       end
 
-      def load_association(records, name)
+      def load_association(records, name, assoc_select)
         return if records.empty?
         return if records.first.association(name.to_sym).loaded?
         klass = records.first.class
         if reflection = klass.reflections[name.to_sym]
           assoc_class = association_klass(reflection)
           datasource_class = assoc_class.default_datasource
-          # TODO: extract serializer_class from parent serializer association
-          serializer_class = Datasource::Base.consumer_adapter.get_serializer_for(assoc_class)
 
-          # TODO: can we make it use datasource scope (with_serializer)? like Sequel
           scope = assoc_class.all
           datasource = datasource_class.new(scope)
-          datasource_select = serializer_class._attributes.dup
-          Datasource::Base.reflection_select(association_reflection(klass, name.to_sym), [], datasource_select)
-          datasource.select(*datasource_select)
+          assoc_select_attributes = assoc_select.reject { |att| att.kind_of?(Hash) }
+          assoc_select_associations = assoc_select.select { |att| att.kind_of?(Hash) }
+          Datasource::Base.reflection_select(association_reflection(klass, name.to_sym), [], assoc_select_attributes)
+          datasource.select(*assoc_select_attributes)
           select_values = datasource.get_select_values
 
           begin
@@ -163,8 +161,10 @@ module Datasource
           end
 
           assoc_records = records.flat_map { |record| record.send(name) }.compact
-          serializer_class._associations.each_pair do |assoc_name, options|
-            load_association(assoc_records, assoc_name)
+          assoc_select_associations.each do |assocs|
+            assocs.each_pair do |assoc_name, assoc_select|
+              load_association(assoc_records, assoc_name, assoc_select)
+            end
           end
           datasource.results(assoc_records)
         end
@@ -193,7 +193,7 @@ module Datasource
 
       def load_associations(ds, records)
         ds.expose_associations.each_pair do |assoc_name, assoc_select|
-          load_association(records, assoc_name)
+          load_association(records, assoc_name, assoc_select)
         end
       end
 

data/lib/datasource/adapters/sequel.rb

@@ -149,7 +149,7 @@ module Datasource
           {
             name => ->(ds) {
               ds.with_datasource(datasource_class)
-              .datasource_select(*(self_append_select + assoc_select))
+              .datasource_select(*(assoc_select + self_append_select))
             }
           }
         else

data/lib/datasource/base.rb

@@ -83,14 +83,29 @@ module Datasource
         end
       @expose_attributes = []
       @expose_associations = {}
+      @select_all_columns = false
+    end
+
+    def select_all_columns
+      column_attributes = self.class._attributes.values.select do |att|
+        att[:klass].nil?
+      end
+      columns = column_attributes.map { |att| att[:name] }
+      select(*columns)
+      @select_all_columns = true
+
+      columns
     end
 
     def select_all
-      @expose_attributes = self.class._attributes.keys.dup
+      attributes = self.class._attributes.keys
+      select(*attributes)
+      @select_all_columns = true
+
+      attributes
     end
 
     def select(*names)
-      failure = ->(name) { fail Datasource::Error, "attribute or association #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, <dependencies>\" in your datasource_module?" }
       newly_exposed_attributes = []
       missing_attributes = []
       names.each do |name|
@@ -99,23 +114,23 @@ module Datasource
             assoc_name = assoc_name.to_s
             if self.class._associations.key?(assoc_name)
               @expose_associations[assoc_name] ||= []
-              @expose_associations[assoc_name] += Array(assoc_select)
+              @expose_associations[assoc_name].concat(Array(assoc_select))
               @expose_associations[assoc_name].uniq!
             else
               missing_attributes << assoc_name
-              failure.call(assoc_name)
             end
           end
         else
           name = name.to_s
-          if self.class._attributes.key?(name)
+          if name == "*"
+            newly_exposed_attributes.concat(select_all_columns.map(&:to_s))
+          elsif self.class._attributes.key?(name)
             unless @expose_attributes.include?(name)
               @expose_attributes.push(name)
               newly_exposed_attributes.push(name)
             end
           else
             missing_attributes << name
-            failure.call(name)
           end
         end
       end
@@ -161,17 +176,28 @@ module Datasource
 
     def get_select_values
       scope_table = adapter.primary_scope_table(self)
-
-      # SQL select values
       select_values = Set.new
-      select_values.add("#{scope_table}.#{self.class.primary_key}")
 
-      self.class._attributes.values.each do |att|
-        if attribute_exposed?(att[:name])
-          if att[:klass] == nil
-            select_values.add("#{scope_table}.#{att[:name]}")
-          elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
-            select_values.add("(#{att[:klass].select_value}) as #{att[:name]}")
+      if @select_all_columns
+        select_values.add("#{scope_table}.*")
+
+        self.class._attributes.values.each do |att|
+          if att[:klass] && attribute_exposed?(att[:name])
+            if att[:klass].ancestors.include?(Attributes::QueryAttribute)
+              select_values.add("(#{att[:klass].select_value}) as #{att[:name]}")
+            end
+          end
+        end
+      else
+        select_values.add("#{scope_table}.#{self.class.primary_key}")
+
+        self.class._attributes.values.each do |att|
+          if attribute_exposed?(att[:name])
+            if att[:klass] == nil
+              select_values.add("#{scope_table}.#{att[:name]}")
+            elsif att[:klass].ancestors.include?(Attributes::QueryAttribute)
+              select_values.add("(#{att[:klass].select_value}) as #{att[:name]}")
+            end
           end
         end
       end
@@ -207,29 +233,33 @@ module Datasource
     def results(rows = nil)
       rows ||= adapter.get_rows(self)
 
-      @expose_attributes.each do |name|
-        att = self.class._attributes[name]
-        fail Datasource::Error, "attribute #{name} doesn't exist for #{self.class.orm_klass.name}, did you forget to call \"computed :#{name}, :db_column_dependency\" in your datasource_module? See https://github.com/mrbrdo/datasource#model-methods--virtual-attributes" unless att
-        klass = att[:klass]
-        next unless klass
-
-        next if rows.empty?
-
-        if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
-          att[:klass]._loader_depends.each do |name|
-            if loader = self.class._loaders[name]
-              if loaded_values = loader.load(rows.map(&self.class.primary_key), rows, @scope)
-                unless rows.first.loaded_values
+      unless rows.empty?
+        @expose_attributes.each do |name|
+          att = self.class._attributes[name]
+          klass = att[:klass]
+          next unless klass
+
+          if att[:klass].ancestors.include?(Attributes::ComputedAttribute)
+            att[:klass]._loader_depends.each do |name|
+              if loader = self.class._loaders[name]
+                if loaded_values = loader.load(rows.map(&self.class.primary_key), rows, @scope)
+                  unless rows.first.loaded_values
+                    rows.each do |row|
+                      row.loaded_values = {}
+                    end
+                  end
                   rows.each do |row|
-                    row.loaded_values = {}
+                    key = row.send(self.class.primary_key)
+                    if loaded_values.key?(key)
+                      row.loaded_values[name] = loaded_values[key]
+                    elsif loader.default_value
+                      row.loaded_values[name] = loader.default_value
+                    end
                   end
                 end
-                rows.each do |row|
-                  row.loaded_values[name] = loaded_values[row.send(self.class.primary_key)] || loader.default_value
-                end
+              else
+                raise Datasource::Error, "loader with name :#{name} could not be found"
               end
-            else
-              raise Datasource::Error, "loader with name :#{name} could not be found"
             end
           end
         end

data/lib/datasource/configuration.rb

@@ -0,0 +1,23 @@
+module Datasource
+  module Configuration
+    include ActiveSupport::Configurable
+    extend ActiveSupport::Concern
+
+    included do |base|
+      base.config.adapters = Configuration.default_adapters
+      base.config.simple_mode = false
+    end
+
+    def self.default_adapters
+      default_adapters = []
+      if defined? ActiveRecord
+        default_adapters.push(:activerecord)
+      elsif defined? Sequel
+        default_adapters.push(:sequel)
+      end
+      if defined? ActiveModel::Serializer
+        default_adapters.push(:ams)
+      end
+    end
+  end
+end

data/lib/datasource/consumer_adapters/active_model_serializers.rb

@@ -36,6 +36,7 @@ module Datasource
       def to_datasource_select(result, klass, serializer = nil, serializer_assoc = nil, adapter = nil)
         adapter ||= Datasource::Base.default_adapter
         serializer ||= get_serializer_for(klass, serializer_assoc)
+        result.unshift("*") if Datasource.config.simple_mode
         result.concat(serializer._attributes)
         result_assocs = {}
         result.push(result_assocs)

data/lib/datasource.rb

@@ -1,6 +1,8 @@
+require 'datasource/configuration'
 module Datasource
   Error = Class.new(StandardError)
   RecursionError = Class.new(StandardError)
+  include Configuration
 
   AdapterPaths = {
     activerecord: 'datasource/adapters/active_record',
@@ -12,25 +14,23 @@ module Datasource
 
 module_function
   def load(*adapters)
-    if adapters.empty?
-      adapters = []
-      if defined? ActiveRecord
-        adapters.push(:activerecord)
-      elsif defined? Sequel
-        adapters.push(:sequel)
-      end
-      if defined? ActiveModel::Serializer
-        adapters.push(:ams)
-      end
+    unless adapters.empty?
+      warn "[DEPRECATION] passing adapters to Datasource.load is deprecated. Use Datasource.setup instead."
+      config.adapters = adapters
     end
 
-    adapters.each do |adapter|
+    config.adapters.each do |adapter|
       adapter = AdapterPaths[adapter]
       adapter = AdapterPaths[adapter] if adapter.is_a?(Symbol)
       require adapter
     end
   end
 
+  def setup
+    yield(config)
+    load
+  end
+
   def orm_adapters
     @orm_adapters ||= begin
       Datasource::Adapters.constants.map { |name| Datasource::Adapters.const_get(name) }

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

@@ -1 +1,10 @@
-Datasource.load(:activerecord, :active_model_serializers)
+Datasource.setup do |config|
+  # Adapters to load
+  # Available ORM adapters: activerecord, sequel
+  # Available Serializer adapters: active_model_serializers
+  config.adapters = [:activerecord, :active_model_serializers]
+
+  # Enable simple mode, which will always select all model database columns,
+  # making Datasource easier to use. See documentation for details.
+  config.simple_mode = true
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: datasource
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Jan Berdajs
@@ -24,6 +24,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.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.0'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -80,20 +94,6 @@ 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'
 - !ruby/object:Gem::Dependency
   name: sequel
   requirement: !ruby/object:Gem::Requirement
@@ -139,6 +139,7 @@ files:
 - lib/datasource/attributes/loader.rb
 - lib/datasource/attributes/query_attribute.rb
 - lib/datasource/base.rb
+- lib/datasource/configuration.rb
 - lib/datasource/consumer_adapters/active_model_serializers.rb
 - lib/datasource/serializer.rb
 - lib/generators/datasource/install_generator.rb