safrano 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 49dc75cf9bfcdff0a03b38eaada7f0a968a09ab3777327f0c893f8f39fd32d8f
+  data.tar.gz: 7103e882037de0e6c89d368ec25cb0f6c6b9ed4be7fc8dff9aa64d0a6107a29d
+SHA512:
+  metadata.gz: e7dbd2370716c6e5f323c9fff63394053521f70af27ee613a288e7ca089071818844a09dc4e400cba4fcd0e227e4c7d38b5d07d2e887aa33553cf8ea57a1e5ec
+  data.tar.gz: 94b84b19d4d7273a0aef7c4a52348e4e77340f95cf64792e6f47dc1cde8e06ae675ee3bc5cd87d8c58e8e8098b914b24bb4e38818f96f75fd2116f32ae6e0d8b

data/lib/odata_rack_builder.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require 'rack'
+require 'rack/cors'
+
+module Rack
+  module OData
+    # just a Wrapper to ensure (force?) that mandatory middlewares are acutally
+    # used
+    class Builder < ::Rack::Builder
+      def initialize(default_app = nil, &block)
+        super(default_app)
+        use ::Rack::Cors
+        instance_eval(&block) if block_given?
+        use ::Rack::Lint
+        use ::Rack::ContentLength
+      end
+    end
+  end
+end

data/lib/rack_app.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require 'rack'
+require_relative 'odata/walker.rb'
+require_relative 'request.rb'
+require_relative 'response.rb'
+require 'pry'
+
+module OData
+  # handle GET PUT etc
+  module MethodHandlers
+    def odata_options
+      # cf. stackoverflow.com/questions/22924678/sinatra-delete-response-headers
+
+      x = if @walker.status == :end
+            headers.delete('Content-Type')
+            @response.headers.delete('Content-Type')
+            [200, {}, '']
+          else
+            odata_error
+          end
+      @response.headers['Content-Type'] = ''
+      x
+    end
+
+    def odata_error
+      if @walker.error.nil?
+        [500, {}, 'Server Error']
+      else
+        @walker.error.odata_get(@request)
+      end
+    end
+
+    def odata_delete
+      if @walker.status == :end
+        @walker.end_context.odata_delete(@request)
+      else
+        odata_error
+      end
+    end
+
+    def odata_patch
+      if @walker.status == :end
+        @walker.end_context.odata_patch(@request)
+      else
+        odata_error
+      end
+    end
+
+    def odata_get
+      if @walker.status == :end
+        @walker.end_context.odata_get(@request)
+      else
+        odata_error
+      end
+    end
+
+    def odata_post
+      if @walker.status == :end
+        @walker.end_context.odata_post(@request)
+      else
+        odata_error
+      end
+    end
+
+    def odata_head
+      [200, {}, '']
+    end
+  end
+
+  # the main Rack server app. Source: the Rack docu/examples and partly
+  # inspired from Sinatra
+  class ServerApp
+    METHODS_REGEXP = Regexp.new('HEAD|OPTIONS|GET|POST|PATCH|PUT|DELETE')
+    include MethodHandlers
+    def before
+      headers 'Cache-Control' => 'no-cache'
+      headers 'Expires' => '-1'
+      headers 'Pragma' => 'no-cache'
+
+      @request.service_base = self.class.get_service_base
+
+      neg_error = @request.negotiate_service_version
+
+      raise Error if neg_error
+
+      return false unless @request.service
+
+      headers 'DataServiceVersion' => @request.service.data_service_version
+    end
+
+    # dispatch for all methods requiring parsing of the path
+    # with walker (ie. allmost all excepted HEAD)
+    def dispatch_with_walker
+      @walker = @request.create_odata_walker
+      case @request.request_method
+      when 'GET'
+        odata_get
+      when 'POST'
+        odata_post
+      when 'DELETE'
+        odata_delete
+      when 'OPTIONS'
+        odata_options
+      when 'PATCH', 'PUT'
+        odata_patch
+      else
+        raise Error
+      end
+    end
+
+    def dispatch
+      req_ret = if @request.request_method !~ METHODS_REGEXP
+                  [404, {}, ['Did you get lost?']]
+                elsif @request.request_method == 'HEAD'
+                  odata_head
+                else
+                  dispatch_with_walker
+                end
+      @response.status, rsph, @response.body = req_ret
+      headers rsph
+    end
+
+    def call(env)
+      @request = OData::Request.new(env)
+      @response = OData::Response.new
+
+      before
+
+      dispatch
+
+      @response.finish
+    end
+
+    # Set multiple response headers with Hash.
+    def headers(hash = nil)
+      @response.headers.merge! hash if hash
+      @response.headers
+    end
+
+    def self.enable_batch
+      @service_base.enable_batch
+    end
+
+    def self.get_service_base
+      @service_base
+    end
+
+    def self.set_servicebase(sbase, p_prefix = '')
+      @service_base = sbase
+      @service_base.path_prefix p_prefix
+      @service_base.enable_v1_service
+      @service_base.enable_v2_service
+    end
+
+    def self.publish_service(&block)
+      sbase = OData::ServiceBase.new
+      sbase.instance_eval(&block) if block_given?
+      sbase.finalize_publishing
+      set_servicebase(sbase)
+    end
+  end
+end

