blix-rest 0.1.30

data/lib/blix/rest/resource_cache.rb

@@ -0,0 +1,50 @@
+module Blix::Rest
+  
+  module ResourceCache
+
+    private
+    
+    def _cache_hash
+      @_cache ||= {}
+    end
+
+    def _cache_get(*args,&block)
+      field = args[0].to_s
+      if block && args.length == 1
+        if  _cache?(field)
+          _cache_hash[field]
+        else
+          _cache_hash[field]= block.call
+        end
+      elsif args.length == 1
+        _cache_hash[field]
+      elsif  args.length == 2
+        if  _cache?(field)
+          _cache_hash[field]
+        else
+          _cache_hash[field]= args[1]
+        end
+      else
+        raise "wrong number of arguments:#{args.length} for 1 or 2"
+      end
+    end
+
+    def _cache_set(field,val)
+      _cache_hash[field.to_s] = val
+    end
+
+    def _cache_reset(field)
+      _cache_hash.delete field.to_s
+    end
+
+    def _cache(field)
+      _cache_hash[field.to_s]
+    end
+
+    def _cache?(field)
+      _cache_hash.key?(field.to_s)
+    end
+    
+  end
+  
+end

data/lib/blix/rest/response.rb

@@ -0,0 +1,26 @@
+# pass a response object to the controller to set
+# header status and content.
+
+module Blix::Rest
+
+
+  class Response
+
+    attr_accessor :status
+    attr_reader   :headers
+    attr_accessor :content
+
+    def initialize
+      @status  = 200
+      @headers  = {}
+      @content = nil
+    end
+
+    def set(status,content=nil,headers=nil)
+      @status = status if status
+      @content = String.new(content) if content
+      @headers.merge!(headers) if headers
+    end
+
+  end
+end

