data_filter 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c24377c49a51265afaddbcc4a5a2c595a408e5a7
+  data.tar.gz: c1cdf33d9fd1fb2fa603830f532bb8f37498bbfe
+SHA512:
+  metadata.gz: 06d289a95c37300bd77ec74d7fb5f162a5c50fc2fab77b2db4e23e1ca0f9ffeecf806d53577ac5b535cf9b499ef801f4ac8dbe4f2d7b5e4cc6c940f79bd52700
+  data.tar.gz: 505a8fa5f671a0c481b0f6244298eacf7f5e9e92db7d1ebde08e8a2451b81673961387f85e207c4e7687d914e0d7c94374d93f7c869b827d085ce003836e2c73

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.1.3
+before_install: gem install bundler -v 1.10.6

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, ethnicity, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http://contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Josh Bodah
+
+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,49 @@
+# DataFilter
+
+an extensible DSL for filtering data sets
+
+## Installation
+
+```rb
+gem install data_filter
+```
+
+## Usage
+
+`DataFilter::FilterSet::create` provides a DSL for creating a collection
+of filters which can be applied to your data. The DSL is designed to be
+controller friendly and will only apply filters if a parameter is specified.
+If a filter doesn't do what you need then you can pass any object that responds
+to `#call` (e.g. a lambda) to `add_filter`.
+
+```rb
+filter_set = DataFilter::FilterSet.create do
+  # Fuzzy comparison
+  like_filter :name, by: params[:name]
+
+  # Keyword search
+  keyword_filter [:gender], by: params[:gender]
+
+  # Match truthy/falsey values
+  truthy_filter :student, match: params[:is_student]
+
+  # Check if within range
+  range_filter :age, ceiling: params[:max_age]
+
+  # Add a custom filter
+  add_filter -> (user) { user if user.student || user.age > 25 }
+end
+
+data = [
+  User.create(name: 'Josh', age: 26, student: false, gender: :male),
+  User.create(name: 'Lauren', age: 25, student: true, gender: :female)
+]
+
+# By default data which doesn't match all of the filters will be filtered out
+filter_set.call(data)
+```
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "data_filter"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/data_filter.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'data_filter/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "data_filter"
+  spec.version       = DataFilter::VERSION
+  spec.authors       = ["Josh Bodah"]
+  spec.email         = ["jb3689@yahoo.com"]
+
+  spec.summary       = %q{an extensible DSL for filtering data sets}
+  spec.homepage      = "https://github.com/backupify/data_filter"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/lib/data_filter/filter_set.rb

