safrano 0.2.0 → 0.3.0

data/lib/odata/filter/sequel.rb

@@ -0,0 +1,208 @@
+require_relative './tree.rb'
+module OData
+  module Filter
+    # Base class for Leaves, Trees, RootTrees etc
+    class Node
+    end
+
+    # Leaves are Nodes with a parent but no children
+    class Leave < Node
+    end
+
+    # RootTrees have childrens but no parent
+    class RootTree
+      def apply_to_dataset(dtcx, jh)
+        filtexpr = @children.first.leuqes(jh)
+        dtcx = jh.dataset.where(filtexpr).select_all(jh.start_model.table_name)
+      end
+
+      def sequel_expr(jh)
+        @children.first.leuqes(jh)
+      end
+    end
+
+    # Tree's have Parent and children
+    class Tree < RootTree
+    end
+
+    # For functions... should have a single child---> the argument list
+    class FuncTree < Tree
+      def leuqes(jh)
+        case @value
+        when :startswith
+          Sequel.like(args[0].leuqes(jh),
+                      args[1].leuqes_starts_like(jh))
+        when :endswith
+          Sequel.like(args[0].leuqes(jh),
+                      args[1].leuqes_ends_like(jh))
+        when :substringof
+          # there are two possible signatures
+          if (args[0].is_a?(QString) && args[1].is_a?(Literal))
+            # substringof('Rhum', name)  -->
+            # name contains substr 'Rhum'
+            Sequel.like(args[1].leuqes(jh),
+                        args[0].leuqes_substringof_like(jh))
+          # according to the spec it should be like that?
+          # elsif args[1].is_a? QString
+          ## substringof(name, '__Route du Rhum__')  -->
+          ## '__Route du Rhum__' contains name as a substring
+          # Sequel.like(args[1].leuqes_substringof_like(dtcx),
+          # args[0].leuqes(dtcx)   )
+          # or like that?
+          #          elsif args[1].is_a? QString
+          #          # substringof(name, 'Route du Rhum')  -->
+          #          # name contains substr 'Rhum'  ??
+          #            Sequel.like(args[0].leuqes(dtcx) ,
+          #                        args[1].leuqes_substringof_like(dtcx) )
+          elsif (args[0].is_a?(Literal) && args[1].is_a?(Literal))
+            Sequel.like(args[1].leuqes(jh),
+                        args[0].leuqes_substringof_like(jh))
+          else
+            # TODO... actually not supported?
+            raise OData::Filter::Parser::ErrorFunctionArgumentType
+          end
+        when :concat
+          Sequel.join([args[0].leuqes(jh),
+                       args[1].leuqes(jh)])
+        when :length
+          Sequel.char_length(args.first.leuqes(jh))
+        when :trim
+          Sequel.trim(args.first.leuqes(jh))
+        when :toupper
+          Sequel.function(:upper, args.first.leuqes(jh))
+        when :tolower
+          Sequel.function(:lower, args.first.leuqes(jh))
+        else
+          raise OData::FilterParseError
+        end
+      end
+    end
+
+    # Indentity Func to use as "parent" func of parenthesis expressions
+    # --> allow to handle generically parenthesis always as argument of
+    # some function
+    class IdentityFuncTree < FuncTree
+      def leuqes(jh)
+        args.first.leuqes(jh)
+      end
+    end
+
+    # unary op eg. NOT
+    class UnopTree < Tree
+      def leuqes(jh)
+        case @value
+        when :not
+          Sequel.~(@children.first.leuqes(jh))
+        else
+          raise OData::FilterParseError
+        end
+      end
+    end
+
+    # Bin ops
+    class BinopTree < Tree
+      def leuqes(jh)
+        leuqes_op = case @value
+                    when :eq
+                      :'='
+                    when :ne
+                      :'!='
+                    when :le
+                      :<=
+                    when :ge
+                      :'>='
+                    when :lt
+                      :<
+                    when :gt
+                      :>
+                    when :or
+                      :OR
+                    when :and
+                      :AND
+                    else
+                      raise OData::FilterParseError
+                    end
+
+        Sequel::SQL::BooleanExpression.new(leuqes_op,
+                                           @children[0].leuqes(jh),
+                                           @children[1].leuqes(jh))
+      end
+    end
+
+    # Arguments or lists
+    class ArgTree
+    end
+
+    # Numbers (floating point, ints, dec)
+    class FPNumber
+      def leuqes(_jh)
+        Sequel.lit(@value)
+      end
+
+      def leuqes_starts_like(_jh)
+        "#{@value.to_s}%"
+      end
+
+      def leuqes_ends_like(_jh)
+        "%#{@value.to_s}"
+      end
+
+      def leuqes_substringof_like(_jh)
+        "%#{@value.to_s}%"
+      end
+    end
+
+    # Literals are unquoted words
+    class Literal
+      def leuqes(jh)
+        if jh.start_model.db_schema.has_key?(@value.to_sym)
+          Sequel[jh.start_model.table_name][@value.to_sym]
+        else
+          raise OData::Filter::Parser::ErrorWrongColumnName
+        end
+      end
+
+      # non stantard extensions to support things like
+      # substringof(Rhum, name)  ????
+      def leuqes_starts_like(_jh)
+        "#{@value}%"
+      end
+
+      def leuqes_ends_like(_jh)
+        "%#{@value}"
+      end
+
+      def leuqes_substringof_like(_jh)
+        "%#{@value}%"
+      end
+    end
+
+    # Qualit (qualified lits) are words separated by /
+    class Qualit
+      def leuqes(jh)
+        jh.add(@path)
+        talias = jh.start_model.get_alias_sym(@path)
+        Sequel[talias][@attrib.to_sym]
+      end
+    end
+
+    # Quoted Strings
+    class QString
+      def leuqes(_jh)
+        @value
+      end
+
+      def leuqes_starts_like(_jh)
+        "#{@value}%"
+      end
+
+      def leuqes_ends_like(_jh)
+        "%#{@value}"
+      end
+
+      def leuqes_substringof_like(_jh)
+        "%#{@value}%"
+      end
+    end
+  end
+end