data/lib/request.rb

@@ -0,0 +1,158 @@
+#!/usr/bin/env ruby
+
+require 'rack'
+
+module OData
+  # monkey patch deactivate Rack/multipart because it does not work on simple
+  # OData $batch requests when the content-length
+  # 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
+
+    # borowed from Sinatra
+    class AcceptEntry
+      attr_accessor :params
+      attr_reader :entry
+      def initialize(entry)
+        params = entry.scan(HEADER_PARAM).map! do |s|
+          key, value = s.strip.split('=', 2)
+          value = value[1..-2].gsub(/\\(.)/, '\1') if value.start_with?('"')
+          [key, value]
+        end
+
+        @entry = entry
+        @type = entry[/[^;]+/].delete(' ')
+        @params = Hash[params]
+        @q = @params.delete('q') { 1.0 }.to_f
+      end
+
+      def method_missing(*args, &block)
+        to_str.send(*args, &block)
+      end
+
+      def <=>(other)
+        other.priority <=> priority
+      end
+
+      def priority
+        # We sort in descending order; better matches should be higher.
+        [@q, -@type.count('*'), @params.size]
+      end
+
+      def respond_to?(*args)
+        super || to_str.respond_to?(*args)
+      end
+
+      def to_s(full = false)
+        full ? entry : to_str
+      end
+
+      def to_str
+        @type
+      end
+    end
+    ## original coding:
+    #    # The set of media-types. Requests that do not indicate
+    #    # one of the media types presents in this list will not be eligible
+    #    # for param parsing like soap attachments or generic multiparts
+    #    PARSEABLE_DATA_MEDIA_TYPES = [
+    #      'multipart/related',
+    #      'multipart/mixed'
+    #    ]
+    #    # Determine whether the request body contains data by checking
+    #    # the request media_type against registered parse-data media-types
+    #    def parseable_data?
+    #      PARSEABLE_DATA_MEDIA_TYPES.include?(media_type)
+    #    end
+    def parseable_data?
+      false
+    end
+    # OData extension
+    attr_accessor :service_base
+    attr_accessor :service
+    attr_accessor :walker
+
+    def create_odata_walker
+      @walker = Walker.new(@service, path_info)
+    end
+
+    def accept
+      @env['safrano.accept'] ||= begin
+        if @env.include?('HTTP_ACCEPT') && (@env['HTTP_ACCEPT'].to_s != '')
+          @env['HTTP_ACCEPT'].to_s.scan(HEADER_VAL_WITH_PAR)
+                             .map! { |e| AcceptEntry.new(e) }.sort
+        else
+          [AcceptEntry.new('*/*')]
+        end
+      end
+    end
+
+    def uribase
+      return @uribase if @uribase
+
+      @uribase =
+        "#{env['rack.url_scheme']}://#{env['HTTP_HOST']}#{service.xpath_prefix}"
+    end
+
+    def accept?(type)
+      preferred_type(type).to_s.include?(type)
+    end
+
+    def preferred_type(*types)
+      accepts = accept # just evaluate once
+      return accepts.first if types.empty?
+
+      types.flatten!
+      return types.first if accepts.empty?
+
+      accepts.detect do |pattern|
+        type = types.detect { |t| File.fnmatch(pattern, t) }
+        return type if type
+      end
+    end
+
+    def negotiate_service_version
+      maxv = if (rqv = env['HTTP_MAXDATASERVICEVERSION'])
+               OData::ServiceBase.parse_data_service_version(rqv)
+             else
+               OData::MAX_DATASERVICE_VERSION
+             end
+      return OData::BadRequestError if maxv.nil?
+      # client request an too old version --> 501
+      return OData::NotImplementedError if maxv < OData::MIN_DATASERVICE_VERSION
+
+      minv = if (rqv = env['HTTP_MINDATASERVICEVERSION'])
+               OData::ServiceBase.parse_data_service_version(rqv)
+             else
+               OData::MIN_DATASERVICE_VERSION
+             end
+      return OData::BadRequestError if minv.nil?
+      # client request an too new version --> 501
+      return OData::NotImplementedError if minv > OData::MAX_DATASERVICE_VERSION
+      return OData::BadRequestError if minv > maxv
+
+      v = if (rqv = env['HTTP_DATASERVICEVERSION'])
+            OData::ServiceBase.parse_data_service_version(rqv)
+          else
+            OData::MAX_DATASERVICE_VERSION
+          end
+
+      return OData::BadRequestError if v.nil?
+      return OData::NotImplementedError if v > OData::MAX_DATASERVICE_VERSION
+      return OData::NotImplementedError if v < OData::MIN_DATASERVICE_VERSION
+
+      @service = nil
+      @service = case maxv
+                 when '1'
+                   @service_base.v1
+                 when '2', '3', '4'
+                   @service_base.v2
+                 end
+      nil
+    end
+  end
+end

