safrano 0.0.10 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ae6e14f540ba9628bfc170798e0323f25c0fea026f1ce887ae9f3ca1a11d9ea
-  data.tar.gz: 302b802de3bed4f604ff0c9bd1591521b45ce40deef7773d2df8631f9c6b577f
+  metadata.gz: 34ab64bf4fd2bbde8453e754091a3bd5618f41e6d51d9d15c9c678efcb38d544
+  data.tar.gz: d0ee4590389199a0e3530aee4a7aa244dde9355de8506a1091c5e0215ad40d78
 SHA512:
-  metadata.gz: c316569a4275ef505467d6c4f954da9d9c357998ca5584aa58a50311e4d81ea3bf8f4fa34b1137640aa00c591cd6aaedb38f65824b0c7d0f2ba650a14a9882a7
-  data.tar.gz: bbdd2ea715ebfe121dd0f82c10b6c5dc788202b5a8dafc1c81c14b5506377fa91d51379443c9a8769a54efacaf12cb8edbd9cb3a71bfcc0a0df959aec79eef37
+  metadata.gz: b9531e9de93d7d117ea1b58c1a90967706b102078513752f0bfef2447dc9c5988438d7ee1e9053827da0e58ac2aad07a6450a7c27b1fa5833ba329fe6c2bd4a8
+  data.tar.gz: 9e102e3c98ce0d47c0dd1dda33c8b2b76e0b7a3b9503d3af86c2ae08404773000b87442711ca230875d715148f90d870e9e63b9aae5c866677d4b0e8ca687ddd

data/lib/multipart.rb

@@ -1,182 +1,518 @@
 #!/usr/bin/env ruby
 
+CRLF = "\r\n".freeze
+LF = "\n".freeze
+
+require 'securerandom'
+require 'webrick/httpstatus'
+
 # Simple multipart support for OData $batch purpose
+module MIME
+  # a mime object has a header(with content-type etc) and a content(aka body)
+  class Media
+    # Parser for MIME::Media
+    class Parser
+      attr_accessor :lines
+      attr_accessor :target
+      def initialize
+        @state = :h
+        @lines = []
+        @target_hd = {}
+        @target_ct = nil
+        @sep = CRLF
+      end
 
-module Multi
-  RETNL = "\r\n".freeze
-  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*)\s*$}.freeze
-  module Parts
-    class Base
-      attr_accessor :parts
-      attr_reader :body
-      attr_reader :headers
-
-      def initialize(boundary)
-        @boundary = boundary
-        @headers = {}
-        @body = ''
-        @parts = []
+      def addline(line)
+        @lines << line
       end
 
-      def finalize
-        @parts.each do |part|
-          @body << "--#{@boundary}#{RETNL}"
-          @body << part.message_s
-          @body << RETNL
+      def parse(level: 0)
+        @level = level
+        return unless @lines
+
+        @lines.each do |line|
+          case @state
+          when :h
+            if (hmd = /^([\w-]+)\s*:\s*(.*)/.match(line))
+              @target_hd[hmd[1].downcase] = hmd[2].strip
+
+            elsif /^#{CRLF}$/ =~ line
+              @target_ct = @target_hd['content-type'] || 'text/plain'
+              @state = new_content
+
+            end
+
+          when :b
+            @target.parser.addline(line)
+
+          when :bmp
+
+            @state = :first_part if @target.parser.first_part(line)
+
+          when :first_part
+            if @target.parser.next_part(line)
+              @state = :next_part
+            # this is for when there is only one part
+            # (first part is the last one)
+            elsif @target.parser.last_part(line)
+              @state = :end
+            else
+              @target.parser.addline(line)
+            end
+
+          when :next_part
+
+            if @target.parser.next_part(line)
+
+            elsif @target.parser.last_part(line)
+              @state = :end
+            else
+              @target.parser.addline(line)
+            end
+          end
         end
-        @body << "--#{@boundary}--#{RETNL}"
-        @headers['Content-Length'] = @body.bytesize.to_s
-        @body
+        # Warning: recursive here
+        @target.parser.parse(level: level)
+        @target.parser = nil
+        @lines = nil
+        @target
       end
