safrano 0.2.0 → 0.3.0

data/lib/odata/relations.rb

@@ -47,6 +47,16 @@ module OData
         raise ArgumentError
       end
     end
+
+    def with_metadata_info(xnamespace)
+      bdprops = []
+      each_endobj do |eo|
+        bdprops << { type: "#{xnamespace}.#{eo}",
+                     role: eo,
+                     multiplicity: multiplicity[eo] }
+      end
+      yield name, bdprops
+    end
   end
 
   # some usefull stuff
@@ -74,5 +84,31 @@ module OData
         @list[rid] = rel
       end
     end
+
+    def get_metadata_xml_attribs(from, to, assoc_type, xnamespace)
+      rel = get([from, to])
+      # use Sequel reflection to get multiplicity (will be used later
+      # in 2. Associations below)
+      case assoc_type
+      # TODO: use multiplicity 1 when needed instead of '0..1'
+      when :one_to_one
+        rel.set_multiplicity(from, '0..1')
+        rel.set_multiplicity(to, '0..1')
+      when :one_to_many
+        rel.set_multiplicity(from, '0..1')
+        rel.set_multiplicity(to, '*')
+      when :many_to_one
+        rel.set_multiplicity(from, '*')
+        rel.set_multiplicity(to, '0..1')
+      when :many_to_many
+        rel.set_multiplicity(from, '*')
+        rel.set_multiplicity(to, '*')
+      end
+      # <NavigationProperty Name="Supplier"
+      # Relationship="ODataDemo.Product_Supplier_Supplier_Products"
+      #         FromRole="Product_Supplier" ToRole="Supplier_Products"/>
+      { 'Name' => to, 'Relationship' => "#{xnamespace}.#{rel.name}",
+        'FromRole' => from, 'ToRole' => to }
+    end
   end
 end

data/lib/odata/url_parameters.rb

@@ -0,0 +1,58 @@
+require 'odata/error.rb'
+
+# url parameters processing . Mostly delegates to specialised classes
+# (filter, order...) to convert into Sequel exprs.
+module OData
+  class UrlParameters
+    attr_reader :filt
+    attr_reader :ordby
+    def initialize(jh, params)
+      @jh = jh
+      @params = params
+    end
+
+    def check_filter
+      return unless @params['$filter']
+
+      @filt = FilterByParse.new(@params['$filter'], @jh)
+      return BadRequestFilterParseError if @filt.parse_error?
+
+      # nil is the expected return for no errors
+      nil
+    end
+
+    def check_order
+      return unless @params['$orderby']
+
+      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
+
+      @ordby = Order.new_by_parse(@params['$orderby'], @jh)
+
+      # nil is the expected return for no errors
+      nil
+    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)
+      end
+    end
+  end
+end

data/lib/odata/walker.rb

@@ -79,57 +79,70 @@ module OData
                  end
     end
 
+    # perform a content-id ($batch changeset ref) transition
+    def do_run_with_content_id
+      if @content_id_refs.is_a? Hash
+        if (@context = @content_id_refs[@context.to_s])
+          @status = :run
+        else
+          @context = nil
+          @status = :error
+          # TODO: more appropriate error handling
+          @error = OData::ErrorNotFound
+        end
+      else
+        @context = nil
+        @status = :error
+        # TODO: more appropriate error handling
+        @error = OData::ErrorNotFound
+      end
+    end
+
+    # little hacks... depending on returned state, set some attributes
+    def state_mappings
+      case @status
+      when :end_with_count
+        @do_count = true
+        @status = :end
+      when :end_with_value
+        @raw_value = true
+        @status = :end
+      when :run_with_links
+        @do_links = true
+        @status = :run
+      end
+    end
+
+    def do_next_transition
+      @context, @status, @error = @tr_next.do_transition(@context)
+      # little hack's
+      case @status
+        # we dont have the content-id references data on service level
+        # but we have it here, so in case of a $content-id transition
+        # the returned context is just the id, and we get the final result
+        # entity reference here and place it in @context
+      when :run_with_content_id
+        do_run_with_content_id
+      end
+
+      @contexts << @context
+      @path_remain = @tr_next.path_remain
+      @path_done << @tr_next.path_done
+
+      # little hack's
+      state_mappings
+    end
+
     def eo
       while @context
         get_next_transition
         if @tr_next