data/lib/response.rb

@@ -0,0 +1,68 @@
+#!/usr/bin/env ruby
+require 'rack'
+
+# monkey patch deactivate Rack/multipart because it does not work on simple
+# OData $batch requests when the content-length is not passed
+module OData
+  # borrowed fro Sinatra
+  # The response object. See Rack::Response and Rack::Response::Helpers for
+  # more info:
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+  class Response < ::Rack::Response
+    DROP_BODY_RESPONSES = [204, 205, 304].freeze
+    def initialize(*)
+      super
+      headers['Content-Type'] ||= 'text/html'
+    end
+
+    def body=(value)
+      value = value.body while ::Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete 'Content-Length'
+        headers.delete 'Content-Type'
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers['Content-Length'] = calculated_content_length.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers['Content-Type'] && !headers['Content-Length'] && (Array === body)
+    end
+
+    def calculated_content_length
+      body.inject(0) { |l, p|  l + p.bytesize }
+    end
+
+    def drop_content_info?
+      (status.to_i / 100 == 1) || drop_body?
+    end
+
+    def drop_body?
+      DROP_BODY_RESPONSES.include?(status.to_i)
+    end
+  end
+end

data/lib/safrano.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'rexml/document'
+require 'safrano_core.rb'
+require 'odata/entity.rb'
+require 'odata/collection.rb'
+require 'service.rb'
+require 'odata/walker.rb'
+require 'sequel'
+require 'rack_app'
+require 'odata_rack_builder'

data/lib/safrano_core.rb

