safrano 0.0.1 → 0.0.2

data/lib/odata/entity.rb

@@ -0,0 +1,267 @@
+#!/usr/bin/env ruby
+# !/usr/bin/env ruby
+
+require 'json'
+require 'pp'
+require 'rexml/document'
+require 'safrano.rb'
+require 'odata/collection.rb' # required for  self.class.entity_type_name ??
+
+module OData
+  # this will be mixed in the  Model classes (subclasses of Sequel Model)
+  module Entity
+    attr_reader :params
+    attr_reader :uribase
+
+    # methods related to transitions to next state (cf. walker)
+    module Transitions
+      def allowed_transitions
+        aurgx = self.class.attribute_url_regexp
+        alltr = [
+          Safrano::TransitionEnd,
+          Safrano::TransitionCount,
+          Safrano::Transition.new(%r{\A/(#{aurgx})(.*)\z},
+                                  trans: 'transition_attribute')
+        ]
+        if (ncurgx = self.class.nav_collection_url_regexp)
+          alltr <<
+            Safrano::Transition.new(%r{\A/(#{ncurgx})(.*)\z},
+                                    trans: 'transition_nav_collection')
+
+        end
+        if (neurgx = self.class.nav_entity_url_regexp)
+          alltr <<
+            Safrano::Transition.new(%r{\A/(#{neurgx})(.*)\z},
+                                    trans: 'transition_nav_entity')
+        end
+        alltr
+      end
+
+      def transition_end(_match_result)
+        [nil, :end]
+      end
+
+      def transition_count(_match_result)
+        [self, :end]
+      end
+
+      def transition_attribute(match_result)
+        attrib = match_result[1]
+        [values[attrib.to_sym], :run]
+      end
+
+      def transition_nav_collection(match_result)
+        attrib = match_result[1]
+        [get_related(attrib), :run]
+        #        attr_klass = self.class.nav_collection_attribs[attrib].to_s
+        #        [get_related(attr_klass), :run]
+      end
+
+      def transition_nav_entity(match_result)
+        attrib = match_result[1]
+        [get_related_entity(attrib), :run]
+      end
+    end
+
+    include Transitions
+
+    def nav_values
+      @nav_values = {}
+
+      if self.class.nav_entity_attribs
+        self.class.nav_entity_attribs.each_key do |na_str|
+          @nav_values[na_str.to_sym] = send(na_str)
+        end
+      end
+      @nav_values
+    end
+
+    def nav_coll
+      @nav_coll = {}
+      if self.class.nav_collection_attribs
+        self.class.nav_collection_attribs.each_key do |nc_str|
+          @nav_coll[nc_str.to_sym] = send(nc_str)
+        end
+      end
+      @nav_coll
+    end
+
+    def uri_path
+      kla = self.class
+      "#{kla.entity_set_name}(#{pk_uri})"
+    end
+
+    def uri(uriba)
+      "#{uriba}/#{uri_path}"
+    end
+
+    # Json formatter for a single entity (probably OData V1/V2 like)
+    def to_odata_json(service:)
+      { 'd' => service.get_entity_odata_h(entity: self,
+                                          expand: @params['$expand'],
+                                          uribase: @uribase) }.to_json
+    end
+
+    # post paylod expects the new entity in an array
+    def to_odata_post_json(service:)
+      { 'd' => service.get_coll_odata_h(array: [self],
+                                        uribase: @uribase) }.to_json
+    end
+
+    def type_name
+      self.class.type_name
+    end
+
+    # metadata for json h
+    def metadata_h(uribase:)
+      {   uri: uri(uribase),
+          type: type_name }
+    end
+
+    # Finally Process REST verbs...
+    def odata_get(req)
+      @params = req.params
+      @uribase = req.uribase
+      if req.accept?('application/json')
+        [200, { 'Content-Type' => 'application/json;charset=utf-8' },
+         to_odata_json(service: req.service)]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    def odata_delete(req)
+      if req.accept?('application/json')
+        delete
+        [200, { 'Content-Type' => 'application/json;charset=utf-8' },
+         { 'd' => req.service.get_emptycoll_odata_h }.to_json]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    def odata_post(req)
+      # TODO: check Request body format...
+      data = JSON.parse(req.body.read)['d']
+      @uribase = req.uribase
+
+      if req.accept?('application/json')
+        data.delete('__metadata')
+
+        update_fields(data, self.class.data_fields, missing: :skip)
+
+        [202, to_odata_post_json(service: req.service)]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    def odata_patch(req)
+      # TODO: check Request body format...
+
+      data = JSON.parse(req.body.read)['d']
+      @uribase = req.uribase
+
+      if req.accept?('application/json')
+        data.delete('__metadata')
+        update_fields(data, self.class.data_fields, missing: :skip)
+        # patch should return 204 + no content
+        [204, []]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    # redefinitions of the main methods for a navigated collection
+    # (eg. all Books of Author[2]  is Author[2].Books.all )
+    module NavigationRedefinitions
+      def all
+        @child_method.call
+      end
+
+      def count
+        @child_method.call.count
+      end
+
+      # TODO: fix design
+      def navigated_coll
+        true
+      end
+
+      def navigated_dataset
+        @child_dataset_method.call
+      end
+
+      # TODO: this is designed by my left foot. maybe my right one can do better
+      # at least it does what it should (testunit passed)
+      def [](*args)
+        y = @child_method.call
+        return nil unless (found = super(args))
+
+        #        y.find { |e| e.pk_val == found.pk_val }
+        y.find { |e| e.values == found.values }
+      end
+
+      def each
+        y = @child_method.call
+        y.each { |enty| yield enty }
+      end
+
+      def to_a
+        y = @child_method.call
+        y.to_a
+      end
+    end
+    # GetRelated that returns a anonymous Class (ie. representing a collection)
+    # subtype of the related object Class  ( childklass )
+    # (...to_many relationship )
+    def get_related(childattrib)
+      parent = self
+      childklass = self.class.nav_collection_attribs[childattrib]
+      Class.new(childklass) do
+        # this makes use of Sequel's Model relationships; eg this is
+        # 'Race[12].Edition'
+        # where Race[12] would be our self and 'Edition' is the
+        # childattrib(collection)
+        @child_method = parent.method(childattrib.to_sym)
+        @child_dataset_method = parent.method("#{childattrib}_dataset".to_sym)
+        prepare_pk
+        prepare_fields
+        # Now in this anonymous Class we can refine the "all, count and []
+        # methods, to take into account the relationship
+        extend NavigationRedefinitions
+      end
+    end
+
+    # GetRelatedEntity that returns an single related Entity
+    # (...to_one relationship )
+    def get_related_entity(childattrib)
+      # this makes use of Sequel's Model relationships; eg this is
+      # 'Race[12].RaceType'
+      # where Race[12] would be our self and 'RaceType' is the single
+      # childattrib entity
+      child_method = method(childattrib.to_sym)
+      child_method.call
+    end
+  end
+  # end of module ODataEntity
+
+  # for a single public key
+  module EntitySinglePK
+    include Entity
+    def pk_uri
+      pk
+    end
+  end
+
+  # for multiple key
+  module EntityMultiPK
+    include Entity
+    def pk_uri
+      #     self.class.primary_key is provided by Sequel as
+      # array of symbols
+      self.class.primary_key.map { |pk| "#{pk}='#{values[pk]}'" }.join(',')
+    end
+  end
+end
+# end of Module OData

data/lib/odata/error.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'pp'
+require 'rexml/document'
+require 'safrano.rb'
+
+# Error handling
+module OData
+  # 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)
+      end
+    end
+    # when published association was not defined on Sequel level
+    class ModelAssociationNameError < NameError
+      def initialize(klass, symb)
+        symbname = symb.to_s
+        msg = "There is no association :#{symbname} defined in class #{klass}"
+        super(msg, symbname)
+      end
+    end
+  end
+
+  # base module for HTTP errors
+  module Error
+    def odata_get(req)
+      if req.accept?('application/json')
+        [const_get(:HTTP_CODE),
+         { 'Content-Type' => 'application/json;charset=utf-8' },
+         { 'odata.error' => { 'code' => '', 'message' => @msg } }.to_json]
+      else
+        [const_get(:HTTP_CODE),
+         { 'Content-Type' => 'text/plain;charset=utf-8' }, @msg]
+      end
+    end
+  end
+  # http Bad Req.
+  class BadRequestError
+    extend  Error
+    HTTP_CODE = 400
+    @msg = 'Bad Request Error'
+  end
+  # for Syntax error in Filtering
+  class BadRequestFilterParseError < BadRequestError
+    HTTP_CODE = 400
+    @msg = 'Bad Request: Syntax error in Filter'
+  end
+  # http not found
+  class ErrorNotFound
+    extend  Error
+    HTTP_CODE = 404
+    @msg = 'The requested ressource was not found'
+  end
+  # Transition error (Safrano specific)
+  class ServerTransitionError
+    extend  Error
+    HTTP_CODE = 500
+    @msg = 'Server error: Segment could not be parsed'
+  end
+  # generic http 500 server err
+  class ServerError
+    extend  Error
+    HTTP_CODE = 500
+    @msg = 'Server error'
+  end
+  # not implemented (Safrano specific)
+  class NotImplementedError
+    extend  Error
+    HTTP_CODE = 501
+  end
+  # batch not implemented (Safrano specific)
+  class BatchNotImplementedError
+    extend  Error
+    HTTP_CODE = 501
+    @msg = 'Not implemented: OData batch'
+  end
+  # error in filter parsing (Safrano specific)
+  class FilterParseError < BadRequestError
+    extend  Error
+    HTTP_CODE = 400
+  end
+end

data/lib/odata/relations.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+
+require 'set'
+require 'pp'
+
+# OData relation related classes/module
+module OData
+  # we represent a relation as a Set (unordered) of two end elements
+  class Relation < Set
+    #    attr_reader :rid
+    attr_accessor :multiplicity
+
+    def initialize(arg)
+      super(arg)
+      @multiplicity = {}
+    end
+
+    def sa
+      sort
+    end
+
+    # we need a from/to order independant ID
+    def rid
+      OData::RelationManager.build_id(self)
+    end
+
+    # we need a from/to order independant OData like name
+    def name
+      x = sa.map(&:to_s)
+      y = x.reverse
+      [x.join('_'), y.join('_')].join('_')
+    end
+
+    def each_endobj
+      tmp = to_a.sort
+      yield tmp.first
+      yield tmp.last
+    end
+
+    def set_multiplicity(obj, mult)
+      ms = mult.to_s
+      raise ArgumentError unless include?(obj)
+
+      case ms
+      when '1', '*', '0..1'
+        @multiplicity[obj] = ms
+      else
+        raise ArgumentError
+      end
+    end
+  end
+
+  # some usefull stuff
+  class RelationManager
+    def initialize
+      @list = {}
+    end
+
+    def self.build_id(arg)
+      arg.sort.map(&:to_s).join('_')
+    end
+
+    def each_rel
+      raise ArgumentError unless block_given?
+
+      @list.each { |_rid, rel| yield rel }
+    end
+
+    def get(arg)
+      rid = OData::RelationManager.build_id(arg)
+      if @list.key?(rid)
+        @list[rid]
+      else
+        rel = OData::Relation.new(arg)
+        @list[rid] = rel
+      end
+    end
+  end
+end

data/lib/odata/walker.rb

@@ -0,0 +1,100 @@
+#!/usr/bin/env ruby
+
+require 'json'
+require 'pp'
+require 'rexml/document'
+require 'safrano.rb'
+
+module OData
+  # handle navigation in the Datamodel tree of entities/attributes
+  # input is the url path. Url parameters ($filter etc...) are NOT handled here
+  # This uses a state transition algorithm
+  class Walker
+    attr_accessor :contexts
+    attr_accessor :context
+    attr_accessor :end_context
+    attr_reader   :path_start
+    attr_accessor :path_remain
+    attr_accessor :path_done
+    attr_accessor :status
+    attr_accessor :error
+
+    # is $count requested?
+    attr_accessor :do_count
+
+    def initialize(service, path)
+      path = URI.decode_www_form_component(path)
+      @context = service
+      @contexts = [@context]
+      @path_start = @path_remain = if service
+                                     unprefixed(service.xpath_prefix, path)
+                                   else # This is for batch function
+                                     path
+                                   end
+      @path_done = ''
+      @status = :start
+      @end_context = nil
+      @do_count = nil
+      eo
+    end
+
+    def unprefixed(prefix, path)
+      if (prefix == '') || (prefix == '/')
+        path
+      else
+        path.sub!(/\A#{prefix}/, '')
+      end
+    end
+
+    def get_next_transition
+      # this does not work if there are multiple valid transitions
+      # like when we have attributes that are substring of each other
+      # --> instead of using detect (ie take first transition)
+      # we need to use select and then find the longest match
+      #        tr_next = @context.allowed_transitions.detect do |t|
+      #          t.do_match(@path_remain)
+      #        end
+
+      valid_tr = @context.allowed_transitions.select do |t|
+        t.do_match(@path_remain)
+      end
+      # this is a very fragile and obscure but required hack (wanted: a
+      # better one) to make attributes that are substrings of each other
+      # work well
+      @tr_next = if valid_tr
+                   if valid_tr.size == 1
+                     valid_tr.first
+                   elsif valid_tr.size > 1
+                     valid_tr.max_by { |t| t.match_result[1].size }
+                   end
+                 end
+    end
+
+    def eo
+      while @context
+        get_next_transition
+        if @tr_next
+          @context, @status, @error = @tr_next.do_transition(@context)
+          @contexts << @context
+          @path_remain = @tr_next.path_remain
+          @path_done << @tr_next.path_done
+          # little hack
+          if @status == :end_with_count
+            @do_count = true
+            @status == :end
+          end
+        else
+          @context = nil
+          @status = :error
+          #          @error = OData::ServerError
+          @error = OData::ErrorNotFound
+        end
+
+      end
+      # TODO: shouldnt we raise an error here if @status != :end ?
+      return false unless @status == :end
+
+      @end_context = @contexts.size >= 2 ? @contexts[-2] : @contexts[1]
+    end
+  end
+end