data/lib/blix/rest/server.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+module Blix::Rest
+  class Server
+
+    def initialize(opts = {})
+      @_parsers = {}
+      @_mime_types = {}
+
+      # register the default parsers and any passed in as options.
+
+      register_parser('html', HtmlFormatParser.new)
+      register_parser('json', JsonFormatParser.new)
+      register_parser('xml', XmlFormatParser.new)
+      register_parser('raw', RawFormatParser.new)
+      extract_parsers_from_options(opts)
+      @_options = opts
+    end
+
+    def _cache
+      @_cache ||= {}
+    end
+
+    def extract_parsers_from_options(opts)
+      opts.each do |k, v|
+        next unless k =~ /^(\w*)_parser&/
+
+        format = Regexp.last_match(1)
+        parser = v
+        register_parser(format, parser)
+      end
+    end
+
+    def set_custom_headers(format, headers)
+      parser = get_parser(format)
+      raise "parser not found for custom headers format=>#{format}" unless parser
+
+      parser.__custom_headers = headers
+    end
+
+    def get_parser(format)
+      @_parsers[format.to_s]
+    end
+
+    def get_parser_from_type(type)
+      @_mime_types[type.downcase]
+    end
+
+    def register_parser(format, parser)
+      raise "#{k} must be an object with parent class Blix::Rest::FormatParser" unless parser.is_a?(FormatParser)
+
+      parser._format = format
+      @_parsers[format.to_s.downcase] = parser
+      parser._types.each { |t| @_mime_types[t.downcase] = parser } # register each of the mime types
+    end
+
+    def retrieve_params(env)
+      post_params = {}
+      body        = ''
+      params = env['params'] || {}
+      params.merge!(::Rack::Utils.parse_nested_query(env['QUERY_STRING']))
+
+      if env['rack.input']
+        post_params = ::Rack::Utils::Multipart.parse_multipart(env)
+        unless post_params
+          body = env['rack.input'].read
+          env['rack.input'].rewind
+
+          if body.empty?
+            post_params = {}
+          else
+            begin
+              post_params = case (env['CONTENT_TYPE'])
+                            when URL_ENCODED
+                              ::Rack::Utils.parse_nested_query(body)
+                            when JSON_ENCODED then
+                              json = MultiJson.load(body)
+                              if json.is_a?(Hash)
+                                json
+                              else
+                                { '_json' => json }
+                              end
+                            else
+                              {}
+              end
+            rescue StandardError => e
+              raise BadRequestError, "Invalid parameters: #{e.class}"
+            end
+          end
+        end
+      end
+      [params, post_params, body]
+    end
+
+    # accept header can have multiple entries. match on regexp
+    # can look like this
+    # text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8   !!!!!
+
+    def get_format(env)
+      case env['HTTP_ACCEPT']
+      when JSON_ENCODED then :json
+      when HTML_ENCODED then :html
+      when XML_ENCODED then :xml
+      end
+    end
+
+    def get_format_from_mime(mime)
+      case mime
+      when 'application/json' then :json
+      when 'text/html' then :html
+      when 'application/xml'  then :xml
+      when 'application/xhtml+xml' then :xhtml
+      when '*/*' then :*
+      end
+    end
+
+    # attempt to handle mjltiple accept formats here..
+    # mime can include '.../*' and '*/*'
+    # FIXME
+    def get_format_new(env, options)
+      accept = options && options[:accept] || :json
+      accept = [accept].flatten
+
+      requested = env['HTTP_ACCEPT'].to_s.split(',')
+      requested.each do |request|
+        parts = request.split(';') # the quality part is after a ;
+        mime = parts[0].strip # the mime type
+        try = get_format_from_mime(mime)
+        next unless try
+        return accept[0] || :json if try == :*
+        return try if accept.include?(try)
+      end
+      nil # no match found
+    end
+
+    # convert the response to the appropriate format
+    def format_error(_message, _format)
+      parser
+    end
+
+    def call(env)
+      req = Rack::Request.new(env)
+
+      verb            = env['REQUEST_METHOD']
+      path            = req.path
+
+      blk, path_params, options = RequestMapper.match(verb, path)
+
+      blk, path_params, options = RequestMapper.match('ALL', path) unless blk
+
+      default_format = options && options[:default] && options[:default].to_sym
+      force_format = options && options[:force] && options[:force].to_sym
+      do_cache = options && options[:cache]
+      clear_cache = options && options[:cache_reset]
+
+      query_format = options && options[:query] && req.GET['format'] && req.GET['format'].to_sym
+
+      format = query_format || path_params[:format] || get_format_new(env, options) || default_format || :json
+
+      parser = get_parser(force_format || format)
+
+      return [406, {}, ["Invalid Format: #{format}"]] unless parser
+
+      parser._options = options
+
+      # check for cached response end return with cached response if found.
+      #
+      if do_cache && _cache["#{verb}|#{format}|#{path}"]
+        response = _cache["#{verb}|#{format}|#{path}"]
+        return [response.status, response.headers.merge('X-Blix-Cache' => 'cached'), [response.content]]
+      end
+
+      response = Response.new
+
+      if parser.__custom_headers
+        response.headers.merge! parser.__custom_headers
+      else
+        parser.set_default_headers(response.headers)
+      end
+
+      if blk
+
+        begin
+          params = env['params']
+          value  = blk.call(path_params, params, req, format, response, @_options)
+        rescue ServiceError => e
+          response.set(e.status, parser.format_error(e.message), e.headers)
+        rescue AuthorizationError => e
+          response.set(401, parser.format_error(e.message), AUTH_HEADER => "#{e.type} realm=\"#{e.realm}\", charset=\"UTF-8\"")
+        rescue Exception => e
+          response.set(500, parser.format_error('internal error'))
+          ::Blix::Rest.logger <<  "----------------------------\n#{$!}\n----------------------------"
+          ::Blix::Rest.logger <<  "----------------------------\n#{$@}\n----------------------------"
+        else # no error
+          parser.format_response(value, response)
+          # cache response if requested
+          _cache.clear if clear_cache
+          _cache["#{verb}|#{format}|#{path}"] = response if do_cache
+        end
+
+      else
+        response.set(404, parser.format_error('Invalid Url'))
+      end
+      [response.status, response.headers, [response.content]]
+    end
+
+  end
+end

