rice_cooker 0.1.1

data/lib/rice_cooker/helpers.rb

@@ -0,0 +1,287 @@
+require 'active_support'
+
+module RiceCooker
+  # Will be thrown when invalid sort param
+  class InvalidSortException < Exception
+  end
+
+  class InvalidFilterException < Exception
+  end
+
+  class InvalidFilterValueException < Exception
+  end
+
+  class InvalidRangeException < Exception
+  end
+
+  class InvalidRangeValueException < Exception
+  end
+
+  module Helpers
+    extend ActiveSupport::Concern
+
+    # From https://github.com/josevalim/inherited_resources/blob/master/lib/inherited_resources/class_methods.rb#L315
+    def controller_resource_class(controller)
+      detected_resource_class = nil
+
+      if controller.respond_to? :name
+        detected_resource_class ||= begin
+          namespaced_class = controller.name.sub(/Controller$/, '').singularize
+          namespaced_class.constantize
+        rescue NameError
+          nil
+        end
+
+        # Second priority is the top namespace model, e.g. EngineName::Article for EngineName::Admin::ArticlesController
+        detected_resource_class ||= begin
+          namespaced_classes = controller.name.sub(/Controller$/, '').split('::')
+          namespaced_class = [namespaced_classes.first, namespaced_classes.last].join('::').singularize
+          namespaced_class.constantize
+        rescue NameError
+          nil
+        end
+
+        # Third priority the camelcased c, i.e. UserGroup
+        detected_resource_class ||= begin
+          camelcased_class = controller.name.sub(/Controller$/, '').gsub('::', '').singularize
+          camelcased_class.constantize
+        rescue NameError
+          nil
+        end
+
+      elsif controller.respond_to? :controller_name
+        # Otherwise use the Group class, or fail
+        detected_resource_class ||= begin
+          class_name = controller.controller_name.classify
+          class_name.constantize
+        rescue NameError => e
+          raise unless e.message.include?(class_name)
+          nil
+        end
+      else
+        detected_resource_class = nil
+      end
+      detected_resource_class
+    end
+
+    # Overridable method for available sortable fields
+    def sortable_fields_for(model)
+      if model.respond_to?(:sortable_fields)
+        model.sortable_fields.map(&:to_sym)
+      elsif model.respond_to?(:column_names)
+        model.column_names.map(&:to_sym)
+      else
+        []
+      end
+    end
+
+    # Overridable method for available filterable fields
+    def filterable_fields_for(model)
+      if model.respond_to?(:filterable_fields)
+        model.filterable_fields.map(&:to_sym)
+      elsif model.respond_to?(:column_names)
+        model.column_names.map(&:to_sym)
+      else
+        []
+      end
+    end
+
+    # Overridable method for available rangeable fields
+    def rangeable_fields_for(model)
+      if model.respond_to?(:rangeable_fields)
+        model.rangeable_fields.map(&:to_sym)
+      else
+        filterable_fields_for(model)
+      end
+    end
+
+    # ------------------------ Sort helpers --------------------
+
+    # model -> resource_class with inherited resources
+    def parse_sorting_param(sorting_param, model)
+      return {} unless sorting_param.present?
+
+      sorting_params = CSV.parse_line(URI.unescape(sorting_param)).collect do |sort|
+        if sort.start_with?('-')
+          sorting_param = { field: sort[1..-1].to_s.to_sym, direction: :desc}
+        else
+          sorting_param = { field: sort.to_s.to_sym, direction: :asc}
+        end
+
+        check_sorting_param(model, sorting_param)
+        sorting_param
+      end
+      sorting_params.map { |par| [par[:field], par[:direction]] }.to_h
+    end
+
+    def check_sorting_param(model, sorting_param)
+      sort_field = sorting_param[:field]
+      sortable_fields = sortable_fields_for(model)
+
+      unless sortable_fields.include? sort_field.to_sym
+        raise InvalidSortException, "The #{sort_field} field is not sortable"
+      end
+    end
+
+    def param_from_defaults(sorting_params)
+      sorting_params.map { |k, v| "#{v == :desc ? '-' : ''}#{k}" }.join(',')
+    end
+
+    def apply_sort_to_collection(collection, sorting_params)
+      return collection unless collection.any?
+      # p "Before apply: #{sorting_params.inspect}"
+      collection.order(sorting_params)
+    end
+
+    # ------------------------ Filter helpers --------------------
+
+    # Va transformer le param url en hash exploitable
+    def parse_filtering_param(filtering_param, allowed_params)
+      return {} unless filtering_param.present?
+
+      fields = {}
+
+      # Extract the fields for each type from the fields parameters
+      if filtering_param.is_a?(Hash)
+        filtering_param.each do |field, value|
+          resource_fields = value.split(',') unless value.nil? || value.empty?
+          fields[field.to_sym] = resource_fields
+        end
+      else
+        raise InvalidFilterException, "Invalid filter format for #{filtering_param}"
+      end
+      check_filtering_param(fields, allowed_params)
+      fields
+    end
+
+    # Our little barrier <3
+    def check_filtering_param(filtering_param, allowed)
+      🔞 = filtering_param.keys.map(&:to_sym) - allowed.map(&:to_sym)
+      raise InvalidFilterException, "Attributes #{🔞.map(&:to_s).to_sentence} doesn't exists or aren't filterables. Available filters are: #{allowed.to_sentence}" if 🔞.any?
+    end
+
+    # On va essayer de garder un format commun, qui est:
+    #
+    # ```
+    # filter: {
+    #   proc: -> (values) { * je fais des trucs avec les values * },
+    #   all: ['les', 'valeurs', 'aceptées'],
+    #   description: "La description dans la doc"
+    # }
+    # ```
+    #
+    # On va donc transformer `additional` dans le format ci-dessus
+    #
+    def format_additional_param(additional, context_format = 'filtering')
+      if additional.is_a? Hash
+        additional = additional.map do |field, value|
+          if value.is_a?(Hash)
+            value = {
+              proc: nil,
+              all: [],
+              description: ''
+            }.merge(value)
+          elsif value.is_a? Array
+            value = {
+              proc: value.try(:at, 0),
+              all: value.try(:at, 1) || [],
+              description: value.try(:at, 2) || ''
+            }
+          elsif value.is_a? Proc
+            value = {
+              proc: value,
+              all: [],
+              description: ''
+            }
+          else
+            raise "Unable to format addional #{context_format} params (got #{additional})"
+          end
+          [field, value]
+        end.to_h
+      end
+      additional
+    end
+
+    def apply_filter_to_collection(collection, filtering_params, additional = {})
+      return collection if collection.nil?
+
+      filtering_params.each do |field, value|
+        if additional.key?(field) && additional[field].key?(:proc)
+
+          # Si on a fourni des valeurs, on verifie qu'elle matchent
+          if additional[field].key?(:all) && additional[field][:all].try(:any?)
+            allowed = additional[field][:all].map(&:to_s)
+            raise InvalidFilterValueException, "Value #{(value - allowed).to_sentence} is not allowed for filter #{field}, can be #{allowed.to_sentence}" if (value - allowed).any?
+          end
+
+          collection = collection.instance_exec(value, &(additional[field][:proc]))
+        elsif value.is_a?(String) || value.is_a?(Array)
+          collection = collection.where(field => value)
+        elsif value.is_a?(Hash) && value.key?(:proc)
+          collection
+        end
+      end
+      collection
+    end
+
+    # ------------------------ Range helpers --------------------
+
+    # Va transformer le param url en hash exploitable
+    def parse_ranged_param(ranged_param, allowed_params)
+      return {} unless ranged_param.present?
+
+      fields = {}
+
+      # Extract the fields for each type from the fields parameters
+      if ranged_param.is_a?(Hash)
+        ranged_param.each do |field, value|
+          resource_fields = value.split(',') unless value.nil? || value.empty?
+          raise InvalidRangeException, "Invalid range format for #{ranged_param}. Too many arguments for filter (#{resource_fields})." if resource_fields.length > 2
+          raise InvalidRangeException, "Invalid range format for #{ranged_param}. Begin and end must be separated by a comma (,)." if resource_fields.length < 2
+          fields[field.to_sym] = resource_fields
+        end
+      else
+        raise InvalidRangeException, "Invalid range format for #{ranged_param}"
+      end
+      check_ranged_param(fields, allowed_params)
+      fields
+    end
+
+    # Our little barrier <3
+    def check_ranged_param(ranged_param, allowed)
+      🔞 = ranged_param.keys.map(&:to_sym) - allowed.map(&:to_sym)
+      raise InvalidRangeException, "Attributes #{🔞.map(&:to_s).to_sentence} doesn't exists or aren't rangeables. Available ranges are: #{allowed.to_sentence}" if 🔞.any?
+    end
+
+
+    def apply_range_to_collection(collection, ranged_params, additional = {})
+      return collection if collection.nil?
+
+      ranged_params.each do |field, value|
+        if additional.key?(field) && additional[field].key?(:proc)
+
+          # Si on a fourni des valeurs, on verifie qu'elle matchent
+          if additional[field].key?(:all) && additional[field][:all].try(:any?)
+            allowed = additional[field][:all].map(&:to_s)
+            raise InvalidRangeValueException, "
+              Value #{(value - allowed).to_sentence} is not allowed for range #{field}, can be #{allowed.to_sentence}
+            " if (value - allowed).any?
+          end
+          collection = collection.instance_exec(value.try(:first), value.try(:last), &(additional[field][:proc]))
+        elsif value.is_a? Array
+          from, to = value.slice(0, 2)
+          begin
+            collection = collection.where(field => from..to)
+          rescue ArgumentError
+            raise InvalidRangeValueException, "
+              Unable to create a range between values '#{from}' and '#{to}'
+            "
+          end
+        elsif value.is_a?(Hash) && value.key?(:proc)
+          collection
+        end
+      end
+      collection
+    end
+  end
+end

