safrano 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 49dc75cf9bfcdff0a03b38eaada7f0a968a09ab3777327f0c893f8f39fd32d8f
-  data.tar.gz: 7103e882037de0e6c89d368ec25cb0f6c6b9ed4be7fc8dff9aa64d0a6107a29d
+  metadata.gz: d62d07c9e0df09819503c296c06aad10d160915649158c3e8aff15368880e2a4
+  data.tar.gz: 9666f85a2826483709ed963fe6a48fef768b5fe78c3adef504d2b8c412f86703
 SHA512:
-  metadata.gz: e7dbd2370716c6e5f323c9fff63394053521f70af27ee613a288e7ca089071818844a09dc4e400cba4fcd0e227e4c7d38b5d07d2e887aa33553cf8ea57a1e5ec
-  data.tar.gz: 94b84b19d4d7273a0aef7c4a52348e4e77340f95cf64792e6f47dc1cde8e06ae675ee3bc5cd87d8c58e8e8098b914b24bb4e38818f96f75fd2116f32ae6e0d8b
+  metadata.gz: c8f61683c7bbdb3f8f45aa70e760d60b02e7acfca8ee6027d869f33f5fa16b475d85a04b549f132506e7653b064658947f8b6e8cdc2bdc1dea8fb992699e0155
+  data.tar.gz: 682bc1b1bba6e68c3f2855f6242aa3119883bbf1baacab74e90ee4671d5e827508eaad1d55eda9f596bcedfdeff5953a5c0e09599c094bd53b1d5e6dcfa2ffa9

data/lib/odata/batch.rb

