safrano 0.4.0 → 0.4.5

data/lib/odata/error.rb

@@ -1,23 +1,31 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'json'
 require 'rexml/document'
-require 'safrano.rb'
+require_relative '../safrano/contract'
 
 # Error handling
-module OData
+module Safrano
   # for errors occurring in API (publishing) usage --> Exceptions
   module API
     # when published class is not a Sequel Model
     class ModelNameError < NameError
       def initialize(name)
-        super("class #{name} is not a Sequel Model", name)
+        super("class #{name} is not a Sequel Model")
       end
     end
+
+    # when published complex type is not a Complex Type
+    class ComplexTypeNameError < NameError
+      def initialize(name)
+        super("class #{name} is not a ComplexType")
+      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)
+        super("Model #{name} does not have the mandatory media attributes content_type/media_src")
       end
     end
 
@@ -29,47 +37,101 @@ module OData
         super(msg, symbname)
       end
     end
+
+    # duplicate attribute name
+    class ModelDuplicateAttributeError < NameError
+      def initialize(klass, symb)
+        symbname = symb.to_s
+        msg = "There is already an attribute :#{symbname} defined in class #{klass}"
+        super(msg, symbname)
+      end
+    end
   end
 
   # base module for HTTP errors, when used as a Error Class
   module ErrorClass
+    include ::Safrano::Contract::Invalid
+    def http_code
+      const_get(:HTTP_CODE)
+    end
+    EMPTYH = {}.freeze
     def odata_get(req)
+      message = (m = @msg.to_s).empty? ? to_s : m
       if req.accept?(APPJSON)
