pluckers 1.0.0

data/lib/pluckers/features/base/has_one_reflections.rb

@@ -0,0 +1,122 @@
+module Pluckers
+  ##
+  # This module groups diferent modules that will configure and build the
+  # results for a specific kind of information (attributes, translations,
+  # relations...)
+  #
+  # All this modules will have two methods, one for configuration (e.g, attributes
+  # to be included in the real pluck) and one for building the final results
+  module Features
+
+    module Base
+
+      ##
+      # This module implements plucking has_one relationships in a recursive
+      # way.
+      #
+      # The options used in this feature are:
+      #
+      #  * reflections: A hash of the reflections we will pluck recursively. The
+      #    key of this hash will be the name of the reflection and the value is
+      #    another hash of options.
+      #
+      #    - scope: You can limit the scope of the objects plucked. E.g, you
+      #      could use Author.active instead of Author.all. Notice that .all is
+      #      the default.
+      #
+      #    - plucker: You can use a custom plucker instead of Pluckers::Base in
+      #      case you want any specific logic. Pluckers::Base is the default one.
+      #
+      #    - Any other option will be passed to the plucker, so you can send any
+      #      other regular option such as attributes, custom ones or even more
+      #      reflections. Recursivity FTW!!
+      #
+      module HasOneReflections
+
+
+        ##
+        # Here we obtain the has_one reflections to include in the pluck
+        # operation and also include the relation foreign key in the attributes to
+        # pluck for this model.
+        def configure_query
+          super
+
+          pluck_reflections = @options[:reflections] || {}
+
+          return if pluck_reflections.blank?
+
+          @has_one_reflections = { }
+
+          # We iterate through the class reflections passed as options
+          @klass_reflections.slice(*pluck_reflections.keys).
+          # And select those that are BelongsTo
+            select{|_, r| active_record_has_one_reflection?(r)}.
+          # And store them in the has_one_reflection hash that will be used later
+            each do |name, reflection|
+              name = name.to_sym
+              @has_one_reflections[name] = pluck_reflections[name]
+            end
+
+        end
+
+        ##
+        # In this method we get the reflections and for each one creates and
+        # executes a new plucker.
+        #
+        # This pluck gives the whole process a recursive character and options
+        # for that plucker may be passed in the options hash.
+        def build_results
+          super
+
+          return if @has_one_reflections.blank?
+          # For each reflection
+          @has_one_reflections.each do |name, reflection|
+            # As an example we will imagine that we are plucking BlogPosts and
+            # this relation is the Author
+
+            # We get the meta information about the reflection
+            klass_reflection = @klass_reflections[name]
+
+            # initialize some options such as the plucker or the scope of the pluck
+            scope = reflection[:scope] || klass_reflection.klass.send(all_method)
+            plucker = reflection[:plucker] || Pluckers::Base
+
+            # If there are attributes configured to be plucked we add the foreign
+            # key as we will need it to relate the records
+            reflection[:attributes] |= [klass_reflection.foreign_key.to_sym] if reflection[:attributes]
+
+            # And now we create the plucker. Notice that we add a where to the
+            # scope, so we filter the records to pluck as we only get those with
+            # an id in the set of the foreign keys of the records already
+            # plucked by the base plucker
+            #
+            # In our Example we would be doing something like
+            # Author.all.where(id: author_ids)
+            reflection_plucker = plucker.new scope.where(
+                klass_reflection.foreign_key => @results.map{|_, r| r[klass_reflection.active_record_primary_key.to_sym] }
+              ),
+              reflection
+
+            # We initialize so we return a nil if there are no record related
+            @results.each do |_,result|
+              result[name] = nil
+            end
+
+            # And now pluck the related class and process the results
+            reflection_plucker.pluck.each do |r|
+              # For each related result (Author) we search those records
+              # (BlogPost) that are related (post.author_id == author.id) and
+              # insert them in the relationship attributes
+              @results.each do |_,result|
+                if result[klass_reflection.active_record_primary_key.to_sym] == r[klass_reflection.foreign_key.to_sym]
+                  result[name] = r
+                end
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/pluckers/features/base/has_one_through_reflections.rb

