safrano 0.4.3 → 0.5.1

data/lib/safrano.rb

@@ -1,42 +1,22 @@
+# frozen_string_literal: true
+
 require 'json'
 require 'rexml/document'
-require_relative 'safrano/multipart.rb'
-require_relative 'safrano/core.rb'
-require_relative 'odata/entity.rb'
-require_relative 'odata/attribute.rb'
-require_relative 'odata/navigation_attribute.rb'
-require_relative 'odata/collection.rb'
-require_relative 'safrano/service.rb'
-require_relative 'odata/walker.rb'
+require_relative 'safrano/version'
+require_relative 'safrano/deprecation'
+require_relative 'safrano/core_ext'
+require_relative 'safrano/contract'
+require_relative 'safrano/multipart'
+require_relative 'safrano/core'
+require_relative 'odata/transition'
+require_relative 'odata/edm/primitive_types'
+require_relative 'odata/entity'
+require_relative 'odata/attribute'
+require_relative 'odata/navigation_attribute'
+require_relative 'odata/model_ext'
+require_relative 'safrano/service'
+require_relative 'odata/walker'
 require 'sequel'
-require_relative 'safrano/sequel_join_by_paths.rb'
+require_relative 'safrano/sequel_join_by_paths'
 require_relative 'safrano/rack_app'
-require_relative 'safrano/odata_rack_builder'
-require_relative 'safrano/version'
-
-# picked from activsupport; needed for ruby < 2.5
-# Destructively converts all keys using the +block+ operations.
-# Same as +transform_keys+ but modifies +self+.
-class Hash
-  def transform_keys!
-    keys.each do |key|
-      self[yield(key)] = delete(key)
-    end
-    self
-  end unless method_defined? :transform_keys!
-
-  def symbolize_keys!
-    transform_keys! { |key| key.to_sym rescue key }
-  end
-end
-
-# needed for ruby < 2.5
-class Dir
-  def self.each_child(dir)
-    Dir.foreach(dir) do |x|
-      next if (x == '.') || (x == '..')
-
-      yield x
-    end
-  end unless respond_to? :each_child
-end
+require_relative 'safrano/rack_builder'

data/lib/safrano/contract.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+module Safrano
+  # Design: the Invalid module and the Valid class share exactly the same
+  # methods (ie. interface) so methods returning such objects can be
+  # post-processed in a declarative way
+  # Example:
+  #   something.do_stuff(param).tap_valid{|valid_result| ... }
+  #                             .tap_error{|error|  ... }
+
+  module Contract
+    # represents a invalid result, ie. an error
+    # this shall be included/extended to our Error classes thus
+    # automagically making them contract/flow enabled
+
+    # All tap_valid* handlers are not executed
+    #     tap_error* handlers are executed
+    module Invalid
+      def tap_error
+        yield self
+        self # allow chaining
+      end
+
+      def tap_valid
+        self # allow chaining
+      end
+
+      def if_valid
+        self
+      end
+
+      def if_error
+        yield self ## return this
+      end
+
+      def if_valid_collect
+        self
+      end
+
+      def map_result!
+        self # allow chaining
+      end
+
+      def collect_result!
+        self # allow chaining
+      end
+
+      def error
+        self
+      end
+
+      def result
+        nil
+      end
+    end
+
+    class Error
+      include Invalid
+    end
+
+    # represents a valid result.
+    # All tap_valid* handlers are executed
+    #     tap_error* handlers are not executed
+    class Valid
+      attr_reader :result
+
+      def initialize(result)
+        @result = result
+      end
+
+      def tap_error
+        self # allow chaining
+      end
+
+      def tap_valid
+        yield @result
+        self # allow chaining
+      end
+
+      def if_valid
+        yield @result ## return this
+      end
+
+      def if_error
+        self # allow chaining
+      end
+
+      def if_valid_collect
+        yield(*@result) ## return this
+      end
+
+      def map_result!
+        @result = yield @result
+        self # allow chaining
+      end
+
+      def collect_result!
+        @result = yield(*@result)
+        self # allow chaining
+      end
+
+      def error
+        nil
+      end
+    end # class Valid
+
+    def self.valid(result)
+      Contract::Valid.new(result)
+    end
+
+    def self.and(*contracts)
+      # pick the first error if any
+      if (ff = contracts.find(&:error))
+        return ff
+      end
+
+      # return a new one with @result = list of the contracts's results
+      # usually this then be reduced again with #collect_result! or #               #if_valid_collect methods
+      valid(contracts.map(&:result))
+    end
+
+    # shortcut for Contract.and(*contracts).collect_result!
+    def self.collect_result!(*contracts)
+      # pick the first error if any
+      if (ff = contracts.find(&:error))
+        return ff
+      end
+
+      # return a new one with @result = yield(*list of the contracts's results)
+      valid(yield(*contracts.map(&:result)))
+    end
+
+    # generic success return, when return value does not matter
+    # but usefull for control-flow
+    OK = Contract.valid(nil).freeze
+    # generic error return, when error value does not matter
+    # but usefull for control-flow
+    NOT_OK = Error.new.freeze
+    NOK = NOT_OK # it's shorter
+  end # Contract
+end