@@ -0,0 +1,185 @@
+module DataFilter
+  # Represents a collection of data filters that can be called on
+  # data. Provides a DSL for creating a filter set and only adding
+  # filters the filters that you need.
+  class FilterSet
+    attr_reader :filters
+
+    def initialize
+      @filters = []
+    end
+
+    # Add a filter to the filter set
+    #
+    # @param filter [#call]
+    #   a callable filter. Can be a proc, lambda, or any object
+    #   that responds to #call
+    # @return [FilterSet] the amended filter set
+    def add_filter(filter)
+      @filters << filter
+      self
+    end
+
+    # Run the filter set on a single data item
+    #
+    # @param item [Object] some item that we want to pass through all
+    #   of the filters in the filter set
+    # @return [Object, nil] the original item or nil
+    def filter(item)
+      @filters.reduce(item) { |i, filter| i if filter.call(i) }
+    end
+
+    # Run the filter set on a collection of data items
+    #
+    # @param items [Enumerable<Object>] collection of items that we want to
+    #   pass through all of the filters in the filter set
+    # @return [Enumerable<Object>] the filtered results
+    def batch(items)
+      items.select { |i| filter(i) }
+    end
+
+    # A DSL for creating a series of filters that can be called
+    #
+    # Provides a cleaner way to define a {DataFilter::FilterSet}
+    # with a bunch of different filters
+    #
+    # Conditionally adds filters to the set based on whether or not
+    # any valid search terms are provided (useful for Controller params)
+    #
+    # @example Office365::Mail::MessagesController
+    #   filter_set = DataFilter::FilterSet.create do
+    #     like_filter :to,        by: params[:to]
+    #     like_filter :from,      by: params[:from]
+    #     like_filter :cc,        by: params[:cc]
+    #     like_filter :bcc,       by: params[:bcc]
+    #     like_filter :subject,   by: params[:subject]
+    #
+    #     keyword_filter [:to, :from, :cc, :bcc, :subject], by: params[:keyword]
+    #
+    #     range_filter :date, floor: start_date, ceiling: end_date
+    #
+    #     if params[:has_attachment] === true
+    #       range_filter :attachment_count, floor: 1
+    #     elsif params[:has_attachment] === false
+    #       range_filter :attachment_count, ceiling: 0, nil_default: 0
+    #     end
+    #   end
+    module DSL
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        # Initializes a new {DataFilter::FilterSet} using a block.
+        # The block conforms to the DSL defined in this method.
+        # Delegates undefined messages to the caller's scope.
+        #
+        # @yield the DSL block
+        # @return [DataFilter::FilterSet] the filter set evaluated
+        #   with the DSL
+        def create(&block)
+          original_self = eval 'self', block.binding
+          instance = new
+          instance.instance_variable_set(:@original_self, original_self)
+          instance.instance_eval &block
+          instance
+        end
+      end
+
+      # Adds a {DataFilter::LikeFilter} to the filter set
+      #
+      # @param field_sym [Symbol] name of the data method we want
+      #   to filter
+      # @option opts [Object] :by the value we want to use when
+      #   filtering the data item
+      def like_filter(field_sym, opts = {})
+        if opts[:by]
+          @filters << LikeFilter.new(field_sym, opts[:by])
+        end
+      end
+
+      # Adds a {DataFilter::KeywordFilter} to the filter set
+      #
+      # @param field_syms [Array<Symbol>] a collection of all of the data
+      #   methods we want to inspect when filtering
+      # @option opts [Object] :by the value we want to use when filtering
+      #   the data item
+      def keyword_filter(field_syms, opts = {})
+        if opts[:by]
+          @filters << KeywordFilter.new(field_syms, opts[:by])
+        end
+      end
+
+      # Adds a {DataFilter::RangeFilter} to the filter set
+      #
+      # @param field_sym [Symbol] name of the data method we want to
+      #  filter
+      # @option opts [Comparable] :floor the range beginning we want to
+      #   filter the data item by
+      # @option opts [Comparable] :ceiling the range end we want to filter
+      #   the data item by
+      # @option opts [Comparable] :nil_default the value to use if the
+      #   data item has no field value
+      def range_filter(field_sym, opts = {})
+        if opts[:floor] || opts[:ceiling]
+          @filters << RangeFilter.new(field_sym, **opts)
+        end
+      end
+
+      # Adds a {DataFilter::RangeOverlapFilter} to the filter set
+      #
+      # @param start_sym [Symbol] name of the start field we want to
+      #  filter
+      # @param end_sym [Symbol] name of the end field we want to
+      #  filter
+      # @option opts [Comparable] :floor the range beginning we want to
+      #   filter the data item by
+      # @option opts [Comparable] :ceiling the range end we want to filter
+      #   the data item by
+      # @option opts [Comparable] :nil_default the value to use if the
+      #   data item has no field value
+      def range_overlap_filter(start_sym, end_sym, opts = {})
+        if opts[:floor] || opts[:ceiling]
+          @filters << RangeOverlapFilter.new(start_sym, end_sym, **opts)
+        end
+      end
+
+      # Adds a {DataFilter::TruthyFilter} to the filter set
+      #
+      # @param field_sym [Symbol] name of the field to match on
+      # @param match [Object] truthy/falsey value to use to determine whether
+      #   the filter should match/filter truthy fields or falsey fields
+      def truthy_filter(field_sym, match: nil)
+        # Skip filter if match is not specified
+        return if match.nil?
+        if is_falsey?(match)
+          @filters << TruthyFilter.new(field_sym, invert: true)
+        else
+          @filters << TruthyFilter.new(field_sym)
+        end
+      end
+
+      # Used to support the DSL. Calls out to the parent scope if
+      # we receive a message we can't respond to
+      def method_missing(sym, *args, &block)
+        @original_self.send(sym, *args, &block)
+      end
+
+      # Used to support the DSL. Calls out to the parent scope if
+      # we receive a message we can't respond to
+      def respond_to_missing?(sym, include_all = false)
+        @original_self.respond_to?(sym, include_all)
+      end
+
+      private
+
+
+      # TODO DRY up
+      def is_falsey?(val)
+        [false, 'false'].include?(val)
+      end
+    end
+
+    include DSL
+  end
+end

data/lib/data_filter/keyword_filter.rb

