safrano 0.3.4 → 0.4.4

data/lib/odata/navigation_attribute.rb

@@ -1,11 +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 Safrano
+  # 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
 
-module OData
   # 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,
@@ -24,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
@@ -42,36 +62,28 @@ 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
   end
 
   # Represents a named but nil-valued navigation-attribute of an Entity
   # (usually resulting from a NULL FK db value)
   class NilNavigationAttribute
-    attr_reader :name
-    attr_reader :parent
-    def initialize(parent, name)
-      @parent = parent
-      @name = name
-      @navattr_reflection = parent.class.association_reflections[name.to_sym]
-      @klass = @navattr_reflection[:class_name].constantize
-    end
-
+    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
@@ -80,38 +92,44 @@ module OData
     # create the nav. entity
     def odata_post(req)
       # delegate to the class method
-      @klass.odata_create_entity_and_relation(req, @navattr_reflection, @parent)
+      @nav_klass.odata_create_entity_and_relation(req,
+                                                  @navattr_reflection,
+                                                  @nav_parent)
     end
 
     # create the nav. entity
     def odata_put(req)
       # delegate to the class method
-      @klass.odata_create_entity_and_relation(req, @navattr_reflection, @parent)
+      @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 ...)
     def ==(other)
-      (@parent == other.parent) && (@name == other.name)
+      (@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]
+        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,16 +76,16 @@ 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
 
-    def get_metadata_xml_attribs(from, to, assoc_type, xnamespace)
+    def get_metadata_xml_attribs(from, to, assoc_type, xnamespace, attrname)
       rel = get([from, to])
       # use Sequel reflection to get multiplicity (will be used later
       # in 2. Associations below)
@@ -107,7 +107,7 @@ module OData
       # <NavigationProperty Name="Supplier"
       # Relationship="ODataDemo.Product_Supplier_Supplier_Products"
       #         FromRole="Product_Supplier" ToRole="Supplier_Products"/>
-      { 'Name' => to, 'Relationship' => "#{xnamespace}.#{rel.name}",
+      { 'Name' => attrname, 'Relationship' => "#{xnamespace}.#{rel.name}",
         'FromRole' => from, 'ToRole' => to }
     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/{safrano_core.rb → odata/transition.rb}

@@ -1,63 +1,8 @@
-#!/usr/bin/env ruby
+# frozen_string_literal: true
 
-# our main namespace
-module OData
-  # some prominent constants... probably already defined elsewhere eg in Rack
-  # but lets KISS
-  CONTENT_TYPE = 'Content-Type'.freeze
-  CTT_TYPE_LC = 'content-type'.freeze
-  TEXTPLAIN_UTF8 = 'text/plain;charset=utf-8'.freeze
-  APPJSON = 'application/json'.freeze
-  APPXML = 'application/xml'.freeze
-  MP_MIXED = 'multipart/mixed'.freeze
-  APPXML_UTF8 = 'application/xml;charset=utf-8'.freeze
-  APPATOMXML_UTF8 = 'application/atomsvc+xml;charset=utf-8'.freeze
-  APPJSON_UTF8 = 'application/json;charset=utf-8'.freeze
-
-  CT_JSON = { CONTENT_TYPE => APPJSON_UTF8 }.freeze
-  CT_TEXT = { CONTENT_TYPE => TEXTPLAIN_UTF8 }.freeze
-  CT_ATOMXML = { CONTENT_TYPE => APPATOMXML_UTF8 }.freeze
-  CT_APPXML = { CONTENT_TYPE => APPXML_UTF8 }.freeze
-
-  # Type mapping DB --> Edm
-  #  TypeMap = {"INTEGER" => "Edm.Int32" , "TEXT" => "Edm.String",
-  # "STRING" => "Edm.String"}
-  # Todo: complete mapping... this is just for the most common ones
-
-  # TODO: use Sequel GENERIC_TYPES: -->
-  # Constants
-  # GENERIC_TYPES = %w'String Integer Float Numeric BigDecimal Date DateTime
-  # Time File TrueClass FalseClass'.freeze
-  # Classes specifying generic types that Sequel will convert to
-  # database-specific types.
-  DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.freeze
-
-  def self.get_edm_type(db_type:)
-    case db_type
-    when 'INTEGER'
-      'Edm.Int32'
-    when 'TEXT', 'STRING'
-      'Edm.String'
-    else
-      'Edm.String' if DB_TYPE_STRING_RGX =~ db_type
-    end
-  end
-end
+require_relative 'error'
 
-module REXML
-  # some small extensions
-  class Document
-    def to_pretty_xml
-      formatter = REXML::Formatters::Pretty.new(2)
-      formatter.compact = true
-      strio = ''
-      formatter.write(root, strio)
-      strio
-    end
-  end
-end
-
-# Core
+# our main namespace
 module Safrano
   # represents a state transition when navigating/parsing the url path
   # from left to right
@@ -66,6 +11,15 @@ module Safrano
     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)
@@ -88,9 +42,9 @@ module Safrano
 
     def path_done
       if @match_result
-        @match_result[1] || ''
+        @match_result[1] || EMPTYSTR
       else
-        ''
+        EMPTYSTR
       end
     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