safrano 0.2.0 → 0.3.0

data/lib/odata/collection_order.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'odata/error.rb'
 
 # Ordering with ruby expression
@@ -15,13 +13,11 @@ end
 module OData
   # base class for ordering
   class Order
-    attr_reader :assoc
-    attr_reader :assocs
     attr_reader :oarg
-    def initialize(ostr, _dtset)
+    def initialize(ostr, jh)
       ostr.strip!
       @orderp = ostr
-      @assocs = Set.new
+      @jh = jh
       build_oarg if @orderp
     end
 
@@ -31,30 +27,26 @@ module OData
 
     # 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)
+    def self.new_by_parse(orderstr, jh)
+      Order.new_full_match_complexpr(orderstr, jh)
     end
 
     # handle  with Sequel
-    def self.new_full_match_complexpr(orderstr, dtset)
-      ComplexOrder.new(orderstr, dtset)
+    def self.new_full_match_complexpr(orderstr, jh)
+      ComplexOrder.new(orderstr, jh)
     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]
+                @jh.add @assoc
+
+                Sequel[@jh.start_model.get_alias_sym(@assoc)][field.strip.to_sym]
               else
                 Sequel[field.strip.to_sym]
               end
@@ -69,21 +61,22 @@ module OData
 
   # complex ordering logic
   class ComplexOrder < Order
-    def initialize(orderstr, dtset)
+    def initialize(orderstr, jh)
       super
-      @dt = dtset
       @olist = []
+      @jh = jh
       return unless orderstr
 
       @olist = orderstr.split(',').map do |ostr|
-        oo = Order.new(ostr, dtset)
-        @assocs.add oo.assoc if oo.assoc
+        oo = Order.new(ostr, @jh)
         oo.oarg
       end
     end
 
     def apply_to_dataset(dtcx)
-      @olist.each { |oarg| dtcx = dtcx.order(oarg) }
+      @olist.each { |oarg|
+        dtcx = dtcx.order(oarg)
+      }
       dtcx
     end
   end

data/lib/odata/entity.rb

@@ -12,12 +12,11 @@ module OData
     # methods related to transitions to next state (cf. walker)
     module Transitions
       def allowed_transitions