@@ -0,0 +1,129 @@
+module Pluckers
+  ##
+  # This module groups diferent modules that will configure and build the
+  # results for a specific kind of information (attributes, translations,
+  # relations...)
+  #
+  # All this modules will have two methods, one for configuration (e.g, attributes
+  # to be included in the real pluck) and one for building the final results
+  module Features
+
+    module Base
+
+      ##
+      # This module implements plucking has_many :through relationships in a
+      # recursive way.
+      #
+      # The options used in this feature are:
+      #
+      #  * reflections: A hash of the reflections we will pluck recursively. The
+      #    key of this hash will be the name of the reflection and the value is
+      #    another hash of options.
+      #
+      #    - scope: You can limit the scope of the objects plucked. E.g, you
+      #      could use Author.active instead of Author.all. Notice that .all is
+      #      the default.
+      #
+      #    - plucker: You can use a custom plucker instead of Pluckers::Base in
+      #      case you want any specific logic. Pluckers::Base is the default one.
+      #
+      #    - Any other option will be passed to the plucker, so you can send any
+      #      other regular option such as attributes, custom ones or even more
+      #      reflections. Recursivity FTW!!
+      #
+      module HasOneThroughReflections
+
+
+        ##
+        # Here we obtain the has_many :through reflections to include in the pluck
+        # operation and also include the relation foreign key in the attributes to
+        # pluck for this model.
+        def configure_query
+          super
+
+          pluck_reflections = @options[:reflections] || {}
+
+          return if pluck_reflections.blank?
+
+          @has_one_through_reflections = { }
+
+          # We iterate through the class reflections passed as options
+          @klass_reflections.slice(*pluck_reflections.keys).
+          # And select those that are Through and which delegate reflection is a HasMany
+            select{|_, r| active_record_has_one_through_reflection?(r)}.
+          # And store them in the has_many_reflection hash that will be used later
+            each do |name, reflection|
+              name = name.to_sym
+              @has_one_through_reflections[name] = pluck_reflections[name]
+            end
+        end
+
+        ##
+        # In this method we get the reflections and for each one creates and
+        # executes a new plucker.
+        #
+        # This pluck gives the whole process a recursive character and options
+        # for that plucker may be passed in the options hash.
+        def build_results
+          super
+
+          return if @has_one_through_reflections.blank?
+
+          @has_one_through_reflections.each do |name, reflection|
+            # As an example we will imagine that we are plucking BlogPost and
+            # this relation is the :user, that is a relationship through
+            # Author
+
+            # We get the meta information about the :through reflection (:user)
+            klass_reflection = @klass_reflections[name]
+
+            # And also the has_many reflection (:posts) as we will need it to fetch information
+            reflection_to_pluck =  klass_reflection.chain.reverse.first
+
+            # initialize some options such as the plucker or the scope of the pluck
+            scope = reflection_to_pluck.klass.send(all_method)
+
+            # Essentially we are going to pluck the has_one relationship and
+            # add the reflections option so it recursively plucks the has_one
+            # :user reflection from BlogPost.
+            plucker = reflection[:plucker] || Pluckers::Base
+            plucker_options = {
+              attributes: [reflection_to_pluck.active_record_primary_key.to_sym],
+              reflections: { klass_reflection.source_reflection.name => reflection }
+            }
+
+            # In order to create this intermediary plucker we add a where to the
+            # scope, so we filter the records to pluck as we only get those with
+            # an id in the set of the foreign keys of the records already
+            # plucked by the base plucker
+            #
+            # In our Example we would be doing something like
+            # Author.all.where(id: author_ids)
+            reflection_plucker = plucker.new scope.where(
+                reflection_to_pluck.active_record_primary_key => @results.map{|_, r| r[reflection_to_pluck.foreign_key.to_sym] }
+              ),
+              plucker_options
+
+            # We initialize so we return an empty array if there are no record
+            # related
+            @results.each do |_, result|
+              result[name] ||= nil
+            end
+
+            reflection_plucker.pluck.each do |r|
+              @results.each do |_,result|
+                # For each related result (Author) we search those records
+                # (BlogPost) that are related (author.id == post.author_id) and
+                # insert not the record itself but the desired reflection in the
+                # result
+                if result[reflection_to_pluck.foreign_key.to_sym] == r[reflection_to_pluck.active_record_primary_key.to_sym]
+                  result[name] = r[name]
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pluckers/features/base/pluck.rb

@@ -0,0 +1,30 @@
+module Pluckers
+  ##
+  # This module groups diferent modules that will configure and build the
+  # results for a specific kind of information (attributes, translations,
+  # relations...)
+  #
+  # All this modules will have two methods, one for configuration (e.g, attributes
+  # to be included in the real pluck) and one for building the final results
+  module Features
+
+    module Base
+
+      ##
+      # This module implements the actual pluck. In ActiveRecord 4 and greater
+      # it just uses the standard `pluck' method but in other AR versions it
+      # could need some customizations.
+      module Pluck
+
+        def pluck_records fields_to_pluck
+          @records.pluck(*fields_to_pluck)
+        end
+
+        def all_method
+          :all
+        end
+
+      end
+    end
+  end
+end

data/lib/pluckers/features/base/renaming.rb