@@ -0,0 +1,190 @@
+#!/usr/bin/env ruby
+
+require 'rack_app.rb'
+require 'safrano_core.rb'
+
+module OData
+  module Batch
+    # Mayonaise
+    class MyOApp < OData::ServerApp
+      attr_writer :full_req
+
+      def batch_call(env)
+        @request = OData::Request.new(env)
+        @response = OData::Response.new
+
+        dispatch
+
+        @response.finish
+      end
+
+      def batch_body
+        b = ''
+        @response.headers.each { |k, v| b << k.to_s << ':' << v.to_s << "\r\n" }
+        b << "\r\n"
+        b << @response.body[0].to_s
+        b << "\r\n"
+      end
+    end
+
+    # Moutarde
+    class RequestPartBuilder
+      attr_accessor :body_str
+      attr_accessor :odata_headers
+      attr_accessor :headers
+      attr_accessor :http_method
+      attr_accessor :uri
+      attr_accessor :env
+      def initialize
+        @headers = {}
+        @odata_headers = {}
+        @body_str = ''
+      end
+
+      # shamelessely copied from Rack::TEST:Session
+      def headers_for_env
+        converted_headers = {}
+
+        @headers.each do |name, value|
+          env_key = name.upcase.tr('-', '_')
+          env_key = 'HTTP_' + env_key unless env_key == 'CONTENT_TYPE'
+          converted_headers[env_key] = value
+        end
+
+        converted_headers
+      end
+
+      def batch_env
+        @env = ::Rack::MockRequest.env_for(@uri,
+                                           method: @http_method,
+                                           input: @body_str)
+        @env.merge! headers_for_env
+        @env
+      end
+    end
+    # Huile d'olive extra
+    class HandlerBase
+      TREND = Safrano::Transition.new('', trans: 'transition_end')
+      def allowed_transitions
+        @allowed_transitions = [TREND]
+      end
+
+      def transition_end(_match_result)
+        [nil, :end]
+      end
+    end
+    # jaune d'oeuf
+    class DisabledHandler < HandlerBase
+      def odata_post(_req)
+        [404, {}, '$batch is not enabled ']
+      end
+
+      def odata_get(_req)
+        [404, {}, '$batch is not enabled ']
+      end
+    end
+    # battre le tout
+    class EnabledHandler < HandlerBase
+      HTTP_VERB_URI_REGEXP = /^(POST|GET|PUT|PATCH)\s+(\S*)\s?(\S*)$/.freeze
+      HEADER_REGEXP = %r{^([a-zA-Z\-]+):\s*([0-9a-zA-Z\-\/]+;?\S*)\s*$}.freeze
+      attr_accessor :boundary
+      attr_accessor :mmboundary
+      attr_accessor :body_str
+      attr_accessor :parts
+      attr_accessor :request
+
+      def initialize
+        @parts = []
+      end
+
+      def odata_post(req)
+        odata_batch(req)
+      end
+
+      def odata_get(_req)
+        [405, {}, 'You cant GET $batch, POST it ']
+      end
+
+      def odata_batch(req)
+        @request = req
+        if @request.media_type == 'multipart/mixed'
+          read
+          parse
+          [202,
+           { 'Content-Type' => "multipart/mixed;boundary=#{@boundary}" },
+           process_parts]
+        else
+          [415, {}, 'Unsupported Media Type']
+        end
+      end
+
+      def read
+        @body_str = @request.body.read
+        @boundary = @request.media_type_params['boundary']
+        @mmboundary = '--' << @boundary
+      end
+
+      def parse
+        body_str.split(@mmboundary).each do |p|
+          @parts << parse_part(p) unless (p == '--\n') || p == '--' || p.empty?
+        end
+      end
+
+      # Ultrasimplified parser...
+      def parse_part(inp)
+        state = :start
+        part = RequestPartBuilder.new
+        inp.each_line do |l|
+          next if l.strip.empty?
+
+          case state
+          when :start, :ohd
+            md = l.strip.match(HEADER_REGEXP)
+
+            if md
+              state = :ohd
+              part.odata_headers[md[1]] = md[2]
+            else
+              md = l.strip.match(HTTP_VERB_URI_REGEXP)
+              if md
+                state = :hd
+                part.http_method = md[1]
+                part.uri = md[2]
+              end
+            end
+          when :hd
+            md = l.strip.match(HEADER_REGEXP)
+            if md
+              state = :hd
+              part.headers[md[1]] = md[2]
+            else
+              part.body_str << l
+              state = :bd
+            end
+
+          when :bd
+            part.body_str << l
+          end
+        end
+        part
+      end
+
+      def process_parts
+        full_batch_body = ''
+        @parts.each do |p|
+          next unless p.uri
+
+          batcha = MyOApp.new
+
+          batcha.full_req = @request
+
+          batcha.batch_call(p.batch_env)
+
+          full_batch_body << @mmboundary << "\r\n"
+          full_batch_body << batcha.batch_body
+        end
+        full_batch_body << @mmboundary << "--\r\n"
+      end
+    end
+  end
+end

data/lib/odata/collection.rb