-          @context, @status, @error = @tr_next.do_transition(@context)
-          # little hack's
-          case @status
-            # we dont have the content-id references data on service level
-            # but we have it here, so in case of a $content-id transition
-            # the returned context is just the id, and we get the final result
-            # entity reference here and place it in @context
-          when :run_with_content_id
-            if @content_id_refs.is_a? Hash
-              if (@context = @content_id_refs[@context.to_s])
-                @status = :run
-              else
-                @context = nil
-                @status = :error
-                # TODO: more appropriate error handling
-                @error = OData::ErrorNotFound
-              end
-            else
-              @context = nil
-              @status = :error
-              # TODO: more appropriate error handling
-              @error = OData::ErrorNotFound
-            end
-          end
-
-          @contexts << @context
-          @path_remain = @tr_next.path_remain
-          @path_done << @tr_next.path_done
-
-          # little hack's
-          case @status
-          when :end_with_count
-            @do_count = true
-            @status = :end
-          when :end_with_value
-            @raw_value = true
-            @status = :end
-          when :run_with_links
-            @do_links = true
-            @status = :run
-          end
+          do_next_transition
         else
           @context = nil
           @status = :error
           @error = OData::ErrorNotFound
         end
-
       end
       # TODO: shouldnt we raise an error here if @status != :end ?
       return false unless @status == :end

data/lib/request.rb

@@ -8,8 +8,6 @@ module OData
   # is not passed
   class Request < Rack::Request
     HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/.freeze
-    # HEADER_VALUE_WITH_PARAMS = /(?:(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*)
-    #                             \s*(?:;#{HEADER_PARAM})*/
     HEADER_VAL_RAW = '(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*'.freeze
     HEADER_VAL_WITH_PAR = /(?:#{HEADER_VAL_RAW})\s*(?:;#{HEADER_PARAM})*/.freeze
 
@@ -135,7 +133,7 @@ module OData
     end
 
     def with_parsed_data(on_error: nil)
-      if content_type == 'application/json'
+      if content_type == APPJSON
         # Parse json payload
         begin
           data = JSON.parse(body.read)

data/lib/safrano.rb

@@ -10,5 +10,22 @@ require 'odata/collection.rb'
 require 'service.rb'
 require 'odata/walker.rb'
 require 'sequel'
+require_relative './sequel_join_by_paths.rb'
 require 'rack_app'
 require 'odata_rack_builder'
+
+# picked from activsupport; needed for ruby < 2.5
+# Destructively converts all keys using the +block+ operations.
+# Same as +transform_keys+ but modifies +self+.
+class Hash
+  def transform_keys!
+    keys.each do |key|
+      self[yield(key)] = delete(key)
+    end
+    self
+  end unless method_defined? :transform_keys!
+
+  def symbolize_keys!
+    transform_keys! { |key| key.to_sym rescue key }
+  end
+end

data/lib/safrano_core.rb

@@ -1,7 +1,24 @@
 #!/usr/bin/env ruby
 
-# Type mapping DB --> Edm
+# our main namespace
 module OData
+  # some prominent constants... probably already defined elsewhere eg in Rack
+  # but lets KISS
+  CONTENT_TYPE = 'Content-Type'.freeze
+  TEXTPLAIN_UTF8 = 'text/plain;charset=utf-8'.freeze
+  APPJSON = 'application/json'.freeze
+  APPXML = 'application/xml'.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
@@ -12,6 +29,8 @@ module OData
   # 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'
@@ -19,7 +38,7 @@ module OData
     when 'TEXT', 'STRING'
       'Edm.String'
     else
-      'Edm.String' if /\ACHAR\s*\(\d+\)\z/ =~ db_type
+      'Edm.String' if DB_TYPE_STRING_RGX =~ db_type
     end
   end
 end
@@ -45,22 +64,25 @@ module Safrano
     attr_accessor :trans
     attr_accessor :match_result
     attr_accessor :rgx
-    def initialize(arg, trans: nil)
+    attr_reader :remain_idx
+    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
 
-    # this assumes some implicit rules in the way the regexps are built
+    # remain_idx is the index of the last match-data. ususally its 2
+    # but can be overidden
     def path_remain
-      @match_result[2] if @match_result && @match_result[2]
+      @match_result[@remain_idx] if @match_result && @match_result[@remain_idx]
     end
 
     def path_done
@@ -81,8 +103,9 @@ module Safrano
                                       trans: 'transition_metadata')
   TransitionBatch = Transition.new('\A(\/\$batch)(.*)',
                                    trans: 'transition_batch')