data/lib/rice_cooker/range.rb

@@ -0,0 +1,36 @@
+require 'active_support'
+
+module RiceCooker
+  module Range
+    extend ActiveSupport::Concern
+
+    FILTER_PARAM = :range
+
+    module ClassMethods
+      include Helpers
+
+      def ranged(additional_ranged_params = {})
+        cattr_accessor :ranged_keys
+        cattr_accessor :custom_ranges
+
+        resource_class ||= controller_resource_class(self) unless respond_to?(:resource_class)
+
+        # On normalize tout ca
+        additional_ranged_params = format_additional_param(additional_ranged_params, 'ranged')
+
+        # On recupere tous les filtres autorisés
+        allowed_keys = (rangeable_fields_for(resource_class) + additional_ranged_params.keys)
+
+        # On recupere le default
+        self.ranged_keys = allowed_keys
+        self.custom_ranges = additional_ranged_params
+
+        has_scope :range, type: :hash, only: [:index] do |_controller, scope, value|
+          params = parse_ranged_param(value, ranged_keys)
+          scope = apply_range_to_collection(scope, params, custom_ranges)
+          scope
+        end
+      end
+    end
+  end
+end

data/lib/rice_cooker/sort.rb

@@ -0,0 +1,49 @@
+require 'csv'
+require 'active_support'
+
+module RiceCooker
+  module Sort
+    extend ActiveSupport::Concern
+
+    SORT_PARAM = :sort
+
+    module ClassMethods
+      include Helpers
+
+      #
+      # Will handle collection (index) sorting on inherited resource controllers
+      #
+      # All endpoints support multiple sort fields by allowing comma-separated (`,`) sort fields.
+      # Sort fields are applied in the order specified.
+      # The sort order for each sort field is ascending unless it is prefixed with a minus (U+002D HYPHEN-MINUS, “-“), in which case it is descending.
+      #
+      def sorted(default_sorting_params = { id: :desc })
+        cattr_accessor :default_order
+        cattr_accessor :sorted_keys
+
+        resource_class ||= controller_resource_class(self) unless respond_to?(:resource_class)
+
+        return unless sorted_keys.nil? || resource_class.nil?
+
+        default_sorting_params = { default_sorting_params => :asc } if default_sorting_params.is_a? Symbol
+
+        # On recupere le default
+        self.default_order = default_sorting_params
+        self.sorted_keys = (resource_class.respond_to?(:sortable_fields) ? resource_class.sortable_fields : [])
+        default_sort = param_from_defaults(default_sorting_params)
+
+        has_scope :sort, default: default_sort, only: [:index] do |controller, scope, value|
+          if controller.params[SORT_PARAM].present?
+            scope = apply_sort_to_collection(scope, parse_sorting_param(value, resource_class))
+          else
+            scope = apply_sort_to_collection(scope, default_sorting_params)
+          end
+          scope
+        end
+
+      rescue NoMethodError => e
+        "Just wanna die ⚓️ #{e}"
+      end
+    end
+  end
+end

