active_hash_relation 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4b491ebb86ce76c8bd1380597b0c1fcba6c787b5
+  data.tar.gz: 59ce2d3323cfe3b85aa5fc50b9fc81c9414cd666
+SHA512:
+  metadata.gz: 6580c8a889a299e994b2af5dd32d937281afce27c9583838fc793b0d93c0ef9638f7ea0e89bb283bd2bb699aae8fe1dc804953e6e7ef284890b5da0c063c220c
+  data.tar.gz: e63134ea30cec6c28cc92dfbf46bd0689465464542c6b2d87d36d90c7fe5a57491ea0211fc3f948a17530589baa8a809af0a0191413fb1179528494ca2b236e0

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_hash_relation.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Filippos Vasilakis
+
+MIT License
+
+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,112 @@
+# ActiveHashRelation
+
+## Introduction
+Simple gem that allows you to manipulate ActiveRecord::Relation using JSON. For instance:
+```ruby
+apply_filters(resource, {name: 'RPK', id: [1,2,3,4,5,6,7,8,9], start_date: {leq: "2014-10-19"}, act_status: "ongoing"})
+```
+filter a resource based on it's associations:
+```ruby
+apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9})
+```
+or even filter a resource based on it's associations' associations:
+```ruby
+apply_filters(resource, {updated_at: { geq: "2014-11-2 14:25:04"}, unit: {id: 9, areas: {id: 22} }})
+```
+and the list could go on.. Basically your whole db is exposed there. It's perfect for filtering a collection of resources on APIs.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_hash_relation'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_hash_relation
+## How to use
+The gem exposes only one method: `apply_filters(resource, hash_params, include_associations: true, model: nil)`. `resource` is expected to be an ActiveRecord::Relation.
+That way, you can add your custom filters before passing the `Relation` to `ActiveHashRelation`.
+
+In order to use it you have to include ActiveHashRelation module in your class. For instance in a Rails API controller you would do:
+
+```ruby
+class Api::V1::ResourceController < Api::V1::BaseController
+  include ActiveHashRelation
+
+  def index
+    resources = apply_filters(Resource.all, params)
+
+    authorized_resources = policy_scope(resource)
+
+    render json: resources, each_serializer: Api::V1::ResourceSerializer
+  end
+end
+```
+
+## The API
+### Columns
+For each param, `apply_filters` method will search in the model's (derived from the first param, or explicitly defined as the last param) all the record's column names and associations. (filtering based on scopes are not working at the moment but will be supported soon). For each column, if there is such a param, it will apply the filter based on the column type. The following column types are supported:
+
+#### Primary
+You can apply a filter a column which is a primary key by value or using an array like:
+* `{primary_key_column: 5}`
+* `{primary_key)column: [1,3,4,5,6,7]}`
+
+#### Integer, Float, Decimal, Date, Time or Datetime/Timestamp
+You can apply an equality filter:
+* `{example_column: 500}`
+or using a hash as a value you get more options:
+* `{example_column: {le: 500}}`
+* `{example_column: {leq: 500}}`
+* `{example_column: {ge: 500}}`
+* `{example_column: {geq: 500}}`
+
+Of course you can provide a compination of those like:
+* `{example_column: {geq: 500, le: 1000}}`
+
+The same api is for Date, Time or Datetime/Timestamp.
+
+#### Boolean
+The boolean value is converted from string using ActiveRecord's `TRUE_VALUES` through `value_to_boolean` method.. So for a value to be true must be one of the following: `[true, 1, '1', 't', 'T', 'true', 'TRUE']`. Anything else is false. 
+* `{example_column: true}`
+* `{example_column: 0}`
+
+#### String or Text
+You can apply an incensitive matching filter (currently working only for Postgres):
+* `{example_column: test}`
+
+The above filter will search all records that include `test` in the `example_column` field. A better would be nice here, for instance, setting the search sensitive or insensitive, start or end with a string etch
+
+
+### Associations
+If the association is a `belongs_to` or `has_one`, then the hash key name must be in singular. If the association is `has_many` the attribute must be in plural reflecting the association type. When you have, in your hash, filters for an association, the sub-hash is passed in the association's model. For instance, let's say a user has many microposts and the following filter is applied (could be through an HTTP GET request on controller's index method):
+* `{email: test@user.com, microposts: {created_at { leq: 12-9-2014} }`
+
+Internally, ActiveHashRelation, extracts `{created_at { leq: 12-9-2014} }` and runs it on Micropost model. So the final query will look like:
+
+```ruby
+micropost_filter = Micropost.all.where("CREATED_AT =< ?", '12-9-2014'.to_datetime)
+User.where(email: 'test@user.com').joins(:microposts).merge(micropost_filter)
+```
+
+### Scopes
+Scopes are supported via a tiny monkeypatch in the ActiveRecord's scope class method which holds the name of each scope. Only scopes that don't accept arguments are supported. The rest could also be supported but it wouldn't make much sense.. If you want to filter based on a scope in a model, the scope names should go under `scopes` sub-hash. For instance the following:
+* `{ scopes: { planned: true } }`
+
+will run the `.planned` scope on the resource.
+
+### Whitelisting
+If you don't want to allow a column/association/scope just remove it from the params hash.
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/active_hash_relation/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

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/active_hash_relation.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_hash_relation/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_hash_relation"
+  spec.version       = ActiveHashRelation::VERSION
+  spec.authors       = ["Filippos Vasilakis"]
+  spec.email         = ["vasilakisfil@gmail.com"]
+  spec.summary       = %q{Simple gem that allows you to run multiple ActiveRecord::Relation using hash. Perfect for APIs.}
+  spec.description   = spec.summary
+  spec.homepage      = "https://www.kollegorna.se"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/active_hash_relation/association_filters.rb

@@ -0,0 +1,21 @@
+module ActiveHashRelation::AssociationFilters
+  def filter_associations(resource, params, model: nil)
+    unless model
+      model = model_class_name(resource)
+    end
+
+    model.reflect_on_all_associations.map(&:name).each do |association|
+      if params[association]
+        association_name = association.to_s.titleize.split.join
+        association_filters = ActiveHashRelation::FilterApplier.new(
+          association_name.singularize.constantize.all,
+          params[association],
+          include_associations: true
+        ).apply_filters
+        resource = resource.joins(association).merge(association_filters)
+      end
+    end
+
+    return resource
+  end
+end

data/lib/active_hash_relation/column_filters.rb

@@ -0,0 +1,77 @@
+module ActiveHashRelation::ColumnFilters
+  def model_class_name(resource)
+    resource.class.to_s.split('::').first.constantize
+  end
+
+  def filter_primary(resource, column, param)
+    resource = resource.where(id: param)
+  end
+
+  def filter_integer(resource, column, table_name, param)
+    if !param.is_a? Hash
+      return resource.where(column => param)
+    else
+      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+    end
+  end
+
+  def filter_float(resource, column, table_name, param)
+    filter_integer(resource, column, table_name, param)
+  end
+
+  def filter_decimal(resource, column, table_name, param)
+    filter_integer(resource, column, table_name, param)
+  end
+
+  def filter_string(resource, column, table_name, param)
+    resource = resource.where("#{table_name}.#{column} ILIKE ?", "%#{param}%")
+  end
+
+  def filter_text(resource, column, param)
+    return filter_string(resource, column, param)
+  end
+
+  def filter_date(resource, column, table_name, param)
+    if !param.is_a? Hash
+      resource = resource.where(column => param[column])
+    else
+      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+    end
+
+    return resource
+  end
+
+  def filter_datetime(resource, column, table_name, param)
+    if !param.is_a? Hash
+      resource = resource.where(column => param[column])
+    else
+      return apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+    end
+
+    return resource
+  end
+
+  def filter_boolean(resource, column, param)
+    b_param = ActiveRecord::ConnectionAdapters::Column.value_to_boolean(param)
+
+    resource = resource.where(column => b_param)
+  end
+
+  private
+
+  def apply_leq_geq_le_ge_filters(resource, table_name, column, param)
+    if param[:leq]
+      resource = resource.where("#{table_name}.#{column} <= ?", param[:leq])
+    elsif param[:le]
+      resource = resource.where("#{table_name}.#{column} < ?", param[:leq])
+    end
+
+    if param[:geq]
+      resource = resource.where("#{table_name}.#{column} >= ?", param[:geq])
+    elsif param[:ge]
+      resource = resource.where("#{table_name}.#{column} > ?", param[:geq])
+    end
+
+    return resource
+  end
+end

data/lib/active_hash_relation/filter_applier.rb

@@ -0,0 +1,50 @@
+module ActiveHashRelation
+  class FilterApplier
+    include ColumnFilters
+    include AssociationFilters
+    include ScopeFilters
+
+    def initialize(resource, params, include_associations: false, model: nil)
+      @resource = resource
+      @params = HashWithIndifferentAccess.new(params)
+      @include_associations = include_associations
+      @model = model
+    end
+
+
+    def apply_filters
+      unless @model
+        @model = model_class_name(@resource)
+      end
+      table_name = @model.table_name
+      @model.columns.each do |c|
+        next if @params[c.name.to_s].nil?
+
+        @resource = filter_primary(@resource, c.name, @params[c.name]) and next if c.primary
+        case c.type
+        when :integer
+          @resource = filter_integer(@resource, c.name, table_name, @params[c.name])
+        when :float
+          @resource = filter_float(@resource, c.name, table_name, @params[c.name])
+        when :decimal
+          @resource = filter_decimal(@resource, c.name, table_name, @params[c.name])
+        when :string
+          @resource = filter_string(@resource, c.name, table_name, @params[c.name])
+        when :date
+          @resource = filter_date(@resource, c.name, table_name, @params[c.name])
+        when :datetime, :timestamp
+          @resource = filter_datetime(@resource, c.name, table_name, @params[c.name])
+        when :boolean
+          @resource = filter_boolean(@resource, c.name, @params[c.name])
+        end
+      end
+
+
+      @resource = filter_scopes(@resource, @params[:scopes]) if @params.include?(:scopes)
+      @resource = filter_associations(@resource, @params)
+
+      return @resource
+    end
+
+  end
+end

data/lib/active_hash_relation/scope_filters.rb

@@ -0,0 +1,15 @@
+module ActiveHashRelation::ScopeFilters
+  def filter_scopes(resource, params, model: nil)
+    unless model
+      model = model_class_name(resource)
+    end
+
+    model.scope_names.each do |scope|
+      if params.include?(scope)
+        resource = resource.send(scope)
+      end
+    end
+
+    return resource
+  end
+end

data/lib/active_hash_relation/version.rb

@@ -0,0 +1,3 @@
+module ActiveHashRelation
+  VERSION = "0.0.1"
+end

data/lib/active_hash_relation.rb

@@ -0,0 +1,17 @@
+require "active_record/scope_names"
+require "active_hash_relation/version"
+require "active_hash_relation/column_filters"
+require "active_hash_relation/scope_filters"
+require "active_hash_relation/association_filters"
+require "active_hash_relation/filter_applier"
+
+module ActiveHashRelation
+  def apply_filters(resource, params, include_associations: false, model: nil)
+    FilterApplier.new(
+      resource,
+      params,
+      include_associations: include_associations,
+      model: model
+    ).apply_filters
+  end
+end

data/lib/active_record/scope_names.rb

@@ -0,0 +1,34 @@
+module ActiveRecord
+  module Scoping
+    module Named
+      module ClassMethods
+        attr_reader :scope_names
+
+        def scope(name, body, &block)
+          @scope_names ||= []
+          unless body.respond_to?(:call)
+            raise ArgumentError, 'The scope body needs to be callable.'
+          end
+
+          if dangerous_class_method?(name)
+            raise ArgumentError, "You tried to define a scope named \"#{name}\" " \
+              "on the model \"#{self.name}\", but Active Record already defined " \
+              "a class method with the same name."
+          end
+
+          extension = Module.new(&block) if block
+
+          singleton_class.send(:define_method, name) do |*args|
+            scope = all.scoping { body.call(*args) }
+            scope = scope.extending(extension) if extension
+
+            scope || all
+          end
+
+
+          @scope_names << name if body.arity.eql?(0)
+        end
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,87 @@
+--- !ruby/object:Gem::Specification
+name: active_hash_relation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Filippos Vasilakis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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'
+description: Simple gem that allows you to run multiple ActiveRecord::Relation using
+  hash. Perfect for APIs.
+email:
+- vasilakisfil@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- active_hash_relation.gemspec
+- lib/active_hash_relation.rb
+- lib/active_hash_relation/association_filters.rb
+- lib/active_hash_relation/column_filters.rb
+- lib/active_hash_relation/filter_applier.rb
+- lib/active_hash_relation/scope_filters.rb
+- lib/active_hash_relation/version.rb
+- lib/active_record/scope_names.rb
+homepage: https://www.kollegorna.se
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Simple gem that allows you to run multiple ActiveRecord::Relation using hash.
+  Perfect for APIs.
+test_files: []