blix-rest 0.1.30

data/lib/blix/rest/format.rb

@@ -0,0 +1,15 @@
+# the format of a request is determined by
+# - the uri extension    eg: .html
+# - the mime type of the request ( only for html, xml, json )
+# - in some cases a query parameter.
+
+# this file is for looking into the idea of mapping
+# multiple extensions and multiple mime types onto one
+# format type.
+
+# for now it does not seem neccessary.
+
+module Blix::Rest
+
+
+end

data/lib/blix/rest/format_parser.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+module Blix::Rest
+  # this is the base class for all the format parsers
+  class FormatParser
+
+    attr_accessor :__custom_headers
+
+    def set_default_headers(headers)
+      # headers[CACHE_CONTROL]= CACHE_NO_STORE
+      # headers[PRAGMA]       = NO_CACHE
+      # headers[CONTENT_TYPE] = CONTENT_TYPE_JSON
+    end
+
+    attr_reader :_format
+
+    attr_writer :_options
+
+    def _options
+      @_options || {}
+    end
+
+    def _format=(val)
+      @_format = val.to_s.downcase
+    end
+
+    def self._types
+      @_types || []
+    end
+
+    def _types
+      self.class._types
+    end
+
+    # the accept header types that correspont to this parser.
+    def self.accept_types(types)
+      types = [types].flatten
+      @_types = types
+    end
+
+    # construct the body of an error messsage.
+    def format_error(message)
+      message.to_s
+    end
+
+    # set the response content / headers / status
+    # headers are the default headers if not set
+    # status is 200 if not set
+    def format_response(value, response)
+      response.content = value.to_s
+    end
+
+  end
+
+  #-----------------------------------------------------------------------------
+  # the default json format parser
+  #
+  class JsonFormatParser < FormatParser
+
+    accept_types CONTENT_TYPE_JSON
+
+    def set_default_headers(headers)
+      headers[CACHE_CONTROL] = CACHE_NO_STORE
+      headers[PRAGMA]       = NO_CACHE
+      headers[CONTENT_TYPE] = CONTENT_TYPE_JSON
+    end
+
+    def format_error(message)
+      MultiJson.dump({"error"=>message.to_s}) rescue "{\"error\":\"Internal Formatting Error\"}"
+    end
+
+    def format_response(value, response)
+      if value.is_a?(RawJsonString)
+        response.content = if _options[:nodata]
+                             value.to_s
+                           else
+                             "{\"data\":#{value}}"
+                           end
+      else
+        begin
+          response.content = if _options[:nodata]
+                               MultiJson.dump(value)
+                             else
+                               MultiJson.dump('data' => value)
+                           end
+        rescue Exception => e
+          ::Blix::Rest.logger << e.to_s
+          response.set(500, format_error('Internal Formatting Error'))
+        end
+      end
+    end
+
+  end
+
+  #-----------------------------------------------------------------------------
+  # the default raw format parser
+  #
+  class RawFormatParser < FormatParser
+
+    # def set_default_headers(headers)
+    #   #headers[CACHE_CONTROL]= CACHE_NO_STORE
+    #   #headers[PRAGMA]       = NO_CACHE
+    # end
+
+    def format_error(message)
+      message
+    end
+
+    def format_response(value, response)
+      response.content = value.to_s
+    end
+
+  end
+
+  #-----------------------------------------------------------------------------
+  # the default xml format parser
+  #
+  class XmlFormatParser < FormatParser
+
+    accept_types CONTENT_TYPE_XML
+
+    def set_default_headers(headers)
+      headers[CACHE_CONTROL] = CACHE_NO_STORE
+      headers[PRAGMA]       = NO_CACHE
+      headers[CONTENT_TYPE] = CONTENT_TYPE_XML
+    end
+
+    def format_error(message)
+      "<error>#{message}</error>"
+    end
+
+    def format_response(value, response)
+      response.content = value.to_s # FIXME
+    end
+
+  end
+
+  #-----------------------------------------------------------------------------
+  # the default html format parser
+  #
+  class HtmlFormatParser < FormatParser
+
+    accept_types CONTENT_TYPE_HTML
+
+    def set_default_headers(headers)
+      headers[CACHE_CONTROL] = CACHE_NO_STORE
+      headers[PRAGMA]       = NO_CACHE
+      headers[CONTENT_TYPE] = CONTENT_TYPE_HTML
+    end
+
+    def format_error(message)
+      %(
+        <html>
+        <head></head>
+        <body>
+        <p>#{message}</p>
+        </body>
+        </html>
+      )
+    end
+
+    def format_response(value, response)
+      response.content = value.to_s
+    end
+
+  end
+end

data/lib/blix/rest/handlebars_assets_fix.rb

