predicator 1.2.1 → 2.0.0

data/.rubocop.yml

@@ -1,46 +0,0 @@
-AllCops:
-  TargetRubyVersion: 2.3
-  DisabledByDefault: true
-  Exclude:
-    - "lib/predicator/parser.rb" #generated file
-    - "lib/predicator/lexer.rex.rb" #generated file
-
-Bundler/DuplicatedGem:
-  Enabled: true
-Lint:
-  Enabled: true
-Performance:
-  Enabled: true
-Security:
-  Enabled: true
-
-# Single quotes being faster is hardly measurable and only affects parse time.
-# Enforcing double quotes reduces the times where you need to change them
-# when introducing an interpolation. Use single quotes only if their semantics
-# are needed.
-Style/StringLiterals:
-  EnforcedStyle: double_quotes
-
-# Seattle style
-Style/MethodDefParentheses:
-  EnforcedStyle: require_no_parentheses
-
-# Allow regex argument in Seattle style
-Lint/AmbiguousRegexpLiteral:
-  Enabled: false
-
-# Allow block argument in Seattle style
-Lint/AmbiguousOperator:
-  Enabled: false
-
-# No long classes
-Style/ClassLength:
-  Enabled: true
-  Exclude:
-    - "test/**/*.rb"
-    - "lib/predicator/visitors/instructions.rb"
-    - "lib/predicator/evaluator.rb"
-
-Lint/HandleExceptions:
-  Exclude:
-    - lib/tasks/**/*.rake

data/.travis.yml

@@ -1,5 +0,0 @@
-language: ruby
-rvm:
-  - 2.0
-  - 2.1
-  - 2.2

data/CODE_OF_CONDUCT.md

