safrano 0.3.2 → 0.4.2

data/lib/odata/error.rb

@@ -1,5 +1,3 @@
-#!/usr/bin/env ruby
-
 require 'json'
 require 'rexml/document'
 require 'safrano.rb'
@@ -14,6 +12,13 @@ module OData
         super("class #{name} is not a Sequel Model", name)
       end
     end
+    # when published class as media does not have the mandatory media fields
+    class MediaModelError < NameError
+      def initialize(name)
+        super("Model #{name} does not have the mandatory media attributes content_type/media_src", name)
+      end
+    end
+
     # when published association was not defined on Sequel level
     class ModelAssociationNameError < NameError
       def initialize(klass, symb)
@@ -24,22 +29,33 @@ module OData
     end
   end
 
-  # base module for HTTP errors
-  module Error
+  # base module for HTTP errors, when used as a Error Class
+  module ErrorClass
     def odata_get(req)
-      if req.accept?('application/json')
-        [const_get(:HTTP_CODE),
-         { 'Content-Type' => 'application/json;charset=utf-8' },
+      if req.accept?(APPJSON)
+        [const_get(:HTTP_CODE), CT_JSON,
          { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
       else
-        [const_get(:HTTP_CODE),
-         { 'Content-Type' => 'text/plain;charset=utf-8' }, @msg]
+        [const_get(:HTTP_CODE), CT_TEXT, @msg]
       end
     end
   end
+
+  # base module for HTTP errors, when used as an Error instance
+  module ErrorInstance
+    def odata_get(req)
+      if req.accept?(APPJSON)
+        [self.class.const_get(:HTTP_CODE), CT_JSON,
+         { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
+      else
+        [self.class.const_get(:HTTP_CODE), CT_TEXT, @msg]
+      end
+    end
+  end
+
   # http Bad Req.
   class BadRequestError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 400
     @msg = 'Bad Request Error'
   end
@@ -49,11 +65,36 @@ module OData
     @msg = 'Bad Request: Failed changeset '
   end
 
+  # $value request for a non-media entity
+  class BadRequestNonMediaValue < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: $value request for a non-media entity'
+  end
+  class BadRequestSequelAdapterError < BadRequestError
+    include ErrorInstance
+    def initialize(err)
+      @msg = err.inner.message
+    end
+  end
+
   # for Syntax error in Filtering
   class BadRequestFilterParseError < BadRequestError
     HTTP_CODE = 400
-    @msg = 'Bad Request: Syntax error in Filter'
+    @msg = 'Bad Request: Syntax error in $filter'
+  end
+
+  # for Syntax error in $expand param
+  class BadRequestExpandParseError < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: Syntax error in $expand'
+  end
+
+  # for Syntax error in $orderby param
+  class BadRequestOrderParseError < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: Syntax error in $orderby'
   end
+
   # for $inlinecount error
   class BadRequestInlineCountParamError < BadRequestError
     HTTP_CODE = 400
@@ -61,36 +102,36 @@ module OData
   end
   # http not found
   class ErrorNotFound
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 404
     @msg = 'The requested ressource was not found'
   end
   # Transition error (Safrano specific)
   class ServerTransitionError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 500
     @msg = 'Server error: Segment could not be parsed'
   end
   # generic http 500 server err
   class ServerError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 500
     @msg = 'Server error'
   end
   # not implemented (Safrano specific)
   class NotImplementedError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 501
   end
   # batch not implemented (Safrano specific)
   class BatchNotImplementedError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 501
     @msg = 'Not implemented: OData batch'
   end
   # error in filter parsing (Safrano specific)
   class FilterParseError < BadRequestError
-    extend  Error
+    extend  ErrorClass
     HTTP_CODE = 400
   end
 end

data/lib/odata/expand.rb

@@ -0,0 +1,123 @@
+require 'odata/error.rb'
+
+# all dataset expanding related classes in our OData module
+# ie  do eager loading
+module OData
+  # base class for expanding
+  class ExpandBase
+    EmptyExpand = new # re-useable empty expanding (idempotent)
+    EMPTYH = {}.freeze
+
+    def self.factory(expandstr)
+      expandstr.nil? ? EmptyExpand : MultiExpand.new(expandstr)
+    end
+
+    # output template
+    attr_reader :template
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def empty?
+      true
+    end
+
+    def parse_error?
+      false
+    end
+
+    def template
+      EMPTYH
+    end
+  end
+
+  # single expand
+  class Expand < ExpandBase
+    # sequel eager arg.
+    attr_reader :arg
+    attr_reader :template
+
+    # used for Sequel eager argument
+    # Recursive array to deep hash
+    # [1,2,3,4]  -->  {1=>{2=>{3=>4}}}
+    # [1] --> 1
+    DEEPH_0 = ->(inp) { inp.size > 1 ? { inp[0] => DEEPH_0.call(inp[1..-1]) } : inp[0] }
+
+    # used for building output template
+    # Recursive array to deep hash
+    # [1,2,3,4]  -->  {1=>{2=>{3=>4}}}
+    # [1] --> { 1 => {} }
+    DEEPH_1 = ->(inp) { inp.size > 1 ? { inp[0] => DEEPH_1.call(inp[1..-1]) } : { inp[0] => {} } }
+
+    NODESEP = '/'.freeze
+
+    def initialize(exstr)
+      exstr.strip!
+      @expandp = exstr
+      @nodes = @expandp.split(NODESEP)
+      build_arg
+    end
+
+    def apply_to_dataset(dtcx)
+      dtcx
+    end
+
+    def build_arg
+      #   'a/b/c/d'  ==> {a: {b:{c: :d}}}
+      #   'xy'  ==> :xy
+      @arg = DEEPH_0.call(@nodes.map(&:to_sym))
+      @template = DEEPH_1.call(@nodes)
+    end
+
+    def parse_error?
+      # todo
+      false
+    end
+
+    def empty?
+      false
+    end
+  end
+
+  # Multi expanding logic
+  class MultiExpand < ExpandBase
+    COMASPLIT = /\s*,\s*/.freeze
+    attr_reader :template
+
+    def initialize(expandstr)
+      expandstr.strip!
+      @expandp = expandstr
+      @exlist = []
+
+      @exlist = expandstr.split(COMASPLIT).map { |exstr| Expand.new(exstr) }
+      build_template
+    end
+
+    def apply_to_dataset(dtcx)
+      # use eager loading for each used association
+      @exlist.each { |exp| dtcx = dtcx.eager(exp.arg) }
+      dtcx
+    end
+
+    def build_template
+      #   'a/b/c/d,xy'  ==> [ {'a' =>{ 'b' => {'c' => {'d' => {} } }}},
+      #                       { 'xy' => {} }]
+      #
+      @template = @exlist.map(&:template)
+
+      # { 'a'  => { 'b' => {'c' => 'd' }},
+      #   'xy' => {} }
+      @template = @template.inject({}) { |mrg, elmt| mrg.merge elmt }
+    end
+
+    def parse_error?
+      # todo
+      false
+    end
+
+    def empty?
+      false
+    end
+  end
+end

data/lib/odata/filter/error.rb

@@ -1,4 +1,10 @@
 module OData
+  class SequelAdapterError < StandardError
+    attr_reader :inner
+    def initialize(err)
+      @inner = err
+    end
+  end
   module Filter
     class Parser
       # Parser errors

data/lib/odata/filter/parse.rb

@@ -68,24 +68,18 @@ module OData
         each_typed_token(@input) do |tok, typ|
           case typ
           when :FuncTree
-            with_accepted(tok, typ) do
-              grow_at_cursor(FuncTree.new(tok))
-            end
+            with_accepted(tok, typ) { grow_at_cursor(FuncTree.new(tok)) }
           when :Delimiter
             case tok
             when '('
               with_accepted(tok, typ) do
-                unless @cursor.is_a? FuncTree
-                  grow_at_cursor(IdentityFuncTree.new)
-                end
+                grow_at_cursor(IdentityFuncTree.new) unless @cursor.is_a? FuncTree
                 openarg = ArgTree.new('(')
                 @stack << openarg
                 grow_at_cursor(openarg)
               end
             when ')'
-              unless (@cursor = @stack.pop)
-                break invalid_closing_delimiter_error(tok, typ)
-              end
+              break invalid_closing_delimiter_error(tok, typ) unless (@cursor = @stack.pop)
 
               with_accepted(tok, typ) do
                 @cursor.update_state(tok, typ)
@@ -94,9 +88,7 @@ module OData
             end
 
           when :Separator
-            unless (@cursor = @stack.last)
-              break invalid_separator_error(tok, typ)
-            end
+            break invalid_separator_error(tok, typ) unless (@cursor = @stack.last)
 
             with_accepted(tok, typ) { @cursor.update_state(tok, typ) }
 

data/lib/odata/filter/sequel.rb

@@ -13,7 +13,7 @@ module OData
     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)
+        jh.dataset(dtcx).where(filtexpr).select_all(jh.start_model.table_name)
       end
 
       def sequel_expr(jh)
@@ -38,21 +38,21 @@ module OData
         when :substringof
 
           # there are multiple possible argument types (but all should return edm.string)
-          if (args[0].is_a?(QString))
+          if args[0].is_a?(QString)
             # substringof('Rhum', name)  -->
             # name contains substr 'Rhum'
             Sequel.like(args[1].leuqes(jh),
                         args[0].leuqes_substringof_sig1(jh))
           # special non standard (ui5 client) case ?
-          elsif (args[0].is_a?(Literal) && args[1].is_a?(Literal))
+          elsif args[0].is_a?(Literal) && args[1].is_a?(Literal)
             Sequel.like(args[1].leuqes(jh),
                         args[0].leuqes_substringof_sig1(jh))
-          elsif (args[1].is_a?(QString))
+          elsif args[1].is_a?(QString)
             # substringof(name, '__Route du Rhum__')  -->
             # '__Route du Rhum__' contains name as a substring
             # TODO... check if the database supports instr (how?)
             # othewise use substr(postgresql) or whatevr?
-            instr_substr_func = if (Sequel::Model.db.adapter_scheme == :postgres)
+            instr_substr_func = if Sequel::Model.db.adapter_scheme == :postgres
                                   Sequel.function(:strpos, args[1].leuqes(jh), args[0].leuqes(jh))
                                 else
                                   Sequel.function(:instr, args[1].leuqes(jh), args[0].leuqes(jh))
@@ -167,26 +167,24 @@ module OData
       end
 
       def leuqes_starts_like(_jh)
-        "#{@value.to_s}%"
+        "#{@value}%"
       end
 
       def leuqes_ends_like(_jh)
-        "%#{@value.to_s}"
+        "%#{@value}"
       end
 
       def leuqes_substringof_sig1(_jh)
-        "%#{@value.to_s}%"
+        "%#{@value}%"
       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
+        raise OData::Filter::Parser::ErrorWrongColumnName unless jh.start_model.db_schema.key?(@value.to_sym)
+
+        Sequel[jh.start_model.table_name][@value.to_sym]
       end
 
       # non stantard extensions to support things like

data/lib/odata/filter/tree.rb

@@ -238,7 +238,7 @@ module OData
         end
       end
 
-      # TODO different num types?
+      # TODO: different num types?
       def edm_type
         :any
       end
@@ -279,12 +279,10 @@ module OData
         when :Separator
           if @value == '(' && tok == ',' && @state == :val
             true
+          elsif @state == :sep
+            [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
           else
-            if (@state == :sep)
-              [false, Parser::ErrorInvalidToken.new(tok, typ, self)]
-            else
-              true
-            end
+            true
           end
         when :Literal, :Qualit, :QString, :FuncTree, :FPNumber
           if (@state == :open) || (@state == :sep)
@@ -350,22 +348,20 @@ module OData
       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
+        raise Parser::Error.new(self, Qualit) unless (md = REGEXP.match(val))
+
+        @path = md[1].chomp('/')
+        @attrib = md[2]
       end
     end
 
     # Quoted Strings
     class QString < Leave
-      DoubleQuote = "''".freeze
-      SingleQuote = "'".freeze
+      DBL_QO = "''".freeze
+      SI_QO = "'".freeze
       def initialize(val)
         # unescape double quotes
-        super(val.gsub(DoubleQuote, SingleQuote))
+        super(val.gsub(DBL_QO, SI_QO))
       end
 
       def accept?(tok, typ)

data/lib/odata/navigation_attribute.rb

@@ -0,0 +1,150 @@
+require 'json'
+require_relative '../safrano/core.rb'
+require_relative './entity.rb'
+
+module OData
+  # remove the relation between entity and parent by clearing
+  # the FK field(s) (if allowed)
+  def self.remove_nav_relation(assoc, parent)
+    return unless assoc
+
+    return unless assoc[:type] == :many_to_one
+
+    # removes/clear the FK values in parent
+    # thus deleting the "link" between the entity and the parent
+    # Note: This is called if we have to delete the child--> can only be
+    # done after removing the FK in parent (if allowed!)
+    lks = [assoc[:key]].flatten
+    lks.each do |lk|
+      parent.set(lk => nil)
+      parent.save(transaction: false)
+    end
+  end
+
+  # link newly created entities(child) to an existing parent
+  # by following the association_reflection rules
+  def self.create_nav_relation(child, assoc, parent)
+    return unless assoc
+
+    # Note: this coding shares some bits from our sequel/plugins/join_by_paths,
+    # method build_unique_join_segments
+    # eventually there is an opportunity to have more reusable code here
+    case assoc[:type]
+    when :one_to_many, :one_to_one
+      # sets the FK values in child to corresponding related parent key-values
+      # thus creating the "link" between the new entity and the parent
+      # if a FK value is already set (not nil/NULL) then only check the
+      # consistency with the corresponding parent key-value
+      # If the FK value and the parent key value are different, then it's  a
+      # a Bad Request error
+
+      leftm = assoc[:model] # should be same as parent.class
+      lks = [leftm.primary_key].flatten
+      rks = [assoc[:key]].flatten
+      join_cond = rks.zip(lks).to_h
+      join_cond.each do |rk, lk|
+        if child.values[rk] # FK in new entity from payload not nil, only check consistency
+          # with the parent - id(s)
+          # if (child.values[rk] != parent.pk_hash[lk]) # error...
+          # TODO
+          # end
+        else # we can set the FK value, thus creating the "link"
+          child.set(rk => parent.pk_hash[lk])
+        end
+      end
+    when :many_to_one
+      # sets the FK values in parent to corresponding related child key-values
+      # thus creating the "link" between the new entity and the parent
+      # Per design, this can only be called when the FK value is nil
+      # from NilNavigationAttribute.odata_post
+      lks = [assoc[:key]].flatten
+      rks = [child.class.primary_key].flatten
+      join_cond = rks.zip(lks).to_h
+      join_cond.each do |rk, lk|
+        if parent.values[lk] # FK in parent not nil, only check consistency
+          # with the child - id(s)
+          # if parent.values[lk] != child.pk_hash[rk] # error...
+          # TODO
+          # end
+        else # we can set the FK value, thus creating the "link"
+          parent.set(lk => child.pk_hash[rk])
+        end
+      end
+    end
+  end
+
+  module EntityBase
+    module NavigationInfo
+      attr_reader :nav_parent
+      attr_reader :navattr_reflection
+      attr_reader :nav_name
+      def set_relation_info(parent, name)
+        @nav_parent = parent
+        @nav_name = name
+        @navattr_reflection = parent.class.association_reflections[name.to_sym]
+        @nav_klass = @navattr_reflection[:class_name].constantize
+      end
+    end
+  end
+
+  # Represents a named but nil-valued navigation-attribute of an Entity
+  # (usually resulting from a NULL FK db value)
+  class NilNavigationAttribute
+    include EntityBase::NavigationInfo
+    def odata_get(req)
+      if req.walker.media_value
+        OData::ErrorNotFound.odata_get
+      elsif req.accept?(APPJSON)
+        [200, CT_JSON, to_odata_json(service: req.service)]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    # create the nav. entity
+    def odata_post(req)
+      # delegate to the class method
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
+    end
+
+    # create the nav. entity
+    def odata_put(req)
+      #      if req.walker.raw_value
+      # delegate to the class method
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
+      #      else
+      #      end
+    end
+
+    # empty output as OData json (v2)
+    def to_odata_json(*)
+      { 'd' => EMPTY_HASH }.to_json
+    end
+
+    # for testing purpose (assert_equal ...)
+    def ==(other)
+      (@nav_parent == other.nav_parent) && (@nav_name == other.nav_name)
+    end
+
+    # methods related to transitions to next state (cf. walker)
+    module Transitions
+      def transition_end(_match_result)
+        [nil, :end]
+      end
+
+      def transition_value(_match_result)
+        [self, :end_with_value]
+      end
+
+      def allowed_transitions
+        [Safrano::TransitionEnd,
+         Safrano::TransitionValue]
+      end
+    end
+    include Transitions
+  end
+end