toller 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4ac81008c0c129af6b87f8021fa9f9b6c11b88b6023d6ce2775c74ed384ce68d
+  data.tar.gz: 99355eb92d24c18a5b59fde10658463aeea8d1a075cce28da6408b5b4757c86e
+SHA512:
+  metadata.gz: f373b0612a6d960bbc2dfcc3975cf8e9e2e5c9346836f99f98f7607ce96f36eaa627b3f3116f18d699b158e4410a80ce85c33d959202798bc0c6b11f76b719ab
+  data.tar.gz: a3d9ba5fe8083d69a79a8853e9ad49a8abe8fae09d9a5106580362ef433ff60c899a964b2a4c0827af3e7375f3a1ed220671e55f3c526b450742db96cf449be8

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 David Freerksen
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,68 @@
+# Toller
+
+URL based filtering and sorting. See the wiki for usage information.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'toller'
+```
+
+And then execute:
+
+```bash
+$ bundle install
+```
+
+## Filtering
+
+Filters are not automagically set up for you. You define the filters you want.
+
+### Filter Types
+
+* integer - Filter on an integer column
+* boolean - Filter on a boolean column
+* string - Filter on a string column
+* text - Filter on a text column
+* date - Filter on a date column
+* time - Filter on a time column
+* datetime - Filter on a datetime column
+* scope - Filter on an ActiveRecord scope
+
+## Sort
+
+Sorting is not automagically set up for you. You define the sorting you want.
+
+Sort parameters are passed in the URL as such `?sort=position`. Multiple sort parameters can be passed like so `?sort=-published_at,title`.
+
+### Sort Types
+
+Every sort must have a type. Valid sort types are:
+
+* integer - Sort on an integer column
+* string - Sort on a string column
+* text - Sort on a text column
+* date - Sort on a date column
+* time - Sort on a time column
+* datetime - Sort on a datetime column
+* scope - Sort on an ActiveRecord scope
+
+## Testing
+
+```bash
+$ bin/test
+```
+
+## Contributing
+
+1. Fork it ([https://github.com/dfrerksen/recieve/fork](https://github.com/dfrerksen/recieve/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
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'bundler/gem_tasks'
+
+APP_RAKEFILE = File.expand_path('spec/dummy/Rakefile', __dir__)
+load 'rails/tasks/engine.rake'

data/lib/toller.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'toller/filter'
+require 'toller/filters/mutators/boolean'
+require 'toller/filters/mutators/date'
+require 'toller/filters/mutators/datetime'
+require 'toller/filters/mutators/integer'
+require 'toller/filters/mutators/time'
+require 'toller/filters/scope_handler'
+require 'toller/filters/where_handler'
+require 'toller/filtrator'
+require 'toller/sort'
+require 'toller/sorts/order_handler'
+require 'toller/sorts/scope_handler'
+
+##
+# Toller
+#
+# Query param based filtering and sorting
+#
+module Toller
+  extend ActiveSupport::Concern
+
+  def filtrate(collection)
+    Filtrator.filter(collection, filter_params, sort_params, retrievals)
+  end
+
+  included do
+    # none
+  end
+
+  class_methods do
+    def filter_on(parameter, type:, **options)
+      _filters << Filter.new(parameter, type, options)
+    end
+
+    def sort_on(parameter, type:, **options)
+      _filters << Sort.new(parameter, type, options)
+    end
+
+    def _filters
+      @_filters ||= []
+    end
+  end
+
+  def filter_params
+    params.fetch(filter_param_key.to_sym, {})
+  end
+
+  def sort_params
+    params.fetch(sort_param_key.to_sym, '').split(',')
+  end
+
+  def filter_param_key
+    :filters
+  end
+
+  def sort_param_key
+    :sort
+  end
+
+  private
+
+  def retrievals
+    self.class.ancestors.flat_map { |klass| klass.try(:_filters) }.compact
+  end
+end

data/lib/toller/filter.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Toller
+  ##
+  # Filter
+  #
+  class Filter
+    attr_reader :parameter, :properties, :type
+
+    def initialize(parameter, type, options)
+      @parameter = parameter
+      @type = type
+      @properties = options.reverse_merge(
+        field: parameter,
+        default: false,
+        scope_name: nil
+      )
+    end
+
+    def apply!(collection, value)
+      if type == :scope
+        Filters::ScopeHandler.new.call(collection, value, properties)
+      else
+        Filters::WhereHandler.new.call(collection, type, value, properties)
+      end
+    end
+
+    def default
+      properties[:default]
+    end
+  end
+end

data/lib/toller/filters/mutators/boolean.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    module Mutators
+      ##
+      # Boolean filter mutator
+      #
+      module Boolean
+        module_function
+
+        def call(value)
+          %w[1 t true y yes].include?(value)
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/mutators/date.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    module Mutators
+      ##
+      # Date filter mutator
+      #
+      module Date
+        module_function
+
+        def call(value)
+          range_dots = inclusive_or_exclusive_range(value)
+
+          return value if range_dots.blank?
+
+          range(value, range_dots)
+        end
+
+        def range(value, dots)
+          Range.new(*value.split(dots))
+        end
+
+        def inclusive_or_exclusive_range(value)
+          return '...' if value.include?('...')
+          return '..' if value.include?('..')
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/mutators/datetime.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    module Mutators
+      ##
+      # Datetime filter mutator
+      #
+      module Datetime
+        module_function
+
+        def call(value)
+          range_dots = inclusive_or_exclusive_range(value)
+
+          return value if range_dots.blank?
+
+          range(value, range_dots)
+        end
+
+        def range(value, dots)
+          Range.new(*value.split(dots))
+        end
+
+        def inclusive_or_exclusive_range(value)
+          return '...' if value.include?('...')
+          return '..' if value.include?('..')
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/mutators/integer.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    module Mutators
+      ##
+      # Integer filter mutator
+      #
+      module Integer
+        module_function
+
+        def call(value)
+          return value unless range?(value)
+
+          range(value)
+        end
+
+        def range?(value)
+          range_dots = inclusive_or_exclusive_range(value)
+
+          range_dots.present?
+        end
+
+        def range(value)
+          Range.new(*value.split(inclusive_or_exclusive_range(value)))
+        end
+
+        def inclusive_or_exclusive_range(value)
+          return '...' if value.include?('...')
+          return '..' if value.include?('..')
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/mutators/time.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    module Mutators
+      ##
+      # Time filter mutator
+      #
+      module Time
+        module_function
+
+        def call(value)
+          range_dots = inclusive_or_exclusive_range(value)
+
+          return value if range_dots.blank?
+
+          range(value, range_dots)
+        end
+
+        def range(value, dots)
+          Range.new(*value.split(dots))
+        end
+
+        def inclusive_or_exclusive_range(value)
+          return '...' if value.include?('...')
+          return '..' if value.include?('..')
+
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/toller/filters/scope_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    ##
+    # Scope handler for filter
+    #
+    class ScopeHandler
+      def call(collection, value, properties)
+        scoped_name = properties[:scope_name] || properties[:field]
+
+        collection.public_send(scoped_name, value)
+      end
+    end
+  end
+end

data/lib/toller/filters/where_handler.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Toller
+  module Filters
+    ##
+    # Where handler for filter
+    #
+    class WhereHandler
+      def call(collection, type, value, properties)
+        field_name = properties[:field]
+
+        mutated_value = value_mutator(type, value)
+
+        collection.where(field_name => mutated_value)
+      end
+
+      private
+
+      def value_mutator(type, value)
+        return value unless %i[boolean date datetime integer time].include?(type)
+
+        send("#{type}_mutator", value)
+      end
+
+      def boolean_mutator(value)
+        Mutators::Boolean.call(value)
+      end
+
+      def integer_mutator(value)
+        Mutators::Integer.call(value)
+      end
+
+      def date_mutator(value)
+        Mutators::Date.call(value)
+      end
+
+      def time_mutator(value)
+        Mutators::Time.call(value)
+      end
+
+      def datetime_mutator(value)
+        Mutators::Datetime.call(value)
+      end
+    end
+  end
+end

data/lib/toller/filtrator.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Toller
+  ##
+  # Filtrator
+  #
+  class Filtrator
+    attr_reader :collection, :filter_params, :retrievals, :sort_params
+
+    def self.filter(collection, filter_params, sort_params, retrievals)
+      new(collection, filter_params, sort_params, retrievals).filter
+    end
+
+    def initialize(collection, filter_params, sort_params, retrievals)
+      @collection = collection
+      @filter_params = filter_params
+      @sort_params = sort_params
+      @retrievals = retrievals
+    end
+
+    def filter
+      active_retrievals.reduce(collection) do |items, retrieval|
+        param_value = if retrieval.is_a?(Filter)
+                        filter_params.fetch(retrieval.parameter, nil)
+                      else
+                        sort_params.include?("-#{retrieval.parameter}") ? :desc : :asc
+                      end
+
+        retrieval.apply!(items, param_value)
+      end
+    end
+
+    private
+
+    def active_retrievals
+      retrievals.select do |retrieval|
+        retrieval.is_a?(Filter) ? filtering_activated?(retrieval) : sorting_activated?(retrieval)
+      end
+    end
+
+    def filtering_activated?(retrieval)
+      return true if filter_params.blank? && retrieval.default
+
+      filter_params.fetch(retrieval.parameter, nil).present?
+    end
+
+    def sorting_activated?(retrieval)
+      return true if sort_params.blank? && retrieval.default
+
+      string_parameter = retrieval.parameter.to_s
+
+      sort_params.include?(string_parameter) || sort_params.include?("-#{string_parameter}")
+    end
+  end
+end

data/lib/toller/sort.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Toller
+  ##
+  # Sort
+  #
+  class Sort
+    attr_reader :parameter, :properties, :type
+
+    def initialize(parameter, type, options)
+      @parameter = parameter
+      @type = type
+      @properties = options.reverse_merge(
+        field: parameter,
+        default: false,
+        scope_name: nil
+      )
+    end
+
+    def apply!(collection, direction = :asc)
+      if type == :scope
+        Sorts::ScopeHandler.new.call(collection, direction, properties)
+      else
+        Sorts::OrderHandler.new.call(collection, direction, properties)
+      end
+    end
+
+    def default
+      properties[:default]
+    end
+  end
+end

data/lib/toller/sorts/order_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Toller
+  module Sorts
+    ##
+    # Order handler for filter
+    #
+    class OrderHandler
+      def call(collection, direction, properties)
+        field_name = properties[:field]
+
+        collection.order(field_name => direction)
+      end
+    end
+  end
+end

data/lib/toller/sorts/scope_handler.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Toller
+  module Sorts
+    ##
+    # Scope handler for sort
+    #
+    class ScopeHandler
+      def call(collection, direction, properties)
+        scoped_name = properties[:scope_name] || properties[:field]
+
+        collection.public_send(scoped_name, direction)
+      end
+    end
+  end
+end

data/lib/toller/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Toller
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: toller
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- David Freerksen
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2020-09-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+- !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'
+description: Description of Toller.
+email:
+- dfreerksen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/toller.rb
+- lib/toller/filter.rb
+- lib/toller/filters/mutators/boolean.rb
+- lib/toller/filters/mutators/date.rb
+- lib/toller/filters/mutators/datetime.rb
+- lib/toller/filters/mutators/integer.rb
+- lib/toller/filters/mutators/time.rb
+- lib/toller/filters/scope_handler.rb
+- lib/toller/filters/where_handler.rb
+- lib/toller/filtrator.rb
+- lib/toller/sort.rb
+- lib/toller/sorts/order_handler.rb
+- lib/toller/sorts/scope_handler.rb
+- lib/toller/version.rb
+homepage: https://github.com/dfreerksen/toller
+licenses:
+- MIT
+metadata: {}
+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: []
+rubygems_version: 3.0.3
+signing_key:
+specification_version: 4
+summary: Summary of Toller.
+test_files: []