-        [const_get(:HTTP_CODE), CT_JSON,
-         { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
+        # json is default content type so we dont need to specify it here again
+        [self.http_code, EMPTY_HASH,
+         { 'odata.error' => { 'code' => "#{http_code}",
+                              'type' => to_s,
+                              'message' => message } }.to_json]
       else
-        [const_get(:HTTP_CODE), CT_TEXT, @msg]
+        [self.http_code, CT_TEXT, message]
       end
     end
   end
-  
+
   # base module for HTTP errors, when used as an Error instance
   module ErrorInstance
+    include ::Safrano::Contract::Invalid
+    # can(should) be overriden in subclasses
+    def msg
+      @msg
+    end
+
     def odata_get(req)
+      message = (m = msg.to_s).empty? ? self.class.to_s : m
       if req.accept?(APPJSON)
-        [self.class.const_get(:HTTP_CODE), CT_JSON,
-         { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
+        # json is default content type so we dont need to specify it here again
+        [self.class.http_code, EMPTY_HASH,
+         { 'odata.error' => { 'code' => "#{self.class.http_code}",
+                              'type' => "#{self.class}",
+                              'message' => message } }.to_json]
       else
-        [self.class.const_get(:HTTP_CODE), CT_TEXT, @msg]
+        [self.class.http_code, CT_TEXT, message]
       end
     end
   end
-  
+
+  # generic http 500 server err
+  class ServerError
+    extend  ErrorClass
+    HTTP_CODE = 500
+    @msg = 'Server error'
+  end
+
+  # for outputing Sequel exceptions that we could not prevent
+  class SequelExceptionError < ServerError
+    include ErrorInstance
+    def initialize(seqle7n)
+      @msg = seqle7n.message
+    end
+  end
+
+  # for outputing Ruby StandardError exceptions that we could not prevent
+  class RubyStandardErrorException < ServerError
+    include ErrorInstance
+    def initialize(rubye7n)
+      @msg = rubye7n.message
+    end
+  end
+
   # http Bad Req.
   class BadRequestError
     extend  ErrorClass
+    include ErrorInstance
     HTTP_CODE = 400
-    @msg = 'Bad Request Error'
+    @msg = 'Bad Request'
+    def initialize(reason)
+      @msg = "Bad Request : #{reason}"
+    end
   end
+
   # Generic failed changeset
   class BadRequestFailedChangeSet < BadRequestError
-    HTTP_CODE = 400
     @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
@@ -78,49 +140,130 @@ module OData
       @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 invalid attribute in path
+  class BadRequestInvalidAttribPath < BadRequestError
+    include ErrorInstance
+    def initialize(model, attr)
+      @msg = "Bad Request: the attribute #{attr} is invalid for entityset #{model.entity_set_name}"
+    end
+  end
+
+  # for invalid attribute in $expand param
+  class BadRequestExpandInvalidPath < BadRequestError
+    include ErrorInstance
+    def initialize(model, path)
+      @msg = "Bad Request: the $expand path #{path} is invalid for entityset #{model.entity_set_name}"
+    end
+  end
+  # for invalid properti(es) in $select param
+  class BadRequestSelectInvalidProps < BadRequestError
+    include ErrorInstance
+    def initialize(model, iprops)
+      @msg = ((iprops.size > 1) ? "Bad Request: the $select properties #{iprops.to_a.join(', ')} are invalid for entityset #{model.entity_set_name}" : "Bad Request: the $select property #{iprops.first} is invalid for entityset #{model.entity_set_name}")
+    end
+  end
+
+  # for Syntax error in $orderby param
+  class BadRequestOrderParseError < BadRequestError
+    @msg = 'Bad Request: Syntax error in $orderby'
   end
+
   # for $inlinecount error
   class BadRequestInlineCountParamError < BadRequestError
-    HTTP_CODE = 400
     @msg = 'Bad Request: wrong $inlinecount parameter'
   end
+
   # http not found
   class ErrorNotFound
     extend  ErrorClass
     HTTP_CODE = 404
     @msg = 'The requested ressource was not found'
   end
+
+  # http not found segment
+  class ErrorNotFoundSegment < ErrorNotFound
+    include ErrorInstance
+
+    def initialize(segment)
+      @msg = "The requested ressource segment #{segment} was not found"
+    end
+  end
+
   # Transition error (Safrano specific)
-  class ServerTransitionError
-    extend  ErrorClass
-    HTTP_CODE = 500
+  class ServerTransitionError < ServerError
     @msg = 'Server error: Segment could not be parsed'
   end
-  # generic http 500 server err
-  class ServerError
-    extend  ErrorClass
-    HTTP_CODE = 500
-    @msg = 'Server error'
-  end
+
   # not implemented (Safrano specific)
   class NotImplementedError
     extend  ErrorClass
     HTTP_CODE = 501
   end
-  # batch not implemented (Safrano specific)
-  class BatchNotImplementedError
+
+  # version not implemented (Safrano specific)
+  class VersionNotImplementedError
     extend  ErrorClass
     HTTP_CODE = 501
+    @msg = 'The requested OData version is not yet supported'
+  end
+  # batch not implemented (Safrano specific)
+  class BatchNotImplementedError < NotImplementedError
     @msg = 'Not implemented: OData batch'
   end
+
   # error in filter parsing (Safrano specific)
   class FilterParseError < BadRequestError
     extend  ErrorClass
-    HTTP_CODE = 400
+  end
+
+  class FilterFunctionNotImplementedError < BadRequestError
+    extend  ErrorClass
+    include ErrorInstance
+    @msg = 'the requested $filter function is Not implemented'
+    def initialize(xmsg)
+      @msg = xmsg
+    end
+  end
+  class FilterUnknownFunctionError < BadRequestError
+    include ErrorInstance
+    def initialize(badfuncname)
+      @msg = "Bad request: unknown function #{badfuncname} in $filter"
+    end
+  end
+  class FilterParseErrorWrongColumnName < BadRequestError
+    extend ErrorClass
+    @msg = 'Bad request: invalid property name in $filter'
+  end
+  class FilterParseWrappedError < BadRequestError
+    include ErrorInstance
+    def initialize(exception)
+      @msg = exception.to_s
+    end
+  end
+  class ServiceOperationParameterMissing < BadRequestError
+    include ErrorInstance
+    def initialize(missing:, sopname:)
+      @msg = "Bad request: Parameter(s) missing for for service operation #{sopname} : #{missing.join(', ')}"
+    end
+  end
+
+  class ServiceOperationParameterError < BadRequestError
+    include ErrorInstance
+    def initialize(type:, value:, param:, sopname:)
+      @type = type
+      @value = value
+      @param = param
+      @sopname = sopname
+    end
+
+    def msg
+      "Bad request: Parameter #{@param} with value '#{@value}' cannot be converted to type #{@type} for service operation #{@sopname}"
+    end
   end
 end

data/lib/odata/expand.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require 'odata/error.rb'
+
+# all dataset expanding related classes in our OData module
+# ie  do eager loading
+module Safrano
+  # base class for expanding
+  class ExpandBase
+    EmptyExpand = new # re-useable empty expanding (idempotent)
+    EMPTYH = {}.freeze
+
+    def self.factory(expandstr, model)
+      expandstr.nil? ? EmptyExpand : MultiExpand.new(expandstr, model)
+    end
+
+    # output template
+    attr_reader :template
+
+    def apply_to_dataset(dtcx)
+      Contract.valid(dtcx)
+    end
+
+    def empty?
+      true
+    end
+
+    def parse_error?
+      Contract::OK
+    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)
+      Contract.valid(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 empty?
+      false
+    end
+  end
+
+  # Multi expanding logic
+  class MultiExpand < ExpandBase
+    COMASPLIT = /\s*,\s*/.freeze
+    attr_reader :template
+
+    # Note: if you change this method, please also update arity_full_monkey?
+    #       see below
+    def initialize(expandstr, model)
+      expandstr.strip!
+      @model = model
+      @expandp = expandstr
+
+      @exstrlist = expandstr.split(COMASPLIT)
+      @exlist = @exstrlist.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) }
+      Contract.valid(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?
+      @exstrlist.each do |expstr|
+        return BadRequestExpandInvalidPath.new(@model, expstr) unless @model.expand_path_valid? expstr
+      end
+
+      Contract::OK
+    end
+
+    def empty?
+      false
+    end
+  end
+end

data/lib/odata/filter/base.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Safrano
+  module Filter
+    # Base class for Leaves, Trees, RootTrees etc
+    class Node
+      def success(res)
+        Contract.valid(res)
+      end
+    end
+
+    # Leaves are Nodes with a parent but no children
+    class Leave < Node
+    end
+
+    # RootTrees have childrens but no parent
+    class RootTree < Node
+    end
+
+    # Tree's have Parent and children
+    class Tree < RootTree
+    end
+
+    # For functions... should have a single child---> the argument list
+    class FuncTree < Tree
+    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
+    end
+
+    # unary op eg. NOT
+    class UnopTree < Tree
+    end
+
+    # Bin ops
+    class BinopTree < Tree
+    end
+
+    class BinopBool < BinopTree
+    end
+
+    class BinopArithm < BinopTree
+    end
+
+    # Arguments or lists
+    class ArgTree < Tree
+    end
+
+    # Numbers (floating point, ints, dec)
+    class FPNumber < Leave
+    end
+
+    # Literals are unquoted words without /
+    class Literal < Leave
+    end
+
+    # Null Literal is unquoted null word
+    class NullLiteral < Literal
+      LEUQES = nil
+    end
+
+    # Qualit (qualified lits) are words separated by /
+    # path/path/path/attrib
+    class Qualit < Literal
+    end
+
+    # Quoted Strings
+    class QString < Leave
+    end
+  end
+end