pluckers 1.0.0

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

@@ -0,0 +1,116 @@
+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:
+      #
+      #  * attributes: Names of attributes of the objects to be plucked. This
+      #    attributes should be the names of the translated attributes by Globalize.
+      #
+      #  * attributes_with_locale: A hash when the key is a locale and the value
+      #    is an array of attributes to pluck. As a result we will have a series of
+      #    attributes with the name following the syntax attreibute_locale. E.g: The
+      #    option could be { es: [:name], en: [:name, :location]} and we would obtain
+      #    :name_es, :name_en and :location_en keys in the hash result
+
+      module Globalize
+
+
+        ##
+        # Here we include in the @attributes_to_pluck array the attribute names
+        # and SQL required for Globalize
+        def configure_query
+          super
+
+          return if @klass_reflections[:translations].nil?
+
+          if @options[:attributes]
+
+            # First we get those attributes received bia the attributes option
+            # that must be translated
+            plucker_attributes = @options[:attributes].map(&:to_sym)
+
+            klass_translated_attributes = @records.try(:translated_attribute_names) || []
+            klass_translated_attributes = klass_translated_attributes.map(&:to_sym)
+
+            @translated_attributes = plucker_attributes & klass_translated_attributes
+
+            # And we remove it from the attributes options, so the simple
+            # attributes feature don't receive them
+            @options[:attributes] = plucker_attributes - klass_translated_attributes
+
+          end
+
+          # And initialize with an empty array if we didn't receive any
+          @translated_attributes ||= []
+
+          # And then get the attributes that must be returned for a specific locale
+          @attributes_with_locale = @options[:attributes_with_locale] || {}
+
+          unless @translated_attributes.blank? && @attributes_with_locale.blank?
+
+            # We obtain the info about the translations relation
+            translation_table_name = @records.klass::Translation.table_name
+            translation_foreign_key = @klass_reflections[:translations].foreign_key
+
+            # And we perform a join for each locale
+            fallbacks = ::Globalize.fallbacks(::Globalize.locale)
+
+            fallbacks.each do |locale|
+              @records = @records.joins(
+                "LEFT OUTER JOIN #{translation_table_name} AS locale_#{locale}_translation ON (
+                  #{@records.klass.table_name}.id = locale_#{locale}_translation.#{translation_foreign_key} AND
+                  locale_#{locale}_translation.locale = '#{locale}'
+                )")
+
+            end
+
+            # The attribute to pluck must get the first non nil field
+            @attributes_to_pluck += @translated_attributes.map do |field|
+              {
+                name: field,
+                sql: "COALESCE(NULL, #{
+                  fallbacks.map{|locale| "locale_#{locale}_translation.#{field}" }.join(',')
+                  })"
+              }
+            end
+
+            # For the attributes with locale (name_es, name_en...)
+            @attributes_with_locale.each do |locale, attributes|
+
+              # We add the locales that are not fallback
+              unless fallbacks.include? locale
+                @records = @records.joins(
+                  "LEFT OUTER JOIN #{translation_table_name} AS locale_#{locale}_translation ON (
+                    #{@records.klass.table_name}.id = locale_#{locale}_translation.#{translation_foreign_key} AND
+                    locale_#{locale}_translation.locale = '#{locale}'
+                  )")
+              end
+
+              # And we add the attribute to be plucked
+              @attributes_to_pluck += attributes.map do |field|
+                {
+                  name: "#{field}_#{locale}".to_sym,
+                  sql: "locale_#{locale}_translation.#{field}"
+                }
+              end
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,190 @@
+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_and_belongs_to_many 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 HasAndBelongsToManyReflections
+
+
+        ##
+        # Here we obtain the has_many 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_and_belongs_to_many_reflections = { }
+
+          # We iterate through the class reflections passed as options
+          @klass_reflections.slice(*pluck_reflections.keys).
+          # And select those that are HasMany
+            select{|_, r| active_record_has_and_belongs_to_many_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_and_belongs_to_many_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_and_belongs_to_many_reflections.blank?
+
+          build_only_ids_has_and_belongs_to_many_reflections
+          build_complete_has_and_belongs_to_many_reflections
+
+        end
+
+        ##
+        # This method build the reflections completely, creating hashes for each record, etc.
+        #
+        # It searches reflections that has not the :only_ids option enabled and
+        # then creates pluckers for them.
+        private def build_complete_has_and_belongs_to_many_reflections
+
+          @has_and_belongs_to_many_reflections.reject {|_, reflection| reflection[:only_ids] }.each do |name, reflection|
+            # As an example we will imagine that we are plucking Authors and
+            # this relation is the :posts
+
+            # 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
+
+            # We will use the _ids already fetched to check which records we should pluck
+            ids_reflection_name = "#{name.to_s.singularize}_ids".to_sym
+
+            ids_to_query = @results.map do |_, result|
+              result[ids_reflection_name]
+            end
+
+            ids_to_query = ids_to_query.flatten
+
+
+
+            # 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 _ids arrays already plucked
+            #
+            # In our Example we would be doing something like
+            # Category.all.where(id: category_ids)
+            reflection_plucker = plucker.new scope.where(id: ids_to_query), reflection
+
+            # We initialize so we return an empty array if there are no record
+            # related
+            @results.each do |_, result|
+              result[name] ||= []
+            end
+
+
+            reflection_plucker.pluck.each do |r|
+              @results.each do |_,result|
+                # For each related result (category) we search those records
+                # (BlogPost) that include the category id in its _ids array
+                if result[ids_reflection_name].include? r[:id].to_i
+                  result[name] << r
+                end
+              end
+            end
+
+            # And now we get rid of duplicates
+            @results.each do |_,result|
+              result[name].uniq!
+            end
+
+          end
+        end
+
+        ##
+        # This method build the ids for the records instead of creating the hashes.
+        #
+        # Unlike the has_many relationships, we don't search reflections that
+        # has the :only_ids option enabled as we will need these ids also for
+        # the other relationships.
+        private def build_only_ids_has_and_belongs_to_many_reflections
+
+          @has_and_belongs_to_many_reflections.each do |name, reflection|
+            # As an example we will imagine that we are plucking BlogPosts and
+            # this relation is the :categories one
+
+            # We get the meta information about the reflection
+            klass_reflection = @klass_reflections[name]
+
+            # We get the ids. This query is dependant on the ActiveRecord
+            # version, so every feature version has a different implementation
+            join_results = has_and_belongs_to_many_ids(klass_reflection)
+
+            ids_reflection_name = "#{name.to_s.singularize}_ids".to_sym
+
+            # Next, we initialize the _ids array for each result
+            @results.each do |_, result|
+              result[ids_reflection_name] ||= []
+            end
+
+            # And now, the foreign_keys.
+            # In our example with BlogPost and Category they would be:
+            # model_foreign_key = blog_post_id
+            # related_model_foreign_key = category_id
+            model_foreign_key = klass_reflection.foreign_key
+            related_model_foreign_key = klass_reflection.association_foreign_key
+
+            # And for each result we fill the results
+            join_results.each do |r|
+              @results[r[model_foreign_key].to_i][ids_reflection_name] << r[related_model_foreign_key].to_i
+            end
+
+            # And eliminate duplicates
+            @results.each do |_,result|
+              result[ids_reflection_name].uniq!
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,193 @@
+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 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.
+      #
+      #    - only_ids: We can get the _ids array instead of an array with hashes
+      #      if we pass this option as true. If we do any fields or plucker
+      #      option will be ignored.
+      #
+      #    - 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 HasManyReflections
+
+
+        ##
+        # Here we obtain the has_many 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_many_reflections = { }
+
+          # We iterate through the class reflections passed as options
+          @klass_reflections.slice(*pluck_reflections.keys).
+          # And select those that are HasMany
+            select{|_, r| active_record_has_many_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_many_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_many_reflections.blank?
+
+          build_complete_reflections
+          build_only_ids_reflections
+
+        end
+
+        ##
+        # This method build the reflections completely, creating hashes for each record, etc.
+        #
+        # It searches reflections that has not the :only_ids option enabled and
+        # then creates pluckers for them.
+        private def build_complete_reflections
+
+          @has_many_reflections.reject {|_, reflection| reflection[:only_ids] }.each do |name, reflection|
+            # As an example we will imagine that we are plucking Authors and
+            # this relation is the :posts
+
+            # 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
+            # BlogPost.all.where(author_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 an empty array if there are no record
+            # related
+            @results.each do |_, result|
+              result[name] ||= []
+            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 them in the relationship attributes
+                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
+
+        ##
+        # This method build the ids for the records instead of creating the hashes.
+        #
+        # It searches reflections that has the :only_ids option enabled and then
+        # creates pluckers for them.
+        private def build_only_ids_reflections
+
+          @has_many_reflections.select {|_, reflection| reflection[:only_ids] }.each do |name, reflection|
+            # As an example we will imagine that we are plucking Authors and
+            # this relation is the :posts
+
+            # We get the meta information about the reflection
+            klass_reflection = @klass_reflections[name]
+
+            # We can send an scope option for filtering the related records
+            scope = reflection[:scope] || klass_reflection.klass.send(all_method)
+
+            # We override the attributes as we only get the required ones for
+            # relating the records
+            reflection[:attributes] = [klass_reflection.foreign_key.to_sym, klass_reflection.active_record_primary_key.to_sym]
+
+            # And now, create the plucker, filtering the records so we only get
+            # the related ones
+            reflection_plucker = Pluckers::Base.new scope.where(
+                klass_reflection.foreign_key => @results.map{|_, r| r[klass_reflection.active_record_primary_key.to_sym] }
+              ),
+              reflection
+
+            # Now we create the _ids attribute for each result
+            ids_reflection_name = "#{name.to_s.singularize}_ids".to_sym
+
+            @results.each do |_, result|
+              result[ids_reflection_name] ||= []
+            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 the id in the _ids array
+                  if result[klass_reflection.active_record_primary_key.to_sym] == r[klass_reflection.foreign_key.to_sym]
+                    result[ids_reflection_name] << r[klass_reflection.active_record_primary_key.to_sym]
+                  end
+                end
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,131 @@
+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 HasManyThroughReflections
+
+
+        ##
+        # 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_many_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_many_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_many_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_many_through_reflections.blank?
+
+          @has_many_through_reflections.each do |name, reflection|
+            # As an example we will imagine that we are plucking Authors and
+            # this relation is the :references, that is a relationship through
+            # BlogPost
+
+            # We get the meta information about the :through reflection (:references)
+            klass_reflection = @klass_reflections[name]
+
+            # And also the has_many reflection (:posts) as we wiil 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_many relationship and
+            # add the reflections option so it recursively plucks the has_many
+            # :references reflection from BlogPost.
+            plucker = reflection[:plucker] || Pluckers::Base
+            plucker_options = {
+              attributes: [reflection_to_pluck.foreign_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
+            # BlogPost.all.where(author_id: author_ids)
+            reflection_plucker = plucker.new scope.where(
+                reflection_to_pluck.foreign_key => @results.map{|_, r| r[reflection_to_pluck.active_record_primary_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] ||= []
+            end
+
+            reflection_plucker.pluck.each do |r|
+              @results.each do |_,result|
+                # For each related result (BlogPost) we search those records
+                # (Author) 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.active_record_primary_key.to_sym] == r[reflection_to_pluck.foreign_key.to_sym] &&
+                  r[klass_reflection.source_reflection.name]
+
+                  result[name] += [r[klass_reflection.source_reflection.name]].flatten
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end