-        aurgx = self.class.attribute_url_regexp
         alltr = [
           Safrano::TransitionEnd,
           Safrano::TransitionCount,
           Safrano::TransitionLinks,
-          Safrano::Transition.new(%r{\A/(#{aurgx})(.*)\z},
+          Safrano::Transition.new(self.class.transition_attribute_regexp,
                                   trans: 'transition_attribute')
         ]
         if (ncurgx = self.class.nav_collection_url_regexp)
@@ -70,20 +69,17 @@ module OData
     def nav_values
       @nav_values = {}
 
-      if self.class.nav_entity_attribs
-        self.class.nav_entity_attribs.each_key do |na_str|
-          @nav_values[na_str.to_sym] = send(na_str)
-        end
+      self.class.nav_entity_attribs&.each_key do |na_str|
+        @nav_values[na_str.to_sym] = send(na_str)
       end
+
       @nav_values
     end
 
     def nav_coll
       @nav_coll = {}
-      if self.class.nav_collection_attribs
-        self.class.nav_collection_attribs.each_key do |nc_str|
-          @nav_coll[nc_str.to_sym] = send(nc_str)
-        end
+      self.class.nav_collection_attribs&.each_key do |nc_str|
+        @nav_coll[nc_str.to_sym] = send(nc_str)
       end
       @nav_coll
     end
@@ -105,6 +101,23 @@ module OData
                                           uribase: @uribase) }.to_json
     end
 
+    # needed for proper datetime output
+    # TODO design/performance
+    def casted_values
+      # WARNING; this code is duplicated in attribute.rb
+      # (and the inverted transformation is in test/client.rb)
+      # will require a more systematic solution some day
+      values.transform_values! { |v|
+        case v
+        when Time
+          # try to get back the database time zone and value
+          (v + v.gmt_offset).utc.to_datetime
+        else
+          v
+          end
+      }
+    end
+
     # post paylod expects the new entity in an array
     def to_odata_post_json(service:)
       { 'd' => service.get_coll_odata_h(array: [self],
@@ -131,19 +144,17 @@ module OData
     def odata_get(req)
       copy_request_infos(req)
 
-      if req.accept?('application/json')
-        [200, { 'Content-Type' => 'application/json;charset=utf-8' },
-         to_odata_json(service: req.service)]
+      if req.accept?(APPJSON)
+        [200, CT_JSON, to_odata_json(service: req.service)]
       else # TODO: other formats
         415
       end
     end
 
     def odata_delete(req)
-      if req.accept?('application/json')
+      if req.accept?(APPJSON)
         delete
-        [200, { 'Content-Type' => 'application/json;charset=utf-8' },
-         { 'd' => req.service.get_emptycoll_odata_h }.to_json]
+        [200, CT_JSON, { 'd' => req.service.get_emptycoll_odata_h }.to_json]
       else # TODO: other formats
         415
       end
@@ -153,7 +164,7 @@ module OData
       data = JSON.parse(req.body.read)
       @uribase = req.uribase
 
-      if req.accept?('application/json')
+      if req.accept?(APPJSON)
         data.delete('__metadata')
 
         if req.in_changeset
@@ -194,21 +205,6 @@ module OData
         # patch should return 204 + no content
         [204, {}, []]
       end
-
-      # if ( req.content_type == 'application/json' )
-      ## Parse json payload
-      # begin
-      # data = JSON.parse(req.body.read)
-      # rescue JSON::ParserError => e
-      # return [400, {}, ['JSON Parser Error while parsing payload : ',
-      # e.message]]
-
-      # end
-
-      # else # TODO: other formats
-
-      # [415, {}, []]
-      # end
     end
 
     # redefinitions of the main methods for a navigated collection
@@ -227,18 +223,12 @@ module OData
         true
       end
 
-      def navigated_dataset
+      def dataset
         @child_dataset_method.call
       end
 
-      # TODO: this is designed by my left foot. maybe my right one can do better
-      # at least it does what it should (testunit passed)
-      def [](*args)
-        y = @child_method.call
-        return nil unless (found = super(args))
-
-        #        y.find { |e| e.pk_val == found.pk_val }
-        y.find { |e| e.values == found.values }
+      def navigated_dataset
+        @child_dataset_method.call
       end
 
       def each

data/lib/odata/filter/error.rb

@@ -0,0 +1,53 @@
+module OData
+  module Filter
+    class Parser
+      # Parser errors
+      class Error < StandardError
+        attr_reader :tok
+        attr_reader :typ
+        attr_reader :cur_val
+        attr_reader :cur_typ
+        def initialize(tok, typ, cur)
+          @tok = tok
+          @typ = typ
+          return unless cur
+
+          @cur_val = cur.value
+          @cur_typ = cur.class
+        end
+      end
+      # Invalid Tokens
+      class ErrorInvalidToken < Error
+      end
+      # Unmached closed
+      class ErrorUnmatchedClose < Error
+      end
+
+      class ErrorFunctionArgumentType < StandardError
+      end
+
+      class ErrorWrongColumnName < StandardError
+      end
+
+      # Invalid function arity
+      class ErrorInvalidArity < Error
+      end
+      # Invalid separator in this context (missing parenthesis?)
+      class ErrorInvalidSeparator < Error
+      end
+
+      # unmatched quot3
+      class UnmatchedQuoteError < Error
+      end
+
+      # wrong type of function argument
+      class ErrorInvalidArgumentType < StandardError
+        def initialize(tree, expected:,  actual:)
+          @tree = tree
+          @expected = expected
+          @actual = actual
+        end
+      end
+    end
+  end
+end

data/lib/odata/filter/parse.rb

@@ -0,0 +1,171 @@
+require_relative './token.rb'
+require_relative './tree.rb'
+require_relative './error.rb'
+
+# top level OData namespace
+module OData
+  # for handling $filter
+  module Filter
+    # Parser for $filter input
+    class Parser
+      include Token
+      attr_reader :cursor
+      def initialize(input)
+        @tree = RootTree.new
+        @cursor = @tree
+        @input = input
+        @stack = []
+        @binop_stack = []
+      end
+
+      def grow_at_cursor(child)
+        raise 'unknown BroGrammingError' if @cursor.nil?
+
+        @cursor.attach(child)
+        @cursor = child
+      end
+
+      def cursor_at_parent
+        @cursor = @cursor.parent
+      end
+
+      # detach cursor from parent and move cursor to the parent
+      # return the detached subtree
+      def detach_cursor
+        left = @cursor
+        cursor_at_parent
+        @cursor.detach(left)
+      end
+
+      def insert_before_cursor(node)
+        left = detach_cursor
+        grow_at_cursor(node)
+        @cursor.attach(left)
+      end
+
+      def invalid_separator_error(tok, typ)
+        @error = ErrorInvalidSeparator.new(tok, typ, @cursor)
+      end
+
+      def unmatched_quote_error(tok, typ)
+        @error = UnmatchedQuoteError.new(tok, typ, @cursor)
+      end
+
+      def invalid_closing_delimiter_error(tok, typ)
+        @error = ErrorUnmatchedClose.new(tok, typ, @cursor)
+      end
+
+      def with_accepted(tok, typ)
+        acc, err = @cursor.accept?(tok, typ)
+        if acc
+          yield
+        else
+          @error = err
+        end
+      end
+
+      def build
+        each_typed_token(@input) do |tok, typ|
+          case typ
+          when :FuncTree
+            with_accepted(tok, typ) do
+              grow_at_cursor(FuncTree.new(tok))
+            end
+          when :Delimiter
+            case tok
+            when '('
+              with_accepted(tok, typ) do
+                unless @cursor.is_a? FuncTree
+                  grow_at_cursor(IdentityFuncTree.new)
+                end
+                openarg = ArgTree.new('(')
+                @stack << openarg
+                grow_at_cursor(openarg)
+              end
+            when ')'
+              unless (@cursor = @stack.pop)
+                break invalid_closing_delimiter_error(tok, typ)
+              end
+
+              with_accepted(tok, typ) do
+                @cursor.update_state(tok, typ)
+                cursor_at_parent
+              end
+            end
+
+          when :Separator
+            unless (@cursor = @stack.last)
+              break invalid_separator_error(tok, typ)
+            end
+
+            with_accepted(tok, typ) { @cursor.update_state(tok, typ) }
+
+          when :UnopTree
+            unoptr = UnopTree.new(tok)
+            if (prev = @binop_stack.last)
+              # handling of lower precedence binding vs the other
+              # ones(le,gt,eq...)
+              unless prev.precedence < unoptr.precedence
+                @cursor = @binop_stack.pop
+                @binop_stack << unoptr
+              end
+            else
+              @binop_stack << unoptr
+            end
+            grow_at_cursor(unoptr)
+
+          when :BinopTree
+            with_accepted(tok, typ) do
+              binoptr = BinopTree.new(tok)
+              if (prev = @binop_stack.last)
+                # handling of lower precedence binding vs the other
+                # ones(le,gt,eq...)
+                unless prev.precedence < binoptr.precedence
+                  @cursor = @binop_stack.pop
+                  @binop_stack << binoptr
+                end
+              else
+                @binop_stack << binoptr
+              end
+              insert_before_cursor(binoptr)
+            end
+          when :Literal
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+              grow_at_cursor(Literal.new(tok))
+            end
+
+          when :Qualit
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+              grow_at_cursor(Qualit.new(tok))
+            end
+
+          when :QString
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+              grow_at_cursor(QString.new(tok))
+            end
+
+          when :FPNumber
+            with_accepted(tok, typ) do
+              @cursor.update_state(tok, typ)
+              grow_at_cursor(FPNumber.new(tok))
+            end
+          when :unmatchedQuote
+            break unmatched_quote_error(tok, typ)
+          else
+            raise 'Severe Error'
+          end
+          break if @error
+        end
+        begin
+          @tree.check_types unless @error
+        rescue ErrorInvalidArgumentType => e
+          @error = e
+        end
+        @error || @tree
+      end
+    end
+  end
+end