@@ -0,0 +1,55 @@
+module Pluckers
+  ##
+  # This module groups diferent modules that will configure and build the
+  # results for a specific kind of information (attributes, translations,
+  # relations...)
+  #
+  # All this modules will have two methods, one for configuration (e.g, attributes
+  # to be included in the real pluck) and one for building the final results
+  module Features
+
+    module Base
+
+      ##
+      # This module implements plucking belongs_to relationships in a recursive
+      # way.
+      #
+      # The options used in this feature are:
+      #
+      #  * renames: A hash of the attributes/reflections/whatever that will be
+      #    renamed. The key is the old name and the value is the new name.
+      #
+      module Renaming
+
+
+        ##
+        # Here we obtain the renames enabled for this plucker
+        def configure_query
+          super
+
+          @renames = @options.delete(:renames)
+          @renames ||= {}
+          @renames = @renames.with_indifferent_access
+
+        end
+
+        ##
+        # In this method we get the renames and check result by result which
+        # ones must be applied
+        def build_results
+          super
+
+          @renames.each do |old_name, new_name|
+            @results.each do |_,result|
+              if result.keys.include? old_name.to_sym
+                result[new_name.to_sym] = result.delete(old_name.to_sym)
+              end
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/pluckers/features/base/simple_attributes.rb

@@ -0,0 +1,64 @@
+module Pluckers
+  ##
+  # This module groups diferent modules that will configure and build the
+  # results for a specific kind of information (attributes, translations,
+  # relations...)
+  #
+  # All this modules will have two methods, one for configuration (e.g, fields
+  # to be included in the real pluck) and one for building the final results
+  module Features
+
+    module Base
+
+      ##
+      # This module implements fetching simple attributes (columns) from the
+      # database through the AR's pluck method.
+      #
+      # The options used in this feature are:
+      #
+      #  * attributes: Names of attributes of the objects to be plucked. This
+      #    attributes should be the names of the columns in the database.
+      module SimpleAttributes
+
+
+        ##
+        # Here we initialize the simple attributes to be retrieved and checks
+        # that those attributes exists in the current scope.
+        def configure_query
+          super
+
+          attributes = @options[:attributes]
+          attributes ||= default_attributes
+
+          plucker_attributes = attributes.map(&:to_sym)
+
+          klass_attributes = @records.attribute_names.map(&:to_sym)
+
+          # Validate that all attributes exists in the model
+          if (missing_attributes = plucker_attributes - klass_attributes).any?
+            raise ArgumentError.new("Plucker attributes '#{missing_attributes.to_sentence}', are missing in #{@records.klass}")
+          end
+
+          simple_attributes = plucker_attributes & klass_attributes
+
+          @attributes_to_pluck += simple_attributes.map {|f| { name: f, sql: "\"#{@records.table_name}\".#{f}" }}
+
+        end
+
+        ##
+        # We don't need to perform any extra operation as the pluck is executed
+        # in the Pluckers::Base class. We could omit this definition, but leave
+        # it for example purposes.
+        def build_results
+          super
+        end
+
+        ##
+        # This private method returns the default attributes that must be retrieved
+        private def default_attributes records = @records
+          records.attribute_names
+        end
+      end
+    end
+  end
+end

data/lib/pluckers/version.rb

@@ -0,0 +1,3 @@
+module Pluckers
+  VERSION = "1.0.0"
+end

data/lib/pluckers.rb

@@ -0,0 +1,7 @@
+require 'active_record'
+require "pluckers/base"
+require "pluckers/version"
+
+module Pluckers
+
+end

data/pluckers.gemspec

