safrano 0.2.0 → 0.3.0

data/lib/odata/collection_filter.rb

@@ -1,7 +1,8 @@
-#!/usr/bin/env ruby
-
 require 'odata/error.rb'
 
+require_relative 'filter/parse.rb'
+require_relative 'filter/sequel.rb'
+
 # a few helper method
 class String
   MASK_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
@@ -31,502 +32,30 @@ class String
       "'$#{cnt}'"
     end
     yield tmpstr
-    #    tmpstr2.gsub(UNMASK_RGX) do |_m|
-    #      k = Regexp.last_match(2).to_s
-    #      "'#{Regexp.last_match(1)}#{repl[k]}#{Regexp.last_match(3)}'"
-    #    end
   end
 end
 
 # filter base class and subclass in our OData namespace
 module OData
-  # handles associations in filter arguments
-  module FilterWithAssoc
-    def get_assoc
-      @assoc, @fn = @fn.split('/') if @fn.include?('/')
-    end
-
-    def get_qualified_fn(dtcx)
-      seqtn = if dtcx.respond_to? :table_name
-                @assoc ? @assoc.to_sym : dtcx.table_name
-              else
-                @assoc ? @assoc.to_sym : dtcx.model.table_name
-              end
-      Sequel[seqtn][@fn.to_sym]
-    end
-  end
-
-  # base class for filtering
-  class Filter
-    attr_reader :assoc
-    attr_reader :assocs
-    QUO = /'((?:[^']|(?:\'{2}))*)'/.freeze
-    NOTQ = /((?:[^'\s\)])*)/.freeze
-
-    def initialize(matx)
-      @matx = matx
-      @assocs = Set.new
-    end
-
-    class << self
-      attr_reader :regexp
-    end
-
-    # input : the filter string
-    # returns a filter object that should have a apply_to(cx) method
-    def self.new_by_parse(filterstr, dtset = nil)
-      # handle complex flat expressions (flat = without relationships)
-      # with Sequel
-      ComplexFilter.new(filterstr, dtset)
-    end
-
-    # try to handle a simple expression like < fieldname EQ value >
-    # or < substringof(a,b) >
-    # NO parenthesis and no  AND/OR handled here
-    def self.new_full_match(filterstr)
-      full_reg = Regexp.new(/\A#{regexp}\z/)
-      # this needs to return nil, not false, or some testcase will fail
-      return nil unless (matx = filterstr.match(full_reg))
-
-      # actually it's self.new(matx)
-      new(matx)
-    end
-
-    def apply_to_dataset(dtcx)
-      dtcx
-    end
-
-    def apply_associations(dtcx)
-      @assocs.each { |aj| dtcx = dtcx.association_join(aj) }
-      dtcx
-    end
-  end
-
-  # well...
-  class EqualFilter < Filter
-    include FilterWithAssoc
-    EQL = '[eE][qQ]|[LlgGNn][eETt]'.freeze
-
-    def self.qualified_regexp(paths_rx)
-      /\s*(#{paths_rx})\s+(#{EQL})\s+(?:#{QUO}|#{NOTQ})\s*/
-    end
-
-    def initialize(matx)
-      super(matx)
-      @fn = matx[1]
-      get_assoc if @fn
-
-      @val = matx[3] ? matx[3].gsub("''", "'") : matx[4]
-
-      @op = matx[2].downcase
-    end
-
-    # ugly hack... but working
-    def gen_sql(dtcx)
-      # handle ambiguous column names (joins) by qualifiying the names
-      #      seqfn = @assoc ? Sequel[@assoc.to_sym][@fn.to_sym] : @fn.to_sym
-      # handle ambiguous column names (joins) by qualifiying the names
-      # for the main table as well
-      # TODO: find a better way to differentiate between the two types
-      #      of dtcx : Model or Dataset
-
-      # DONE: same handling for order and substring and everywhere where
-      # qualified fieldnames could be needed (uses attrib path regexp)
-      x = apply_to_dataset(dtcx)
-      # ugly ugly hack :-(
-      y = x.unordered.sql.sub(x.unfiltered.unordered.sql + ' WHERE', '')
-      y
-    end
-
-    def apply_op_to_dataset(dtcx, lefval, rightval)
-      case @op
-      when 'eq'
-        dtcx.where(lefval => rightval)
-      when 'ne'
-        dtcx.exclude(lefval => rightval)
-      when 'le'
-        dtcx.where { lefval <= rightval }
-      when 'ge'
-        dtcx.where { lefval >= rightval }
-      when 'lt'
-        dtcx.where { lefval < rightval }
-      when 'gt'
-        dtcx.where { lefval > rightval }
-      else
-        raise OData::FilterParseError
-      end
-    end
-
-    def apply_to_dataset(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      # using @val in Procs below does not work reliably. Using a local var
-      # seems to work better
-      argval = @val
-
-      apply_op_to_dataset(dtcx, seqfn, argval)
-    end
-
-    def apply_to_object(inp)
-      case @op
-      when 'eq'
-        get_value(inp) == @val
-      when 'ne'
-        get_value(inp) != @val
-      else
-        raise OData::FilterParseError
-      end
-    end
-  end
-
-  class Func2a_EqualFilter < EqualFilter
-    FUNC = 'concat'.freeze
-    attr_reader :funcname
-
-    # like for concat(Name, 'xyz') EQ 'blablux'
-    def self.qualified_regexp(pathsrx)
-      /\s*(#{FUNC})\((#{pathsrx}),\s*(?:#{QUO})\)\s+(#{EQL})\s+(?:#{QUO})\s*/
-    end
-
-    def initialize(matx)
-      #      super(matx)
-      @funcname = matx[1]
-      @fn = matx[2]
-      get_assoc if @fn
-      @farg = matx[3].gsub("''", "'")
-      @op = matx[4].downcase
-
-      @val = matx[5].gsub("''", "'")
-    end
-
-    def apply_to_dataset(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      # using @val in Procs below does not work reliably. Using a local var
-      # seems to work better
-      argval = @val
-      seqfunc = case @funcname
-                when 'concat'
-                  Sequel.join([seqfn, @farg])
-                else
-                  raise OData::FilterParseError
-                end
-      apply_op_to_dataset(dtcx, seqfunc, argval)
-    end
-  end
-  class Func2b_EqualFilter < EqualFilter
-    FUNC = 'concat'.freeze
-    attr_reader :funcname
-
-    # like for concat('xyz', Name) EQ 'blablux'
-    def self.qualified_regexp(pathsrx)
-      /\s*(#{FUNC})\((?:#{QUO}),\s*(#{pathsrx})\)\s+(#{EQL})\s+(?:#{QUO})\s*/
-    end
-
-    def initialize(matx)
-      #      super(matx)
-      @funcname = matx[1]
-      @fn = matx[3]
-      get_assoc if @fn
-      @farg = matx[2].gsub("''", "'")
-      @op = matx[4].downcase
-
-      @val = matx[5].gsub("''", "'")
-    end
-
-    def apply_to_dataset(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      # using @val in Procs below does not work reliably. Using a local var
-      # seems to work better
-      argval = @val
-      seqfunc = case @funcname
-                when 'concat'
-                  Sequel.join([@farg, seqfn])
-                else
-                  raise OData::FilterParseError
-                end
-      apply_op_to_dataset(dtcx, seqfunc, argval)
-    end
-  end
-
-  class Func2c_EqualFilter < EqualFilter
-    FUNC = 'concat'.freeze
-    attr_reader :funcname
-
-    # like for concat(first_ame, last_name) EQ 'blablux'
-    def self.qualified_regexp(pathsrx)
-      /\s*(#{FUNC})\((#{pathsrx}),\s*(#{pathsrx})\)\s+(#{EQL})\s+(?:#{QUO})\s*/
-    end
-
-    def get_assoc
-      @assoc, @fn = @fn.split('/') if @fn.include?('/')
-      assoc1, @fn1 = @fn1.split('/') if @fn1.include?('/')
-      return unless assoc1 != @assoc
-
-      # TODO... handle this
-      raise OData::ServerError
-    end
-
-    def get_qualified_fn1(dtcx)
-      seqtn = if dtcx.respond_to? :table_name
-                @assoc ? @assoc.to_sym : dtcx.table_name
-              else
-                @assoc ? @assoc.to_sym : dtcx.model.table_name
-              end
-      Sequel[seqtn][@fn1.to_sym]
-    end
-
-    def initialize(matx)
-      #      super(matx)
-      @funcname = matx[1]
-      @fn = matx[2]
-      @fn1 = matx[3]
-      get_assoc if @fn
-
-      @op = matx[4].downcase
-
-      @val = matx[5].gsub("''", "'")
-    end
-
-    def apply_to_dataset(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      seqfn1 = get_qualified_fn1(dtcx)
-      # using @val in Procs below does not work reliably. Using a local var
-      # seems to work better
-      argval = @val
-      seqfunc = case @funcname
-                when 'concat'
-                  Sequel.join([seqfn, seqfn1])
-                else
-                  raise OData::FilterParseError
-                end
-      apply_op_to_dataset(dtcx, seqfunc, argval)
-    end
-  end
-
-  # equality expressions with functions having 1 parameter
-  # like for  length(name) eq 2
-  class FuncEqualFilter < EqualFilter
-    FUNC = 'length|trim|tolower|toupper'.freeze
-
-    attr_reader :funcname
-
-    def self.qualified_regexp(pathsrx)
-      /\s*(#{FUNC})\((#{pathsrx})\)\s+(#{EQL})\s+(?:#{QUO}|#{NOTQ})\s*/
-    end
-
-    def initialize(matx)
-      super(matx)
-      @funcname = matx[1]
-      @fn = matx[2]
-      get_assoc if @fn
-
-      @op = matx[3].downcase
-
-      @val = matx[4] ? matx[4].gsub("''", "'") : matx[5]
-    end
-
-    def apply_to_dataset(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      # using @val in Procs below does not work reliably. Using a local var
-      # seems to work better
-      argval = @val
-      seqfunc = case @funcname
-                when 'length'
-                  argval = Sequel.lit(@val)
-                  Sequel.char_length(seqfn)
-                when 'trim'
-                  Sequel.trim(seqfn)
-                when 'toupper'
-                  Sequel.function(:upper, seqfn)
-                when 'tolower'
-                  Sequel.function(:lower, seqfn)
-                else
-                  raise OData::FilterParseError
-                end
-
-      apply_op_to_dataset(dtcx, seqfunc, argval)
-    end
-  end
-
-  # keyword based
-  class FilterWithKeyword < Filter
-    attr_reader :keyword
-  end
-
-  # for substringof('value', field)
-  class SubstringOfFilterSig1 < FilterWithKeyword
-    include FilterWithAssoc
-
-    def self.qualified_regexp(paths_rx)
-      # Note:    QUOTED_RGX captures the string content without
-      #          start and end quote (no need to un-quote)
-      #          NOTQ_RGX captures an not-quoted value argument
-      #          (like for numbers)
-      /(substringof)\((?:#{QUO}|#{NOTQ}),\s*(#{paths_rx})\)/
-    end
-
-    def initialize(matx)
-      super(matx)
-
-      @fn = matx[4]
-      get_assoc if @fn
-      #      @val = matx[2].strip_single_quote
-      @val = matx[2] ? matx[2].gsub("''", "'") : matx[3]
-      @keyword = matx[1]
-    end
-
-    def whcl(dtcx)
-      # handle ambiguous column names (joins) by qualifiying the names
-      # seqfn = @assoc ? Sequel[@assoc.to_sym][@fn.to_sym] : @fn.to_sym
-      seqfn = get_qualified_fn(dtcx)
-      Sequel.like(seqfn, "%#{@val}%")
-    end
-
-    def gen_sql(dtcx)
-      sql_ = ''
-      dt = dtcx.respond_to?(:dataset) ? dtcx.dataset : dtcx
-      dt.literal_append(sql_, whcl(dt))
-      sql_
-    end
-
-    def apply_to_dataset(dtcx)
-      dtcx.where(whcl(dtcx))
-    end
-  end
-  # for substringof(field,'value')
-  class SubstringOfFilterSig2 < FilterWithKeyword
-    include FilterWithAssoc
-
-    def initialize(matx)
-      super(matx)
-      @fn = matx[2]
-      get_assoc if @fn
-      @val = matx[3]
-      @keyword = matx[1]
-
-      raise FilterParseError
-    end
-
-    def apply_to_dataset(dtcx)
-      dtcx
-    end
-  end
-
-  # Filter by start/end with
-  class StartOrEndsWithFilter < FilterWithKeyword
-    include FilterWithAssoc
-    # DONE: better handle quotes vs not-quotes. Unblanced quotes are now handled
-    # example : startswith(year, 190')
-
-    def self.qualified_regexp(paths)
-      /(endswith|startswith)\((#{paths}),\s*(?:#{QUO}|#{NOTQ})\s*\)/
-    end
-
-    def initialize(matx)
-      super(matx)
-      # DONE: the regexp should only match on known field names...
-      # --> use qualified_regexp(attr_paths_rgx)
-      @fn = matx[2]
-      get_assoc if @fn
-      # double quotes need to be unescaped
-      @val = matx[3] ? matx[3].gsub("''", "'") : matx[4]
-      @keyword = matx[1]
-    end
-
-    def whcl(dtcx)
-      seqfn = get_qualified_fn(dtcx)
-      case @keyword
-      when 'startswith'
-        Sequel.like(seqfn, "#{@val}%")
-      when 'endswith'
-        Sequel.like(seqfn, "%#{@val}")
-      else
-        raise FilterParseError
-      end
-    end
-
-    def gen_sql(dtcx)
-      sql_ = ''
-      dt = dtcx.respond_to?(:dataset) ? dtcx.dataset : dtcx
-      dt.literal_append(sql_, whcl(dt))
-      #            puts "in gen_sql :  sql_ == " , sql_
-      sql_
+  # should handle everything by parsing
+  class FilterByParse
+    def initialize(filterstr, jh)
+      @filterstr = filterstr.dup
+      @ast = OData::Filter::Parser.new(@filterstr).build
+      @jh = jh
     end
 
     def apply_to_dataset(dtcx)
-      dtcx.where(whcl(dtcx))
+      filtexpr = @ast.sequel_expr(@jh)
+      dtcx = @jh.dataset(dtcx).where(filtexpr).select_all(@jh.start_model.table_name)
     end
-  end
 
-  FILTER_CLASSES = [EqualFilter,
-                    SubstringOfFilterSig1,
-                    SubstringOfFilterSig2,
-                    StartOrEndsWithFilter].freeze
-  def Filter.new_by_simple_full_match(filterstr)
-    new_filt_obj = nil
-    OData::FILTER_CLASSES.find do |fklas|
-      new_filt_obj = fklas.new_full_match(filterstr)
-    end
-    new_filt_obj
-  end
-
-  # handles some combinations
-  class ComplexFilter < Filter
-    # list of active Subfilter classes. The ordering is important
-    SUBFILTERS = [EqualFilter,
-                  FuncEqualFilter,
-                  Func2a_EqualFilter,
-                  Func2b_EqualFilter,
-                  Func2c_EqualFilter,
-                  SubstringOfFilterSig1,
-                  StartOrEndsWithFilter].freeze
-    # for counting number of AND OR's
-    ANDORRGX = /(AND|OR\s+)/i.freeze
-
-    # for detecting consecutive  AND OR
-    ANDORERRRGX = /(AND|OR)\s+[\(\)]*(AND|OR)/i.freeze
-
-    def initialize(filterstr, dtset)
-      super(nil)
-      @filterstr = filterstr.dup
-
-      @attrib_paths_url_regexp = if dtset.is_a? Sequel::Model::ClassMethods
-                                   dtset.attrib_paths_url_regexp.dup
-                                 else
-                                   dtset.model.attrib_paths_url_regexp.dup
-                                 end
-
-      @active_subfs = []
-      @osql = filterstr.dup
-      @dt = dtset
-
-      md = nil
-      @osql.with_mask_quoted_substrings! do |s|
-        unless (@and_or_err = ANDORERRRGX.match(s))
-          md = ANDORRGX.match(s)
-
-          @expected_count = md.nil? ? 1 : md.size
-          SUBFILTERS.each { |klass| init_subfilter(klass) }
-        end
-      end
+    def sequel_expr
+      @ast.sequel_expr(@jh)
     end
 
     def parse_error?
-      @and_or_err || (@active_subfs.size != @expected_count)
-    end
-
-    def init_subfilter(subfiltclass)
-      rgx = subfiltclass.qualified_regexp(@attrib_paths_url_regexp)
-      @osql.gsub!(rgx) do |_mx|
-        subf = subfiltclass.new(Regexp.last_match)
-        @active_subfs << subf
-        @assocs.add(subf.assoc.to_sym) if subf.assoc
-        subf.gen_sql(@dt)
-      end
-    end
-
-    def apply_to_dataset(dtcx)
-      # new Sequel 5.6 requires -- lit --
-      dtcx.where(Sequel.lit(@osql))
+      @ast.kind_of? StandardError
     end
   end
 end