-  TransitionContentId = Transition.new('\A(\/\$\d+)(.*)',
-                                       trans: 'transition_content_id')
+  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',

data/lib/sequel/plugins/join_by_paths.rb

@@ -0,0 +1,239 @@
+#!/usr/bin/env ruby
+
+require 'set'
+require 'sequel'
+
+# some helpers
+class String
+  # thanks https://stackoverflow.com/questions/1448670/ruby-stringto-class
+  def constantize
+    names = split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    const = Object
+    names.each do |name|
+      const = if const.const_defined?(name)
+                const.const_get(name)
+              else
+                const.const_missing(name)
+              end
+    end
+    const
+  end
+end
+
+class PathNode < String
+  attr_reader :table_name
+  attr_accessor :model_class
+  attr_accessor :path_str
+  def initialize(str, start_model)
+    super(str)
+    @start_model = start_model
+  end
+
+  def table_name
+    @model_class.table_name
+  end
+
+  def set_model_class_by_parent_model(pmclass)
+    @model_class = pmclass.association_reflection(to_sym)[:class_name].constantize
+  end
+
+  def alias_sym
+    @start_model.get_alias_sym(path_str)
+  end
+end
+
+class QPath
+  attr_reader :segments
+  attr_reader :start_model
+  attr_reader :qpath
+
+  def initialize(smodel, path_str)
+    @qpath = path_str
+    @start_model = smodel
+    segment
+  end
+
+  def size
+    @segments.size
+  end
+
+  # source: ..https://ruby-doc.org/core-2.6.5/Hash.html
+  def ==(other)
+    (self.class === other) &&
+      (@start_model == other.start_model) &&
+      (@qpath == other.qpath)
+  end
+
+  alias eql? ==
+
+  def hash
+    @start_model.hash ^ @qpath.hash # XOR
+  end
+
+  def segment
+    @segments = []
+    start_node = @start_model.create_path_node('')
+    start_node.model_class = @start_model
+    path_str = ''
+    path_nodes = []
+    start_node.path_str = path_str
+    nodes = [start_node]
+    nodes.concat @qpath.split('/').map { |nstr| @start_model.create_path_node(nstr) }
+    if (ns = nodes.size) > 1
+      nodes[0...-1].each_with_index do |node, i|
+        nodes[i + 1].set_model_class_by_parent_model(node.model_class)
+        path_nodes << nodes[i + 1]
+        nodes[i + 1].path_str = path_nodes.join('/')
+        @segments << [node, nodes[i + 1]]
+      end
+    end
+  end
+end
+
+class JoinByPathsHelper < Set
+  attr_reader :result
+  attr_reader :start_model
+
+  def initialize(smodel)
+    super()
+    @start_model = smodel
+  end
+
+  def build_unique_join_segments
+    return (@result = []) if empty?
+
+    maxlen = map(&:size).max
+    iset = nil
+    @result = []
+
+    (0...maxlen).each do |i|
+      iset = Set.new
+      each { |qp| (iset << qp.segments[i]) if qp.segments[i] }
+      @result << iset
+    end
+
+    @result.map! do |jseg|
+      jseg.map  do |seg|
+        leftm = seg.first.model_class
+        assoc = leftm.association_reflection(seg.last.to_sym)
+        rightm = seg.last.model_class
+        # cf.  documentation in sequel/model/associations.rb
+        case assoc[:type]
+        # :many_to_one :: Foreign key in current model's table points to
+        #                 associated model's primary key.
+        when :many_to_one
+          lks = [assoc[:key]].flatten
+          rks = [rightm.primary_key].flatten
+
+        when :one_to_many, :one_to_one
+          # :one_to_many :: Foreign key in associated model's table points to this
+          #                 model's primary key.
+          # :one_to_one :: Similar to one_to_many in terms of foreign keys, but
+          #                only one object is associated to the current object through the
+          #                association.
+          lks = [leftm.primary_key].flatten
+          rks = [assoc[:key]].flatten
+
+          # TODO
+          # when         # :many_to_many :: A join table is used that has a foreign key that points
+          #                  to this model's primary key and a foreign key that points to the
+          #                  associated model's primary key.  Each current model object can be
+          #                  associated with many associated model objects, and each associated
+          #                  model object can be associated with many current model objects.
+          # when    # :one_through_one :: Similar to many_to_many in terms of foreign keys, but only one object
+          #                     is associated to the current object through the association.
+          #                     Provides only getter methods, no setter or modification methods.
+
+        end
+
+        lks.map! { |k| Sequel[seg.first.alias_sym][k] } unless seg.first.empty?
+
+        rks.map! { |k| Sequel[seg.last.alias_sym][k] }
+
+        { type: assoc[:type],
+          segment: seg,
+          left: leftm.table_name,
+          right: rightm.table_name,
+          alias: seg.last.alias_sym,
+          left_keys: lks,
+          right_keys: rks,
+          cond: rks.zip(lks).to_h }
+      end
+    end
+  end
+
+  def add(path_str)
+    super(QPath.new(@start_model, path_str))
+  end
+
+  def dataset(start_dtset = nil)
+    start_dataset = (start_dtset || @start_model.dataset)
+    return start_dataset if empty?
+
+    build_unique_join_segments
+    @result.flatten.inject(start_dataset) do |dt, jo|
+      dt.left_join(Sequel[jo[:right]].as(jo[:alias]),
+                   jo[:cond],
+                   implicit_qualifier: jo[:left])
+    end
+  end
+
+  def join_by_paths_helper(*pathlist)
+    pathlist.each { |path_str| add path_str }
+    self
+  end
+end
+
+module Sequel
+  module Plugins
+    module JoinByPaths
+      def self.apply(model)
+        model.instance_exec do
+          @aliases_sym = {}
+          @alias_cnt = 0
+        end
+      end
+
+      def self.configure(model)
+        model.instance_eval do
+          @aliases_sym = {}
+          @alias_cnt = 0
+        end
+      end
+      module ClassMethods
+        attr_reader :aliases_sym
+        attr_reader :alias_cnt
+        Plugins.inherited_instance_variables(self,
+                                             :@aliases_sym => :dup,
+                                             :@alias_cnt => :dup)
+
+        def get_alias_sym(pstr)
+          if @aliases_sym.key?(pstr)
+            @aliases_sym[pstr]
+          else
+            @alias_cnt += 1
+            @aliases_sym[pstr] = "a#{@alias_cnt}".to_sym
+          end
+        end
+
+        def create_path_node(pstr)
+          PathNode.new(pstr, self)
+        end
+
+        def join_by_paths_helper(*pathlist)
+          jh = JoinByPathsHelper.new(self)
+          pathlist.each { |path_str| jh.add path_str }
+          jh
+        end
+      end
+      module DatasetMethods
+        attr_reader :join_helper
+        def join_by_paths(*pathlist)
+          model.join_by_paths_helper(*pathlist).dataset
+        end
+      end
+    end
+  end
+end