filterparams 0.9.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eccbf86937a65862760d9b9856f638b9fbcfba53
+  data.tar.gz: 9421ba18a6af48111c5da4983d1339afde31dc61
+SHA512:
+  metadata.gz: dc6bcb9a1600115563e86a1da14c7238fe284284875c90d624a8982428c01fa9ddc040e78a3b51bb09f2f81042d6338b2de7502814ba63040995dc3b7d448add
+  data.tar.gz: 9823903da6ba5dfea2c80a6fc3a00a54778dc361d7bf955930df967f408c5e67e9d5b6a601c48e8ce4dd8872893de12cd8b9f27fb07b3382b62eac12c4f2f8f6

data/LICENSE.txt

@@ -0,0 +1,8 @@
+The MIT License (MIT)
+Copyright (c) 2016 Christoph Brand
+
+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,200 @@
+# Ruby Filterparams #
+
+Filterparams is a library for specifying filters through a REST API
+on collection resources on top of HTTP. It provides the capability
+to specify SQL-like syntax on top of query parameters.
+
+Due to it's intended use of building [JSONAPI](http://jsonapi.org/)
+libraries with this definition, it is compatible with the definition
+and encapsulates it's syntax through the prefixed `filter` parameters.
+
+## Installation ##
+
+The library is available through the `filterparams` gem on [RubyGems](https://rubygems.org/gems/filterparams)
+and thus can be installed through the command line or by adding the package to
+your Gemfile.
+
+```
+gem install filterparams
+```
+
+## Example ##
+
+Given the URL (non URL escaped for better readability):
+
+```
+/users?filter[param][name][like][no_brand_name]=doe&filter[param][first_name]=doe%&filter[binding]=(!no_brand_name&first_name)&filter[order]=name&filter[order]=desc(first_name)
+```
+
+It can be parsed with the following code:
+
+```ruby
+require 'uri'
+require 'cgi'
+require 'filterparams'
+
+url = 'http://www.example.com/users?' +
+      'filter[param][name][like][no_brand_name]=doe' +
+      '&filter[param][first_name]=doe%' +
+      '&filter[binding]=%28%21no_brand_name%26first_name%29' +
+      '&filter[order]=name&filter[order]=desc(first_name)'
+
+data = CGI.parse(URI.parse(url).query)
+
+Filterparams::extract_query(data)
+```
+
+This would result into a query instance being produced with the
+following data:
+
+```
+#<Filterparams::Query:0x007ff78b1a51c8
+ @filters=
+  #<Filterparams::And:0x007ff78b1a57e0
+   @left=
+    #<Filterparams::Not:0x007ff78b1a6ed8
+     @inner=
+      #<Filterparams::Parameter:0x007ff78b1ee940
+       @alias="no_brand_name",
+       @filter="like",
+       @name="name",
+       @value="doe">>,
+   @right=
+    #<Filterparams::Parameter:0x007ff78b1ee918
+     @alias=nil,
+     @filter=nil,
+     @name="first_name",
+     @value="doe%">>,
+ @orders=
+  [#<Filterparams::Order:0x007ff78b1ee5f8 @direction="asc", @name="name">,
+   #<Filterparams::Order:0x007ff78b1ee3a0
+    @direction="desc",
+    @name="first_name">]>
+```
+
+The orders can be accessed through the `.orders` method and the filter
+binding through `.filters`.
+
+## Syntax ##
+
+All arguments must be prefixed by "filter". It is possible to
+query for specific data with filters, apply orders to the result
+and to combine filters through AND, NOT and OR bindings.
+
+The syntax builds under the filter parameter a virtual object.
+The keys of the object are simulated through specifying `[{key}]`
+in the passed query parameter. Thus `filter[param]` would point
+to the param key in the filter object.
+
+### Filter specification ###
+
+The solution supports to query data through the `param` subkey.
+
+```
+filter[param][{parameter_name}][{operation}][{alias}] = {to_query_value}
+```
+
+The `operation` and `alias` parameters may be omitted. If no
+`alias` is provided the given parameter name is used for it.
+If no `operation` is given, the default one is used (in the
+example this would be equal).
+
+Example:
+```
+filter[param][phone_number][like]=001%
+```
+
+This would add a filter to all phone numbers which start with "001".
+
+### Filter binding ###
+
+Per default all filters are combined through AND clauses.
+You can change that by specifying the `filter[binding]` argument.
+
+This is where the aliases which you can define come into place.
+The binding provides means to combine filters with AND and OR.
+Also you are able to negate filters here.
+
+The filters are addressed by their alias or name, if no alias is
+provided.
+
+If you have a filter `search_for_name`, `search_for_phone_number`
+and `search_for_account_number` defined you can say
+`search_for_name OR NOT search_for_number AND search_for_account_number`
+by specifying the following filter:
+
+```
+filter[binding]=search_for_name|(!search_for_phone_number&search_for_account_number)
+```
+
+Even though the brackets are useless here, you can use them in
+more complex filters.
+
+The following table summarizes the possible configuration options:
+<table>
+  <thead>
+    <tr>
+      <th>Type</th>
+      <th>Symbol</th>
+      <th>Example</th>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>AND</td>
+      <td>&</td>
+      <td>a&b</td>
+    </tr>
+    <tr>
+      <td>OR</td>
+      <td>|</td>
+      <td>a|b</td>
+    </tr>
+    <tr>
+      <td>NOT</td>
+      <td>!</td>
+      <td>!a</td>
+    </tr>
+    <tr>
+      <td>Bracket</td>
+      <td>()</td>
+      <td>(a|b)&c</td>
+    </tr>
+  </tbody>
+</table>
+
+### Ordering ###
+
+To specify a sort order of the results the `filter[order]` parameter
+may be used. The value can be specified multiple times. To add
+ordering you have to provide the name of the parameter which should
+be ordered, not its alias!
+
+If you want to order by `name`, `first_name` and in reverse order
+`balance` you can do so by specifying the following query url
+parameters:
+
+```
+filter[order]=name&filter[order]=first_name&filter[order]=desc(balance)
+```
+
+As you can see the `desc()` definition can be used to indicate
+reverse ordering.
+
+## License ##
+
+The project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+## Used libraries ##
+
+For parsing the query parameters the [`parslet`](https://kschiess.github.io/parslet/)
+library is used. It is released under the [MIT License](https://github.com/kschiess/parslet/blob/master/LICENSE).
+
+## Other Languages ##
+
+This is a list of projects implementing the same API for other languages.
+Currently this list only has one entry.
+
+- Go - [go-filterparams](https://github.com/cbrand/go-filterparams)
+- Python - [python-filterparams](https://github.com/cbrand/python-filterparams)
+- JavaScript (Client) - [filterparams](https://github.com/cbrand/js-filterparams-client)

data/lib/filterparams.rb

@@ -0,0 +1 @@
+require_relative './filterparams/api'

data/lib/filterparams/api.rb

@@ -0,0 +1,49 @@
+require_relative './obj'
+require_relative './param_extractor'
+require_relative './order_extractor'
+require_relative './binding'
+
+module Filterparams
+  class << self
+    def extract_query(data)
+      params = extract_params_hash data
+      orders = extract_orders data
+      filter = if data.key? FILTER_BINDING_KEY
+                 extract_filter data[FILTER_BINDING_KEY], params
+               else
+                 auto_filter_for params
+               end
+
+      query = Filterparams::Query.new
+      query.filter(filter).add_order_obj(*orders)
+    end
+
+    private
+
+    FILTER_BINDING_KEY = 'filter[binding]'.freeze
+    ORDER_KEY = 'filter[order]'.freeze
+
+    def extract_filter(filter_string, params)
+      if filter_string.is_a? Array
+        filter_string = filter_string[0]
+      end
+
+      parsed = Filterparams::BindingParser.new.parse(filter_string)
+      Filterparams::BindingTransform.new(params).apply(parsed)
+    end
+
+    def extract_params_hash(params)
+      Filterparams::ParamExtractor.new(params).params_hash
+    end
+
+    def extract_orders(params)
+      Filterparams::OrderExtractor.new(params[ORDER_KEY] || []).orders
+    end
+
+    def auto_filter_for(params)
+      params.values.inject do |left, right|
+        Filterparams::And.new(left, right)
+      end
+    end
+  end
+end

data/lib/filterparams/binding.rb

@@ -0,0 +1,2 @@
+require_relative './binding/binding_parser'
+require_relative './binding/binding_transform'

data/lib/filterparams/binding/binding_parser.rb

@@ -0,0 +1,47 @@
+require 'parslet'
+
+module Filterparams
+  class BindingParser < Parslet::Parser
+    rule(:space) { match('\s').repeat(1) }
+    rule(:space?) { space.maybe }
+
+    rule(:lparen) { str('(') >> space? }
+    rule(:rparen) { str(')') >> space? }
+
+    rule(:and_operator) { str('&') }
+    rule(:or_operator) { str('|') }
+
+    rule(:parameter) { match('[\w\-\_]').repeat(1).as(:parameter) }
+
+    rule(:bracket) do
+      lparen >> space? >> clause.as(:clause) >> space? >> rparen
+    end
+
+    rule(:and_clause_element) { parameter | not_operation | bracket }
+    rule(:and_clause) do
+      and_clause_element.as(:left) >> space? >>
+        and_operator.as(:operator) >> space? >>
+        (and_clause | and_clause_element).as(:right)
+    end
+    rule(:or_clause_element) do
+      and_clause | parameter | not_operation | bracket
+    end
+    rule(:or_clause) do
+      or_clause_element.as(:left) >> space? >>
+        or_operator.as(:operator) >> space? >>
+        clause.as(:right)
+    end
+    rule(:inner_not) { bracket | parameter | not_operation }
+    rule(:not_operation) do
+      str('!').as(:operator) >> space? >> inner_not.as(:clause)
+    end
+
+    rule(:clause) do
+      or_clause | and_clause | parameter | bracket | not_operation
+    end
+
+    rule(:binding) { space? >> clause >> space? }
+
+    root(:binding)
+  end
+end

data/lib/filterparams/binding/binding_transform.rb

@@ -0,0 +1,46 @@
+require 'parslet'
+require_relative '../obj'
+
+module Filterparams
+  class BindingTransform < Parslet::Transform
+    rule(operator: '&', left: simple(:left), right: simple(:right)) do
+      Filterparams::And.new(left, right)
+    end
+    rule(operator: '|', left: simple(:left), right: simple(:right)) do
+      Filterparams::Or.new(left, right)
+    end
+    rule(operator: '!', clause: simple(:clause)) do
+      Filterparams::Not.new(clause)
+    end
+    rule(clause: simple(:clause)) do
+      clause
+    end
+    rule(parameter: simple(:param_name)) do |dictionary|
+      param_with(dictionary[:param_name])
+    end
+
+    def initialize(params)
+      @params = params
+      super()
+    end
+
+    private
+
+    def param_with(name)
+      name = name.to_s
+      if @params[name].nil?
+        raise StandardError, "Param with name #{name} does not exist"
+      end
+      @params[name]
+    end
+
+    def call_on_match(bindings, block)
+      if block
+        return instance_exec(bindings, &block) if block.arity == 1
+
+        context = Context.new(bindings)
+        return context.instance_eval(&block)
+      end
+    end
+  end
+end

data/lib/filterparams/obj.rb

@@ -0,0 +1,6 @@
+require_relative './obj/and'
+require_relative './obj/not'
+require_relative './obj/or'
+require_relative './obj/order'
+require_relative './obj/parameter'
+require_relative './obj/query'

data/lib/filterparams/obj/and.rb

@@ -0,0 +1,9 @@
+require_relative './binding_operation'
+
+module Filterparams
+  class And < Filterparams::BindingOperation
+    def equal?(other)
+      other.is_a?(Filterparams::And) && super(other)
+    end
+  end
+end

data/lib/filterparams/obj/binding_operation.rb

@@ -0,0 +1,14 @@
+module Filterparams
+  class BindingOperation
+    attr_accessor :left, :right
+
+    def initialize(left, right)
+      self.left = left
+      self.right = right
+    end
+
+    def equal?(other)
+      left == other.left && right == other.right
+    end
+  end
+end

data/lib/filterparams/obj/not.rb

@@ -0,0 +1,13 @@
+module Filterparams
+  class Not
+    attr_accessor :inner
+
+    def initialize(inner)
+      self.inner = inner
+    end
+
+    def equal?(other)
+      other.is_a?(Filterparams::Not) && other.inner == inner
+    end
+  end
+end

data/lib/filterparams/obj/or.rb

@@ -0,0 +1,9 @@
+require_relative './binding_operation'
+
+module Filterparams
+  class Or < Filterparams::BindingOperation
+    def equal?(other)
+      other.is_a?(Filterparams::Or) && super(other)
+    end
+  end
+end

data/lib/filterparams/obj/order.rb

@@ -0,0 +1,12 @@
+require_relative './binding_operation'
+
+module Filterparams
+  class Order < Filterparams::BindingOperation
+    attr_accessor :name, :direction
+
+    def initialize(name, is_desc = false)
+      self.name = name
+      self.direction = is_desc ? 'desc' : 'asc'
+    end
+  end
+end

data/lib/filterparams/obj/parameter.rb

@@ -0,0 +1,28 @@
+module Filterparams
+  class Parameter
+    attr_accessor :name, :filter, :value, :alias
+
+    def initialize(name, params = {})
+      self.name = name
+      self.filter = params[:filter] || nil
+      self.value = params[:value] || nil
+      self.alias = params[:alias] || nil
+    end
+
+    def identification
+      if self.alias.nil?
+        name
+      else
+        self.alias
+      end
+    end
+
+    def equal?(other)
+      if other.is_a? Parameter
+        name == other.name && self.alias == other.alias
+      else
+        false
+      end
+    end
+  end
+end

data/lib/filterparams/obj/query.rb

@@ -0,0 +1,40 @@
+require_relative './and'
+require_relative './order'
+
+module Filterparams
+  class Query
+    attr_accessor :filters, :orders
+
+    def initialize
+      self.filters = nil
+      self.orders = []
+    end
+
+    def clone
+      query = Filterparams::Query.new
+      query.filters = filters
+      query.orders.push(*orders)
+      query
+    end
+
+    def add_order(name, descending = false)
+      add_order_obj Filterparams::Order.new(name, descending)
+    end
+
+    def add_order_obj(*order_obj)
+      query = clone
+      query.orders.push(*order_obj)
+      query
+    end
+
+    def filter(filter_obj)
+      query = clone
+      query.filters = if query.filters.nil?
+                        filter_obj
+                      else
+                        Filterparams::And.new(query.filters, filter_obj)
+                      end
+      query
+    end
+  end
+end

data/lib/filterparams/order_extractor.rb

@@ -0,0 +1,42 @@
+require_relative './obj/order'
+
+module Filterparams
+  class OrderExtractor
+    ORDER_MATCHER = /(
+      (?<direction>\w+)\((?<directed_param>\w+)\)|
+      (?<param>\w+)
+    )/x
+
+    def initialize(orders)
+      orders = [orders] unless orders.is_a? Array
+
+      @orders = orders
+    end
+
+    def orders
+      @order_objs ||= extract_orders
+    end
+
+    private
+
+    def extract_orders
+      @orders.map { |order| generate_order(order) }
+             .reject(&:nil?)
+    end
+
+    def generate_order(order_string)
+      match = ORDER_MATCHER.match(order_string)
+      return nil if match.nil?
+
+      if match['param'].nil?
+        direction = match['direction']
+        name = match['directed_param']
+      else
+        direction = 'asc'
+        name = match['param']
+      end
+
+      Filterparams::Order.new(name, direction == 'desc')
+    end
+  end
+end

data/lib/filterparams/param_extractor.rb

@@ -0,0 +1,60 @@
+require_relative './obj'
+
+module Filterparams
+  class ParamExtractor
+    FILTER_MATCHES = /filter\[param\]\[(?<name>\w+)\]
+                      (\[(?<filter>\w+)\](\[(?<alias>\w+)\])?)?/x
+
+    def initialize(params)
+      @params = params
+    end
+
+    def params
+      match_hashes.map { |map| generate_param map }
+    end
+
+    def params_hash
+      filter_args = params.map do |parameter|
+        [parameter.identification, parameter]
+      end.flatten
+      Hash[*filter_args]
+    end
+
+    private
+
+    def generate_param(param_hash)
+      Filterparams::Parameter.new(param_hash[:name], param_hash)
+    end
+
+    def match_hashes
+      matches = @params.map do |key, value|
+        if value.is_a? Array
+          value = if value.size > 0
+                    value[0]
+                  else
+                    nil
+                  end
+        end
+
+        {
+          match: FILTER_MATCHES.match(key),
+          value: value
+        }
+      end
+      matches = matches.reject { |map| map[:match].nil? }
+      matches.map do |map|
+        create_match_lookup(map)
+      end
+    end
+
+    def create_match_lookup(map)
+      match = map[:match]
+      {
+        name: match['name'],
+        value: map[:value],
+        filter: match['filter'],
+        alias: match['alias']
+      }
+    end
+  end
+end

metadata

@@ -0,0 +1,378 @@
+--- !ruby/object:Gem::Specification
+name: filterparams
+version: !ruby/object:Gem::Version
+  version: 0.9.1
+platform: ruby
+authors:
+- Christoph Brand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov-json
+  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'
+- !ruby/object:Gem::Dependency
+  name: simplecov-rcov
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop-checkstyle_formatter
+  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'
+- !ruby/object:Gem::Dependency
+  name: ci_reporter_rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: parslet
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.6.0
+description: |
+  # Ruby Filterparams #
+
+  Filterparams is a library for specifying filters through a REST API
+  on collection resources on top of HTTP. It provides the capability
+  to specify SQL-like syntax on top of query parameters.
+
+  Due to it's intended use of building [JSONAPI](http://jsonapi.org/)
+  libraries with this definition, it is compatible with the definition
+  and encapsulates it's syntax through the prefixed `filter` parameters.
+
+  ## Installation ##
+
+  The library is available through the `filterparams` gem on [RubyGems](https://rubygems.org/gems/filterparams)
+  and thus can be installed through the command line or by adding the package to
+  your Gemfile.
+
+  ```
+  gem install filterparams
+  ```
+
+  ## Example ##
+
+  Given the URL (non URL escaped for better readability):
+
+  ```
+  /users?filter[param][name][like][no_brand_name]=doe&filter[param][first_name]=doe%&filter[binding]=(!no_brand_name&first_name)&filter[order]=name&filter[order]=desc(first_name)
+  ```
+
+  It can be parsed with the following code:
+
+  ```ruby
+  require 'uri'
+  require 'cgi'
+  require 'filterparams'
+
+  url = 'http://www.example.com/users?' +
+        'filter[param][name][like][no_brand_name]=doe' +
+        '&filter[param][first_name]=doe%' +
+        '&filter[binding]=%28%21no_brand_name%26first_name%29' +
+        '&filter[order]=name&filter[order]=desc(first_name)'
+
+  data = CGI.parse(URI.parse(url).query)
+
+  Filterparams::extract_query(data)
+  ```
+
+  This would result into a query instance being produced with the
+  following data:
+
+  ```
+  #<Filterparams::Query:0x007ff78b1a51c8
+   @filters=
+    #<Filterparams::And:0x007ff78b1a57e0
+     @left=
+      #<Filterparams::Not:0x007ff78b1a6ed8
+       @inner=
+        #<Filterparams::Parameter:0x007ff78b1ee940
+         @alias="no_brand_name",
+         @filter="like",
+         @name="name",
+         @value="doe">>,
+     @right=
+      #<Filterparams::Parameter:0x007ff78b1ee918
+       @alias=nil,
+       @filter=nil,
+       @name="first_name",
+       @value="doe%">>,
+   @orders=
+    [#<Filterparams::Order:0x007ff78b1ee5f8 @direction="asc", @name="name">,
+     #<Filterparams::Order:0x007ff78b1ee3a0
+      @direction="desc",
+      @name="first_name">]>
+  ```
+
+  The orders can be accessed through the `.orders` method and the filter
+  binding through `.filters`.
+
+  ## Syntax ##
+
+  All arguments must be prefixed by "filter". It is possible to
+  query for specific data with filters, apply orders to the result
+  and to combine filters through AND, NOT and OR bindings.
+
+  The syntax builds under the filter parameter a virtual object.
+  The keys of the object are simulated through specifying `[{key}]`
+  in the passed query parameter. Thus `filter[param]` would point
+  to the param key in the filter object.
+
+  ### Filter specification ###
+
+  The solution supports to query data through the `param` subkey.
+
+  ```
+  filter[param][{parameter_name}][{operation}][{alias}] = {to_query_value}
+  ```
+
+  The `operation` and `alias` parameters may be omitted. If no
+  `alias` is provided the given parameter name is used for it.
+  If no `operation` is given, the default one is used (in the
+  example this would be equal).
+
+  Example:
+  ```
+  filter[param][phone_number][like]=001%
+  ```
+
+  This would add a filter to all phone numbers which start with "001".
+
+  ### Filter binding ###
+
+  Per default all filters are combined through AND clauses.
+  You can change that by specifying the `filter[binding]` argument.
+
+  This is where the aliases which you can define come into place.
+  The binding provides means to combine filters with AND and OR.
+  Also you are able to negate filters here.
+
+  The filters are addressed by their alias or name, if no alias is
+  provided.
+
+  If you have a filter `search_for_name`, `search_for_phone_number`
+  and `search_for_account_number` defined you can say
+  `search_for_name OR NOT search_for_number AND search_for_account_number`
+  by specifying the following filter:
+
+  ```
+  filter[binding]=search_for_name|(!search_for_phone_number&search_for_account_number)
+  ```
+
+  Even though the brackets are useless here, you can use them in
+  more complex filters.
+
+  The following table summarizes the possible configuration options:
+  <table>
+    <thead>
+      <tr>
+        <th>Type</th>
+        <th>Symbol</th>
+        <th>Example</th>
+      </tr>
+    </thead>
+    <tbody>
+      <tr>
+        <td>AND</td>
+        <td>&</td>
+        <td>a&b</td>
+      </tr>
+      <tr>
+        <td>OR</td>
+        <td>|</td>
+        <td>a|b</td>
+      </tr>
+      <tr>
+        <td>NOT</td>
+        <td>!</td>
+        <td>!a</td>
+      </tr>
+      <tr>
+        <td>Bracket</td>
+        <td>()</td>
+        <td>(a|b)&c</td>
+      </tr>
+    </tbody>
+  </table>
+
+  ### Ordering ###
+
+  To specify a sort order of the results the `filter[order]` parameter
+  may be used. The value can be specified multiple times. To add
+  ordering you have to provide the name of the parameter which should
+  be ordered, not its alias!
+
+  If you want to order by `name`, `first_name` and in reverse order
+  `balance` you can do so by specifying the following query url
+  parameters:
+
+  ```
+  filter[order]=name&filter[order]=first_name&filter[order]=desc(balance)
+  ```
+
+  As you can see the `desc()` definition can be used to indicate
+  reverse ordering.
+
+  ## License ##
+
+  The project is licensed under the [MIT License](https://opensource.org/licenses/MIT).
+
+  ## Used libraries ##
+
+  For parsing the query parameters the [`parslet`](https://kschiess.github.io/parslet/)
+  library is used. It is released under the [MIT License](https://github.com/kschiess/parslet/blob/master/LICENSE).
+
+  ## Other Languages ##
+
+  This is a list of projects implementing the same API for other languages.
+  Currently this list only has one entry.
+
+  - Go - [go-filterparams](https://github.com/cbrand/go-filterparams)
+  - Python - [python-filterparams](https://github.com/cbrand/python-filterparams)
+  - JavaScript (Client) - [filterparams](https://github.com/cbrand/js-filterparams-client)
+email: christoph@brand.rest
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/filterparams.rb
+- lib/filterparams/api.rb
+- lib/filterparams/binding.rb
+- lib/filterparams/binding/binding_parser.rb
+- lib/filterparams/binding/binding_transform.rb
+- lib/filterparams/obj.rb
+- lib/filterparams/obj/and.rb
+- lib/filterparams/obj/binding_operation.rb
+- lib/filterparams/obj/not.rb
+- lib/filterparams/obj/or.rb
+- lib/filterparams/obj/order.rb
+- lib/filterparams/obj/parameter.rb
+- lib/filterparams/obj/query.rb
+- lib/filterparams/order_extractor.rb
+- lib/filterparams/param_extractor.rb
+homepage: https://github.com/cbrand/ruby-filterparams
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Parser for filterparams query parameters
+test_files: []