@@ -1,49 +0,0 @@
-# Contributor Code of Conduct
-
-As contributors and maintainers of this project, and in the interest of
-fostering an open and welcoming community, 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, religion, or nationality.
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery
-* Personal attacks
-* Trolling or insulting/derogatory comments
-* Public or private harassment
-* Publishing other's private information, such as physical or electronic
-  addresses, without explicit permission
-* Other unethical or 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, or to ban temporarily or
-permanently any contributor for other behaviors that they deem inappropriate,
-threatening, offensive, or harmful.
-
-By adopting this Code of Conduct, project maintainers commit themselves to
-fairly and consistently applying these principles to every aspect of managing
-this project. Project maintainers who do not follow or enforce the Code of
-Conduct may be permanently removed from the project team.
-
-This code of conduct applies both within project spaces and in public spaces
-when an individual is representing the project or its community.
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be
-reported by contacting a project maintainer at ubergeek3141@gmail.com. All
-complaints will be reviewed and investigated and will result in a response that
-is deemed necessary and appropriate to the circumstances. Maintainers are
-obligated to maintain confidentiality with regard to the reporter of an
-incident.
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage],
-version 1.3.0, available at
-[http://contributor-covenant.org/version/1/3/0/][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

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

data/HISTORY.md

@@ -1,51 +0,0 @@
-### 1.2.1 / 2020-08-04
-
-* Moves project to riddler/predicator
-
-### 1.2.0 / 2018-09-13
-
-* Adds type casting to comparisons
-* Adds date type and predicates
-* Adds "from now" and "ago" relative dates
-* Adds "present" and "blank" predicates
-* Adds "starts with" and "ends with" string comparisons
-
-### 1.1.0 / 2017-12-06
-
-* Rescues errors when comparing invalid types
-
-### 1.0.0 / 2017-09-22
-
-* Adds new lexer
-* Introduces the stack machine and instructions
-* Adds LessThan predicate
-* Adds Between predicate
-* Adds In and Not In predicates (with arrays)
-* Adds BooleanVariable predicate
-
-### 0.4.0 / 2016-06-09
-
-* Adds double dispatch for relation predicates
-* Adds method predicate (.blank? and .present?)
-* Adds Context#eval
-
-### 0.3.0 / 2016-03-11
-
-* Adds more relation predicates (GT, LT, GTE, LTE, NEQ)
-* Adds between predicate
-
-### 0.2.1 / 2016-02-22
-
-* Makes RACC a development dependency (trying to get working on MagLev)
-
-### 0.2.0 / 2016-02-21
-
-* Makes RACC a runtime dependency
-
-### 0.1.0 / 2016-02-21
-
-* Changed from Parslet to RACC
-
-### 0.0.0 / 2016-02-08
-
-* Birthday!

data/Rakefile

@@ -1,24 +0,0 @@
-require "rubygems"
-require "bundler/gem_tasks"
-require "rake/testtask"
-require "oedipus_lex"
-
-Rake.application.rake_require "oedipus_lex"
-
-Rake::TestTask.new :test do |t|
-  t.libs << "test"
-  t.test_files = FileList["test/**/test_*.rb"]
-  t.warning = false
-end
-
-desc "Generate the lexer"
-task lexer: "lib/predicator/lexer.rex.rb"
-
-desc "Compile and generate the parser"
-task parser: :lexer do
-  sh "racc -l -o lib/predicator/parser.rb lib/predicator/parser.y"
-end
-
-task test: :parser
-
-task default: :test

data/lib/predicator/context.rb

@@ -1,18 +0,0 @@
-module Predicator
-  class Context
-    def initialize params={}
-      @bindings = {}
-      params.each{ |key,value| bind key, value }
-    end
-
-    def bind name, value
-      @bindings[name.to_s] = value
-    end
-    alias :[]= :bind
-
-    def binding_for name
-      @bindings[name.to_s]
-    end
-    alias :[] :binding_for
-  end
-end

data/lib/predicator/lexer.rex

@@ -1,69 +0,0 @@
-class Predicator::Lexer
-options
-  lineno
-  column
-macro
-  SPACE       /[ \t\r\n]/
-  LPAREN      /\(/
-  RPAREN      /\)/
-  LBRACKET    /\[/
-  RBRACKET    /\]/
-  TRUE        /true\b/
-  FALSE       /false\b/
-  BETWEEN     /between\b/
-  IN          /in\b/
-  BANG        /!/
-  NOT         /not\b/
-  DOT         /\./
-  COMMA       /,/
-  AND         /and\b/
-  OR          /or\b/
-  EQ          /=/
-  GT          />/
-  LT          /</
-  ENDSWITH    /ends with/
-  STARTSWITH  /starts with/
-  BEGINSWITH  /begins with/
-  BLANK       /is blank/
-  PRESENT     /is present/
-  AGO         /ago/
-  FROMNOW     /from now/
-  DATE        /\d{4}[-|\/]\d{2}[-|\/]\d{2}/i
-  DURATION    /\d+d/
-  INTEGER     /[+-]?\d(_?\d)*\b/
-  STRING      /(["'])(?:\\?.)*?\1/
-  IDENTIFIER  /[a-z][A-Za-z0-9_]*\b/
-rule
-  /#{SPACE}/       # ignore space
-  /#{LPAREN}/      { [:LPAREN, text] }
-  /#{RPAREN}/      { [:RPAREN, text] }
-  /#{LBRACKET}/    { [:LBRACKET, text] }
-  /#{RBRACKET}/    { [:RBRACKET, text] }
-  /#{TRUE}/        { [:TRUE, text] }
-  /#{FALSE}/       { [:FALSE, text] }
-  /#{BETWEEN}/     { [:BETWEEN, text] }
-  /#{IN}/          { [:IN, text] }
-  /#{BANG}/        { [:BANG, text] }
-  /#{NOT}/         { [:NOT, text] }
-  /#{DOT}/         { [:DOT, text] }
-  /#{COMMA}/       { [:COMMA, text] }
-  /#{AND}/         { [:AND, text] }
-  /#{OR}/          { [:OR, text] }
-  /#{EQ}/          { [:EQ, text] }
-  /#{GT}/          { [:GT, text] }
-  /#{LT}/          { [:LT, text] }
-  /#{AGO}/         { [:AGO, text] }
-  /#{FROMNOW}/     { [:FROMNOW, text] }
-  /#{ENDSWITH}/    { [:ENDSWITH, text] }
-  /#{STARTSWITH}/  { [:STARTSWITH, text] }
-  /#{BEGINSWITH}/  { [:STARTSWITH, text] }
-  /#{BLANK}/       { [:BLANK, text] }
-  /#{PRESENT}/     { [:PRESENT, text] }
-  /#{DATE}/        { [:DATE, text] }
-  /#{DURATION}/    { [:DURATION, text] }
-  /#{INTEGER}/     { [:INTEGER, text] }
-  /#{STRING}/      { [:STRING, text[1...-1]] }
-  /#{IDENTIFIER}/  { [:IDENTIFIER, text] }
-inner
-  def do_parse; end
-end

data/lib/predicator/lexer.rex.rb

@@ -1,187 +0,0 @@
-# encoding: UTF-8
-#--
-# This file is automatically generated. Do not modify it.
-# Generated by: oedipus_lex version 2.5.0.
-# Source: lib/predicator/lexer.rex
-#++
-
-class Predicator::Lexer
-  require 'strscan'
-
-  SPACE      = /[ \t\r\n]/
-  LPAREN     = /\(/
-  RPAREN     = /\)/
-  LBRACKET   = /\[/
-  RBRACKET   = /\]/
-  TRUE       = /true\b/
-  FALSE      = /false\b/
-  BETWEEN    = /between\b/
-  IN         = /in\b/
-  BANG       = /!/
-  NOT        = /not\b/
-  DOT        = /\./
-  COMMA      = /,/
-  AND        = /and\b/
-  OR         = /or\b/
-  EQ         = /=/
-  GT         = />/
-  LT         = /</
-  ENDSWITH   = /ends with/
-  STARTSWITH = /starts with/
-  BEGINSWITH = /begins with/
-  BLANK      = /is blank/
-  PRESENT    = /is present/
-  AGO        = /ago/
-  FROMNOW    = /from now/
-  DATE       = /\d{4}[-|\/]\d{2}[-|\/]\d{2}/i
-  DURATION   = /\d+d/
-  INTEGER    = /[+-]?\d(_?\d)*\b/
-  STRING     = /(["'])(?:\\?.)*?\1/
-  IDENTIFIER = /[a-z][A-Za-z0-9_]*\b/
-
-  class LexerError < StandardError ; end
-  class ScanError < LexerError ; end
-
-  attr_accessor :lineno
-  attr_accessor :filename
-  attr_accessor :ss
-  attr_accessor :state
-
-  alias :match :ss
-
-  def matches
-    m = (1..9).map { |i| ss[i] }
-    m.pop until m[-1] or m.empty?
-    m
-  end
-
-  def action
-    yield
-  end
-
-  attr_accessor :old_pos
-
-  def column
-    idx = ss.string.rindex("\n", old_pos) || -1
-    old_pos - idx - 1
-  end
-
-  def scanner_class
-    StringScanner
-  end unless instance_methods(false).map(&:to_s).include?("scanner_class")
-
-  def parse str
-    self.ss     = scanner_class.new str
-    self.lineno = 1
-    self.state  ||= nil
-
-    do_parse
-  end
-
-  def parse_file path
-    self.filename = path
-    open path do |f|
-      parse f.read
-    end
-  end
-
-  def location
-    [
-      (filename || "<input>"),
-      lineno,
-      column,
-    ].compact.join(":")
-  end
-
-  def next_token
-
-    token = nil
-
-    until ss.eos? or token do
-      self.lineno += 1 if ss.peek(1) == "\n"
-      self.old_pos = ss.pos
-      token =
-        case state
-        when nil then
-          case
-          when ss.skip(/#{SPACE}/) then
-            # do nothing
-          when text = ss.scan(/#{LPAREN}/) then
-            action { [:LPAREN, text] }
-          when text = ss.scan(/#{RPAREN}/) then
-            action { [:RPAREN, text] }
-          when text = ss.scan(/#{LBRACKET}/) then
-            action { [:LBRACKET, text] }
-          when text = ss.scan(/#{RBRACKET}/) then
-            action { [:RBRACKET, text] }
-          when text = ss.scan(/#{TRUE}/) then
-            action { [:TRUE, text] }
-          when text = ss.scan(/#{FALSE}/) then
-            action { [:FALSE, text] }
-          when text = ss.scan(/#{BETWEEN}/) then
-            action { [:BETWEEN, text] }
-          when text = ss.scan(/#{IN}/) then
-            action { [:IN, text] }
-          when text = ss.scan(/#{BANG}/) then
-            action { [:BANG, text] }
-          when text = ss.scan(/#{NOT}/) then
-            action { [:NOT, text] }
-          when text = ss.scan(/#{DOT}/) then
-            action { [:DOT, text] }
-          when text = ss.scan(/#{COMMA}/) then
-            action { [:COMMA, text] }
-          when text = ss.scan(/#{AND}/) then
-            action { [:AND, text] }
-          when text = ss.scan(/#{OR}/) then
-            action { [:OR, text] }
-          when text = ss.scan(/#{EQ}/) then
-            action { [:EQ, text] }
-          when text = ss.scan(/#{GT}/) then
-            action { [:GT, text] }
-          when text = ss.scan(/#{LT}/) then
-            action { [:LT, text] }
-          when text = ss.scan(/#{AGO}/) then
-            action { [:AGO, text] }
-          when text = ss.scan(/#{FROMNOW}/) then
-            action { [:FROMNOW, text] }
-          when text = ss.scan(/#{ENDSWITH}/) then
-            action { [:ENDSWITH, text] }
-          when text = ss.scan(/#{STARTSWITH}/) then
-            action { [:STARTSWITH, text] }
-          when text = ss.scan(/#{BEGINSWITH}/) then
-            action { [:STARTSWITH, text] }
-          when text = ss.scan(/#{BLANK}/) then
-            action { [:BLANK, text] }
-          when text = ss.scan(/#{PRESENT}/) then
-            action { [:PRESENT, text] }
-          when text = ss.scan(/#{DATE}/) then
-            action { [:DATE, text] }
-          when text = ss.scan(/#{DURATION}/) then
-            action { [:DURATION, text] }
-          when text = ss.scan(/#{INTEGER}/) then
-            action { [:INTEGER, text] }
-          when text = ss.scan(/#{STRING}/) then
-            action { [:STRING, text[1...-1]] }
-          when text = ss.scan(/#{IDENTIFIER}/) then
-            action { [:IDENTIFIER, text] }
-          else
-            text = ss.string[ss.pos .. -1]
-            raise ScanError, "can not match (#{state.inspect}) at #{location}: '#{text}'"
-          end
-        else
-          raise ScanError, "undefined state at #{location}: '#{state}'"
-        end # token = case state
-
-      next unless token # allow functions to trigger redo w/ nil
-    end # while
-
-    raise LexerError, "bad lexical result at #{location}: #{token.inspect}" unless
-      token.nil? || (Array === token && token.size >= 2)
-
-    # auto-switch state
-    self.state = token.last if token && token.first == :state
-
-    token
-  end # def next_token
-    def do_parse; end
-end # class

data/lib/predicator/parser.y

@@ -1,120 +0,0 @@
-class Predicator::Parser
-
-options no_result_var
-
-token TRUE FALSE LPAREN RPAREN LBRACKET RBRACKET
-      BANG NOT DOT COMMA AT AND OR
-      EQ GT LT BETWEEN IN PRESENT BLANK
-      INTEGER STRING IDENTIFIER
-      DATE DURATION AGO FROMNOW
-      STARTSWITH ENDSWITH
-
-rule
-  predicate
-    : boolean_predicate
-    | logical_predicate
-    | group_predicate
-    | comparison_predicate
-    ;
-  boolean_predicate
-    : TRUE                      { AST::True.new true }
-    | FALSE                     { AST::False.new false }
-    | variable                  { AST::BooleanVariable.new val.first }
-    ;
-  logical_predicate
-    : BANG predicate            { AST::Not.new val.last }
-    | predicate AND predicate   { AST::And.new val.first, val.last }
-    | predicate OR predicate    { AST::Or.new val.first, val.last }
-    | variable PRESENT          { AST::Present.new val.first }
-    | variable BLANK            { AST::Blank.new val.first }
-    ;
-  group_predicate
-    : LPAREN predicate RPAREN   { AST::Group.new val[1] }
-    ;
-  comparison_predicate
-    : integer_comparison_predicate
-    | string_comparison_predicate
-    | date_comparison_predicate
-    ;
-  integer_comparison_predicate
-    : variable EQ integer                      { AST::IntegerEqual.new val.first, val.last }
-    | variable GT integer                      { AST::IntegerGreaterThan.new val.first, val.last }
-    | variable LT integer                      { AST::IntegerLessThan.new val.first, val.last }
-    | variable BETWEEN integer AND integer     { AST::IntegerBetween.new val.first, val[2], val.last }
-    | variable IN integer_array                { AST::IntegerIn.new val.first, val.last }
-    | variable NOT IN integer_array            { AST::IntegerNotIn.new val.first, val.last }
-    ;
-  string_comparison_predicate
-    : variable EQ string                       { AST::StringEqual.new val.first, val.last }
-    | variable GT string                       { AST::StringGreaterThan.new val.first, val.last }
-    | variable LT string                       { AST::StringLessThan.new val.first, val.last }
-    | variable IN string_array                 { AST::StringIn.new val.first, val.last }
-    | variable NOT IN string_array             { AST::StringNotIn.new val.first, val.last }
-    | variable STARTSWITH string               { AST::StringStartsWith.new val.first, val.last }
-    | variable ENDSWITH string                 { AST::StringEndsWith.new val.first, val.last }
-    ;
-  date_comparison_predicate
-    : variable EQ date                         { AST::DateEqual.new val.first, val.last }
-    | variable GT date                         { AST::DateGreaterThan.new val.first, val.last }
-    | variable LT date                         { AST::DateLessThan.new val.first, val.last }
-    | variable BETWEEN date AND date           { AST::DateBetween.new val.first, val[2], val.last }
-    ;
-  integer_array
-    : LBRACKET integer_array_contents RBRACKET { AST::IntegerArray.new val[1] }
-    ;
-  integer_array_contents
-    : integer
-    | integer_array_contents COMMA integer     { [val.first, val.last].flatten }
-    ;
-  string_array
-    : LBRACKET string_array_contents RBRACKET  { AST::StringArray.new val[1] }
-    ;
-  string_array_contents
-    : string
-    | string_array_contents COMMA string       { [val.first, val.last].flatten }
-    ;
-  integer
-    : INTEGER                   { AST::Integer.new val.first.to_i }
-    ;
-  string
-    : STRING                    { AST::String.new val.first }
-    ;
-  date
-    : DATE                      { AST::Date.new val.first }
-    | duration AGO              { AST::DateAgo.new val.first }
-    | duration FROMNOW          { AST::DateFromNow.new val.first }
-    ;
-  duration
-    : DURATION                  { AST::Duration.new val.first }
-    ;
-  variable
-    : IDENTIFIER                { AST::Variable.new val.first }
-    | variable DOT IDENTIFIER   { AST::Variable.new [val.first, val.last].flatten.join(".") }
-    ;
-end
-
----- inner
-    def initialize
-      @lexer = Lexer.new
-    end
-
-    def parse string
-      @lexer.parse string
-      do_parse
-    end
-
-    def next_token
-      @lexer.next_token
-    end
-
-    def on_error type, val, values
-      super
-    rescue Racc::ParseError
-      trace = values.each_with_index.map{|l, i| "#{' ' * i}#{l}"}
-      raise ParseError, "\nparse error on value #{val.inspect}\n#{trace.join("\n")}"
-    end
-
----- header
-require "predicator/lexer.rex"
-require "predicator/visitors"
-require "predicator/ast"

data/lib/predicator/visitors/dot.rb

@@ -1,113 +0,0 @@
-module Predicator
-  module Visitors
-    class Dot < Visitor
-      attr_reader :nodes, :edges
-
-      def initialize
-        @nodes = []
-        @edges = []
-      end
-
-      def accept node
-        super
-        <<-eodot
-digraph parse_tree {
-  size="8,5"
-  node [shape = none];
-  edge [dir = none];
-  #{@nodes.join "\n  "}
-  #{@edges.join "\n  "}
-}
-        eodot
-      end
-
-      private
-
-      def visit_children node
-        node.children.each do |c|
-          @edges << "#{node.object_id} -> #{c.object_id};"
-        end
-        super
-      end
-
-      def visit_EQ node
-        @nodes << "#{node.object_id} [label=\"=\"];"
-        super
-      end
-
-      def visit_GT node
-        @nodes << "#{node.object_id} [label=\">\"];"
-        super
-      end
-
-      def visit_LT node
-        @nodes << "#{node.object_id} [label=\"<\"];"
-        super
-      end
-
-      def visit_BETWEEN node
-        @nodes << "#{node.object_id} [label=\"between\"];"
-        super
-      end
-
-      def visit_AND node
-        @nodes << "#{node.object_id} [label=\"and\"];"
-        super
-      end
-
-      def visit_OR node
-        @nodes << "#{node.object_id} [label=\"or\"];"
-        super
-      end
-
-      def visit_NOT node
-        @nodes << "#{node.object_id} [label=\"!\"];"
-        super
-      end
-
-      def visit_GROUP node
-        @nodes << "#{node.object_id} [label=\"( )\"];"
-        super
-      end
-
-      def visit_DATEAGO node
-        @nodes << "#{node.object_id} [label=\"ago\"];"
-        super
-      end
-
-      def visit_DATEFROMNOW node
-        @nodes << "#{node.object_id} [label=\"from now\"];"
-        super
-      end
-
-      def visit_STRSTARTSWITH node
-        @nodes << "#{node.object_id} [label=\"starts with\"];"
-        super
-      end
-
-      def visit_STRENDSWITH node
-        @nodes << "#{node.object_id} [label=\"ends with\"];"
-        super
-      end
-
-      def visit_STRING node
-        value = node.left
-        @nodes << "#{node.object_id} [label=\"'#{value}'\"];"
-      end
-
-      def terminal node
-        value = node.left.to_s
-        @nodes << "#{node.object_id} [label=\"#{value}\"];"
-      end
-
-      def add_source source, parent
-        ast = Predicator.parse source
-        vis = Dot.new
-        vis.accept ast
-        @nodes += vis.nodes
-        @edges += vis.edges
-        @edges << "#{parent.object_id} -> #{ast.object_id};"
-      end
-    end
-  end
-end