safrano 0.4.1 → 0.4.6

data/lib/odata/navigation_attribute.rb

@@ -1,33 +1,31 @@
+# frozen_string_literal: true
+
 require 'json'
-require_relative '../safrano/core.rb'
-require_relative './entity.rb'
+require_relative '../safrano/core'
+require_relative './entity'
 
-module OData
-  
-  # remove the relation between entity and parent by clearing 
+module Safrano
+  # remove the relation between entity and parent by clearing
   # the FK field(s) (if allowed)
-  def OData.remove_nav_relation(entity, assoc, parent)
+  def self.remove_nav_relation(assoc, parent)
     return unless assoc
 
-    case assoc[:type]
-      when :one_to_many, :one_to_one
-      when :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{|lk| 
-          parent.set(lk => nil )
-          parent.save(transaction: false)
-        }
-      
-    end  
+    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 OData.create_nav_relation(child, assoc, parent)
+  def self.create_nav_relation(child, assoc, parent)
     return unless assoc
 
     # Note: this coding shares some bits from our sequel/plugins/join_by_paths,
@@ -46,16 +44,16 @@ module OData
       lks = [leftm.primary_key].flatten
       rks = [assoc[:key]].flatten
       join_cond = rks.zip(lks).to_h
-      join_cond.each { |rk, lk|
+      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
+          # 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
@@ -64,29 +62,15 @@ module OData
       lks = [assoc[:key]].flatten
       rks = [child.class.primary_key].flatten
       join_cond = rks.zip(lks).to_h
-      join_cond.each { |rk, lk|
+      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
+          # 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
-
-  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
@@ -94,12 +78,12 @@ module OData
   # Represents a named but nil-valued navigation-attribute of an Entity
   # (usually resulting from a NULL FK db value)
   class NilNavigationAttribute
-    include EntityBase::NavigationInfo
+    include Safrano::NavigationInfo
     def odata_get(req)
       if req.walker.media_value
-        OData::ErrorNotFound.odata_get
+        Safrano::ErrorNotFound.odata_get
       elsif req.accept?(APPJSON)
-        [200, CT_JSON, to_odata_json(service: req.service)]
+        [200, EMPTY_HASH, to_odata_json(service: req.service)]
       else # TODO: other formats
         415
       end
@@ -108,25 +92,22 @@ module OData
     # create the nav. entity
     def odata_post(req)
       # delegate to the class method
-      @nav_klass.odata_create_entity_and_relation(req, 
-                                                  @navattr_reflection, 
+      @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
+      # delegate to the class method
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
     end
 
     # empty output as OData json (v2)
     def to_odata_json(*)
-      { 'd' => {} }.to_json
+      { 'd' => EMPTY_HASH }.to_json
     end
 
     # for testing purpose (assert_equal ...)
@@ -137,16 +118,18 @@ module OData
     # methods related to transitions to next state (cf. walker)
     module Transitions
       def transition_end(_match_result)
-        [nil, :end]
+        Safrano::Transition::RESULT_END
       end
 
       def transition_value(_match_result)
         [self, :end_with_value]
       end
 
+      ALLOWED_TRANSITIONS = [Safrano::TransitionEnd,
+                             Safrano::TransitionValue].freeze
+
       def allowed_transitions
-        [Safrano::TransitionEnd,
-         Safrano::TransitionValue]
+        ALLOWED_TRANSITIONS
       end
     end
     include Transitions

data/lib/odata/relations.rb

@@ -1,9 +1,9 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
 require 'set'
 
 # OData relation related classes/module
-module OData
+module Safrano
   # we represent a relation as a Set (unordered) of two end elements
   class Relation < Set
     #    attr_reader :rid
@@ -20,7 +20,7 @@ module OData
 
     # we need a from/to order independant ID
     def rid
-      OData::RelationManager.build_id(self)
+      Safrano::RelationManager.build_id(self)
     end
 
     # we need a from/to order independant OData like name
@@ -76,11 +76,11 @@ module OData
     end
 
     def get(arg)
-      rid = OData::RelationManager.build_id(arg)
+      rid = Safrano::RelationManager.build_id(arg)
       if @list.key?(rid)
         @list[rid]
       else
-        rel = OData::Relation.new(arg)
+        rel = Safrano::Relation.new(arg)
         @list[rid] = rel
       end
     end

data/lib/odata/select.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'odata/error'
+
+# all dataset selecting related classes in our OData module
+# ie  do eager loading
+module Safrano
+  # base class for selecting. We have to distinguish between
+  # fields of the current entity, and the navigation properties
+  # we can have one special case
+  #  empty, ie no $select specified --> return all fields and all nav props
+  #            ==> SelectAll
+
+  class SelectBase
+    ALL = new # re-useable selecting-all handler
+
+    def self.factory(selectstr, model)
+      case selectstr&.strip
+      when nil, '', '*'
+        ALL
+      else
+        Select.new(selectstr, model)
+      end
+    end
+
+    def all_props?
+      false
+    end
+
+    def ALL.all_props?
+      true
+    end
+
+    def parse_error?
+      Contract::OK
+    end
+  end
+
+  # single select
+  class Select < SelectBase
+    COMASPLIT = /\s*,\s*/.freeze
+    attr_reader :props
+
+    def initialize(selstr, model)
+      @model = model
+      @selectp = selstr.strip
+      @props = @selectp.split(COMASPLIT)
+    end
+
+    def parse_error?
+      (invalids = @model.find_invalid_props(props.to_set)) ? BadRequestSelectInvalidProps.new(@model, invalids) : Contract::OK
+    end
+  end
+end

data/lib/odata/transition.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require_relative 'error'
+
+# our main namespace
+module Safrano
+  # represents a state transition when navigating/parsing the url path
+  # from left to right
+  class Transition < Regexp
+    attr_accessor :trans
+    attr_accessor :match_result
+    attr_accessor :rgx
+    attr_reader :remain_idx
+
+    EMPTYSTR = ''.freeze
+    SLASH = '/'.freeze
+
+    RESULT_BAD_REQ_ERR = [nil, :error, ::Safrano::BadRequestError].freeze
+    RESULT_NOT_FOUND_ERR = [nil, :error, ::Safrano::ErrorNotFound].freeze
+    RESULT_SERVER_TR_ERR = [nil, :error, ServerTransitionError].freeze
+    RESULT_END = [nil, :end].freeze
+
+    def initialize(arg, trans: nil, remain_idx: 2)
+      @rgx = if arg.respond_to? :each_char
+               Regexp.new(arg)
+             else
+               arg
+             end
+      @trans = trans
+      @remain_idx = remain_idx
+    end
+
+    def do_match(str)
+      @match_result = @rgx.match(str)
+    end
+
+    # remain_idx is the index of the last match-data. ususally its 2
+    # but can be overidden
+    def path_remain
+      @match_result[@remain_idx] if @match_result && @match_result[@remain_idx]
+    end
+
+    def path_done
+      if @match_result
+        @match_result[1] || EMPTYSTR
+      else
+        EMPTYSTR
+      end
+    end
+
+    def do_transition(ctx)
+      ctx.method(@trans).call(@match_result)
+    end
+  end
+
+  TransitionEnd = Transition.new('\A(\/?)\z', trans: 'transition_end')
+  TransitionMetadata = Transition.new('\A(\/\$metadata)(.*)',
+                                      trans: 'transition_metadata')
+  TransitionBatch = Transition.new('\A(\/\$batch)(.*)',
+                                   trans: 'transition_batch')
+  TransitionContentId = Transition.new('\A(\/\$(\d+))(.*)',
+                                       trans: 'transition_content_id',
+                                       remain_idx: 3)
+  TransitionCount = Transition.new('(\A\/\$count)(.*)\z',
+                                   trans: 'transition_count')
+  TransitionValue = Transition.new('(\A\/\$value)(.*)\z',
+                                   trans: 'transition_value')
+  TransitionLinks = Transition.new('(\A\/\$links)(.*)\z',
+                                   trans: 'transition_links')
+  attr_accessor :allowed_transitions
+end

data/lib/odata/url_parameters.rb

@@ -1,58 +1,149 @@
-require 'odata/error.rb'
+# frozen_string_literal: true
+
+require 'odata/error'
 
 # url parameters processing . Mostly delegates to specialised classes
 # (filter, order...) to convert into Sequel exprs.
-module OData
-  class UrlParameters
+module Safrano
+  class UrlParametersBase
+    attr_reader :expand
+    attr_reader :select
+
+    # url params validation methods.
+    # nil is the expected return for no errors
+    # an error class is returned in case of errors
+    # this way we can combine multiple validation calls with logical ||
+    def check_expand
+      @expand.parse_error?
+    end
+
+    def check_select
+      @select.parse_error?
+    end
+
+    def initialize(dataset, params = {})
+      @model = if dataset.respond_to? :model
+                 dataset.model
+               else
+                 dataset
+               end
+      @params = params
+    end
+  end
+
+  # url parameters for a single entity expand/select
+  class UrlParameters4Single < UrlParametersBase
+    def initialize(dataset, params)
+      super
+      @expand = ExpandBase.factory(@params['$expand'], @model)
+      @select = SelectBase.factory(@params['$select'], @model)
+    end
+
+    def check_all
+      return Contract::OK unless @params
+
+      check_expand.if_valid do
+        check_select
+      end
+    end
+  end
+
+  # url parameters for a collection expand/select + filter/order
+  class UrlParameters4Coll < UrlParametersBase
     attr_reader :filt
     attr_reader :ordby
-    def initialize(jh, params)
-      @jh = jh
+
+    def initialize(dataset, params = {})
+      super
+      # join helper is only needed for odering or filtering
+      @jh = @model.join_by_paths_helper if params['$orderby'] || params['$filter']
       @params = params
+      @ordby = OrderBase.factory(@params['$orderby'], @jh)
+      @filt = FilterBase.factory(@params['$filter'])
+      @expand = ExpandBase.factory(@params['$expand'], @model)
+      @select = SelectBase.factory(@params['$select'], @model)
     end
 
-    def check_filter
-      return unless @params['$filter']
+    def check_top
+      return Contract::OK unless @params['$top']
 
-      @filt = FilterByParse.new(@params['$filter'], @jh)
-      return BadRequestFilterParseError if @filt.parse_error?
+      itop = number_or_nil(@params['$top'])
+      (itop.nil? || itop.zero?) ? BadRequestError : Contract::OK
+    end
+
+    def check_skip
+      return Contract::OK unless @params['$skip']
 
-      # nil is the expected return for no errors
-      nil
+      iskip = number_or_nil(@params['$skip'])
+      (iskip.nil? || iskip.negative?) ? BadRequestError : Contract::OK
     end
 
-    def check_order
-      return unless @params['$orderby']
+    def check_inlinecount
+      return Contract::OK unless (icp = @params['$inlinecount'])
 
-      pordlist = @params['$orderby'].dup
-      pordlist.split(',').each do |pord|
-        pord.strip!
-        qualfn, dir = pord.split(/\s/)
-        qualfn.strip!
-        dir.strip! if dir
-        return BadRequestError unless @jh.start_model.attrib_path_valid? qualfn
-        return BadRequestError unless [nil, 'asc', 'desc'].include? dir
-      end
+      ((icp == 'allpages') || (icp == 'none')) ? Contract::OK : BadRequestInlineCountParamError
+    end
+
+    def check_filter
+      (err = @filt.parse_error?) ? err : Contract::OK
+    end
 
-      @ordby = Order.new_by_parse(@params['$orderby'], @jh)
+    def check_orderby
+      return Contract::OK if @ordby.empty?
+      return BadRequestOrderParseError if @ordby.parse_error?
 
-      # nil is the expected return for no errors
-      nil
+      Contract::OK
     end
 
     def apply_to_dataset(dtcx)
-      return dtcx if (@filt.nil? && @ordby.nil?)
-
-      if @filt.nil?
-        dtcx = @jh.dataset.select_all(@jh.start_model.table_name)
-
-        @ordby.apply_to_dataset(dtcx)
-      elsif @ordby.nil?
-        @filt.apply_to_dataset(dtcx)
-      else
-        filtexpr = @filt.sequel_expr
-        dtcx = @jh.dataset(dtcx).where(filtexpr).select_all(@jh.start_model.table_name)
-        @ordby.apply_to_dataset(dtcx)
+      apply_expand_to_dataset(dtcx).if_valid do |dataset|
+        apply_filter_order_to_dataset(dataset)
+      end
+    end
+
+    def apply_expand_to_dataset(dtcx)
+      return Contract.valid(dtcx) if @expand.empty?
+
+      @expand.apply_to_dataset(dtcx)
+    end
+
+    # Warning, the @ordby and @filt objects are coupled by way of the join helper
+    def apply_filter_order_to_dataset(dtcx)
+      return Contract.valid(dtcx) if @filt.empty? && @ordby.empty?
+
+      # filter object and join-helper need to be finalized after filter
+      # has been parsed and checked
+      @filt.finalize(@jh).if_valid do
+        # start with the join
+        dtcx = @jh.dataset(dtcx)
+
+        @filt.apply_to_dataset(dtcx).map_result! do |dataset|
+          dtcx = dataset
+          dtcx = @ordby.apply_to_dataset(dtcx)
+          dtcx.select_all(@jh.start_model.table_name)
+        end
+      end
+    end
+
+    ###########################################################
+    def check_all
+      return Contract::OK unless @params
+
+      # lazy nested proc evaluation.
+      # if one check fails, it will be passed up the chain and the ones
+      # below will not be evaluated
+      check_top.if_valid do
+        check_skip.if_valid do
+          check_orderby.if_valid do
+            check_filter.if_valid do
+              check_expand.if_valid do
+                check_select.if_valid do
+                  check_inlinecount
+                end
+              end
+            end
+          end
+        end
       end
     end
   end