csdl 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5f8bac9da29e72abe7b9ed3d735c9e43dd0299f8
+  data.tar.gz: fbddc9f5fe3edd6c023acfad56e2dac01e3baff6
+SHA512:
+  metadata.gz: bbe665e31c04cacc5922e9f66a6e09835b63516cf900b785df53ade0939aa78e170f29b37723ebe88b3fca8d905467a438a26eff9ab604dc6d899376928c711e
+  data.tar.gz: cdff5b7766ac63008c2c0421f84294a9046bc6d4657149f15675e2768c94fdf24014c8b4daffab0f98f246602979bb7f01bba0c19cf9feff7656e6f5b70326b1

data/.gitignore

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

data/.ruby-version

@@ -0,0 +1 @@
+2.2.2

data/.travis.yml

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

data/Gemfile

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

data/README.md

@@ -0,0 +1,153 @@
+# CSDL
+
+CSDL is a gem for producing Abstract Syntax Trees for the [DataSift CSDL Filter Language](http://dev.datasift.com/docs/csdl).
+Working with an AST instead of raw strings provides a simpler way to test and validate any given CSDL filter.
+
+[![Build Status](https://travis-ci.org/localshred/csdl.svg)](https://travis-ci.org/localshred/csdl)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "csdl"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install csdl
+
+## Usage
+
+Use the DSL provided by `CSDL::Builder` to produce an AST representation of your query, and use `CSDL::Processor` to turn your AST into a raw CSDL string.
+
+Valid builder methods are `closure`, `filter`, `_and`, `_or`, and `_not`. The last three are prefixed to avoid keyword collision.
+
+```ruby
+builder = ::CSDL::Builder.new._or do
+  [
+    closure {
+      _and {
+        [
+          closure {
+            _or {
+              [
+                filter("fb.content", :contains_any, "ebola"),
+                filter("fb.parent.content", :contains_any, "ebola")
+              ]
+            }
+          },
+          _not("fb.content", :contains_any, "government,politics"),
+          filter("fb.author.country_code", :in, "GB")
+        ]
+      }
+    },
+    closure {
+      _and {
+        [
+          closure {
+            _or {
+              [
+                filter("fb.content", :contains_any, "malta,malta island,#malta"),
+                filter("fb.parent.content", :contains_any, "malta,malta island,#malta")
+              ]
+            }
+          },
+          _not("fb.content", :contains_any, "vacation,poker awards")
+        ]
+      }
+    }
+  ]
+end
+
+puts
+puts "Builder..."
+puts builder.to_sexp
+
+puts
+puts "Processing AST..."
+puts ::CSDL::Processor.new.process(builder)
+```
+
+The previous script produces the following output:
+
+```
+Builder...
+(or
+  (closure
+    (and
+      (closure
+        (or
+          (filter
+            (target "fb.content")
+            (operator :contains_any)
+            (argument
+              (string "ebola")))
+          (filter
+            (target "fb.parent.content")
+            (operator :contains_any)
+            (argument
+              (string "ebola")))))
+      (not
+        (target "fb.content")
+        (operator :contains_any)
+        (argument
+          (string "government,politics")))
+      (filter
+        (target "fb.author.country_code")
+        (operator :in)
+        (argument
+          (string "GB")))))
+  (closure
+    (and
+      (closure
+        (or
+          (filter
+            (target "fb.content")
+            (operator :contains_any)
+            (argument
+              (string "malta,malta island,#malta")))
+          (filter
+            (target "fb.parent.content")
+            (operator :contains_any)
+            (argument
+              (string "malta,malta island,#malta")))))
+      (not
+        (target "fb.content")
+        (operator :contains_any)
+        (argument
+          (string "vacation,poker awards"))))))
+
+Processing AST...
+((fb.content contains_any "ebola" OR fb.parent.content contains_any "ebola") AND NOT fb.content contains_any "government,politics" AND fb.author.country_code in "GB") OR ((fb.content contains_any "malta,malta island,#malta" OR fb.parent.content contains_any "malta,malta island,#malta") AND NOT fb.content contains_any "vacation,poker awards")
+```
+
+The processed AST looks like this (manually expanded):
+
+```
+(
+  (
+    fb.content contains_any "ebola"
+    OR fb.parent.content contains_any "ebola"
+  )
+  AND NOT fb.content contains_any "government,politics"
+  AND fb.author.country_code in "GB"
+)
+OR
+(
+  (
+    fb.content contains_any "malta,malta island,#malta"
+    OR fb.parent.content contains_any "malta,malta island,#malta"
+  )
+  AND NOT fb.content contains_any "vacation,poker awards"
+)
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/localshred/csdl](https://github.com/localshred/csdl).
+

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/csdl.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'csdl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "csdl"
+  spec.version       = Csdl::VERSION
+  spec.authors       = ["BJ Neilsen"]
+  spec.email         = ["bj.neilsen@gmail.com"]
+
+  spec.summary       = %q{AST Processor and Query Builder for DataSift's CSDL language}
+  spec.description   = spec.summary
+  spec.homepage      = "https://localshred.github.io"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "ast", "~> 2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.10"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest"
+end

data/lib/csdl.rb

@@ -0,0 +1,13 @@
+require "ast"
+require "csdl/version"
+
+module CSDL
+end
+
+require "csdl/error"
+require "csdl/targets"
+require "csdl/operators"
+require "csdl/builder"
+require "csdl/processor"
+require "csdl/interaction_filter_processor"
+require "csdl/query_filter_processor"

data/lib/csdl/builder.rb

@@ -0,0 +1,73 @@
+module CSDL
+  class Builder
+    include ::AST::Sexp
+
+    def __one_or_more_child_nodes(&block)
+      children = instance_eval(&block)
+      [ children ].flatten
+    end
+
+    def _or(&block)
+      s(:or, *__one_or_more_child_nodes(&block))
+    end
+
+    def _and(&block)
+      s(:and, *__one_or_more_child_nodes(&block))
+    end
+
+    def _not(target, operator, argument = nil)
+      node = filter(target, operator, argument)
+      node.updated(:not)
+    end
+
+    def _return(&block)
+      s(:return, statement_scope(&block))
+    end
+
+    def filter(target, operator, argument = nil)
+      target_node   = s(:target, target)
+      operator_node = s(:operator, operator)
+      argument_node = nil
+
+      unless argument.nil?
+        argument_node_type  = argument.class.name.to_s.downcase.to_sym
+        child_argument_node = s(argument_node_type, argument)
+        argument_node       = s(:argument, child_argument_node)
+      end
+
+      s(:filter, *[target_node, operator_node, argument_node].compact)
+    end
+
+    def logical_group(logical_operator = nil, &block)
+      if logical_operator.nil?
+        s(:logical_group, *__one_or_more_child_nodes(&block))
+      else
+        s(:logical_group, s(logical_operator, *__one_or_more_child_nodes(&block)))
+      end
+    end
+
+    def statement_scope(&block)
+      s(:statement_scope, *__one_or_more_child_nodes(&block))
+    end
+
+    def tag(tag_class, &block)
+      s(:tag,
+        s(:tag_class,
+          s(:string, tag_class)),
+        statement_scope(&block))
+    end
+
+    def tag_tree(tag_nodes, tag_class, &block)
+      tag_node_nodes = tag_nodes.map do |tag_node|
+        s(:tag_node, tag_node)
+      end
+
+      s(:tag,
+        s(:tag_nodes,
+          *tag_node_nodes),
+        s(:tag_class,
+          s(:string, tag_class)),
+        statement_scope(&block))
+    end
+  end
+end

data/lib/csdl/error.rb

@@ -0,0 +1,14 @@
+module CSDL
+  class Error                            < ::StandardError; end
+
+  class InvalidInteractionTargetError    < Error; end
+  class InvalidQueryTargetError          < Error; end
+  class MissingChildNodesError           < Error; end
+  class MissingReturnStatementScopeError < Error; end
+  class MissingTagClassError             < Error; end
+  class MissingTagNodesError             < Error; end
+  class MissingTagStatementScopeError    < Error; end
+  class UnknownOperatorError             < Error; end
+  class UnknownTargetError               < Error; end
+end
+

data/lib/csdl/interaction_filter_processor.rb

@@ -0,0 +1,65 @@
+module CSDL
+  class InteractionFilterProcessor < ::CSDL::Processor
+
+    def on_return(node)
+      statement_scope = node.children.find { |child| child.type == :statement_scope }
+
+      if statement_scope.nil?
+        fail ::CSDL::MissingReturnStatementScopeError, "Invalid CSDL AST: return statment scope is missing"
+      end
+
+      "return #{process(statement_scope)}"
+    end
+
+    def on_statement_scope(node)
+      "{" + process_all(node.children).join(" ") + "}"
+    end
+
+    def on_tag(node)
+      tag_nodes       = node.children.find { |child| child.type == :tag_nodes }
+      tag_class       = node.children.find { |child| child.type == :tag_class }
+      statement_scope = node.children.find { |child| child.type == :statement_scope }
+
+      if tag_class.nil?
+        fail ::CSDL::MissingTagClassError, "Invalid CSDL AST: :tag node must have a :tag_class child node"
+      end
+
+      if statement_scope.nil?
+        fail ::CSDL::MissingTagStatementScopeError, "Invalid CSDL AST: :tag node must have a :statement_scope child node"
+      end
+
+      tag_namespace = "tag"
+      unless tag_nodes.nil?
+        tag_namespace += process(tag_nodes)
+      end
+
+      children = [tag_namespace] + process_all([ tag_class, statement_scope ])
+      children.join(" ")
+    end
+
+    def on_tag_class(node)
+      process(node.children.first)
+    end
+
+    def on_tag_node(node)
+      node.children.first.to_s
+    end
+
+    def on_tag_nodes(node)
+      child_tag_nodes = node.children.select { |child| child.type == :tag_node }
+
+      if child_tag_nodes.empty?
+        fail ::CSDL::MissingTagNodesError, "Invalid CSDL AST: A :tag_nodes node must have at least one :tag_node child"
+      end
+
+      "." + process_all(child_tag_nodes).join(".")
+    end
+
+    def validate_target!(target_key)
+      unless ::CSDL.interaction_target?(target_key)
+        fail ::CSDL::InvalidInteractionTargetError, "Interaction filters cannot use target '#{target_key}'"
+      end
+    end
+
+  end
+end

data/lib/csdl/operators.rb

@@ -0,0 +1,52 @@
+module CSDL
+
+  Operator = Struct.new(:name, :argument_types)
+
+  raw_operators = [
+    [ "contains"         , [ :string ] ],
+    [ "cs contains"      , [ :string ] ],
+    [ "substr"           , [ :string ] ],
+    [ "cs substr"        , [ :string ] ],
+    [ "contains_any"     , [ :string ] ],
+    [ "cs contains_any"  , [ :string ] ],
+    [ "any"              , [ :string ] ],
+    [ "cs any"           , [ :string ] ],
+    [ "wildcard"         , [ :string ] ],
+    [ "cs wildcard"      , [ :string ] ],
+    [ "wild"             , [ :string ] ],
+    [ "cs wild"          , [ :string ] ],
+    [ "contains_all"     , [ :string ] ],
+    [ "cs contains_all"  , [ :string ] ],
+    [ "all"              , [ :string ] ],
+    [ "cs all"           , [ :string ] ],
+    [ "contains_near"    , [ :string ] ],
+    [ "cs contains_near" , [ :string ] ],
+    [ "exists"           , [ :string ] ],
+    [ "in"               , [ :string ] ],
+    [ "url_in"           , [ :string ] ],
+    [ "=="               , [ :string ] ],
+    [ "!="               , [ :string ] ],
+    [ "cs =="            , [ :string ] ],
+    [ "cs !="            , [ :string ] ],
+    [ ">"                , [ :string ] ],
+    [ ">="               , [ :string ] ],
+    [ "<"                , [ :string ] ],
+    [ "<="               , [ :string ] ],
+    [ "regex_partial"    , [ :string ] ],
+    [ "regex_exact"      , [ :string ] ],
+    [ "geo_box"          , [ :string ] ],
+    [ "geo_radius"       , [ :string ] ],
+    [ "geo_polygon"      , [ :string ] ]
+  ]
+
+  OPERATORS = raw_operators.reduce({}) do |accumulator, (operator_name, argument_types)|
+    accumulator[operator_name] = Operator.new(operator_name, argument_types)
+    accumulator
+  end.freeze
+
+  def self.operator?(operator)
+    OPERATORS.key?(operator)
+  end
+
+end
+

data/lib/csdl/processor.rb

@@ -0,0 +1,78 @@
+module CSDL
+  class Processor < ::AST::Processor
+
+    def on_and(node)
+      initial = process(node.children.first)
+      rest = node.children.drop(1)
+
+      rest.reduce(initial) do |csdl, child|
+        csdl += " AND " + process(child)
+        csdl
+      end
+    end
+
+    def on_argument(node)
+      process(node.children.first)
+    end
+
+    def on_logical_group(node)
+      "(" + process_all(node.children).join(" ") + ")"
+    end
+
+    def on_not(node)
+      "NOT " + process(node.updated(:filter))
+    end
+
+    def on_operator(node)
+      operator = node.children.first.to_s
+      unless ::CSDL.operator?(operator)
+        fail ::CSDL::UnknownOperatorError, "Operator #{operator} is unknown"
+      end
+      operator
+    end
+
+    def on_or(node)
+      if node.children.empty?
+        fail ::CSDL::MissingChildNodesError, "Invalid CSDL AST: 'or' nodes must contain at least two child nodes. Expected >= 2, got 0"
+      end
+
+      initial = process(node.children.first)
+      rest = node.children.drop(1)
+
+      if rest.empty?
+        fail ::CSDL::MissingChildNodesError, "Invalid CSDL AST: 'or' nodes must contain at least two child nodes. Expected >= 2, got #{node.children.size}"
+      end
+
+      rest.reduce(initial) do |csdl, child|
+        csdl += " OR " + process(child)
+        csdl
+      end
+    end
+
+    def on_string(node)
+      '"' + node.children.first.to_s.gsub(/"/, '\"') + '"'
+    end
+
+    def on_target(node)
+      target = node.children.first.to_s
+      validate_target!(target)
+      target
+    end
+
+    def on_filter(node)
+      target   = node.children.find { |child| child.type == :target }
+      operator = node.children.find { |child| child.type == :operator }
+      argument = node.children.find { |child| child.type == :argument }
+      process_all([ target, operator, argument ].compact).join(" ")
+    end
+
+    def validate_target!(target_key)
+      unless ::CSDL.target?(target_key)
+        fail ::CSDL::InvalidQueryTargetError, "Query filters cannot use target '#{target_key}'"
+      end
+    end
+
+  end
+end
+
+

data/lib/csdl/query_filter_processor.rb

@@ -0,0 +1,12 @@
+module CSDL
+  class QueryFilterProcessor < ::CSDL::Processor
+
+    def validate_target!(target_key)
+      unless ::CSDL.query_target?(target_key)
+        fail ::CSDL::InvalidQueryTargetError, "Query filters cannot use target '#{target_key}'"
+      end
+    end
+
+  end
+end
+

data/lib/csdl/targets.rb

@@ -0,0 +1,96 @@
+module CSDL
+
+  Target = Struct.new(:name, :interaction?, :analysis?, :query?)
+
+  raw_targets = [
+
+    [ "fb.author.age"                     , true  , true  , true  ] ,
+    [ "fb.author.country"                 , true  , true  , true  ] ,
+    [ "fb.author.country_code"            , true  , true  , true  ] ,
+    [ "fb.author.gender"                  , true  , true  , true  ] ,
+    [ "fb.author.region"                  , true  , true  , true  ] ,
+    [ "fb.author.type"                    , true  , true  , true  ] ,
+    [ "fb.content"                        , true  , false , true  ] ,
+    [ "fb.hashtags"                       , true  , true  , true  ] ,
+    [ "fb.language"                       , true  , true  , true  ] ,
+    [ "fb.link"                           , true  , true  , true  ] ,
+    [ "fb.media_type"                     , true  , true  , true  ] ,
+    [ "fb.parent.author.age"              , true  , true  , true  ] ,
+    [ "fb.parent.author.country"          , true  , true  , true  ] ,
+    [ "fb.parent.author.country_code"     , true  , true  , true  ] ,
+    [ "fb.parent.author.gender"           , true  , true  , true  ] ,
+    [ "fb.parent.author.type"             , true  , true  , true  ] ,
+    [ "fb.parent.content"                 , true  , false , true  ] ,
+    [ "fb.parent.hashtags"                , true  , true  , true  ] ,
+    [ "fb.parent.interface"               , true  , true  , true  ] ,
+    [ "fb.parent.language"                , true  , true  , true  ] ,
+    [ "fb.parent.link"                    , true  , true  , true  ] ,
+    [ "fb.parent.media_type"              , true  , true  , true  ] ,
+    [ "fb.parent.sentiment"               , true  , true  , true  ] ,
+    [ "fb.parent.topics.about"            , true  , false , false ] ,
+    [ "fb.parent.topics.category"         , true  , true  , true  ] ,
+    [ "fb.parent.topics.company_overview" , true  , false , false ] ,
+    [ "fb.parent.topics.location_city"    , true  , false , false ] ,
+    [ "fb.parent.topics.location_street"  , true  , false , false ] ,
+    [ "fb.parent.topics.mission"          , true  , false , false ] ,
+    [ "fb.parent.topics.name"             , true  , true  , true  ] ,
+    [ "fb.parent.topics.products"         , true  , false , false ] ,
+    [ "fb.parent.topics.release_date"     , true  , false , false ] ,
+    [ "fb.parent.topics.username"         , true  , false , false ] ,
+    [ "fb.parent.topics.website"          , true  , false , false ] ,
+    [ "fb.parent.topic_ids"               , true  , true  , true  ] ,
+    [ "fb.sentiment"                      , true  , true  , true  ] ,
+    [ "fb.topics.about"                   , true  , false , false ] ,
+    [ "fb.topics.category"                , true  , true  , true  ] ,
+    [ "fb.topics.company_overview"        , true  , false , false ] ,
+    [ "fb.topics.location_city"           , true  , false , false ] ,
+    [ "fb.topics.location_street"         , true  , false , false ] ,
+    [ "fb.topics.mission"                 , true  , false , false ] ,
+    [ "fb.topics.name"                    , true  , true  , true  ] ,
+    [ "fb.topics.products"                , true  , false , false ] ,
+    [ "fb.topics.release_date"            , true  , false , false ] ,
+    [ "fb.topics.username"                , true  , false , false ] ,
+    [ "fb.topics.website"                 , true  , false , false ] ,
+    [ "fb.topic_ids"                      , true  , true  , true  ] ,
+    [ "fb.type"                           , true  , true  , true  ] ,
+    [ "interaction.content"               , true  , false , true  ] ,
+    [ "interaction.hashtags"              , true  , true  , true  ] ,
+    [ "interaction.media_type"            , true  , true  , true  ] ,
+    [ "interaction.ml.categories"         , false , true  , true  ] ,
+    [ "interaction.raw_content"           , true  , false , true  ] ,
+    [ "interaction.subtype"               , true  , true  , true  ] ,
+    [ "interaction.tag_tree"              , false , true  , false ] ,
+    [ "interaction.tags"                  , false , true  , true  ] ,
+    [ "links.code"                        , true  , true  , true  ] ,
+    [ "links.domain"                      , true  , true  , true  ] ,
+    [ "links.normalized_url"              , true  , true  , true  ] ,
+    [ "links.url"                         , true  , true  , true  ]
+  ]
+
+  TARGETS = raw_targets.reduce({}) do |accumulator, (target_name, interaction, analysis, query)|
+    accumulator[target_name] = Target.new(target_name, interaction, analysis, query)
+    accumulator
+  end.freeze
+
+  INTERACTION_TARGETS = TARGETS.select { |_, target| target.interaction? }
+  ANALYSIS_TARGETS    = TARGETS.select { |_, target| target.analysis? }
+  QUERY_TARGETS       = TARGETS.select { |_, target| target.query? }
+
+  def self.target?(target_name)
+    TARGETS.key?(target_name)
+  end
+
+  def self.interaction_target?(target_name)
+    INTERACTION_TARGETS.key?(target_name)
+  end
+
+  def self.analysis_target?(target_name)
+    ANALYSIS_TARGETS.key?(target_name)
+  end
+
+  def self.query_target?(target_name)
+    QUERY_TARGETS.key?(target_name)
+  end
+
+end
+

data/lib/csdl/version.rb

@@ -0,0 +1,3 @@
+module Csdl
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification
+name: csdl
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- BJ Neilsen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !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: AST Processor and Query Builder for DataSift's CSDL language
+email:
+- bj.neilsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".ruby-version"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- csdl.gemspec
+- lib/csdl.rb
+- lib/csdl/builder.rb
+- lib/csdl/error.rb
+- lib/csdl/interaction_filter_processor.rb
+- lib/csdl/operators.rb
+- lib/csdl/processor.rb
+- lib/csdl/query_filter_processor.rb
+- lib/csdl/targets.rb
+- lib/csdl/version.rb
+homepage: https://localshred.github.io
+licenses: []
+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: AST Processor and Query Builder for DataSift's CSDL language
+test_files: []