@@ -0,0 +1,113 @@
+#!/usr/bin/env ruby
+
+# Type mapping DB --> Edm
+module OData
+  #  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.
+  def self.get_edm_type(db_type:)
+    case db_type
+    when 'INTEGER'
+      'Edm.Int32'
+    when 'TEXT', 'STRING'
+      'Edm.String'
+    else
+      'Edm.String' if /\ACHAR\s*\(\d+\)\z/ =~ db_type
+    end
+  end
+end
+
+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
+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
+    def initialize(arg, trans: nil)
+      @rgx = if arg.respond_to? :each_char
+               Regexp.new(arg)
+             else
+               arg
+             end
+      @trans = trans
+    end
+
+    def do_match(str)
+      @match_result = @rgx.match(str)
+    end
+
+    # this assumes some implicit rules in the way the regexps are built
+    def path_remain
+      @match_result[2] if @match_result && @match_result[2]
+    end
+
+    def path_done
+      if @match_result
+        @match_result[1] || ''
+      else
+        ''
+      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')
+  TransitionCount = Transition.new('(\A\/\$count)(.*)\z',
+                                   trans: 'transition_count')
+  attr_accessor :allowed_transitions
+end
+
+# for $count and number type attributes
+# class Fixnum  deprecated as of ruby 2.4+
+class Integer
+  def odata_get(_req)
+    [200, { 'Content-Type' => 'text/plain;charset=utf-8' }, to_s]
+  end
+end
+
+# for string type attributes
+class String
+  def odata_get(_req)
+    [200, { 'Content-Type' => 'text/plain;charset=utf-8' }, to_s]
+  end
+end
+
+# Final attribute value....
+class Object
+  def allowed_transitions
+    [Safrano::TransitionEnd]
+  end
+
+  def transition_end(_match_result)
+    [nil, :end]
+  end
+end

data/lib/service.rb