@@ -0,0 +1,408 @@
+#!/usr/bin/env ruby
+# Design: Collections are nothing more as Sequel based model classes that have
+# somehow the character of an array (Enumerable)
+# Thus Below we have called that "EntityClass". It's meant as "Collection"
+
+require 'json'
+require 'pp'
+require 'pry'
+require 'rexml/document'
+require 'safrano_core.rb'
+require 'odata/error.rb'
+require 'odata/collection_filter.rb'
+require 'odata/collection_order.rb'
+
+# small helper method
+# http://stackoverflow.com/
+#        questions/24980295/strictly-convert-string-to-integer-or-nil
+def number_or_nil(str)
+  num = str.to_i
+  num if num.to_s == str
+end
+
+# another helper
+# thanks https://stackoverflow.com/questions/1448670/ruby-stringto-class
+class String
+  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
+
+module OData
+  # class methods. They Make heavy use of Sequel::Model functionality
+  # we will add this to our Model classes with "extend" --> self is the Class
+  module EntityClassBase
+    attr_reader :nav_collection_url_regexp
+    attr_reader :nav_entity_url_regexp
+    attr_reader :entity_id_url_regexp
+    attr_reader :attrib_paths_url_regexp
+    attr_reader :nav_collection_attribs
+    attr_reader :nav_entity_attribs
+    attr_reader :data_fields
+
+    attr_accessor :namespace
+
+    # dataset
+    attr_accessor :cx
+
+    # array of the objects --> dataset.to_a
+    attr_accessor :ax
+
+    # url params
+    attr_reader :params
+
+    # initialising block of code to be executed at end of
+    # ServerApp.publish_service after all model classes have been registered
+    # (without the associations/relationships)
+    # typically the block should contain the publication of the associations
+    attr_accessor :deferred_iblock
+
+    # convention: entityType is the Ruby Model class --> name is just to_s
+    def type_name
+      to_s
+    end
+
+    # convention: default for entity_set_name is the model table name
+    def entity_set_name
+      @entity_set_name = (@entity_set_name || table_name.to_s)
+    end
+
+    def execute_deferred_iblock
+      instance_eval { @deferred_iblock.call } if @deferred_iblock
+    end
+
+    # Factory json-> Model Object instance
+    def new_from_hson_h(hash)
+      enty = new
+      hash.delete('__metadata')
+      # DONE: move this somewhere else where it's evaluated only once at setup
+      #data_fields = db_schema.map do |col, cattr|
+      #  cattr[:primary_key] ? nil : col
+      #end.select { |col| col }
+      enty.set_fields(hash, @data_fields, missing: :skip)
+      enty.save
+      enty
+    end
+
+    def odata_get_apply_filter_w_sequel
+      return unless @params['$filter']
+
+      # Sequel requires a dataset to build some sql expressions, so we
+      # need to pass one todo: use a dummy one ?
+      #      @fi = Filter.new_by_parse(@params['$filter'], @cx)
+      return if @fi.parse_error?
+
+      @cx = @fi.apply_to_dataset(@cx)
+      @right_assocs.merge @fi.assocs
+    end
+
+    def odata_get_apply_order_w_sequel
+      return unless @params['$orderby']
+
+      fo = Order.new_by_parse(@params['$orderby'], @cx)
+      @cx = fo.apply_to_dataset(@cx)
+      @left_assocs.merge fo.assocs
+    end
+
+    def odata_get_do_assoc_joins_w_sequel
+      return if @right_assocs.empty? && @left_assocs.empty?
+
+      # Preparation: ensure that the left and right assocs sets are disjoint
+      # by keeping the duplicates in the left assoc set and removing
+      # them from the right assocs set. We can use Set difference...
+      @right_assocs -= @left_assocs
+
+      # this is for the filtering. Normally we can use inner join
+      @right_assocs.each { |aj| @cx = @cx.association_join(aj) }
+      # this is for the ordering.
+      # we need left join otherwise we could miss records sometimes
+      @left_assocs.each { |aj| @cx = @cx.association_left_join(aj) }
+      @cx = @cx.select_all(entity_set_name.to_sym)
+    end
+
+    def odata_get_apply_params_w_sequel
+      @left_assocs = Set.new
+      @right_assocs = Set.new
+      odata_get_apply_filter_w_sequel
+      odata_get_apply_order_w_sequel
+      odata_get_do_assoc_joins_w_sequel
+
+      @cx = @cx.offset(@params['$skip']) if @params['$skip']
+      @cx = @cx.limit(@params['$top']) if @params['$top']
+      @cx
+    end
+
+    def navigated_coll
+      false
+    end
+
+    def odata_get_apply_params
+      odata_get_apply_params_w_sequel
+    end
+
+    # 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_u_p_top
+      return unless @params['$top']
+
+      itop = number_or_nil(@params['$top'])
+      return BadRequestError if itop.nil? || itop.zero?
+    end
+
+    def check_u_p_skip
+      return unless @params['$skip']
+
+      iskip = number_or_nil(@params['$skip'])
+      return BadRequestError if iskip.nil? || (iskip < 0)
+    end
+
+    def check_u_p_filter
+      return unless @params['$filter']
+
+      # Sequel requires a dataset to build some sql expressions, so we
+      # need to pass one todo: use a dummy one ?
+      @fi = Filter.new_by_parse(@params['$filter'], @cx)
+      return BadRequestFilterParseError if @fi.parse_error?
+
+      # nil is the expected return for no errors
+      nil
+    end
+
+    def check_u_p_orderby
+      # TODO: this should be moved into OData::Order somehow, at least partly
+      return unless (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 @attribute_path_list.include? qualfn
+        return BadRequestError unless [nil, 'asc', 'desc'].include? dir
+      end
+      # nil is the expected return for no errors
+      nil
+    end
+
+    def build_attribute_path_list
+      @attribute_path_list = attribute_path_list
+      @attrib_paths_url_regexp = @attribute_path_list.join('|')
+    end
+
+    def attribute_path_list(nodes = Set.new)
+      # break circles
+      return [] if nodes.include?(entity_set_name)
+
+      ret = @columns.map(&:to_s)
+      nodes.add entity_set_name
+      if @nav_entity_attribs
+        @nav_entity_attribs.each do |a, k|
+          ret.concat(k.attribute_path_list(nodes).map { |kc| "#{a}/#{kc}" })
+        end
+      end
+      if @nav_collection_attribs
+        @nav_collection_attribs.each do |a, k|
+          ret.concat(k.attribute_path_list(nodes).map { |kc| "#{a}/#{kc}" })
+        end
+      end
+      ret
+    end
+
+    def check_url_params
+      return nil unless @params
+
+      check_u_p_top || check_u_p_skip || check_u_p_orderby || check_u_p_filter
+    end
+
+    def initialize_dataset
+      # initialize dataset
+      @cx = self
+      @ax = nil
+      @cx = navigated_dataset if @cx.navigated_coll
+    end
+
+    # on model class level we return the collection
+    def odata_get(req)
+      @params = req.params
+      @uribase = req.uribase
+      initialize_dataset
+
+      if (perr = check_url_params)
+        perr.odata_get(req)
+      else
+        odata_get_apply_params
+        if req.walker.do_count
+          [200, { 'Content-Type' => 'text/plain;charset=utf-8' },
+           @cx.count.to_s]
+        elsif req.accept?('application/json')
+          [200, { 'Content-Type' => 'application/json;charset=utf-8' },
+           to_odata_json(service: req.service)]
+        else # TODO: other formats
+          406
+        end
+      end
+    end
+
+    def to_odata_json(service:)
+      expand = @params['$expand']
+      { 'd' => service.get_coll_odata_h(array: get_a,
+                                        expand: expand,
+                                        uribase: @uribase) }.to_json
+    end
+
+    def get_a
+      @ax.nil? ? @cx.to_a : @ax
+    end
+
+    def odata_post(req)
+      # TODO: check Request body format...
+      # TODO: this is for v2 only...
+      data = JSON.parse(req.body.read)['d']
+      if req.accept?('application/json')
+        [201, { 'Content-Type' => 'application/json;charset=utf-8' },
+         new_from_hson_h(data).to_odata_post_json(service: req.service)]
+      else # TODO: other formats
+        415
+      end
+    end
+
+    # this functionally similar to the Sequel Rels (many_to_one etc)
+    # We need to base this on the Sequel rels, or extend them
+    def add_nav_prop_collection(assoc_symb, attr_name_str = nil)
+      @nav_collection_attribs = (@nav_collection_attribs || {})
+      # DONE: Error handling. This requires that associations
+      # have been properly defined with Sequel before
+      assoc = all_association_reflections.find do |a|
+        a[:name] == assoc_symb && a[:model] == self
+      end
+      unless assoc
+        raise OData::API::ModelAssociationNameError.new(self, assoc_symb)
+      end
+
+      attr_class = assoc[:class_name].constantize
+      lattr_name_str = (attr_name_str || assoc_symb.to_s)
+      @nav_collection_attribs[lattr_name_str] = attr_class
+      @nav_collection_url_regexp = @nav_collection_attribs.keys.join('|')
+    end
+
+    def add_nav_prop_single(assoc_symb, attr_name_str = nil)
+      @nav_entity_attribs = (@nav_entity_attribs || {})
+      # DONE: Error handling. This requires that associations
+      # have been properly defined with Sequel before
+      assoc = all_association_reflections.find do |a|
+        a[:name] == assoc_symb && a[:model] == self
+      end
+      unless assoc
+        raise OData::API::ModelAssociationNameError.new(self, assoc_symb)
+      end
+
+      attr_class = assoc[:class_name].constantize
+      lattr_name_str = (attr_name_str || assoc_symb.to_s)
+      @nav_entity_attribs[lattr_name_str] = attr_class
+      @nav_entity_url_regexp = @nav_entity_attribs.keys.join('|')
+    end
+
+    # old names...
+    #    alias_method :add_nav_prop_collection, :addNavCollectionAttrib
+    #    alias_method :add_nav_prop_single, :addNavEntityAttrib
+
+    def prepare_pk
+      if primary_key.is_a? Array
+        @pk_names = []
+        primary_key.each { |pk| @pk_names << pk.to_s }
+        # TODO: better handle quotes based on type
+        # (stringlike--> quote, int-like --> no quotes)
+
+        iuk = @pk_names.map { |pk| "#{pk}='?(\\w+)'?" }
+        @iuk_rgx = /\A#{iuk.join(',\s*')}\z/
+
+        iuk = @pk_names.map { |pk| "#{pk}='?\\w+'?" }
+        @entity_id_url_regexp = /\A\(\s*(#{iuk.join(',\s*')})\s*\)(.*)/
+      else
+        @pk_names = [primary_key.to_s]
+        @entity_id_url_regexp = /\A\('?([\w\s]+)'?\)(.*)/
+      end
+    end
+
+    def prepare_fields
+      @data_fields = db_schema.map do |col, cattr|
+        cattr[:primary_key] ? nil : col
+      end.select { |col| col }
+    end
+
+    # A regexp matching all allowed attributes of the Entity
+    # (eg ID|name|size etc... )
+    def attribute_url_regexp
+      #      db_schema.map { |sch| sch[0] }.join('|')
+      # @columns is from Sequel Model
+      @columns.join('|')
+    end
+
+    # methods related to transitions to next state (cf. walker)
+    module Transitions
+      def transition_end(_match_result)
+        [nil, :end]
+      end
+
+      def transition_count(_match_result)
+        [self, :end_with_count]
+      end
+
+      def transition_id(match_result)
+        #      binding.pry
+        if (id = match_result[1])
+          #               puts "in  transition_id, found #{y}"
+          if (y = find(id))
+            [y, :run]
+          else
+            [nil, :error, ErrorNotFound]
+          end
+        else
+          [nil, :error, ServerTransitionError]
+        end
+      end
+
+      def allowed_transitions
+        [Safrano::TransitionEnd,
+         Safrano::TransitionCount,
+         Safrano::Transition.new(entity_id_url_regexp,
+                                 trans: 'transition_id')]
+      end
+    end
+    include Transitions
+  end
+  # special handling for composite key
+  module EntityClassMultiPK
+    include EntityClassBase
+    # id is for composite key, something like      fx='aas',fy_w='0001'
+    def find(mid)
+      # Note: @iuk_rgx is (needs to be) built on start with
+      # collklass.prepare_pk
+      md = @iuk_rgx.match(mid).to_a
+      md.shift # remove first element which is the whole match
+      self[*md] # Sequel Model rulez
+    end
+  end
+
+  # special handling for single key
+  module EntityClassSinglePK
+    include EntityClassBase
+    # id is really just the  value of single pk
+    def find(id)
+      self[id]
+    end
+  end
+end