Class: Philtre::Predicates

Inherits:
Object
  • Object
show all
Includes:
PredicateDsl.new do not_eq {|expr, val| ~Sequel.expr( expr => val) } def not_like( expr, val ) Sequel.~(like expr, val) end matches( :like ) {|expr, val| Sequel.expr( expr => /#{val}/i) } def not_blank(expr, val) Sequel.~(blank expr, val) end null {|expr,_| Sequel.expr(expr => nil)} not_null {|expr,_| Sequel.~(Sequel.expr(expr => nil))} def blank(expr, _) is_nil = Sequel.expr(expr => nil) is_empty = Sequel.expr(expr => '') Sequel.| is_nil, is_empty end eq {|expr, val| Sequel.expr( expr => val) } gt {|expr, val| expr > val } gte( :gteq ) {|expr, val| expr >= val } lt {|expr, val| expr < val } lte( :lteq ) {|expr, val| expr <= val } # more complex predicates def like_all( expr, arg ) exprs = Array(arg).map {|value| like expr, value } Sequel.& *exprs end def like_any( expr, arg ) exprs = Array(arg).map {|value| like expr, value } Sequel.| *exprs end end
Defined in:
lib/philtre/predicates.rb

Overview

Container for methods which return Sequel::SQL::Expression or something that can become one through Sequel.expr, eg 2013

Reminder: they’re defined as methods so we can benefit from using them inside this class to define other predicates.

This can be extended in all the usual ruby ways: by including a module, reopening the class. Also using extend_with which takes a PredicateDsl block.

Constant Summary collapse

DefaultPredicates =

Define the set of default predicates.

PredicateDsl.new do
  not_eq           {|expr, val| ~Sequel.expr( expr => val)       }

  def not_like( expr, val )
    Sequel.~(like expr, val)
  end

  matches( :like ) {|expr, val|  Sequel.expr( expr => /#{val}/i) }

  def not_blank(expr, val)
    Sequel.~(blank expr, val)
  end

  null {|expr,_| Sequel.expr(expr => nil)}
  not_null {|expr,_| Sequel.~(Sequel.expr(expr => nil))}

  def blank(expr, _)
    is_nil = Sequel.expr(expr => nil)
    is_empty = Sequel.expr(expr => '')
    Sequel.| is_nil, is_empty
  end

  eq               {|expr, val|  Sequel.expr( expr => val)       }
  gt               {|expr, val|    expr >  val                   }
  gte( :gteq )     {|expr, val|    expr >= val                   }
  lt               {|expr, val|    expr <  val                   }
  lte( :lteq )     {|expr, val|    expr <= val                   }

  # more complex predicates
  def like_all( expr, arg )
    exprs = Array(arg).map {|value| like expr, value }
    Sequel.& *exprs
  end

  def like_any( expr, arg )
    exprs = Array(arg).map {|value| like expr, value }
    Sequel.| *exprs
  end
end

Instance Method Summary collapse

Constructor Details

#initialize(&bloc) ⇒ Predicates

Returns a new instance of Predicates.



11
12
13
 
# File 'lib/philtre/predicates.rb', line 11

def initialize( &bloc )
  extend_with &bloc
end

Instance Method Details

#call(field_predicate, value, field = nil) ⇒ Object Also known as: []

TODO this should probably also be method_missing? field is only used once for any given field_predicate



52
53
54
55
56
57
 
# File 'lib/philtre/predicates.rb', line 52

def call( field_predicate, value, field = nil )
  unless respond_to? field_predicate
    define_name_predicate field_predicate, value, field
  end
  send field_predicate, value
end

#extend_with(&bloc) ⇒ Object

pass a block that can contain a combination of def meth_name() or the DSL defined by PredicateDsl.



17
18
19
 
# File 'lib/philtre/predicates.rb', line 17

def extend_with( &bloc )
  extend PredicateDsl.new(&bloc)
end

#predicate_names ⇒ Object 



62
63
64
65
66
67
68
 
# File 'lib/philtre/predicates.rb', line 62

def predicate_names
  # ruby-2.3 no longer stores methods in order of definition. So sort by
  # longest so that we don't get false positives from shorter predicates
  # that are substrings of longer predicates, eg blank matching
  # thing_not_blank.
  DefaultPredicates.instance_methods.sort_by{|name| -name.length}
end