@@ -0,0 +1,36 @@
+module DataFilter
+  # Used to filter a data item by a search term by seeing if
+  # ANY of the data fields' values are similar to the search term
+  #
+  # @example
+  #   object = MyModel.new(text: 'hello world', name: 'goodbye', phrase: 'yo')
+  #   filter = DataFilter::KeywordFilter.new([:name, :phrase], 'hello')
+  #   filter.call(object)
+  #   # => nil
+  class KeywordFilter
+    # @param field_syms [Array<Symbol>] a collection of all of the data
+    #   methods we want to inspect when filtering
+    # @param search_term [String] the value we want to use when filtering
+    #   the data item
+    def initialize(field_syms, search_term)
+      @field_syms = field_syms
+      @search_term = search_term
+    end
+
+    # Filters the item
+    #
+    # @param item [Comparable] the item we want to filter
+    # @return [Object] the original data item
+    def call(item)
+      item if @field_syms.any? { |s| match?(item, s) }
+    end
+
+    private
+
+    # :nodoc:
+    def match?(item, field_sym)
+      item.respond_to?(field_sym) &&
+        DataFilter::LikeFilter.new(field_sym, @search_term).call(item)
+    end
+  end
+end

data/lib/data_filter/like_filter.rb

@@ -0,0 +1,61 @@
+module DataFilter
+  # Used to filter a data item by a search term by seeing if
+  # the data field value is similar to the search term
+  #
+  # @example
+  #   object = MyModel.new(text: 'hello world!')
+  #   filter = DataFilter::LikeFilter.new(:text, 'hello')
+  #   filter.call(object)
+  #   # => #<MyModel text: 'hello world'>
+  class LikeFilter
+    # @param field_sym [Symbol] name of the data method we want
+    #   to filter
+    # @param search_term [String] the value we want to use when
+    #   filtering the data item
+    def initialize(field_sym, search_term)
+      @field_sym = field_sym
+      @search_term = search_term
+    end
+
+    # Filters the item
+    #
+    # @param item [Object] the item we want to filter
+    # @return [Object, nil] the original data item
+    def call(item)
+      if item.respond_to?(@field_sym) &&
+        match?(item.public_send(@field_sym), @search_term)
+        item
+      end
+    end
+
+    private
+
+    # :nodoc:
+    def match?(actual, search_term)
+      case actual
+      when Hash
+        match?(actual.values.flatten, search_term)
+      when Array
+        actual.any? {|item| match?(item, search_term)}
+      when String
+        regexp =
+          normalize(search_term, true)
+            .split(' ')
+            .map {|term| Regexp.escape(term)}
+            .join('|')
+            .insert(0, '(')
+            .insert(-1, ')')
+        normalize(actual, false).match(/#{regexp}/i)
+      end
+    end
+
+    def normalize(str, use_cache = false)
+      if use_cache
+        @normalize_cache ||= {}
+        @normalize_cache[str] ||= str.gsub(/[^\w\s]/, ' ')
+      else
+        str.gsub(/[^\w\s]/, ' ')
+      end
+    end
+  end
+end

data/lib/data_filter/range_filter.rb

@@ -0,0 +1,53 @@
+module DataFilter
+  # Used to filter a data item by some range by seeing if
+  # the data field value falls within that range
+  #
+  # @example with a ceiling
+  #   object = MyModel.new(created_at: Date.parse('2001-01-13'))
+  #   filter = DataFilter::RangeFilter.new(:created_at, ceiling: Date.parse('2003-01-01'))
+  #   filter.call(object)
+  #   # => #<MyModel created_at: #<Date '2001-01-13'>>
+  #
+  # @example with a floor
+  #   object = MyModel.new(file_count: 300)
+  #   filter = DataFilter::RangeFilter.new(:file_count, floor: 1)
+  #   filter_return = filter.call(object)
+  #   # => #<MyModel file_count: 300>
+  #   has_file = filter_return.present?
+  #   # => true
+  class RangeFilter
+    # @param field_sym [Symbol] the field to filter on
+    # @param floor [Comparable] the range beginning we want to filter the data
+    #   item by
+    # @param ceiling [Comparable] the range end we want to filter the data item
+    #   by
+    # @param nil_default [Comparable] the value to use if the data item has no
+    #   field value
+    def initialize(field_sym, floor: nil, ceiling: nil, nil_default: nil)
+      @field_sym    = field_sym
+      @floor        = floor
+      @ceiling      = ceiling
+      @nil_default  = nil_default
+    end
+
+    # Filters the item
+    #
+    # @param item [Comparable] the item we want to filter
+    # @return [Object] the original data item
+    def call(item)
+      if item.respond_to?(@field_sym)
+        actual = item.public_send(@field_sym)
+        actual = @nil_default if actual.nil?
+        item if in_range?(actual)
+      end
+    end
+
+    private
+
+    # :nodoc:
+    def in_range?(actual)
+      return false if actual.nil?
+      (@floor.nil? || actual >= @floor) && (@ceiling.nil? || actual <= @ceiling)
+    end
+  end
+end

data/lib/data_filter/range_overlap_filter.rb

@@ -0,0 +1,52 @@
+module DataFilter
+  # Used to filter a data item by a set of ranges by seeing if
+  # the data field value intersects that range
+  #
+  # @example with a floor and ceiling
+  #   event = MyModel.new(start_time: Date.parse('2001-01-13'), end_time: Date.parse('2002-01-13'))
+  #   filter = DataFilter::RangeOverlapFilter
+  #     .new(:start_time, :end_time, floor: Date.parse('2000-01-13'), ceiling: Date.parse('2003-01-13'))
+  #   filter.call(object)
+  #   # => #<MyModel start_time: #<Date '2001-01-13'>, end_time: #<Date '2002-01-13'>
+  class RangeOverlapFilter
+    # @param start_sym [Symbol] the range start to filter on
+    # @param end_sym [Symbol] the range end to filter on
+    # @param floor [Comparable] the range beginning we want to filter the data
+    #   item by
+    # @param ceiling [Comparable] the range end we want to filter the data item
+    #   by
+    # @param nil_default [Comparable] the value to use if the data item has no
+    #   field value
+    def initialize(start_sym, end_sym, floor: nil, ceiling: nil, nil_default: nil)
+      @start_sym   = start_sym
+      @end_sym     = end_sym
+      @floor       = floor
+      @ceiling     = ceiling
+      @nil_default = nil_default
+    end
+
+    # Filters the item
+    #
+    # @param item [Comparable] the item we want to filter
+    # @return [Object] the original data item
+    def call(item)
+      if item.respond_to?(@start_sym) && item.respond_to?(@end_sym)
+        actual_start = item.public_send(@start_sym)
+        actual_start = @nil_default if actual_start.nil?
+
+        actual_end = item.public_send(@end_sym)
+        actual_end = @nil_default if actual_end.nil?
+
+        item if in_range?(actual_start, actual_end)
+      end
+    end
+
+    private
+
+    # :nodoc:
+    def in_range?(actual_start, actual_end)
+      return false if actual_start.nil? || actual_end.nil?
+      (@floor..@ceiling).overlaps?(actual_start..actual_end)
+    end
+  end
+end

data/lib/data_filter/truthy_filter.rb

@@ -0,0 +1,41 @@
+module DataFilter
+  # Used to filter a data item by whether it is truthy/falsey
+  #
+  # @example
+  #   object = MyModel.new(is_alive: 'false')
+  #   filter = DataFilter::TruthyFilter.new(:is_alive)
+  #   filter.call(object)
+  #   # => nil
+  class TruthyFilter
+    # @param field_sym [Symbol] the name of the field to filter by
+    # @param invert [Boolean] (default: false) set to true if you
+    #   would rather match when the field is falsey instead of when
+    #   it is truthy
+    def initialize(field_sym, invert: false)
+      @field_sym = field_sym
+      @invert = invert
+    end
+
+    # Filters the item
+    #
+    # @param item [Object] the item we want to filter
+    # @return [Object, nil] the original data item
+    def call(item)
+      if item.respond_to?(@field_sym)
+        val = item.public_send(@field_sym)
+        is_falsey = is_falsey?(val)
+        is_match = (@invert ? is_falsey : !is_falsey)
+        if is_match
+          item
+        end
+      end
+    end
+
+    private
+
+    # @private
+    def is_falsey?(val)
+      [false, 'false', 0, nil].include?(val)
+    end
+  end
+end

data/lib/data_filter/version.rb

@@ -0,0 +1,3 @@
+module DataFilter
+  VERSION = '0.1.0'
+end

data/lib/data_filter.rb

@@ -0,0 +1,11 @@
+require 'data_filter/version'
+
+require 'data_filter/filter_set'
+
+require 'data_filter/keyword_filter'
+require 'data_filter/range_filter'
+require 'data_filter/like_filter'
+require 'data_filter/range_overlap_filter'
+require 'data_filter/truthy_filter'
+
+module DataFilter; end

metadata

@@ -0,0 +1,104 @@
+--- !ruby/object:Gem::Specification
+name: data_filter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Josh Bodah
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-09-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: 
+email:
+- jb3689@yahoo.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- data_filter.gemspec
+- lib/data_filter.rb
+- lib/data_filter/filter_set.rb
+- lib/data_filter/keyword_filter.rb
+- lib/data_filter/like_filter.rb
+- lib/data_filter/range_filter.rb
+- lib/data_filter/range_overlap_filter.rb
+- lib/data_filter/truthy_filter.rb
+- lib/data_filter/version.rb
+homepage: https://github.com/backupify/data_filter
+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.2.2
+signing_key: 
+specification_version: 4
+summary: an extensible DSL for filtering data sets
+test_files: []