data/lib/odata/filter/token.rb

@@ -0,0 +1,59 @@
+# top level OData namespace
+module OData
+  module Filter
+    class Parser
+      # Input tokenizer
+      module Token
+        FUNCNAMES = %w[concat substringof endswith startswith length indexof
+                       replace substring trim toupper tolower].freeze
+        FUNCRGX = FUNCNAMES.join('|').freeze
+        QSTRINGRGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
+        BINOPSRGX = '[eE][qQ]|[LlgGNn][eETt]|and|AND|or|OR'.freeze
+        NOTRGX = 'not|NOT'.freeze
+        FPRGX = '\d+(?:\.\d+)?(?:e[+-]?\d+)?'.freeze
+        QUALITRGX = '\w+(?:\/\w+)+'.freeze
+        RGX = /(#{FUNCRGX})|([\(\),])|(#{BINOPSRGX})|(#{NOTRGX})|#{QSTRINGRGX}|(#{FPRGX})|(#{QUALITRGX})|(\w+)|(')/.freeze
+        def each_typed_token(inp)
+          typ = nil
+
+          inp.scan(RGX) do |groups|
+            idx = nil
+            found = nil
+            groups.each_with_index do |tok, i|
+              if (found = tok)
+                idx = i
+                break
+              end
+            end
+            typ = case idx
+                  when 0
+                    :FuncTree
+                  when 1
+                    case found
+                    when '(', ')'
+                      :Delimiter
+                    when ','
+                      :Separator
+                    end
+                  when 2
+                    :BinopTree
+                  when 3
+                    :UnopTree
+                  when 4
+                    :QString
+                  when 5
+                    :FPNumber
+                  when 6
+                    :Qualit
+                  when 7
+                    :Literal
+                  when 8
+                    :unmatchedQuote
+                  end
+            yield found, typ
+          end
+        end
+      end
+    end
+  end
+end

data/lib/odata/filter/tree.rb

@@ -0,0 +1,368 @@
+require_relative './error.rb'
+
+module OData
+  module Filter
+    # Base class for Leaves, Trees, RootTrees etc
+    class Node
+      attr_reader :value
+      def initialize(val, &block)
+        @value = val
+        instance_eval(&block) if block_given?
+      end
+
+      def ==(other)
+        @value == other.value
+      end
+    end
+
+    # Leaves are Nodes with a parent but no children
+    class Leave < Node
+      attr_accessor :parent
+      def accept?(tok, typ)
+        [false, Parser::ErrorInvalidToken(tok, typ)]
+      end
+
+      def check_types; end
+    end
+
+    # RootTrees have childrens but no parent
+    class RootTree < Node
+      attr_reader :children
+      attr_accessor :state
+      def initialize(val: :root, &block)
+        @children = []
+        super(val, &block)
+      end
+
+      def attach(child)
+        child.parent = self
+        @children << child
+      end
+
+      def detach(child)
+        child.parent = nil
+        @children.delete(child)
+      end
+
+      def ==(other)
+        super(other) && (@children == other.children)
+      end
+
+      def update_state(tok, typ) end
+
+      def accept?(tok, typ)
+        case typ
+        when :Literal, :Qualit, :QString, :FuncTree, :ArgTree, :UnopTree, :FPNumber
+          true
+        when :Delimiter
+          if tok == '('
+            true
+          else
+            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          end
+        else
+          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+        end
+      end
+
+      def check_types
+        @children.each(&:check_types)
+      end
+    end
+
+    # Tree's have Parent and children
+    class Tree < RootTree
+      attr_accessor :parent
+
+      def initialize(val)
+        super(val: val)
+      end
+    end
+
+    # For functions... should have a single child---> the argument list
+    class FuncTree < Tree
+      def initialize(val)
+        super(val.downcase.to_sym)
+      end
+
+      def args
+        @children.first.children
+      end
+
+      def arity_full?(cursize)
+        cursize >= max_arity
+      end
+
+      def max_arity
+        case @value
+        when :replace
+          3
+        when :concat, :substringof, :substring, :endswith, :startswith
+          2
+        else
+          1
+        end
+      end
+
+      def edm_type
+        case @value
+        when :concat, :substring
+          :string
+        when :length
+          :int
+        when :substringof, :endswith, :startswith
+          :bool
+        else
+          :any
+        end
+      end
+
+      def accept?(tok, typ)
+        case typ
+        when :BinopTree
+          true
+        else
+          super(tok, typ)
+        end
+      end
+
+      def check_types
+        case @value
+        when :length
+          argtyp = args.first.edm_type
+          if (argtyp != :any) && (argtyp != :string)
+            raise Parser::ErrorInvalidArgumentType.new(self,
+                                                       expected: :string,
+                                                       actual: argtyp)
+          end
+        end
+        super
+      end
+    end
+
+    # Indentity Func to use as "parent" func of parenthesis expressions
+    # --> allow to handle generically parenthesis always as argument of
+    # some function
+    class IdentityFuncTree < FuncTree
+      def initialize
+        super(:__indentity)
+      end
+
+      # we can have parenthesis with one expression inside everywhere
+      # only in FuncTree this is redefined for the function's arity
+      def arity_full?(cursize)
+        cursize >= 1
+      end
+
+      def edm_type
+        @children.first.edm_type
+      end
+    end
+
+    # unary op eg. NOT
+    class UnopTree < Tree
+      def initialize(val)
+        super(val.downcase.to_sym)
+      end
+
+      # reference:
+      # OData v4 par 5.1.1.9 Operator Precedence
+      def precedence
+        case @value
+        when :not
+          7
+        else
+          999
+        end
+      end
+
+      def edm_type
+        case @value
+        when :not
+          :bool
+        else
+          :any
+        end
+      end
+    end
+
+    # Bin ops
+    class BinopTree < Tree
+      def initialize(val)
+        @state = :open
+        super(val.downcase.to_sym)
+      end
+
+      # reference:
+      # OData v4 par 5.1.1.9 Operator Precedence
+      def precedence
+        case @value
+        when :or
+          1
+        when :and
+          2
+        when :eq, :ne
+          3
+        when :gt, :ge, :lt, :le
+          4
+        else
+          999
+        end
+      end
+
+      def update_state(_tok, typ)
+        case typ
+        when :Literal, :Qualit, :QString, :FuncTree, :BinopTree, :UnopTree, :FPNumber
+          @state = :closed
+        end
+      end
+
+      def edm_type
+        case @value
+        when :or, :and, :eq, :ne, :gt, :ge, :lt, :le
+          :bool
+        else
+          :any
+        end
+      end
+    end
+
+    # Arguments or lists
+    class ArgTree < Tree
+      attr_reader :type
+      def initialize(val)
+        @type = :expression
+        @state = :open
+        super
+      end
+
+      def update_state(_tok, typ)
+        case typ
+        when :Delimiter
+          @state = :closed
+        when :Separator
+          @state =  :sep
+        when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
+          @state =  :val
+        end
+      end
+
+      def accept?(tok, typ)
+        case typ
+        when :Delimiter
+          if @value == '(' && tok == ')' && @state != :closed
+            if @parent.arity_full?(@children.size)
+              true
+            else
+              [false, Parser::ErrorInvalidArity.new(tok, typ, self)]
+            end
+          else
+            [false, Parser::ErrorUnmatchedClose.new(tok, typ, self)]
+          end
+        when :Separator
+          if @value == '(' && tok == ',' && @state == :val
+            true
+          else
+            if (@state == :sep)
+              [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+            else
+              true
+            end
+          end
+        when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
+          if (@state == :open) || (@state == :sep)
+            if @parent.arity_full?(@children.size)
+              [false, Parser::ErrorInvalidArity.new(tok, typ, self)]
+            else
+              true
+            end
+          else
+            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+          end
+        when :BinopTree
+          true
+        else
+          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+        end
+      end
+
+      def ==(other)
+        super(other) && @type == other.type && @state == other.state
+      end
+    end
+
+    # Numbers (floating point, ints, dec)
+    class FPNumber < Leave
+      def accept?(tok, typ)
+        case typ
+        when :Delimiter, :Separator, :BinopTree
+          true
+        else
+          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+        end
+      end
+
+      # TODO
+      def edm_type
+        :number
+      end
+    end
+
+    # Literals are unquoted words without /
+    class Literal < Leave
+      def accept?(tok, typ)
+        case typ
+        when :Delimiter, :Separator, :BinopTree
+          true
+        else
+          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+        end
+      end
+
+      def edm_type
+        :any
+      end
+    end
+
+    # Qualit (qualified lits) are words separated by /
+    # path/path/path/attrib
+    class Qualit < Literal
+      REGEXP = /((?:\w+\/)+)(\w+)/.freeze
+      attr_reader :path
+      attr_reader :attrib
+      def initialize(val)
+        super(val)
+        # split into path + attrib
+        if (md = REGEXP.match(val))
+          @path = md[1].chomp('/')
+          @attrib = md[2]
+        else
+          raise Parser::Error.new(self, Qualit)
+        end
+      end
+    end
+
+    # Quoted Strings
+    class QString < Leave
+      DoubleQuote = "''".freeze
+      SingleQuote = "'".freeze
+      def initialize(val)
+        # unescape double quotes
+        super(val.gsub(DoubleQuote, SingleQuote))
+      end
+
+      def accept?(tok, typ)
+        case typ
+        when :Delimiter, :Separator, :BinopTree
+          true
+        else
+          [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
+        end
+      end
+
+      def edm_type
+        :string
+      end
+    end
+  end
+end