irie 1.0.0

data/lib/irie/extensions/paging.rb

@@ -0,0 +1,43 @@
+module Irie
+  module Extensions
+    # Allows paging of results.
+    module Paging
+      extend ::ActiveSupport::Concern
+      ::Irie.available_extensions[:paging] = '::' + Paging.name
+
+      included do
+        include ::Irie::ParamAliases
+
+        class_attribute(:number_of_records_in_a_page, instance_writer: true) unless self.respond_to? :number_of_records_in_a_page
+
+        self.number_of_records_in_a_page = ::Irie.number_of_records_in_a_page
+      end
+
+      def index(options={}, &block)
+        logger.debug("Irie::Extensions::Count.index") if ::Irie.debug?
+        return super(options, &block) unless aliased_param_present?(:page_count)
+        @page_count = (collection.count.to_f / self.number_of_records_in_a_page.to_f).ceil
+        return respond_to?(:autorender_page_count, true) ? autorender_page_count(options, &block) : super(options, &block)
+      end
+
+      protected
+
+      def collection
+        logger.debug("Irie::Extensions::Paging.collection") if ::Irie.debug?
+        object = super
+        page_param_value = aliased_param(:page)
+        unless page_param_value.nil?
+          page = page_param_value.to_i
+          page = 1 if page < 1
+          object = object.offset((self.number_of_records_in_a_page * (page - 1)).to_s)
+          object = object.limit(self.number_of_records_in_a_page.to_s)
+        end
+
+        logger.debug("Irie::Extensions::Paging.collection: relation.to_sql so far: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+
+        set_collection_ivar object
+      end
+
+    end
+  end
+end

data/lib/irie/extensions/paging/autorender_page_count.rb

@@ -0,0 +1,19 @@
+module Irie
+  module Extensions
+    module Paging
+      # Standard rendering of index page count in all formats except html so you don't need views for them.
+      module AutorenderPageCount
+        extend ::ActiveSupport::Concern
+        ::Irie.available_extensions[:autorender_page_count] = '::' + AutorenderPageCount.name
+
+        protected
+
+        def autorender_page_count(options={}, &block)
+          logger.debug("Irie::Extensions::Paging::AutorenderPageCount.autorender_page_count") if ::Irie.debug?
+          render request.format.symbol => { page_count: @page_count }, status: 200, layout: false
+        end
+        
+      end
+    end
+  end
+end

data/lib/irie/extensions/param_filters.rb

@@ -0,0 +1,137 @@
+module Irie
+  module Extensions
+    # Allows filtering of results using ARel predicates.
+    module ParamFilters
+      extend ::ActiveSupport::Concern
+      ::Irie.available_extensions[:param_filters] = '::' + ParamFilters.name
+
+      included do
+        include ::Irie::ParamAliases
+
+        class_attribute(:default_filtered_by, instance_writer: true) unless self.respond_to? :default_filtered_by
+        class_attribute(:composite_param_to_param_name_and_arel_predicate, instance_writer: true) unless self.respond_to? :composite_param_to_param_name_and_arel_predicate
+
+        self.default_filtered_by ||= {}
+        self.composite_param_to_param_name_and_arel_predicate ||= {}
+      end
+
+      module ClassMethods
+
+        protected
+        
+        # A whitelist of filters and definition of filter options related to request parameters.
+        #
+        # If no options are provided or the :using option is provided, defines attributes that are queryable through the operation(s) already defined in can_filter_by_default_using, or can specify attributes:
+        #   can_filter_by :attr_name_1, :attr_name_2 # implied using: [eq] if RestfulJson.can_filter_by_default_using = [:eq] 
+        #   can_filter_by :attr_name_1, :attr_name_2, using: [:eq, :not_eq]
+        #
+        # When :through is specified, it will take the array supplied to through as 0 to many model names following by an attribute name. It will follow through
+        # each association until it gets to the attribute to filter by that via ARel joins, e.g. if the model Foobar has an association to :foo, and on the Foo model there is an assocation
+        # to :bar, and you want to filter by bar.name (foobar.foo.bar.name):
+        #   can_filter_by :my_param_name, through: {foo: {bar: :name}}
+        #
+        # It also supports param to attribute name/joins via define_params, e.g.
+        #   define_params car: :car_attr_name
+        #   can_filter_by :car
+        def can_filter_by(*args)
+          options = args.extract_options!
+
+          opt_using = options.delete(:using)
+          opt_through = options.delete(:through)
+          opt_split = options.delete(:split)
+          raise ::Irie::ConfigurationError.new "options #{options.inspect} not supported by can_filter_by" if options.present?
+
+          self.composite_param_to_param_name_and_arel_predicate = self.composite_param_to_param_name_and_arel_predicate.deep_dup
+
+          # :using is the default action if no options are present
+          if opt_using || options.size == 0
+            predicates = Array.wrap(opt_using || self.can_filter_by_default_using)
+            predicates.each do |predicate|
+              predicate_sym = predicate.to_sym
+              args.each do |param_name|
+                param_name = param_name.to_s
+                if predicate_sym == :eq
+                  self.composite_param_to_param_name_and_arel_predicate[param_name] = [param_name, :eq, opt_split]
+                end
+
+                self.composite_param_to_param_name_and_arel_predicate["#{param_name}#{self.predicate_prefix}#{predicate}"] = [param_name, predicate_sym, opt_split]
+              end
+            end
+          end
+
+          if opt_through
+            raise ::Irie::ConfigurationError.new "Must use extension :params_to_joins to use can_order_by :through" unless ancestors.include?(::Irie::Extensions::ParamsToJoins)
+            args.each do |through_key|
+              # note: handles cloning, etc.
+              self.define_params(through_key => opt_through)
+            end
+          end
+        end
+
+        # Specify default filters and predicates to use if no filter is provided by the client with
+        # the same param name, e.g. if you have:
+        #   default_filter_by :attr_name_1, eq: 5
+        #   default_filter_by :production_date, :creation_date, gt: 1.year.ago, lteq: 1.year.from_now
+        # and both attr_name_1 and production_date are supplied by the client, then it would filter
+        # by the client's attr_name_1 and production_date and filter creation_date by
+        # both > 1 year ago and <= 1 year from now.
+        def default_filter_by(*args)
+          options = args.extract_options!
+
+          self.default_filtered_by = self.default_filtered_by.deep_dup
+          
+          args.each do |param_name|
+            param_name = param_name.to_s
+            if self.default_filtered_by[param_name]
+              # have merge create new instance to help avoid subclass inheritance related sharing issues.
+              self.default_filtered_by[param_name] = self.default_filtered_by[param_name].merge(options)
+            else
+              self.default_filtered_by[param_name] = options
+            end
+          end
+        end
+      end
+
+      protected
+
+      def collection
+        logger.debug("Irie::Extensions::ParamFilters.collection") if ::Irie.debug?
+        object = super
+        already_filtered_by_split_param_names = []
+        self.composite_param_to_param_name_and_arel_predicate.each do |composite_param, param_name_and_arel_predicate, split|
+          if params.key?(composite_param)
+            split_param_name, predicate_sym = *param_name_and_arel_predicate
+            converted_param_values = converted_param_values.collect{|p| p.split(*split)}.flatten unless split.blank?
+            converted_param_values = convert_param(composite_param, params[composite_param])
+            # support for named_params/:through renaming of param name
+            attr_sym = attr_sym_for_param(split_param_name)
+            join_to_apply = join_for_param(split_param_name)
+            object = object.joins(join_to_apply) if join_to_apply
+            arel_table_column = get_arel_table(split_param_name)[attr_sym]
+            raise ::Irie::ConfigurationError.new "can_filter_by/define_params config problem: could not find arel table/column for param name #{split_param_name.inspect} and/or attr_sym #{attr_sym.inspect}" unless arel_table_column
+            object = object.where(arel_table_column.send(predicate_sym, converted_param_values))
+            already_filtered_by_split_param_names << split_param_name
+          end
+        end
+
+        self.default_filtered_by.each do |split_param_name, predicates_to_default_values|
+          unless already_filtered_by_split_param_names.include?(split_param_name) || predicates_to_default_values.blank?
+            attr_sym = attr_sym_for_param(split_param_name)
+            join_to_apply = join_for_param(split_param_name)
+            object = object.joins(join_to_apply) if join_to_apply
+            arel_table_column = get_arel_table(split_param_name)[attr_sym]
+            raise ::Irie::ConfigurationError.new "default_filter_by/define_params config problem: could not find arel table/column for param name #{split_param_name.inspect} and/or attr_sym #{attr_sym.inspect}" unless arel_table_column
+            predicates_to_default_values.each do |predicate_sym, one_or_more_default_values|
+              object = object.where(arel_table_column.send(predicate_sym, Array.wrap(one_or_more_default_values)))
+            end
+          end
+        end
+
+        logger.debug("Irie::Extensions::ParamFilters.collection: relation.to_sql so far: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+        
+        set_collection_ivar object
+      end
+
+    end
+  end
+end

data/lib/irie/extensions/params_to_joins.rb

@@ -0,0 +1,108 @@
+module Irie
+  module Extensions
+    # Depended on by some extensions to handle joins.
+    module ParamsToJoins
+      extend ::ActiveSupport::Concern
+      ::Irie.available_extensions[:params_to_joins] = '::' + ParamsToJoins.name
+
+      included do
+        class_attribute(:params_to_joins, instance_writer: true) unless self.respond_to? :params_to_joins
+        
+        self.params_to_joins ||= {}
+      end
+
+      module ClassMethods
+
+        protected
+        
+        # An alterative method to defining :through options (for can_filter_by, can_order_by, etc.)
+        # in a single place that isn't on the same line as another class method.
+        #
+        # E.g.:
+        #
+        #   define_params name: {company: {employee: :full_name}},
+        #                 color: :external_color
+        #   can_filter_by :name
+        #   default_filter_by :name, eq: 'Guest'
+        #   can_order_by :color
+        #   default_filter_by :color, eq: 'blue'
+        def define_params(*args)
+          options = args.extract_options!
+
+          raise ::Irie::ConfigurationError.new "define_param(s) only takes a single hash of param name(s) to hash(es)" if args.length > 0
+
+          self.params_to_joins = self.params_to_joins.deep_dup
+
+          options.each do |param_name, through_val|
+            param_name = param_name.to_s
+            self.params_to_joins[param_name.to_s] = (convert = ->(hsh, orig=nil) do
+              orig ||= hsh
+              case hsh
+              when String, Symbol
+                {attr_sym: hsh.to_sym}
+              when Hash
+                case hsh.values.first
+                when String, Symbol
+                  {attr_sym: hsh.values.first.to_sym, joins: hsh.keys.first}
+                when Hash
+                  case hsh.values.first.values.first
+                  when String, Symbol
+                    attr_name = hsh.values.first.values.first
+                    hsh[hsh.keys.first] = hsh.values.first.keys.first
+                    {attr_sym: attr_name.to_sym, joins: orig}
+                  when Hash
+                    convert.call(hsh.values.first, orig)
+                  else
+                    raise ::Irie::ConfigurationError.new "Invalid :through option: #{hsh.values.first.values.first} in #{self}"
+                  end
+                else
+                  raise ::Irie::ConfigurationError.new "Invalid :through option: #{hsh.values.first} in #{self}"
+                end
+              else
+                raise ::Irie::ConfigurationError.new "Invalid :through option: #{hsh} in #{self}"
+              end
+            end)[through_val.deep_dup]
+          end
+
+          self.params_to_joins
+        end
+      end
+
+      protected
+
+      # Returns attribute name for the param name.
+      def attr_sym_for_param(param_name)
+        self.params_to_joins[param_name].try(:[], :attr_sym) || param_name
+      end
+
+      # Returns value to be used for the `.joins` query method.
+      def join_for_param(param_name)
+        self.params_to_joins[param_name].try(:[], :joins)
+      end
+
+      # Walk any configured :through options to get the ARel table or return resource_class.arel_table.
+      def get_arel_table(param_name)
+        opts = self.params_to_joins[param_name.to_s] || {}
+        hsh = opts[:joins]
+        return resource_class.arel_table unless hsh && hsh.size > 0
+        # find arel_table corresponding to
+        find_assoc_resource_class = ->(last_resource_class, assoc_name) do
+          next_class = last_resource_class.reflections.map{|refl_assoc_name, refl| refl.class_name.constantize if refl_assoc_name.to_s == assoc_name.to_s}.compact.first
+          raise ::Irie::ConfigurationError.new "#{last_resource_class} is missing association #{hsh.values.first} defined in #{self} through option or define_params" unless next_class
+          next_class
+        end
+
+        (find_arel_table = ->(last_resource_class, val) do
+          case val
+          when String, Symbol
+            find_assoc_resource_class.call(last_resource_class, val).arel_table
+          when Hash
+            find_arel_table.call(find_assoc_resource_class.call(last_resource_class, val.keys.first), val.values.first)
+          else
+            raise ::Irie::ConfigurationError.new "get_arel_table failed because unhandled #{val} in joins in through"
+          end
+        end)[resource_class, opts[:joins]]
+      end
+    end
+  end
+end

data/lib/irie/extensions/query_filter.rb

@@ -0,0 +1,58 @@
+module Irie
+  module Extensions
+    # Allows use of a lambda to work with request parameters to filter results.
+    module QueryFilter
+      extend ::ActiveSupport::Concern
+      ::Irie.available_extensions[:query_filter] = '::' + QueryFilter.name
+
+      included do
+        include ::Irie::ParamAliases
+
+        class_attribute(:param_to_query, instance_writer: true) unless self.respond_to? :param_to_query
+        
+        self.param_to_query ||= {}
+      end
+
+      module ClassMethods
+
+        protected
+        
+        # Specify a custom query to filter by if the named request parameter is provided, e.g.
+        #   can_filter_by_query status: ->(q, status) { status == 'all' ? q : q.where(:status => status) },
+        #                       color: ->(q, color) { color == 'red' ? q.where("color = 'red' or color = 'ruby'") : q.where(:color => color) }
+        def can_filter_by_query(*args)
+          options = args.extract_options!
+
+          raise ::Irie::ConfigurationError.new "arguments #{args.inspect} are not supported by can_filter_by_query" if args.length > 0
+
+          self.param_to_query = self.param_to_query.deep_dup
+          
+          options.each do |param_name, proc|
+            self.param_to_query[param_name.to_sym] = proc
+          end
+        end
+      end
+
+      protected
+
+      def collection
+        logger.debug("Irie::Extensions::QueryFilter.collection") if ::Irie.debug?
+        object = super
+        # convert to relation if model class because proc expects a relation
+        object = object.all unless object.is_a?(ActiveRecord::Relation)
+
+        this_includes = self.action_to_query_includes[params[:action].to_sym] || self.all_action_query_includes
+        self.param_to_query.each do |param_name, param_query|
+          param_value = params[param_name]
+          unless param_value.nil?
+            object = param_query.call(object, convert_param(param_name.to_s, param_value))
+          end
+        end
+
+        logger.debug("Irie::Extensions::QueryFilter.collection: relation.to_sql so far: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+
+        set_collection_ivar object
+      end
+    end
+  end
+end

data/lib/irie/extensions/query_includes.rb

@@ -0,0 +1,107 @@
+module Irie
+  module Extensions
+    # Allows ability to do `.includes(...)` on query to avoid n+1 queries.
+    module QueryIncludes
+      extend ::ActiveSupport::Concern
+      ::Irie.available_extensions[:query_includes] = '::' + QueryIncludes.name
+
+      included do
+        include ::Irie::ParamAliases
+
+        class_attribute(:action_to_query_includes, instance_writer: true) unless self.respond_to? :action_to_query_includes
+        class_attribute(:all_action_query_includes, instance_writer: true) unless self.respond_to? :all_action_query_includes
+
+        self.action_to_query_includes ||= {}
+        self.all_action_query_includes ||= []
+      end
+
+      module ClassMethods
+
+        protected
+        
+        # Calls .includes(*args) on all action queries with args provided to query_includes, e.g.:
+        #   query_includes :category, :comments
+        # or:
+        #   query_includes posts: [{comments: :guest}, :tags]
+        # Note that query_includes_for overrides includes specified by query_includes.
+        def query_includes(*args)
+          options = args.extract_options!
+
+          self.all_action_query_includes = self.all_action_query_includes.deep_dup
+          old_options = self.all_action_query_includes.extract_options!
+          self.all_action_query_includes = (self.all_action_query_includes + args).uniq
+          self.all_action_query_includes << old_options.merge(options)
+        end
+
+        # Calls .includes(...) only on specified action queries, e.g.:
+        #   query_includes_for :create, :update, are: [:category, :comments]
+        #   query_includes_for :index, are: [posts: [{comments: :guest}, :tags]]
+        def query_includes_for(*args)
+          options = args.extract_options!
+
+          opt_are = options.delete(:are)
+          raise ::Irie::ConfigurationError.new "options #{options.inspect} not supported by can_filter_by" if options.present?
+
+          self.action_to_query_includes = self.action_to_query_includes.deep_dup
+
+          args.each do |an_action|
+            if opt_are
+              (self.action_to_query_includes ||= {}).merge!({an_action.to_sym => opt_are})
+            else
+              raise ::Irie::ConfigurationError.new "#{self.class.name} must supply an :are option with includes_for #{an_action.inspect}"
+            end
+          end
+        end
+      end
+
+      protected
+      
+      def collection
+        logger.debug("Irie::Extensions::QueryIncludes.collection") if ::Irie.debug?
+        object = super
+        
+        this_includes = self.action_to_query_includes[params[:action].to_sym] || self.all_action_query_includes
+        if this_includes && this_includes.size > 0
+          object = object.includes(*this_includes)
+        else
+          object
+        end
+
+        logger.debug("Irie::Extensions::QueryIncludes.collection: relation.to_sql so far: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+
+        set_collection_ivar object
+      end
+
+      def resource
+        logger.debug("Irie::Extensions::QueryIncludes.resource") if ::Irie.debug?
+        this_includes = self.action_to_query_includes[params[:action].to_sym] || self.all_action_query_includes
+        if this_includes && this_includes.size > 0
+          # can return the model class, so won't call bang (includes!) method
+          object = end_of_association_chain.includes(*this_includes)
+
+          logger.debug("Irie::Extensions::QueryIncludes.resource: end_of_association_chain.to_sql: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+
+          set_resource_ivar object.send(method_for_find, params[:id])
+        else
+          super
+        end
+      end
+
+      def build_resource
+        logger.debug("Irie::Extensions::QueryIncludes.build_resource") if ::Irie.debug?
+        this_includes = self.action_to_query_includes[params[:action].to_sym] || self.all_action_query_includes
+        if this_includes && this_includes.size > 0
+          # can return the model class, so won't call bang (includes!) method
+          object = end_of_association_chain.includes(*this_includes)
+
+          logger.debug("Irie::Extensions::QueryIncludes.build_resource: end_of_association_chain.to_sql: #{object.to_sql}") if ::Irie.debug? && object.respond_to?(:to_sql)
+
+          set_resource_ivar object.send(method_for_build, *resource_params)
+        else
+          object
+        end
+      end
+
+    end
+  end
+end