@@ -0,0 +1,10 @@
+module HandlebarsAssets
+  
+  module JSON
+    
+    def self.dump(str)
+      str.to_json
+    end
+  end
+  
+end

data/lib/blix/rest/request_mapper.rb

@@ -0,0 +1,332 @@
+# frozen_string_literal: true
+
+module Blix::Rest
+  class RequestMapperError < StandardError; end
+
+  # register routes with this class and then we can match paths to
+  # these routes and return an associated block and parameters.
+  class RequestMapper
+
+    WILD_PLACEHOLDER = '/'
+    PATH_SEP         = '/'
+    STAR_PLACEHOLDER = '*'
+
+    # the
+
+    class TableNode
+
+      attr_accessor :blk
+      attr_reader   :value
+      attr_accessor :opts
+      attr_reader   :parameter
+      attr_reader   :children
+      attr_accessor :extract_format
+
+      def initialize(name)
+        @children = {}
+        if name[0, 1] == ':'
+          @parameter = name[1..-1].to_sym
+          @value     = WILD_PLACEHOLDER
+        elsif name[0, 1] == '*'
+          @parameter = if name[1..-1].empty?
+                         :wildpath
+                       else
+                         name[1..-1].to_sym
+                       end
+          @value = STAR_PLACEHOLDER
+        else
+          @value = name
+        end
+        @extract_format = true
+      end
+
+      def [](k)
+        @children[k]
+      end
+
+      def []=(k, v)
+        @children[k] = v
+      end
+
+    end
+
+    class << self
+
+      def set_path_root(root)
+        root = root.to_s
+        root = '/' + root if root[0, 1] != '/'
+        root += '/' if root[-1, 1] != '/'
+        @path_root = root
+        @path_root_length = @path_root.length - 1
+      end
+
+      def path_root
+        @path_root || '/'
+      end
+
+      attr_reader :path_root_length
+
+      def full_path(path)
+        path = path[1..-1] if path[0, 1] == '/'
+        path_root + path
+      end
+
+      def locations
+        @locations ||= Hash.new { |h, k| h[k] = [] }
+      end
+
+      def table
+        @table ||= compile
+      end
+
+      def dump
+        table.each do |k, v|
+          puts k
+          dump_node(v, 1)
+        end
+      end
+
+      def dump_node(item, indent = 0)
+        puts "#{' ' * indent} value=#{item.value.inspect} opts=#{item.opts.inspect} params=#{item.parameter.inspect}"
+        item.children.each_value { |c| dump_node(c, indent + 1) }
+      end
+
+      # used for testing only !!
+      def reset(vals = nil)
+        save = [@table&.dup, @locations&.dup, @path_root&.dup, @path_root_length]
+        if vals
+          @table     = vals[0]
+          @locations = vals[1]
+          @path_root = vals[2]
+          @path_root_length = vals[3]
+        else
+          @table     = nil
+          @locations = nil
+          @path_root = nil
+          @path_root_length = 0
+        end
+        save
+      end
+
+      # compile routes into a tree structure for easy lookup
+      def compile
+        @table = Hash.new { |h, k| h[k] = TableNode.new('') }
+        locations.each do |verb, routes|
+          routes.each do |info|
+            verb, path, opts, blk = info
+            parts = path.split(PATH_SEP)
+            current = @table[verb]
+            parts.each_with_index do |section, idx|
+              node = TableNode.new(section)
+              # check that a wildstar is the last element.
+              if (section[0] == STAR_PLACEHOLDER) && (idx < (parts.length - 1))
+                raise RequestMapperError, "do not add a path after the * in #{path}"
+              end
+
+              # check that wild card match in name
+              if current[node.value]
+                if (node.value == WILD_PLACEHOLDER) && (node.parameter != current[node.value].parameter)
+                  raise RequestMapperError, "parameter mismatch in route=#{path}, expected #{current[node.value].parameter} but got #{node.parameter}"
+                end
+
+              else
+                current[node.value] = node
+              end
+              current = current[node.value]
+            end
+            current.blk = blk
+            current.opts = opts || {}
+            current.extract_format = opts[:extension] if opts.key?(:extension)
+          end
+        end
+        @table
+      end
+
+      # declare a route
+      def add_path(verb, path, opts = {}, &blk)
+        path = path[1..-1] if path[0, 1] == PATH_SEP
+        RequestMapper.locations[verb] << [verb, path, opts, blk]
+        @table = nil # force recompile
+      end
+
+      # match a given path to  declared route.
+      def match(verb, path)
+        path = PATH_SEP + path if path[0, 1] != PATH_SEP # ensure a leading slash on path
+
+        path = path[path_root_length..-1] if (path_root_length.to_i > 0) #&& (path[0,path_root_length] == path_root)
+        if path
+          path = path[1..-1] if path[0, 1] == PATH_SEP # remove the leading slash
+        else
+          return [nil, {}, nil]
+        end
+
+        parameters = StringHash.new
+
+        parts = path.split(PATH_SEP)
+        current = table[verb]
+        limit   = parts.length - 1
+
+        # handle the root node here
+        if path == ''
+          if current.blk
+            return [current.blk, parameters, current.opts]
+          elsif (havewild = current[STAR_PLACEHOLDER])
+            parameters[havewild.parameter.to_s] = '/'
+            return [havewild.blk, parameters, havewild.opts]
+          else
+            return [nil, {}, nil]
+          end
+        end
+
+        parts.each_with_index do |section, idx|
+          # first save the last node that we used
+          # before updating the current node.
+
+          last = current # table nodes
+
+          # check to see if there is a path which includes a format part
+          # only on the last section
+          if idx == limit
+            if last[section]
+              current = last[section]
+            else
+              format  = File.extname(section)
+              base    = File.basename(section, format)
+              current = last[base]
+              if current
+                parameters['format'] = format[1..-1].to_sym # !format.empty?
+                section = base
+              end
+            end
+          else
+            current = last[section]
+          end
+
+          # if current is set here that means that this section matches a fixed
+          # part of the route.
+          if current
+
+            # if this is the last section then we have to decide here if we
+            # have a valid result..
+            # .. if we have a block then fine ..
+            # .. if there is a wildpath foloowing then fine ..
+            # .. otherwise an error !
+
+            if idx == limit # the last section of request
+              if current.blk
+                return [current.blk, parameters, current.opts]
+              elsif (havewild = current[STAR_PLACEHOLDER])
+                parameters[havewild.parameter.to_s] = '/'
+                return [havewild.blk, parameters, havewild.opts]
+              else
+                return [nil, {}, nil]
+              end
+            end
+          else
+
+            # this section is  not part of a static path so
+            # check if we have a path variable first ..
+
+            current = last[WILD_PLACEHOLDER]
+            if current
+
+              # yes this is a path variable section
+              if idx == limit
+
+                # the last section of request -
+                if current.extract_format
+                  format  = File.extname(section)
+                  base    = File.basename(section, format)
+                  parameters[current.parameter.to_s] = base
+                  parameters['format'] = format[1..-1].to_sym unless format.empty?
+                else
+                  parameters[current.parameter.to_s] = section
+                end
+
+                # check if we have a valid block otherwise see if
+                # a wild path follows.
+
+                if current.blk
+                  return [current.blk, parameters, current.opts]
+                elsif (havewild = current[STAR_PLACEHOLDER])
+                  parameters[havewild.parameter.to_s] = '/'
+                  return [havewild.blk, parameters, havewild.opts]
+                else
+                  return [nil, {}, nil]
+                end
+
+              else
+                parameters[current.parameter.to_s] = section
+              end
+            else
+              current = last[STAR_PLACEHOLDER]
+              if current
+                wildpath = '/' + parts[idx..-1].join('/')
+                wildformat = File.extname(wildpath)
+                unless wildformat.empty? || !current.extract_format
+                  wildpath = wildpath[0..-(wildformat.length + 1)]
+                  parameters['format'] = wildformat[1..-1].to_sym
+                end
+                parameters[current.parameter.to_s] = wildpath
+                return [current.blk, parameters, current.opts]
+              else
+                return [nil, {}, nil]
+              end
+            end
+          end
+        end
+        [nil, {}, nil]
+      end
+
+      # match a path to a route and call any associated block with the extracted parameters.
+      def process(verb, path)
+        blk, params = match(verb, path)
+        blk&.call(params)
+      end
+
+      def routes
+        hash = {}
+        locations.values.each do |group|
+          group.each do |route|
+            verb = route[0]
+            options = route[2]
+            options_string = String.new
+            options_string = ' ' + options.inspect.to_s unless options.empty?
+            path = '/' + route[1]
+            hash[path] ||= {}
+            hash[path][verb] = options_string
+          end
+        end
+        list = hash.to_a
+        list.sort! { |a, b| a[0] <=> b[0] }
+        str = String.new
+        list.each do |route|
+          #pairs = route[1]
+          (HTTP_VERBS + ['ALL']).each do |verb|
+            if route[1].key? verb
+              str << verb << "\t" << route[0] << route[1][verb] << "\n"
+            end
+          end
+          str << "\n"
+        end
+        str
+      end
+
+    end
+
+  end # RequestMapper
+
+  def self.set_path_root(*args)
+    RequestMapper.set_path_root(*args)
+  end
+
+  def self.path_root
+    RequestMapper.path_root
+  end
+
+  def self.full_path(path)
+    RequestMapper.full_path(path)
+  end
+
+  RequestMapper.set_path_root(ENV['BLIX_REST_ROOT']) if ENV['BLIX_REST_ROOT']
+end # Rest