data/lib/rice_cooker/version.rb

@@ -0,0 +1,3 @@
+module RiceCooker
+  VERSION = '0.1.1'.freeze
+end

data/lib/rice_cooker.rb

@@ -0,0 +1,17 @@
+require 'action_controller'
+
+module RiceCooker
+  autoload :Helpers,  'rice_cooker/helpers'
+  autoload :Filter,   'rice_cooker/filter'
+  autoload :Sort,     'rice_cooker/sort'
+  autoload :Range,    'rice_cooker/range'
+  autoload :VERSION,  'rice_cooker/version'
+end
+
+module ActionController
+  class Base
+    include RiceCooker::Sort
+    include RiceCooker::Filter
+    include RiceCooker::Range
+  end
+end

data/lib/tasks/rice_cooker_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rice_cooker do
+#   # Task goes here
+# end

data/rice_cooker.gemspec

@@ -0,0 +1,42 @@
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+
+# Maintain your gem's version:
+require 'rice_cooker/version'
+
+# Describe your gem and declare its dependencies:
+Gem::Specification.new do |s|
+  s.name          = 'rice_cooker'
+  s.version       = RiceCooker::VERSION
+  s.authors       = ['Andre Aubin']
+  s.email         = ['andre.aubin@lambdaweb.fr']
+  s.homepage      = 'https://github.com/lambda2/rice_cooker'
+  s.summary       = 'A collection manager for Rails API\'s'
+  s.description   = 'Handle sort, filters, searches, and ranges on Rails collections.'
+  s.license       = 'MIT'
+
+  s.files         = `git ls-files`.split(/\n/)
+  s.test_files    = `git ls-files -- spec/*`.split(/\n/)
+  s.require_paths = ['lib']
+
+  s.add_dependency 'rails', '~> 5.0.0', '< 5.1'
+  s.add_dependency 'actionpack', '~> 5.0.0', '< 5.1'
+  s.add_dependency 'railties', '~> 5.0.0', '< 5.1'
+  s.add_dependency 'has_scope', '~> 0.7.0', '>= 0.6.0'
+
+  s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rspec-rails'
+  s.add_development_dependency 'rspec-activemodel-mocks'
+  s.add_development_dependency 'mocha', '1.1.0'
+  s.add_development_dependency 'ruby-prof', '0.15.8'
+  s.add_development_dependency 'test-unit', '3.1.3'
+  s.add_development_dependency 'rails-perftest', '0.0.6'
+  s.add_development_dependency 'simplecov', '0.11.1'
+  s.add_development_dependency 'factory_girl_rails', '~> 4.0'
+  s.add_development_dependency 'database_cleaner'
+  s.add_development_dependency 'faker', '1.6.1'
+  s.add_development_dependency 'pry'
+  s.add_development_dependency 'derailed'
+  s.add_development_dependency 'stackprof'
+  s.add_development_dependency 'rubocop', '~> 0.40.0'
+end