data/lib/blix/rest/string_hash.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+unless Hash.method_defined? :transform_keys
+  class Hash
+    # Returns a new hash with all keys converted using the block operation.
+    #
+    #  hash = { name: 'Rob', age: '28' }
+    #
+    #  hash.transform_keys{ |key| key.to_s.upcase }
+    #  # => {"NAME"=>"Rob", "AGE"=>"28"}
+    def transform_keys
+      result = {}
+      each_key do |key|
+        result[yield(key)] = self[key]
+      end
+      result
+    end
+  end
+end
+
+module Blix::Rest
+  # indifferent hash for symbols or string keys.
+  # stores keys as a string
+
+  class StringHash < Hash
+
+    alias_method :parent_merge!, :merge!
+
+    # initialize without conversion. params must be in
+    # string key format.
+    def initialize(*params)
+      super()
+      parent_merge!(*params) unless params.empty?
+    end
+
+    # create with conversion
+    def self.create(params)
+      h = new
+      h.merge(params)
+      h
+    end
+
+    def [](k)
+      super(k.to_s)
+    end
+
+    def get(k, default = nil)
+      if key?(k.to_s)
+        self[k]
+      else
+        default
+      end
+    end
+
+    def merge(*params)
+      super(* params.map { |h| h.transform_keys(&:to_s) })
+    end
+
+    def merge!(*params)
+      super(* params.map { |h| h.transform_keys(&:to_s) })
+    end
+
+    def replace(h)
+      super(h.transform_keys(&:to_s))
+    end
+
+    def has_key?(key)
+      super(key.to_s)
+    end
+
+    def member?(key)
+      super(key.to_s)
+    end
+
+    def store(key, value)
+      super(key.to_s, value)
+    end
+
+    def key(key)
+      super(key.to_s)
+    end
+
+    def key?(key)
+      super(key.to_s)
+    end
+
+    def []=(k, v)
+      super(k.to_s, v)
+    end
+
+    def include?(k)
+      super(k.to_s)
+    end
+
+    def delete(k)
+      super(k.to_s)
+    end
+
+  end
+end

data/lib/blix/rest/version.rb

@@ -0,0 +1,5 @@
+module Blix
+  module Rest
+    VERSION = "0.1.30"
+  end
+end

data/lib/blix/utils.rb

@@ -0,0 +1,2 @@
+require_relative 'utils/misc'
+require_relative 'utils/yaml_config'

data/lib/blix/utils/misc.rb

@@ -0,0 +1,62 @@
+
+
+module Blix
+
+  def self.require_dir(path)
+     raise "invalid dir path:#{path}" unless File.directory?(path)
+     Dir.glob("#{path}/*.rb").each {|file| require File.expand_path(file)[0..-4] }
+  end
+
+
+
+  # filter the hash using the supplied filter
+  #
+  # the filter is an array of keys that are permitted
+  # returns a hash containing only the permitted keys and values
+  def self.filter_hash(filter,hash)
+    hash = hash || {}
+    hash.select {|key, value| filter.include?(key.to_sym) ||  filter.include?(key.to_s)}
+  end
+
+  # used to raise errors on
+  module DatamapperExceptions
+    def save(*args)
+      raise ServiceError, errors.full_messages.join(',') unless super
+      self
+    end
+
+    def update(*args)
+      raise ServiceError, errors.full_messages.join(',') unless super
+      self
+    end
+
+    def destroy(*args)
+      raise ServiceError, errors.full_messages.join(',') unless super
+      true
+    end
+
+    module ClassMethods
+
+    end
+
+    def self.included(mod)
+      mod.extend DatamapperExceptions::ClassMethods
+    end
+
+  end
+
+end
+
+class String
+
+  # try to convert utf special characters to normal characters.
+  def to_ascii
+    unicode_normalize(:nfd).gsub(/[\u0300-\u036f]/, "")
+  end
+
+  # standardize utf strings
+  def normalize
+    unicode_normalize(:nfc)
+  end
+
+end