data/lib/safrano/core.rb

@@ -1,125 +1,43 @@
+# frozen_string_literal: true
+
 # our main namespace
-module OData
+module Safrano
   # frozen empty Array/Hash to reduce unncecessary object creation
   EMPTY_ARRAY = [].freeze
   EMPTY_HASH = {}.freeze
   EMPTY_HASH_IN_ARY = [EMPTY_HASH].freeze
-  EMPTY_STRING = ''.freeze
+  EMPTY_STRING = ''
   ARY_204_EMPTY_HASH_ARY = [204, EMPTY_HASH, EMPTY_ARRAY].freeze
-  SPACE = ' '.freeze
-  COMMA = ','.freeze
+  SPACE = ' '
+  COMMA = ','
 
   # some prominent constants... probably already defined elsewhere eg in Rack
   # but lets KISS
-  CONTENT_TYPE = 'Content-Type'.freeze
-  CTT_TYPE_LC = 'content-type'.freeze
-  TEXTPLAIN_UTF8 = 'text/plain;charset=utf-8'.freeze
-  APPJSON = 'application/json'.freeze
-  APPXML = 'application/xml'.freeze
-  MP_MIXED = 'multipart/mixed'.freeze
-  APPXML_UTF8 = 'application/xml;charset=utf-8'.freeze
-  APPATOMXML_UTF8 = 'application/atomsvc+xml;charset=utf-8'.freeze
-  APPJSON_UTF8 = 'application/json;charset=utf-8'.freeze
+  CONTENT_TYPE = 'Content-Type'
+  CTT_TYPE_LC = 'content-type'
+  TEXTPLAIN_UTF8 = 'text/plain;charset=utf-8'
+  APPJSON = 'application/json'
+  APPXML = 'application/xml'
+  MP_MIXED = 'multipart/mixed'
+  APPXML_UTF8 = 'application/xml;charset=utf-8'
+  APPATOMXML_UTF8 = 'application/atomsvc+xml;charset=utf-8'
+  APPJSON_UTF8 = 'application/json;charset=utf-8'
 
   CT_JSON = { CONTENT_TYPE => APPJSON_UTF8 }.freeze
   CT_TEXT = { CONTENT_TYPE => TEXTPLAIN_UTF8 }.freeze
   CT_ATOMXML = { CONTENT_TYPE => APPATOMXML_UTF8 }.freeze
   CT_APPXML = { CONTENT_TYPE => APPXML_UTF8 }.freeze
 