@@ -0,0 +1,573 @@
+#!/usr/bin/env ruby
+
+require 'rexml/document'
+require 'odata/relations.rb'
+require 'odata/batch.rb'
+require 'odata/error.rb'
+
+module OData
+  # this module has all methods related to expand/defered output preparation
+  # and will be included in Service class
+  module ExpandHandler
+    def get_deferred_odata_h(entity:, attrib:, uribase:)
+      { '__deferred' => { 'uri' => "#{entity.uri(uribase)}/#{attrib}" } }
+    end
+
+    def handle_entity_expand_one(entity:, exp_one:, nav_values_h:, nav_coll_h:,
+                                 uribase:)
+      if exp_one.include?('/')
+        m = %r{\A(\w+)\/?(.*)\z}.match(exp_one)
+        cur_exp = m[1].strip
+        rest_exp = m[2]
+        # TODO: check errorhandling
+        raise OData::ServerError if cur_exp.nil?
+
+        k = cur_exp.to_sym
+      else
+        k = exp_one.strip.to_sym
+        rest_exp = nil
+      end
+
+      if (enval = entity.nav_values[k])
+        nav_values_h[k.to_s] = get_entity_odata_h(entity: enval,
+                                                  expand: rest_exp,
+                                                  uribase: uribase)
+      elsif (encoll = entity.nav_coll[k])
+        # nav attributes that are a collection (x..n)
+        nav_coll_h[k.to_s] = encoll.map do |xe|
+          if xe
+            get_entity_odata_h(entity: xe, expand: rest_exp,
+                               uribase: uribase)
+          end
+        end
+      end
+    end
+
+    def handle_entity_expand(entity:, expand:, nav_values_h:,
+                             nav_coll_h:, uribase:)
+      expand.strip!
+      explist = expand.split(',')
+      # handle multiple expands
+      explist.each do |exp|
+        handle_entity_expand_one(entity: entity, exp_one: exp,
+                                 nav_values_h: nav_values_h,
+                                 nav_coll_h: nav_coll_h,
+                                 uribase: uribase)
+      end
+    end
+
+    def handle_entity_deferred_attribs(entity:, nav_values_h:,
+                                       nav_coll_h:, uribase:)
+      entity.nav_values.each_key do |ksy|
+        ks = ksy.to_s
+        next if nav_values_h.key?(ks)
+
+        nav_values_h[ks] = get_deferred_odata_h(entity: entity,
+                                                attrib: ks, uribase: uribase)
+      end
+      entity.nav_coll.each_key do |ksy|
+        ks = ksy.to_s
+        next if nav_coll_h.key?(ks)
+
+        nav_coll_h[ks] = get_deferred_odata_h(entity: entity, attrib: ks,
+                                              uribase: uribase)
+      end
+    end
+
+    def get_entity_odata_h(entity:, expand: nil, uribase:)
+      hres = {}
+      hres['__metadata'] = entity.metadata_h(uribase: uribase)
+      hres.merge!(entity.values)
+
+      nav_values_h = {}
+      nav_coll_h = {}
+
+      # handle expanded nav attributes
+      unless expand.nil?
+        handle_entity_expand(entity: entity, expand: expand,
+                             nav_values_h: nav_values_h,
+                             nav_coll_h: nav_coll_h,
+                             uribase: uribase)
+      end
+
+      # handle not expanded (deferred) nav attributes
+      # TODO: better design/perf
+      handle_entity_deferred_attribs(entity: entity,
+                                     nav_values_h: nav_values_h,
+                                     nav_coll_h: nav_coll_h,
+                                     uribase: uribase)
+      # merge  ...
+      hres.merge!(nav_values_h)
+      hres.merge!(nav_coll_h)
+
+      hres
+    end
+  end
+end
+
+module OData
+  # xml namespace constants needed for the output of XML service and
+  # and metadata
+  module XMLNS
+    MSFT_ADO = 'http://schemas.microsoft.com/ado'.freeze
+    MSFT_ADO_2009_EDM = "#{MSFT_ADO}/2009/11/edm".freeze
+    MSFT_ADO_2007_EDMX = "#{MSFT_ADO}/2007/06/edmx".freeze
+    MSFT_ADO_2007_META = MSFT_ADO + \
+                         '/2007/08/dataservices/metadata'.freeze
+
+    W3_2005_ATOM = 'http://www.w3.org/2005/Atom'.freeze
+    W3_2007_APP = 'http://www.w3.org/2007/app'.freeze
+  end
+end
+
+# Link to Model
+module OData
+  MAX_DATASERVICE_VERSION = '2'.freeze
+  MIN_DATASERVICE_VERSION = '1'.freeze
+  include XMLNS
+  # Base class for service. Subclass will be for V1, V2 etc...
+  class ServiceBase
+    XML_PREAMBLE = '<?xml version="1.0" encoding="utf-8" standalone="yes"?>' + \
+                   "\r\n".freeze
+
+    # This is just a hash of entity Set Names to the corresponding Class
+    # Example
+    # Book < Sequel::Model(:book)
+    #    @entity_set_name = 'books'
+    # end
+    # ---> @cmap ends up as   {'books' => Book }
+    attr_reader :cmap
+
+    # this is just the *sorted* list of the entity classes
+    # (ie... @cmap.values.sorted)
+    attr_accessor :collections
+
+    attr_accessor :xtitle
+    attr_accessor :xname
+    attr_accessor :xnamespace
+    attr_accessor :xpath_prefix
+    #    attr_accessor :xuribase
+    attr_accessor :meta
+    attr_accessor :batch_handler
+    attr_accessor :relman
+    # Instance attributes for specialized Version specific Instances
+    attr_accessor :v1
+    attr_accessor :v2
+
+    # TODO: more elegant design
+    attr_reader :data_service_version
+
+    def initialize(&block)
+      # Warning: if you add attributes here, you shall need add them
+      # in copy_attribs_to as well
+      #  because of the version subclasses that dont use "super" initialise
+      # (todo: why not??)
+      @meta = ServiceMeta.new(self)
+      @batch_handler = OData::Batch::DisabledHandler.new
+      @relman = OData::RelationManager.new
+      @cmap = {}
+      instance_eval(&block) if block_given?
+    end
+
+    DATASERVICEVERSION_RGX = /\A([1234])(?:\.0);*\w*\z/.freeze
+    # input is the       DataServiceVersion request header string, eg.
+    # '2.0;blabla' ---> Version -> 2
+    def self.parse_data_service_version(inp)
+      m = DATASERVICEVERSION_RGX.match(inp)
+      m[1] if m
+    end
+
+    def enable_batch
+      @batch_handler = OData::Batch::EnabledHandler.new
+      @v1.batch_handler = @batch_handler
+      @v2.batch_handler = @batch_handler
+    end
+
+    def enable_v1_service
+      @v1 = OData::ServiceV1.new
+      copy_attribs_to @v1
+    end
+
+    def enable_v2_service
+      @v2 = OData::ServiceV2.new
+      copy_attribs_to @v2
+    end
+
+    # public API
+    def name(nam)
+      @xname = nam
+    end
+
+    def namespace(namsp)
+      @xnamespace = namsp
+    end
+
+    def title(tit)
+      @xtitle = tit
+    end
+
+    def path_prefix(path_pr)
+      @xpath_prefix = path_pr.sub(%r{/\z}, '')
+    end
+    # end public API
+
+    def copy_attribs_to(other)
+      other.cmap = @cmap
+      other.collections = @collections
+      other.xtitle = @xtitle
+      other.xname = @xname
+      other.xnamespace = @xnamespace
+      #      other.xuribase = @xuribase
+      other.xpath_prefix = @xpath_prefix
+      other.meta = ServiceMeta.new(other) # hum ... #todo: versions as well ?
+      other.relman = @relman
+      other.batch_handler = @batch_handler
+      other
+    end
+
+    def register_model(modelklass, entity_set_name = nil)
+      # check that the provided klass is a Sequel Model
+      unless modelklass.is_a? Sequel::Model::ClassMethods
+        raise OData::API::ModelNameError, modelklass
+      end
+
+      if modelklass.primary_key.is_a?(Array)
+        modelklass.extend OData::EntityClassMultiPK
+        modelklass.include OData::EntityMultiPK
+      else
+        modelklass.extend OData::EntityClassSinglePK
+        modelklass.include OData::EntitySinglePK
+      end
+
+      modelklass.prepare_pk
+      modelklass.prepare_fields
+      esname = (entity_set_name || modelklass).to_s.freeze
+      modelklass.instance_eval { @entity_set_name = esname }
+      @cmap[esname] = modelklass
+      set_collections_sorted(@cmap.values)
+    end
+
+    def publish_model(modelklass, entity_set_name = nil, &block)
+      register_model(modelklass, entity_set_name)
+      # we need to execute the passed block in a deferred step
+      # after all models have been registered (due to rel. dependancies)
+      #      modelklass.instance_eval(&block) if block_given?
+      modelklass.deferred_iblock = block if block_given?
+    end
+
+    def cmap=(imap)
+      @cmap = imap
+      set_collections_sorted(@cmap.values)
+    end
+
+    # take care of sorting required to match longest first while parsing
+    # with     base_url_regexp
+    # example: CrewMember must be matched before Crew otherwise we get error
+    def set_collections_sorted(coll_data)
+      @collections = coll_data
+      if @collections
+        @collections.sort_by! { |klass| klass.entity_set_name.size }.reverse!
+      end
+      @collections
+    end
+
+    # to be called at end of publishing block to ensure we get the right names
+    # and additionally build the list of valid attribute path's used
+    # for validation of $orderby or $filter params
+    def finalize_publishing
+      # build the cmap
+      @cmap = {}
+      @collections.each do |klass|
+        @cmap[klass.entity_set_name] = klass
+      end
+
+      # now that we know all model klasses we can handle relationships
+      execute_deferred_iblocks
+
+      # and finally build the path list
+      @collections.each(&:build_attribute_path_list)
+    end
+
+    def execute_deferred_iblocks
+      @collections.each do |k|
+        k.instance_eval(&k.deferred_iblock) if k.deferred_iblock
+      end
+    end
+
+    ## Warning: base_url_regexp depends on '@collections', and this needs to be
+    ## evaluated after '@collections' is filled !
+    # A regexp matching all allowed base entities (eg product|categories )
+    def base_url_regexp
+      @collections.map(&:entity_set_name).join('|')
+    end
+
+    include Safrano
+    include ExpandHandler
+
+    def service
+      hres = {}
+      hres['d'] = { 'EntitySets' => @collections.map(&:type_name) }
+      hres
+    end
+
+    def service_xml(req)
+      doc = REXML::Document.new
+      # separator required ? ?
+      root = doc.add_element('service', 'xml:base' => req.uribase)
+
+      root.add_namespace('xmlns:atom', XMLNS::W3_2005_ATOM)
+      root.add_namespace('xmlns:app', XMLNS::W3_2007_APP)
+      # this generates the main xmlns attribute
+      root.add_namespace(XMLNS::W3_2007_APP)
+      wp = root.add_element 'workspace'
+
+      title = wp.add_element('atom:title')
+      title.text = @xtitle
+
+      @collections.each do |klass|
+        col = wp.add_element('collection', 'href' => klass.entity_set_name)
+        ct = col.add_element('atom:title')
+        ct.text = klass.type_name
+      end
+
+      XML_PREAMBLE + doc.to_pretty_xml
+    end
+
+    def metadata_xml(_req)
+      doc = REXML::Document.new
+      doc.add_element('edmx:Edmx', 'Version' => '1.0')
+      doc.root.add_namespace('xmlns:edmx', XMLNS::MSFT_ADO_2007_EDMX)
+      serv = doc.root.add_element('edmx:DataServices',
+                                  'm:DataServiceVersion' => '1.0')
+      # 'm:DataServiceVersion' => "#{self.dataServiceVersion}" )
+      # DataServiceVersion: This attribute MUST be in the data service
+      # metadata namespace
+      # (http://schemas.microsoft.com/ado/2007/08/dataservices) and SHOULD
+      # be present on an
+      # edmx:DataServices element [MC-EDMX] to indicate the version of the
+      # data service CSDL
+      # annotations (attributes in the data service metadata namespace) that
+      # are used by the document.
+      # Consumers of a data-service metadata endpoint ought to first read this
+      # attribute value to determine if
+      # they can safely interpret all constructs within the document. The
+      # value of this attribute MUST be 1.0
+      # unless a "FC_KeepInContent" customizable feed annotation
+      # (section 2.2.3.7.2.1) with a value equal to
+      # false is present in the CSDL document within the edmx:DataServices
+      # node. In this case, the
+      # attribute value MUST be 2.0 or greater.
+      # In the absence of DataServiceVersion, consumers of the CSDL document
+      # can assume the highest DataServiceVersion they can handle.
+      serv.add_namespace('xmlns:m', XMLNS::MSFT_ADO_2007_META)
+
+      schema = serv.add_element('Schema',
+                                'Namespace' => @xnamespace,
+                                'xmlns' => XMLNS::MSFT_ADO_2009_EDM)
+      @collections.each do |klass|
+        # 1. all EntityType
+        enty = schema.add_element('EntityType', 'Name' => klass.to_s)
+        # with their properties
+        klass.db_schema.each do |pnam, prop|
+          if prop[:primary_key] == true
+            enty.add_element('Key').add_element('PropertyRef',
+                                                'Name' => pnam.to_s)
+          end
+          #  attrs = {'Name'=>pnam.to_s,
+          #           'Type'=>OData::TypeMap[ prop[:db_type] ]}
+          attrs = { 'Name' => pnam.to_s,
+                    'Type' => OData.get_edm_type(db_type: prop[:db_type]) }
+          attrs['Nullable'] = 'false' if prop[:allow_null] == false
+          enty.add_element('Property', attrs)
+        end
+        # and their Nav attributes == Sequel Model association
+        klass.associations.each do |assoc|
+          # associated objects need to be in the map...
+          next unless @cmap[assoc.to_s]
+
+          from = klass.type_name
+          to = @cmap[assoc.to_s].type_name
+
+          rel = @relman.get([from, to])
+
+          # use Sequel reflection to get multiplicity (will be used later
+          # in 2. Associations below)
+          reflect = klass.association_reflection(assoc)
+          case reflect[: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"/>
+
+          nattrs = { 'Name' => to,
+                     'Relationship' => "#{@xnamespace}.#{rel.name}",
+                     'FromRole' => from,
+                     'ToRole' => to }
+          enty.add_element('NavigationProperty', nattrs)
+        end
+      end
+      # 2. Associations
+      @relman.each_rel do |rel|
+        assoc = schema.add_element('Association', 'Name' => rel.name)
+
+        rel.each_endobj do |eo|
+          assoend = { 'Type' => "#{@xnamespace}.#{eo}",
+                      'Role' => eo,
+                      'Multiplicity' => rel.multiplicity[eo] }
+
+          assoc.add_element('End', assoend)
+        end
+      end
+
+      # 3. Enty container
+      ec = schema.add_element('EntityContainer',
+                              'Name' => @xname,
+                              'm:IsDefaultEntityContainer' => 'true')
+      @collections.each do |klass|
+        # 3.a Entity set's
+        ec.add_element('EntitySet',
+                       'Name' => klass.entity_set_name,
+                       'EntityType' => "#{@xnamespace}.#{klass.type_name}")
+      end
+      # 3.b Association set's
+      @relman.each_rel do |rel|
+        assoc = ec.add_element('AssociationSet',
+                               'Name' => rel.name,
+                               'Association' => "#{@xnamespace}.#{rel.name}")
+
+        rel.each_endobj do |eo|
+          clazz = Object.const_get(eo)
+          assoend = { 'EntitySet' => clazz.entity_set_name.to_s, 'Role' => eo }
+          assoc.add_element('End', assoend)
+        end
+      end
+      XML_PREAMBLE + doc.to_pretty_xml
+    end
+
+    # methods related to transitions to next state (cf. walker)
+    module Transitions
+      def allowed_transitions
+        @allowed_transitions = [
+          Safrano::TransitionEnd,
+          Safrano::TransitionMetadata,
+          Safrano::TransitionBatch,
+          Safrano::Transition.new(%r{\A/(#{base_url_regexp})(.*)},
+                                  trans: 'transition_collection')
+        ]
+      end
+
+      def transition_collection(match_result)
+        [@cmap[match_result[1]], :run] if match_result[1]
+      end
+
+      def transition_batch(_match_result)
+        [@batch_handler, :run]
+      end
+
+      def transition_metadata(_match_result)
+        [@meta, :run]
+      end
+
+      def transition_end(_match_result)
+        [nil, :end]
+      end
+    end
+
+    include Transitions
+
+    def odata_get(req)
+      if req.accept?('application/xml')
+        #  app.headers  'Content-Type' => 'application/xml;charset=utf-8'
+        # Doc: 2.2.3.7.1 Service Document  As per [RFC5023], AtomPub Service
+        # Documents MUST be
+        # identified with the "application/atomsvc+xml" media type (see
+        # [RFC5023] section 8).
+        [200, { 'Content-Type' => 'application/atomsvc+xml;charset=utf-8' },
+         service_xml(req)]
+      else
+        # TODO: other formats ?
+        # this is returned by http://services.odata.org/V2/OData/OData.svc
+        415
+      end
+    end
+  end
+
+  # for OData V1
+  class ServiceV1 < ServiceBase
+    def initialize
+      @data_service_version = '1.0'
+    end
+
+    def get_coll_odata_h(array:, expand: nil, uribase:)
+      array.map do |w|
+        get_entity_odata_h(entity: w,
+                           expand: expand,
+                           uribase: uribase)
+      end
+    end
+
+    def get_emptycoll_odata_h
+      [{}]
+    end
+  end
+
+  # for OData V2
+  class ServiceV2 < ServiceBase
+    def initialize
+      @data_service_version = '2.0'
+    end
+
+    def get_coll_odata_h(array:, expand: nil, uribase:)
+      { 'results' =>
+          array.map do |w|
+            get_entity_odata_h(entity: w,
+                               expand: expand,
+                               uribase: uribase)
+          end }
+    end
+
+    def get_emptycoll_odata_h
+      { 'results' => [{}] }
+    end
+  end
+
+  # a virtual entity for the service metadata
+  class ServiceMeta
+    attr_accessor :service
+    def initialize(service)
+      @service = service
+    end
+
+    def allowed_transitions
+      @allowed_transitions = [Safrano::Transition.new('',
+                                                      trans: 'transition_end')]
+    end
+
+    def transition_end(_match_result)
+      [nil, :end]
+    end
+
+    def odata_get(req)
+      if req.accept?('application/xml')
+        [200, { 'Content-Type' => 'application/xml;charset=utf-8' },
+         @service.metadata_xml(req)]
+      else # TODO: other formats
+        415
+      end
+    end
+  end
+end
+# end of Module OData

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: safrano
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- D.M.
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-04-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.15'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.51'
+description: Safrano is a small experimental OData server framework based on Ruby,
+  Rack and Sequel.
+email: dm@0data.dev
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/odata_rack_builder.rb
+- lib/rack_app.rb
+- lib/request.rb
+- lib/response.rb
+- lib/safrano.rb
+- lib/safrano_core.rb
+- lib/service.rb
+homepage: https://gitlab.com/dm0da/safrano
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Safrano
+test_files: []