safrano 0.0.1 → 0.0.2

data/lib/odata/collection_filter.rb

@@ -0,0 +1,447 @@
+#!/usr/bin/env ruby
+
+require 'odata/error.rb'
+
+# a few helper method
+class String
+  #  MASK_RGX = /'([^']*)'/.freeze
+  MASK_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
+  #  QUOTED_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
+  UNMASK_RGX = /'(%?)(\$\d+)(%?)'/.freeze
+  def with_mask_quoted_substrings!
+    cnt = 0
+    repl = {}
+    gsub!(MASK_RGX) do |_m|
+      cnt += 1
+      repl["$#{cnt}"] = Regexp.last_match(1)
+      "'$#{cnt}'"
+    end
+    yield self
+
+    gsub!(UNMASK_RGX) do |_m|
+      k = Regexp.last_match(2).to_s
+      "'#{Regexp.last_match(1)}#{repl[k]}#{Regexp.last_match(3)}'"
+    end
+  end
+
+  def with_mask_quoted_substrings
+    cnt = 0
+    repl = {}
+    tmpstr = gsub(MASK_RGX) do |_m|
+      cnt += 1
+      repl["$#{cnt}"] = Regexp.last_match(1)
+      "'$#{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
+
+# Handles filtering with ruby expressions
+# (eval and DB full scan used --> better avoid using this)
+module FilterWithRuby
+  # this module requires the @fn attribute to exist where it is used
+  def fn=(farg)
+    @fn = farg
+    @fn_tab = farg.split('/').map(&:to_sym)
+  end
+
+  # returns the attribute named "@fn" of object inp. This version assumes that
+  # @fn can be a path like "address/city"
+  def get_value(inp, colescev = '')
+    obj = inp
+    @fn_tab.each do |csymb|
+      tmp = obj.send(csymb)
+      if tmp.nil?
+        obj = colescev
+        break
+      else
+        obj = tmp
+      end
+    end
+    obj
+  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
+    QUOTED_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
+    NOTQ_RGX = /((?:[^'\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
+
+    # handle complex deep (relations) expressions with Ruby
+    def self.new_full_match_complexpr_by_ruby(filterstr)
+      ComplexFilterByRuby.new(filterstr)
+    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 FilterWithRuby
+    include FilterWithAssoc
+    EQUAL_KW_RGX = '[eE][qQ]|[LlgGNn][eETt]'.freeze
+    RIGHT_RGX = %q{'[^']+'|[^'\)\s]+}.freeze
+
+    def self.qualified_regexp(paths_rx)
+      /\s*(#{paths_rx})\s+(#{EQUAL_KW_RGX})\s+(?:#{QUOTED_RGX}|#{NOTQ_RGX})\s*/
+    end
+
+    def initialize(matx)
+      super(matx)
+      self.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_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
+      case @op
+      when 'eq'
+        dtcx.where(seqfn => @val)
+      when 'ne'
+        dtcx.exclude(seqfn => @val)
+      when 'le'
+        dtcx.where { seqfn <= argval }
+      when 'ge'
+        dtcx.where { seqfn >= argval }
+      when 'lt'
+        dtcx.where { seqfn < argval }
+      when 'gt'
+        dtcx.where { seqfn > argval }
+      else
+        raise OData::FilterParseError
+      end
+    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
+
+  # keyword based
+  class FilterWithKeyword < Filter
+    attr_reader :keyword
+  end
+
+  # for substringof('value', field)
+  class SubstringOfFilterSig1 < FilterWithKeyword
+    include FilterWithRuby
+    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)\((?:#{QUOTED_RGX}|#{NOTQ_RGX}),\s*(#{paths_rx})\)/
+    end
+
+    def initialize(matx)
+      super(matx)
+      #      binding.pry
+      self.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
+
+    def apply_to_object(inp)
+      get_value(inp).include?(@val)
+    end
+  end
+  # for substringof(field,'value')
+  class SubstringOfFilterSig2 < FilterWithKeyword
+    include FilterWithRuby
+    include FilterWithAssoc
+
+    def initialize(matx)
+      super(matx)
+      self.fn = matx[2]
+      get_assoc if @fn
+      @val = matx[3]
+      @keyword = matx[1]
+
+      raise FilterParseError
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def apply_to_object(inp)
+      get_value(inp).include?(@val)
+    end
+  end
+
+  # Filter by start/end with
+  class StartOrEndsWithFilter < FilterWithKeyword
+    include FilterWithRuby
+    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*(?:#{QUOTED_RGX}|#{NOTQ_RGX})\s*\)/
+    end
+
+    def initialize(matx)
+      super(matx)
+      # DONE: the regexp should only match on known field names...
+      # --> use qualified_regexp(attr_paths_rgx)
+      self.fn = matx[2]
+      get_assoc if @fn
+      # double quotes need to be unescaped
+      @val = matx[3] ? matx[3].gsub("''", "'") : matx[4]
+      @keyword = matx[1]
+      ve = Regexp.escape(@val)
+      # used for "filter with ruby"
+      case @keyword
+      when 'startswith'
+        @startend_rgx = Regexp.new("\A#{ve}")
+      when 'endswith'
+        @startend_rgx = Regexp.new("#{ve}\z")
+      else
+        raise FilterParseError
+      end
+    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_
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx.where(whcl(dtcx))
+    end
+
+    def apply_to_object(inp)
+      get_value(inp) =~ @startend_rgx
+    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,
+                  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
+    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))
+    end
+  end
+
+  # Handle complex filter expression with Ruby
+  class ComplexFilterByRuby < Filter
+    def initialize(filterstr)
+      @subf = []
+      @f = nil
+      @rbcode = filterstr.dup
+      @rbcode.with_mask_quoted_substrings! do |_s|
+        SUBFILTERS.each { |klass| init_subfilter(klass) }
+        downcase_and_or
+      end
+    end
+
+    # downcase AND OR in  @rbcode otherwise it is seen as a Ruby constant
+    #  instead as a ruby langu keyword
+    def downcase_and_or
+      @rbcode.gsub!(/(OR|Or|AND|And)/) do |_mx|
+        Regexp.last_match[1].downcase
+      end
+    end
+
+    def init_subfilter(subfiltclass)
+      @rbcode.gsub!(subfiltclass.regexp) do |_mx|
+        @f = subfiltclass.new(Regexp.last_match)
+        @subf << @f
+        "@subf[#{@subf.size - 1}].apply_to_object(@o)"
+      end
+    end
+
+    def apply_to_object(inp)
+      @o = inp
+      b = binding
+      eval(@rbcode, b)
+    end
+  end
+end

data/lib/odata/collection_order.rb

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+require 'pp'
+require 'odata/error.rb'
+
+# Ordering with ruby expression
+module OrderWithRuby
+  # this module requires the @fn attribute to exist where it is used
+  def fn=(fnam)
+    @fn = fnam
+    @fn_tab = fnam.split('/').map(&:to_sym)
+  end
+end
+
+# all ordering related classes in our OData module
+module OData
+  # base class for ordering
+  class Order
+    attr_reader :assoc
+    attr_reader :assocs
+    attr_reader :oarg
+    def initialize(ostr, _dt)
+      ostr.strip!
+      @orderp = ostr
+      @assocs = Set.new
+      build_oarg if @orderp
+    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(orderstr, dtset = nil)
+      Order.new_full_match_complexpr(orderstr, dtset)
+    end
+
+    # handle  with Sequel
+    def self.new_full_match_complexpr(orderstr, dtset)
+      ComplexOrder.new(orderstr, dtset)
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def apply_associations(dtcx)
+      @assocs.each { |aj| dtcx = dtcx.association_join(aj) }
+      dtcx
+    end
+
+    def build_oarg
+      field, ord = @orderp.split(' ')
+      oargu = if field.include?('/')
+                @assoc, field = field.split('/')
+                @assoc = @assoc.to_sym
+                Sequel[@assoc][field.strip.to_sym]
+              else
+                Sequel[field.strip.to_sym]
+              end
+
+      @oarg = if ord == 'desc'
+                Sequel.desc(oargu)
+              else
+                Sequel.asc(oargu)
+              end
+    end
+  end
+
+  # complex ordering logic
+  class ComplexOrder < Order
+    def initialize(orderstr, dtset)
+      super
+      @dt = dtset
+      @olist = []
+      return unless orderstr
+
+      @olist = orderstr.split(',').map do |ostr|
+        oo = Order.new(ostr, dtset)
+        @assocs.add oo.assoc if oo.assoc
+        oo.oarg
+      end
+    end
+
+    def apply_to_dataset(dtcx)
+      @olist.each { |oarg| dtcx = dtcx.order(oarg) }
+      dtcx
+    end
+  end
+end