-  # Type mapping DB --> Edm
-  #  TypeMap = {"INTEGER" => "Edm.Int32" , "TEXT" => "Edm.String",
-  # "STRING" => "Edm.String"}
-  # Todo: complete mapping... this is just for the most common ones
-
-  # 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.
-  DB_TYPE_STRING_RGX = /\ACHAR\s*\(\d+\)\z/.freeze
+  module NavigationInfo
+    attr_reader :nav_parent
+    attr_reader :navattr_reflection
+    attr_reader :nav_name
 
-  # TODO... complete; used in $metadata
-  def self.get_edm_type(db_type:)
-    case db_type.upcase
-    when 'INTEGER'
-      'Edm.Int32'
-    when 'TEXT', 'STRING'
-      'Edm.String'
-    else
-      'Edm.String' if DB_TYPE_STRING_RGX =~ db_type.upcase
+    def set_relation_info(parent, name)
+      @nav_parent = parent
+      @nav_name = name
+      @navattr_reflection = parent.class.association_reflections[name.to_sym]
+      @nav_klass = @navattr_reflection[:class_name].constantize
     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
-    attr_reader :remain_idx
-    def initialize(arg, trans: nil, remain_idx: 2)
-      @rgx = if arg.respond_to? :each_char
-               Regexp.new(arg)
-             else
-               arg
-             end
-      @trans = trans
-      @remain_idx = remain_idx
-    end
-
-    def do_match(str)
-      @match_result = @rgx.match(str)
-    end
-
-    # remain_idx is the index of the last match-data. ususally its 2
-    # but can be overidden
-    def path_remain
-      @match_result[@remain_idx] if @match_result && @match_result[@remain_idx]
-    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')
-  TransitionContentId = Transition.new('\A(\/\$(\d+))(.*)',
-                                       trans: 'transition_content_id',
-                                       remain_idx: 3)
-  TransitionCount = Transition.new('(\A\/\$count)(.*)\z',
-                                   trans: 'transition_count')
-  TransitionValue = Transition.new('(\A\/\$value)(.*)\z',
-                                   trans: 'transition_value')
-  TransitionLinks = Transition.new('(\A\/\$links)(.*)\z',
-                                   trans: 'transition_links')
-  attr_accessor :allowed_transitions
-end

data/lib/safrano/core_ext.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+Dir.glob(File.expand_path('../core_ext/*.rb', __dir__)).sort.each do |path|
+  require path
+end
+
+# 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

data/lib/safrano/deprecation.rb