-    end
-    class Mixed < Base
-      def initialize(boundary)
-        super(boundary)
-        @headers['Content-Type'] = "multipart/mixed;boundary=#{@boundary}"
+
+      def multipart_content(boundary)
+        MIME::Content::Multipart::Base.new(boundary)
       end
 
-      def shadow_copy
-        self.class.new(@boundary)
+      def hook_multipart(content_type, boundary)
+        @target_hd['content-type'] = content_type
+        @target_ct = @target_hd['content-type']
+        @target = multipart_content(boundary)
+        @target.hd = @target_hd
+        @target.ct = @target_ct
+        @state = :bmp
+      end
+      MP_RGX1 = %r{^multipart/(digest|mixed);\s*boundary=\"(.*)\"}.freeze
+      MP_RGX2 = %r{^multipart/(digest|mixed);\s*boundary=(.*)}.freeze
+      def new_content
+        @target =
+          if (md = MP_RGX1.match(@target_ct)) ||
+             (md = MP_RGX2.match(@target_ct))
+            multipart_content(md[2].strip)
+          elsif %r{^application/http} =~ @target_ct
+            MIME::Content::Application::Http.new
+          else
+            MIME::Content::Text::Plain.new
+          end
+        @target.hd.merge! @target_hd
+        @target.ct = @target_ct
+        @target.level = @level
+        @state = @target.is_a?(MIME::Content::Multipart::Base) ? :bmp : :b
       end
 
-      def self.parse(inp, boundary)
-        @mmboundary = "--#{boundary}"
-        ret = Multi::Parts::Mixed.new(boundary)
-        inp.split(@mmboundary).each do |p|
-          ret.parts << parse_part(p) unless (p.strip == '--') || p.empty?
+      def parse_lines(inp, level: 0)
+        @lines = inp
+        parse(level: level)
+      end
+
+      def parse_str(inpstr, level: 0)
+        # we need to keep the line separators --> use io.readlines
+        if inpstr.respond_to?(:readlines)
+          @lines = inpstr.readlines(@sep)
+        else
+          # rack input wrapper only has gets but not readlines
+          sepsave = $INPUT_RECORD_SEPARATOR
+          $INPUT_RECORD_SEPARATOR = @sep
+          while (line = inpstr.gets)
+            @lines << line
+          end
+          $INPUT_RECORD_SEPARATOR = sepsave
+
+        end
+        # tmp hack for test-tools that convert CRLF in payload to LF :-(
+        if @lines.size == 1
+          @sep = LF
+          @lines = @lines.first.split(LF).map { |xline| "#{xline}#{CRLF}" }
         end
-        ret
+        parse(level: level)
       end
 
-      # Ultrasimplified parser...
-      def self.parse_part(inp)
-        state = :start
-        ct_headers = {}
-        headers = {}
-        body_str = ''
-        http_method = nil
-        uri = nil
-        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
-              ct_headers[md[1]] = md[2]
-            else
-              md = l.strip.match(HTTP_VERB_URI_REGEXP)
-              if md
-                state = :hd
-                http_method = md[1]
-                uri = md[2]
+      def parse_string(inpstr, level: 0)
+        @lines = inpstr.split(@sep)
+        if @lines.size == 1
+          @sep = LF
+          @lines = @lines.first.split(LF)
+        end
+        # split is not keeping the separator, we re-add it
+        @lines = @lines.map { |line| "#{line}#{CRLF}" }
+        parse(level: level)
+      end
+    end
+
+    attr_accessor :content
+    attr_accessor :hd
+    attr_accessor :ct
+    attr_accessor :level
+    attr_reader :response
+
+    def initialize
+      @state = :h
+      @hd = {}
+      @ct = nil
+      @parser = Parser.new(self)
+    end
+  end
+
+  # Subclasses for Mime media content
+  module Content
+    # due to the recursive nature of multipart media, a media-content
+    # should be seen as a full-fledged media(header+content) as well
+    class Media < ::MIME::Media
+      attr_accessor :parser
+    end
+
+    # text mime types
+    module Text
+      # Well, it says plain text
+      class Plain < Media
+        # Parser for Text::Plain
+        class Parser
+          def initialize(target)
+            @state = :h
+            @lines = []
+            @target = target
+          end
+
+          def addline(line)
+            @lines << line
+          end
+
+          def parse(level: 0)
+            return unless @lines
+
+            @level = level
+            @lines.each do |line|
+              case @state
+              when :h
+                if (hmd = /^([\w-]+)\s*:\s*(.*)/.match(line))
+                  @target.hd[hmd[1].downcase] = hmd[2].strip
+                elsif /^#{CRLF}$/ =~ line
+                  @state = :b
+                else
+                  @target.content << line
+                  @state = :b
+                end
+              when :b
+                @target.content << line
               end
             end
-          when :hd
-            md = l.strip.match(HEADER_REGEXP)
-            if md
-              state = :hd
-              headers[md[1]] = md[2]
-            else
-              body_str << l
-              state = :bd
-            end
-
-          when :bd
-            body_str << l
+            @lines = nil
+            @target.level = level
+            @target
           end
         end
-        if ct_headers['Content-Type'] == 'application/http'
 
-          Multi::Part::HttpReq.new(headers,
-                                   http_method,
-                                   uri,
-                                   body_str)
+        def initialize
+          @hd = {}
+          @content = ''
+          # set default values. Can be overwritten by parser
+          @hd['content-type'] = 'text/plain'
+          @ct = 'text/plain'
+          @parser = Parser.new(self)
+        end
 
-        else
-          # TODO: should probably be a BadRequestError ?
-          raise RuntimeError
+        def unparse
+          @content
+        end
+
+        def ==(other)
+          (@hd == other.hd) && (@content == other.content)
         end
       end
     end
-  end
 
-  module Part
-    class Base
-      attr_accessor :content_type
-      attr_accessor :content_transfer_enc
-      def initialize
-        @content = nil
-      end
+    # Multipart media
+    module Multipart
+      # base class for multipart mixed, related, digest etc
+      class Base < Media
+        # Parser for Multipart Base class
+        class Parser
+          def initialize(target)
+            @body_lines = []
+            @target = target
+            @parts = []
+            @bound_rgx = /^--#{@target.boundary}\s*$/
+            @lastb_rgx = /^--#{@target.boundary}--\s*$/
+          end
+
+          def parse(level: 0)
+            @target.content = @parts.map do |mlines|
+              MIME::Media::Parser.new.parse_lines(mlines, level: level + 1)
+            end
+            @body_lines = @bound_rgx = @lastb_rgx = nil
+            @parts = nil
+            @target.level = level
+            @target
+          end
+
+          def first_part(line)
+            return unless @bound_rgx =~ line
+
+            @body_lines = []
+          end
+
+          def next_part(line)
+            return unless @bound_rgx =~ line
+
+            collect_part
+            @body_lines = []
+          end
+
+          def last_part(line)
+            return unless @lastb_rgx =~ line
+
+            collect_part
+          end
+
+          def collect_part
+            # according to the multipart RFC spec, the preceeding CRLF
+            # belongs to the boundary
+            # but because we are a CRLF line-based parser we need
+            # to remove it from the end of the last body line
+            return unless @body_lines
 
-      attr_writer :content
+            @body_lines.last.sub!(/#{CRLF}$/, '')
+            @parts << @body_lines
+          end
+
+          def addline(line)
+            @body_lines << line
+          end
+        end
 
-      def message_s
-        result = ''
-        result << "Content-Type: #{@content_type}#{RETNL}"
-        result << "Content-Transfer-Encoding: #{@content_transfer_enc}#{RETNL}"
-        result << RETNL
-        result << content.to_s
-        result
+        attr_reader :boundary
+
+        def initialize(boundary)
+          @boundary = boundary
+          @hd = {}
+          @parser = Parser.new(self)
+        end
+
+        def ==(other)
+          (@boundary == other.boundary) && (@content == other.content)
+        end
+
+        def set_multipart_header
+          @hd['content-type'] = "multipart/mixed; boundary=#{@boundary}"
+        end
+
+        def get_http_resp(batcha)
+          get_response(batcha)
+          [@response.hd, @response.unparse(true)]
+        end
+
+        def get_response(batcha)
+          @response = self.class.new(::SecureRandom.uuid)
+          @response.set_multipart_header
+          if @level == 1 # changeset need their own global transaction
+            # the change requests that are part of if have @level==2
+            # and will be flagged with in_changeset=true
+            # and this will finally be used to skip the transaction
+            # of the changes
+            batcha.db.transaction do
+              begin
+                @response.content = @content.map { |part| part.get_response(batcha) }
+              rescue Sequel::Rollback => e
+                # one of the changes of the changeset has failed
+                # --> provide a dummy empty response for the change-parts
+                # then transmit the Rollback to Sequel
+                @response.content = @content.map { |_part|
+                  MIME::Content::Application::HttpResp.new
+                }
+                raise
+              end
+            end
+          else
+            @response.content = @content.map { |part| part.get_response(batcha) }
+          end
+          @response
+        end
+
+        def unparse(bodyonly = false)
+          b = ''
+          unless bodyonly
+            b << 'Content-Type' << ': ' << @hd['content-type'] << CRLF
+          end
+          b << "#{CRLF}--#{@boundary}#{CRLF}"
+          b << @content.map(&:unparse).join("#{CRLF}--#{@boundary}#{CRLF}")
+          b << "#{CRLF}--#{@boundary}--#{CRLF}"
+          b
+        end
       end
     end
 
-    class HttpReq < Base
-      def initialize(headers, method, url, body)
-        super()
-        @content_type = 'application/http'
-        @content_transfer_enc = 'binary'
-        @headers = headers
-        @http_method = method
-        @url = url
-        @body = body
-      end
+    # for application(http etc.) mime types
+    module Application
+      # Http Request
+      class HttpReq < Media
+        attr_accessor :http_method
+        attr_accessor :uri
 
-      def finalize
-        @content = "#{@http_method} #{@url} HTTP/1.1#{RETNL}"
-        @headers.each do |k, v|
-          @content << "#{k}: #{v}#{RETNL}"
+        def initialize
+          @hd = {}
+          @content = ''
         end
-        if @body != ''
-          @content << RETNL
-          @content << @body
+
+        def unparse
+          b = "#{@http_method} #{@uri} HTTP/1.1#{CRLF}"
+          @hd.each { |k, v| b << k.to_s << ': ' << v.to_s << CRLF }
+          b << CRLF
+          b << @content if @content != ''
+          b
         end
-        @content
       end
 
-      def content
-        @content = (@content || finalize)
-      end
+      # Http Response
+      class HttpResp < Media
+        attr_accessor :status
+        attr_accessor :content
 
-      # shamelessely copied from Rack::TEST:Session
-      def headers_for_env
-        converted_headers = {}
+        APPLICATION_HTTP_11 = ['Content-Type: application/http',
+                               "Content-Transfer-Encoding: binary#{CRLF}",
+                               'HTTP/1.1 '].join(CRLF).freeze
 
-        @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
+        StatusMessage = ::WEBrick::HTTPStatus::StatusMessage.freeze
+
+        def initialize
+          @hd = {}
+          @content = []
         end
 
-        converted_headers
-      end
+        def ==(other)
+          (@hd == other.hd) && (@content == other.content)
+        end
 
-      def batch_env
-        @env = ::Rack::MockRequest.env_for(@url,
-                                           method: @http_method,
-                                           input: @body_str)
-        @env.merge! headers_for_env
-        @env
+        def unparse
+          b = String.new(APPLICATION_HTTP_11)
+          b << "#{@status} #{StatusMessage[@status]} #{CRLF}"
+          @hd.each { |k, v| b << k.to_s << ': ' << v.to_s << CRLF }
+          b << CRLF
+          b << @content.join if @content
+          b
+        end
       end
-    end
 
-    class HttpGet < HttpReq
-      def initialize(url, app_headers)
-        super(app_headers, 'GET', url, '')
+      # For application/http . Content is either a Request or a Response
+      class Http < Media
+        HTTP_R_RGX = %r{^(POST|GET|PUT|MERGE|PATCH)\s+(\S*)\s?(HTTP/1\.1)\s*$}.freeze
+        HEADER_RGX = %r{^([a-zA-Z\-]+):\s*([0-9a-zA-Z\-\/,\s]+;?\S*)\s*$}.freeze
+        HTTP_RESP_RGX = %r{^HTTP/1\.1\s(\d+)\s}.freeze
+
+        # Parser for Http Media
+        class Parser
+          def initialize(target)
+            @state = :http
+            @lines = []
+            @body_lines = []
+            @target = target
+          end
+
+          def addline(line)
+            @lines << line
+          end
+
+          def parse(level: 0)
+            return unless @lines
+
+            @lines.each do |line|
+              case @state
+              when :http
+                if (hmd = /^([\w-]+)\s*:\s*(.*)/.match(line))
+                  @target.hd[hmd[1].downcase] = hmd[2].strip
+                elsif (mdht = HTTP_R_RGX.match(line))
+                  @state = :hd
+                  @target.content = MIME::Content::Application::HttpReq.new
+                  @target.content.http_method = mdht[1]
+                  @target.content.uri = mdht[2]
+                #  HTTP 1.1 status line  --> HttpResp.new
+                elsif (mdht = HTTP_RESP_RGX.match(line))
+                  @state = :hd
+                  @target.content = MIME::Content::Application::HttpResp.new
+                  @target.content.status = mdht[1]
+                end
+              when :hd
+                if (hmd = /^([\w-]+)\s*:\s*(.*)/.match(line))
+                  @target.content.hd[hmd[1].downcase] = hmd[2].strip
+                elsif /^#{CRLF}$/ =~ line
+                  @state = :b
+                else
+                  @body_lines << line
+                  @state = :b
+                end
+              when :b
+                @body_lines << line
+              end
+            end
+
+            @target.content.content = @body_lines.join
+            @target.content.level = level
+            @target.level = level
+            @lines = nil
+            @body_lines = nil
+            @target
+          end
+        end
+
+        def initialize
+          @hd = {}
+          @ct = 'application/http'
+          @parser = Parser.new(self)
+        end
+
+        def ==(other)
+          @content = other.content
+        end
+
+        def get_response(batchapp)
+          # self.content should be the request
+          rack_resp = batchapp.batch_call(@content)
+          @response = MIME::Content::Application::HttpResp.new
+          @response.status = rack_resp[0]
+          @response.hd = rack_resp[1]
+          @response.content = rack_resp[2]
+          @response
+        end
+
+        def unparse
+          b =  "Content-Type: #{@ct}#{CRLF}"
+          b << "Content-Transfer-Encoding: binary#{CRLF}#{CRLF}"
+          b << @content.unparse
+          b
+        end
       end
     end
   end
 end
+
+#    @mimep = MIME::Media::Parser.new
+
+#    @inpstr = File.open('../test/multipart/odata_changeset_1_body.txt','r')
+#    @boundary = 'batch_48f8-3aea-2f04'
+
+#    @inpstr = File.open('../test/multipart/odata_changeset_body.txt','r')
+#    @boundary = 'batch_36522ad7-fc75-4b56-8c71-56071383e77b'
+
+#    @mime = @mimep.hook_multipart('multipart/mixed', @boundary)
+#    @mime = @mimep.parse_str(@inpstr)
+
+#    require 'pry'
+#    binding.pry
+
+#    @inpstr.close
+
+# inp = File.open(ARGV[0], 'r') do |f|
+# f.readlines(CRLF)
+# end
+# x = MIME::Media::Parser.new
+# y = x.parsein(inp)
+# pp y
+# puts '-----------------------------------------------'
+# puts y.unparse

data/lib/odata/batch.rb

@@ -2,33 +2,19 @@
 
 require 'rack_app.rb'
 require 'safrano_core.rb'
-require 'webrick/httpstatus'
 
 module OData
-  RETNEW = "\r\n".freeze
+  # Support for OData multipart $batch Requests
   class Request
     def create_batch_app
       Batch::MyOApp.new(self)
     end
 
-    def parse_multipart_mixed
+    def parse_multipart
+      @mimep = MIME::Media::Parser.new
       @boundary = media_type_params['boundary']
-      Multi::Parts::Mixed.parse(body.read, @boundary)
-    end
-  end
-
-  class Response
-    APPLICATION_HTTP_11 = ['Content-Type: application/http',
-                           "Content-Transfer-Encoding: binary#{RETNEW}",
-                           'HTTP/1.1 '].join(RETNEW).freeze
-    StatusMessage = WEBrick::HTTPStatus::StatusMessage.freeze
-    def message_s
-      b = String.new(APPLICATION_HTTP_11)
-      b << "#{@status} #{StatusMessage[@status]} #{RETNEW}"
-      headers.each { |k, v| b << k.to_s << ':' << v.to_s << RETNEW }
-      b << RETNEW
-      b << @body[0].to_s
-      b << RETNEW
+      @mimep.hook_multipart(media_type, @boundary)
+      @mimep.parse_str(body)
     end
   end
 
@@ -37,9 +23,11 @@ module OData
     class MyOApp < OData::ServerApp
       attr_reader :full_req
       attr_reader :response
+      attr_reader :db
 
       def initialize(full_req)
         @full_req = full_req
+        @db = full_req.service.collections.first.db
       end
 
       # redefined for $batch
@@ -50,16 +38,40 @@ module OData
       end
 
       def batch_call(part_req)
-        env = part_req.batch_env
+        env = batch_env(part_req)
         env['HTTP_HOST'] = @full_req.env['HTTP_HOST']
 
         @request = OData::Request.new(env)
         @response = OData::Response.new
 
+        @request.in_changeset = true if part_req.level == 2
+
         before
         dispatch
+
         @response.finish
       end
+
+      # shamelessely copied from Rack::TEST:Session
+      def headers_for_env(headers)
+        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(mime_req)
+        @env = ::Rack::MockRequest.env_for(mime_req.uri,
+                                           method: mime_req.http_method,
+                                           input: mime_req.content)
+        @env.merge! headers_for_env(mime_req.hd)
+        @env
+      end
     end
 
     # Huile d'olive extra
@@ -91,9 +103,7 @@ module OData
       attr_accessor :parts
       attr_accessor :request
 
-      def initialize
-        @parts = []
-      end
+      def initialize; end
 
       # here we are in the Batch handler object, and this POST should
       # normally handle a $batch request
@@ -101,15 +111,14 @@ module OData
         @request = req
 
         if @request.media_type == 'multipart/mixed'
+
           batcha = @request.create_batch_app
-          @mult_request = @request.parse_multipart_mixed
-          @mult_response = @mult_request.shadow_copy
-
-          @mult_request.parts.each_with_object(@mult_response) do |req_part, mresp|
-            batcha.batch_call(req_part)
-            mresp.parts << batcha.response
-          end
-          [202, @mult_response.headers, @mult_response.finalize]
+          @mult_request = @request.parse_multipart
+          @mult_response = OData::Response.new
+
+          resp_hdrs, @mult_response.body = @mult_request.get_http_resp(batcha)
+
+          [202, resp_hdrs, @mult_response.body[0]]
         else
           [415, {}, 'Unsupported Media Type']
         end

data/lib/odata/collection.rb

@@ -82,7 +82,7 @@ module OData
     end
 
     # Factory json-> Model Object instance
-    def new_from_hson_h(hash)
+    def new_from_hson_h(hash, in_changeset: false)
       enty = new
       hash.delete('__metadata')
       # DONE: move this somewhere else where it's evaluated only once at setup
@@ -90,7 +90,8 @@ module OData
       #  cattr[:primary_key] ? nil : col
       # end.select { |col| col }
       enty.set_fields(hash, @data_fields, missing: :skip)
-      enty.save
+      # in-changeset requests get their own transaction
+      enty.save(transaction: !in_changeset)
       enty
     end
 
@@ -206,7 +207,7 @@ module OData
     def check_u_p_orderby
       # TODO: this should be moved into OData::Order somehow,
       # at least partly
-      return unless (@params['$orderby'])
+      return unless @params['$orderby']
 
       pordlist = @params['$orderby'].dup
       pordlist.split(',').each do |pord|
@@ -278,7 +279,7 @@ module OData
           else
             [200, { 'Content-Type' => 'application/json;charset=utf-8' },
              to_odata_json(service: req.service)]
-           end
+          end
         else # TODO: other formats
           406
         end
@@ -304,12 +305,22 @@ module OData
     def odata_post(req)
       # TODO: check Request body format...
       # TODO: this is for v2 only...
-      data = JSON.parse(req.body.read)
-      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
+      on_error = (proc { raise Sequel::Rollback } if req.in_changeset)
+      req.with_parsed_data(on_error: on_error) do |data|
+        data.delete('__metadata')
+        # validate payload column names
+        if (invalid = invalid_hash_data?(data))
+          on_error.call if on_error
+          return [422, {}, ['Invalid attribute name: ', invalid.to_s]]
+        end
+
+        if req.accept?('application/json')
+          [201, { 'Content-Type' => 'application/json;charset=utf-8' },
+           new_from_hson_h(data, in_changeset: req.in_changeset)
+             .to_odata_post_json(service: req.service)]
+        else # TODO: other formats
+          415
+        end
       end
     end
 
@@ -377,6 +388,10 @@ module OData
       end.select { |col| col }
     end
 
+    def invalid_hash_data?(data)
+      data.keys.map(&:to_sym).find { |ksym| !(@columns.include? ksym) }
+    end
+
     # A regexp matching all allowed attributes of the Entity
     # (eg ID|name|size etc... )
     def attribute_url_regexp
@@ -396,9 +411,7 @@ module OData
       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

data/lib/odata/collection_filter.rb

@@ -4,9 +4,7 @@ require 'odata/error.rb'
 
 # a few helper method
 class String
-  #  MASK_RGX = /'([^']*)'/.freeze
   MASK_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
-  #  QUOTED_RGX = /'((?:[^']|(?:\'{2}))*)'/.freeze
   UNMASK_RGX = /'(%?)(\$\d+)(%?)'/.freeze
   def with_mask_quoted_substrings!
     cnt = 0
@@ -261,10 +259,10 @@ module OData
     def get_assoc
       @assoc, @fn = @fn.split('/') if @fn.include?('/')
       assoc1, @fn1 = @fn1.split('/') if @fn1.include?('/')
-      if assoc1 != @assoc
-        # TODO... handle this
-        raise OData::ServerError
-      end
+      return unless assoc1 != @assoc
+
+      # TODO... handle this
+      raise OData::ServerError
     end
 
     def get_qualified_fn1(dtcx)

data/lib/odata/entity.rb

@@ -151,7 +151,12 @@ module OData
       if req.accept?('application/json')
         data.delete('__metadata')
 
-        update_fields(data, self.class.data_fields, missing: :skip)
+        if req.in_changeset
+          set_fields(data, self.class.data_fields, missing: :skip)
+          save(transaction: false)
+        else
+          update_fields(data, self.class.data_fields, missing: :skip)
+        end
 
         [202, to_odata_post_json(service: req.service)]
       else # TODO: other formats
@@ -160,17 +165,45 @@ module OData
     end
 
     def odata_patch(req)
-      data = JSON.parse(req.body.read)
-      @uribase = req.uribase
-
-      if req.accept?('application/json')
+      on_error = (proc { raise Sequel::Rollback } if req.in_changeset)
+      req.with_parsed_data(on_error: on_error) do |data|
         data.delete('__metadata')
-        update_fields(data, self.class.data_fields, missing: :skip)
+
+        # validate payload column names
+        if (invalid = self.class.invalid_hash_data?(data))
+          on_error.call if on_error
+          return [422, {}, ['Invalid attribute name: ', invalid.to_s]]
+        end
+        # TODO: check values/types
+
+        my_data_fields = self.class.data_fields
+        @uribase = req.uribase
+        #      if req.accept?('application/json')
+
+        if req.in_changeset
+          set_fields(data, my_data_fields, missing: :skip)
+          save(transaction: false)
+        else
+          update_fields(data, my_data_fields, missing: :skip)
+        end
         # patch should return 204 + no content
         [204, {}, []]
-      else # TODO: other formats
-        415
       end
+
+      # if ( req.content_type == 'application/json' )
+      ## Parse json payload
+      # begin
+      # data = JSON.parse(req.body.read)
+      # rescue JSON::ParserError => e
+      # return [400, {}, ['JSON Parser Error while parsing payload : ',
+      # e.message]]
+
+      # end
+
+      # else # TODO: other formats
+
+      # [415, {}, []]
+      # end
     end
 
     # redefinitions of the main methods for a navigated collection

data/lib/rack_app.rb

@@ -77,7 +77,7 @@ module OData
   # 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')
+    METHODS_REGEXP = Regexp.new('HEAD|OPTIONS|GET|POST|PATCH|MERGE|PUT|DELETE')
     include MethodHandlers
     def before
       headers 'Cache-Control' => 'no-cache'
@@ -108,7 +108,7 @@ module OData
         odata_delete
       when 'OPTIONS'
         odata_options
-      when 'PATCH', 'PUT'
+      when 'PATCH', 'PUT', 'MERGE'
         odata_patch
       else
         raise Error

data/lib/request.rb

@@ -13,6 +13,8 @@ module OData
     HEADER_VAL_RAW = '(?:\w+|\*)\/(?:\w+(?:\.|\-|\+)?|\*)*'.freeze
     HEADER_VAL_WITH_PAR = /(?:#{HEADER_VAL_RAW})\s*(?:;#{HEADER_PARAM})*/.freeze
 
+    attr_accessor :in_changeset
+
     # borowed from Sinatra
     class AcceptEntry
       attr_accessor :params
@@ -115,6 +117,25 @@ module OData
       end
     end
 
+    def with_parsed_data(on_error: nil)
+      if content_type == 'application/json'
+        # Parse json payload
+        begin
+          data = JSON.parse(body.read)
+        rescue JSON::ParserError => e
+          on_error.call if on_error
+          return [400, {}, ['JSON Parser Error while parsing payload : ',
+                            e.message]]
+        end
+
+        yield data
+
+      else # TODO: other formats
+
+        [415, {}, []]
+      end
+    end
+
     def negotiate_service_version
       maxv = if (rqv = env['HTTP_MAXDATASERVICEVERSION'])
                OData::ServiceBase.parse_data_service_version(rqv)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: safrano
 version: !ruby/object:Gem::Version
-  version: 0.0.10
+  version: 0.1.0
 platform: ruby
 authors:
 - D.M.
@@ -120,7 +120,11 @@ files:
 homepage: https://gitlab.com/dm0da/safrano
 licenses:
 - MIT
-metadata: {}
+metadata:
+  bug_tracker_uri: https://gitlab.com/dm0da/safrano/issues
+  changelog_uri: https://gitlab.com/dm0da/safrano/blob/master/CHANGELOG
+  source_code_uri: https://gitlab.com/dm0da/safrano/tree/master
+  wiki_uri: https://gitlab.com/dm0da/safrano/wikis/home
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -139,5 +143,5 @@ requirements: []
 rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
-summary: Safrano is a ruby (Sequel + Rack) OData provider
+summary: Safrano is a Ruby  OData provider based on Sequel and Rack
 test_files: []