@@ -0,0 +1,38 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pluckers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pluckers"
+  spec.version       = Pluckers::VERSION
+  spec.authors       = ["David J. Brenes"]
+  spec.email         = ["gems@simplelogica.net"]
+  spec.license       = 'GPL-3.0'
+
+  spec.summary       = %q{Gem extending the idea behind AR's pluck method so we can fetch data from multiple tables}
+  spec.description   = %q{Gem extending the idea behind AR's pluck method so we can fetch data from multiple tables}
+  spec.homepage      = "https://github.com/simplelogica/pluckers"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(bin|gemfiles|test)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", "> 3.2", "< 5.1"
+
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "globalize"
+  spec.add_development_dependency "byebug"
+  spec.add_development_dependency "appraisal", "~> 2.1.0"
+end

metadata

@@ -0,0 +1,236 @@
+--- !ruby/object:Gem::Specification
+name: pluckers
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- David J. Brenes
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-03-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: globalize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+description: Gem extending the idea behind AR's pluck method so we can fetch data
+  from multiple tables
+email:
+- gems@simplelogica.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Appraisals
+- CHANGELOG
+- CODE_OF_CONDUCT.md
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- circle.yml
+- doc/idea.md
+- doc/usage/basics.md
+- doc/usage/extending.md
+- doc/usage/globalize.md
+- doc/usage/relationships.md
+- doc/usage/renaming.md
+- lib/pluckers.rb
+- lib/pluckers/base.rb
+- lib/pluckers/features/active_record_3_2.rb
+- lib/pluckers/features/active_record_3_2/belongs_to_reflections.rb
+- lib/pluckers/features/active_record_3_2/globalize.rb
+- lib/pluckers/features/active_record_3_2/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/active_record_3_2/has_many_reflections.rb
+- lib/pluckers/features/active_record_3_2/has_many_through_reflections.rb
+- lib/pluckers/features/active_record_3_2/has_one_reflections.rb
+- lib/pluckers/features/active_record_3_2/has_one_through_reflections.rb
+- lib/pluckers/features/active_record_3_2/pluck.rb
+- lib/pluckers/features/active_record_3_2/renaming.rb
+- lib/pluckers/features/active_record_3_2/simple_attributes.rb
+- lib/pluckers/features/active_record_4_0.rb
+- lib/pluckers/features/active_record_4_0/belongs_to_reflections.rb
+- lib/pluckers/features/active_record_4_0/globalize.rb
+- lib/pluckers/features/active_record_4_0/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/active_record_4_0/has_many_reflections.rb
+- lib/pluckers/features/active_record_4_0/has_many_through_reflections.rb
+- lib/pluckers/features/active_record_4_0/has_one_reflections.rb
+- lib/pluckers/features/active_record_4_0/has_one_through_reflections.rb
+- lib/pluckers/features/active_record_4_0/pluck.rb
+- lib/pluckers/features/active_record_4_0/renaming.rb
+- lib/pluckers/features/active_record_4_0/simple_attributes.rb
+- lib/pluckers/features/active_record_4_1.rb
+- lib/pluckers/features/active_record_4_1/belongs_to_reflections.rb
+- lib/pluckers/features/active_record_4_1/globalize.rb
+- lib/pluckers/features/active_record_4_1/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/active_record_4_1/has_many_reflections.rb
+- lib/pluckers/features/active_record_4_1/has_many_through_reflections.rb
+- lib/pluckers/features/active_record_4_1/has_one_reflections.rb
+- lib/pluckers/features/active_record_4_1/has_one_through_reflections.rb
+- lib/pluckers/features/active_record_4_1/pluck.rb
+- lib/pluckers/features/active_record_4_1/renaming.rb
+- lib/pluckers/features/active_record_4_1/simple_attributes.rb
+- lib/pluckers/features/active_record_4_2.rb
+- lib/pluckers/features/active_record_4_2/belongs_to_reflections.rb
+- lib/pluckers/features/active_record_4_2/globalize.rb
+- lib/pluckers/features/active_record_4_2/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/active_record_4_2/has_many_reflections.rb
+- lib/pluckers/features/active_record_4_2/has_many_through_reflections.rb
+- lib/pluckers/features/active_record_4_2/has_one_reflections.rb
+- lib/pluckers/features/active_record_4_2/has_one_through_reflections.rb
+- lib/pluckers/features/active_record_4_2/pluck.rb
+- lib/pluckers/features/active_record_4_2/renaming.rb
+- lib/pluckers/features/active_record_4_2/simple_attributes.rb
+- lib/pluckers/features/active_record_5_0.rb
+- lib/pluckers/features/active_record_5_0/belongs_to_reflections.rb
+- lib/pluckers/features/active_record_5_0/globalize.rb
+- lib/pluckers/features/active_record_5_0/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/active_record_5_0/has_many_reflections.rb
+- lib/pluckers/features/active_record_5_0/has_many_through_reflections.rb
+- lib/pluckers/features/active_record_5_0/has_one_reflections.rb
+- lib/pluckers/features/active_record_5_0/has_one_through_reflections.rb
+- lib/pluckers/features/active_record_5_0/pluck.rb
+- lib/pluckers/features/active_record_5_0/renaming.rb
+- lib/pluckers/features/active_record_5_0/simple_attributes.rb
+- lib/pluckers/features/base/belongs_to_reflections.rb
+- lib/pluckers/features/base/globalize.rb
+- lib/pluckers/features/base/has_and_belongs_to_many_reflections.rb
+- lib/pluckers/features/base/has_many_reflections.rb
+- lib/pluckers/features/base/has_many_through_reflections.rb
+- lib/pluckers/features/base/has_one_reflections.rb
+- lib/pluckers/features/base/has_one_through_reflections.rb
+- lib/pluckers/features/base/pluck.rb
+- lib/pluckers/features/base/renaming.rb
+- lib/pluckers/features/base/simple_attributes.rb
+- lib/pluckers/version.rb
+- pluckers.gemspec
+homepage: https://github.com/simplelogica/pluckers
+licenses:
+- GPL-3.0
+metadata:
+  allowed_push_host: https://rubygems.org
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Gem extending the idea behind AR's pluck method so we can fetch data from
+  multiple tables
+test_files: []