@@ -0,0 +1,73 @@
+# frozen-string-literal: true
+
+# shamelessly copied from Sequel...
+
+module Safrano
+  # This module makes it easy to print deprecation warnings with optional backtraces to a given stream.
+  # There are a two accessors you can use to change how/where the deprecation methods are printed
+  # and whether/how backtraces should be included:
+  #
+  #   Safrano::Deprecation.output = $stderr # print deprecation messages to standard error (default)
+  #   Safrano::Deprecation.output = File.open('deprecated_calls.txt', 'wb') # use a file instead
+  #   Safrano::Deprecation.output = false # do not output deprecation messages
+  #
+  #   Safrano::Deprecation.prefix = "SAFRANO DEPRECATION WARNING: " # prefix deprecation messages with a given string (default)
+  #   Safrano::Deprecation.prefix = false # do not prefix deprecation messages
+  #
+  #   Safrano::Deprecation.backtrace_filter = false # don't include backtraces
+  #   Safrano::Deprecation.backtrace_filter = true # include full backtraces
+  #   Safrano::Deprecation.backtrace_filter = 2 # include 2 backtrace lines (default)
+  #   Safrano::Deprecation.backtrace_filter = 1 # include 1 backtrace line
+  #   Safrano::Deprecation.backtrace_filter = lambda{|line, line_no| line_no < 3 || line =~ /my_app/} # select backtrace lines to output
+  module Deprecation
+    @backtrace_filter = false
+    @output = $stderr
+    @prefix = 'SAFRANO DEPRECATION WARNING: '
+
+    class << self
+      # How to filter backtraces.  +false+ does not include backtraces, +true+ includes
+      # full backtraces, an Integer includes that number of backtrace lines, and
+      # a proc is called with the backtrace line and line number to select the backtrace
+      # lines to include.  The default is no backtrace .
+      attr_accessor :backtrace_filter
+
+      # Where deprecation messages should be output, must respond to puts.  $stderr by default.
+      attr_accessor :output
+
+      # Where deprecation messages should be prefixed with ("SEQUEL DEPRECATION WARNING: " by default).
+      attr_accessor :prefix
+    end
+
+    # Print the message and possibly backtrace to the output.
+    def self.deprecate(method, instead = nil)
+      return unless output
+
+      message = instead ? "#{method} is deprecated and will be removed in Safrano 0.6.  #{instead}." : method
+      message = "#{prefix}#{message}" if prefix
+      output.puts(message)
+      case b = backtrace_filter
+      when Integer
+        caller.each do |c|
+          b -= 1
+          output.puts(c)
+          break if b <= 0
+        end
+      when true
+        caller.each { |c| output.puts(c) }
+      when Proc
+        caller.each_with_index { |line, line_no| output.puts(line) if b.call(line, line_no) }
+      end
+      nil
+    end
+
+    # If using ruby 2.3+, use Module#deprecate_constant to deprecate the constant,
+    # otherwise do nothing as the ruby implementation does not support constant deprecation.
+    def self.deprecate_constant(mod, constant)
+      # :nocov:
+      return unless RUBY_VERSION > '2.3'
+
+      # :nocov:
+      mod.deprecate_constant(constant)
+    end
+  end
+end

data/lib/safrano/multipart.rb

@@ -1,13 +1,15 @@
-CRLF = "\r\n".freeze
-LF = "\n".freeze
+# frozen_string_literal: true
+
+CRLF = "\r\n"
+LF = "\n"
 
 require 'securerandom'
-require 'webrick/httpstatus'
+require 'rack/utils'
 
 # Simple multipart support for OData $batch purpose
 module MIME
-  CTT_TYPE_LC = 'content-type'.freeze
-  TEXT_PLAIN = 'text/plain'.freeze
+  CTT_TYPE_LC = 'content-type'
+  TEXT_PLAIN = 'text/plain'
 
   # a mime object has a header(with content-type etc) and a content(aka body)
   class Media
@@ -17,6 +19,7 @@ module MIME
 
       attr_accessor :lines
       attr_accessor :target
+
       def initialize
         @state = :h
         @lines = []
@@ -107,11 +110,11 @@ module MIME
         @target.ct = @target_ct
         @state = :bmp
       end
-      MPS = 'multipart/'.freeze
-      MP_RGX1 = %r{^(digest|mixed);\s*boundary=\"(.*)\"}.freeze
+      MPS = 'multipart/'
+      MP_RGX1 = %r{^(digest|mixed);\s*boundary="(.*)"}.freeze
       MP_RGX2 = %r{^(digest|mixed);\s*boundary=(.*)}.freeze
       #      APP_HTTP_RGX = %r{^application/http}.freeze
-      APP_HTTP = 'application/http'.freeze
+      APP_HTTP = 'application/http'
       def new_content
         @target =
           if @target_ct.start_with?(MPS) &&
@@ -237,7 +240,8 @@ module MIME
 
         def initialize
           @hd = {}
-          @content = ''
+          # we need it unfrozen --> +
+          @content = +''
           # set default values. Can be overwritten by parser
           @hd[CTT_TYPE_LC] = TEXT_PLAIN
           @ct = TEXT_PLAIN
@@ -305,8 +309,10 @@ module MIME
             # to remove it from the end of the last body line
             return unless @body_lines
 
-            #            @body_lines.last.sub!(CRLF_ENDING_RGX, '')
-            @body_lines.last.chomp!(CRLF)
+            # the last line ends up frozen --> chomp! fails
+            # @body_lines.last.chomp!(CRLF)
+            last_line = @body_lines.pop.chomp(CRLF)
+            @body_lines.push last_line
             @parts << @body_lines
           end
 
@@ -360,7 +366,7 @@ module MIME
         end
 
         def set_multipart_header
-          @hd[CTT_TYPE_LC] = "#{OData::MP_MIXED}; boundary=#{@boundary}"
+          @hd[CTT_TYPE_LC] = "#{Safrano::MP_MIXED}; boundary=#{@boundary}"
         end
 
         def get_http_resp(batcha)
@@ -399,15 +405,14 @@ module MIME
           @response.content = [{ 'odata.error' =>
                                { 'message' =>
                                  'Bad Request: Failed changeset ' } }.to_json]
-          @response.hd = OData::CT_JSON
+          @response.hd = Safrano::CT_JSON
           @response
         end
 
         def unparse(bodyonly = false)
-          b = ''
+          b = +String.new
           unless bodyonly
-            #            b << OData::CONTENT_TYPE << ': ' << @hd[OData::CTT_TYPE_LC] << CRLF
-            b << "#{OData::CONTENT_TYPE}: #{@hd[CTT_TYPE_LC]}#{CRLF}"
+            b << "#{Safrano::CONTENT_TYPE}: #{@hd[CTT_TYPE_LC]}#{CRLF}"
           end
 
           b << crbdcr = "#{CRLF}--#{@boundary}#{CRLF}"
@@ -431,14 +436,14 @@ module MIME
 
         def initialize
           @hd = {}
-          @content = ''
+          @content = +String.new
         end
 
         def unparse
-          b = "#{@http_method} #{@uri} HTTP/1.1#{CRLF}"
+          b = +"#{@http_method} #{@uri} HTTP/1.1#{CRLF}"
           @hd.each { |k, v| b << "#{k}: #{v}#{CRLF}" }
           b << CRLF
-          b << @content if @content != ''
+          b << @content unless content.empty?
           b
         end
       end
@@ -452,7 +457,7 @@ module MIME
                                "Content-Transfer-Encoding: binary#{CRLF}",
                                'HTTP/1.1 '].join(CRLF).freeze
 
-        StatusMessage = ::WEBrick::HTTPStatus::StatusMessage.freeze
+        StatusMessage = ::Rack::Utils::HTTP_STATUS_CODES.freeze
 
         def initialize
           @hd = {}
@@ -464,7 +469,7 @@ module MIME
         end
 
         def unparse
-          b = String.new(APPLICATION_HTTP_11)
+          b = +String.new(APPLICATION_HTTP_11)
           b << "#{@status} #{StatusMessage[@status]} #{CRLF}"
           @hd.each { |k, v| b << "#{k}: #{v}#{CRLF}" }
           b << CRLF
@@ -475,9 +480,9 @@ module MIME
 
       # For application/http . Content is either a Request or a Response
       class Http < Media
-        HTTP_MTHS_RGX = 'POST|GET|PUT|MERGE|PATCH|DELETE'.freeze
+        HTTP_MTHS_RGX = 'POST|GET|PUT|MERGE|PATCH|DELETE'
         HTTP_R_RGX = %r{^(#{HTTP_MTHS_RGX})\s+(\S*)\s?(HTTP/1\.1)\s*$}.freeze
-        HEADER_RGX = %r{^([a-zA-Z\-]+):\s*([0-9a-zA-Z\-\/,\s]+;?\S*)\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
@@ -566,7 +571,7 @@ module MIME
         end
 
         def unparse
-          b =  "Content-Type: #{@ct}#{CRLF}"
+          b =  +"Content-Type: #{@ct}#{CRLF}"
           b << "Content-Transfer-Encoding: binary#{CRLF}#{CRLF}"
           b << @content.unparse
           b