cyberweb 0.4.174 → 0.5.225

data/lib/cyberweb/REST/base/helpers/stream.rb

@@ -0,0 +1,75 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Cyberweb::REST::Helpers::Stream
+# =========================================================================== #
+# require 'cyberweb/REST/base/helpers/stream.rb'
+# =========================================================================== #
+module Cyberweb
+
+module REST
+
+module Helpers
+
+# =========================================================================== #
+# Class of the response body in case you use #stream.
+#
+# Three things really matter: The front and back block (back being the
+# block generating content, front the one sending it to the client) and
+# the scheduler, integrating with whatever concurrency feature the Rack
+# handler is using.
+#
+# Scheduler has to respond to defer and schedule.
+# =========================================================================== #
+class Stream
+
+  def self.schedule(*) yield end
+  def self.defer(*)    yield end
+
+  # === initialize
+  def initialize(scheduler = self.class, keep_open = false, &back)
+    @back = back.to_proc
+    @scheduler = scheduler
+    @keep_open = keep_open
+    @callbacks = []
+    @closed = false
+  end
+
+  # === close
+  def close
+    return if closed?
+    @closed = true
+    @scheduler.schedule { @callbacks.each { |c| c.call } }
+  end
+
+  # === each
+  def each(&front)
+    @front = front
+    @scheduler.defer do
+      begin
+        @back.call(self)
+      rescue Exception => e
+        @scheduler.schedule { raise e }
+      end
+      close unless @keep_open
+    end
+  end
+
+  # === <<
+  def <<(data)
+    @scheduler.schedule { @front.call(data.to_s) }
+    self
+  end
+  # === callback
+  def callback(&block)
+    return yield if closed?
+    @callbacks << block
+  end; alias errback callback # === errback
+
+  # === closed?
+  def closed?
+    @closed
+  end
+
+end; end; end; end

data/lib/cyberweb/REST/base/mime_type_entry.rb

@@ -0,0 +1,67 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Cyberweb::REST::MimeTypeEntry
+# =========================================================================== #
+# require 'cyberweb/rest/base/mime_type_entry.rb'
+# =========================================================================== #
+module Cyberweb
+
+module REST
+
+class MimeTypeEntry # === Cyberweb::REST::MimeTypeEntry
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(entry)
+    params = entry.scan(HEADER_PARAM).map! { |s|
+      key, value = s.strip.split('=', 2)
+      if value.start_with?('"')
+        value = value[1..-2].gsub(/\\(.)/, '\1')
+      end
+      [key, value]
+    }
+
+    @type   = entry[/[^;]+/].delete(' ')
+    @params = params.to_h
+  end
+
+  # ========================================================================= #
+  # === accepts?
+  # ========================================================================= #
+  def accepts?(entry)
+    File.fnmatch(entry, self) && matches_params?(entry.params)
+  end
+
+  # ========================================================================= #
+  # === params?
+  # ========================================================================= #
+  def params?
+    @params
+  end; alias params params? # === params
+
+  # ========================================================================= #
+  # === to_str
+  # ========================================================================= #
+  def to_str
+    @type
+  end
+
+  # ========================================================================= #
+  # === matches_params?
+  # ========================================================================= #
+  def matches_params?(params)
+    return true if @params.empty?
+    params.all? { |key, value|
+      !@params.key?(key) || @params[key] == value
+    }
+  end
+
+end; end; end
+
+if __FILE__ == $PROGRAM_NAME
+  accept_entry = Cyberweb::REST::MimeTypeEntry.new
+  pp accept_entry.entry?
+end

data/lib/cyberweb/{constants/file_constants.rb → REST/base/not_found.rb}

@@ -2,15 +2,20 @@
 # Encoding: UTF-8
 # frozen_string_literal: true
 # =========================================================================== #
-# require 'cyberweb/constants/file_constants.rb'
+# require 'cyberweb/REST/base/not_found.rb'
 # =========================================================================== #
+require 'cyberweb/REST/base/error.rb'
 module Cyberweb
 
-  require 'cyberweb/project/project.rb'
+module REST
+
+class NotFound < Error
 
   # ========================================================================= #
-  # === FILE_WEB_IMAGES
+  # === http_status
   # ========================================================================= #
-  FILE_WEB_IMAGES = "#{yaml_directory?}web_images.yml"
+  def http_status
+    404
+  end
 
-end
+end; end; end

data/lib/cyberweb/REST/base/request.rb

@@ -0,0 +1,145 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Cyberweb::REST::Request
+# =========================================================================== #
+# require 'cyberweb/REST/base/request.rb'
+# =========================================================================== #
+module Cyberweb
+
+module REST
+
+# =========================================================================== #
+# Stdlib dependencies:
+# =========================================================================== #
+require 'time'
+require 'uri'
+
+require 'rack'
+require 'rack/protection'
+require 'tilt'
+
+#begin
+  require 'mustermann'
+  require 'mustermann/sinatra'
+  require 'mustermann/regular'
+#rescue LoadError; end
+
+require 'cyberweb/REST/base/extended_rack.rb'
+require 'cyberweb/REST/base/response.rb'
+
+# =========================================================================== #
+# The request object. See Rack::Request for more info:
+#
+#   https://rubydoc.info/github/rack/rack/master/Rack/Request
+#
+# =========================================================================== #  
+class Request < Rack::Request # === Cyberweb::REST::Request
+
+  require 'cyberweb/rest/base/accept_entry.rb'
+  require 'cyberweb/rest/base/mime_type_entry.rb'
+
+  alias secure? ssl?
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize
+  end
+
+  # ========================================================================= #
+  # === params
+  # ========================================================================= #
+  def params
+    super
+  rescue Rack::Utils::ParameterTypeError, Rack::Utils::InvalidParameterError => error
+    raise BadRequest,
+          "Invalid query parameters: #{Rack::Utils.escape_html(error.message)}"
+  rescue EOFError => error
+    raise BadRequest,
+          "Invalid multipart/form-data: #{Rack::Utils.escape_html(error.message)}"
+  end
+
+  # ========================================================================= #
+  # === forwarded?
+  # ========================================================================= #
+  def forwarded?
+    @env and @env.include?('HTTP_X_FORWARDED_HOST')
+  end
+
+  # ========================================================================= #
+  # === preferred_type
+  # ========================================================================= #
+  def preferred_type(*types)
+    return accept.first if types.empty?
+    types.flatten!
+    return types.first if accept.empty?
+    accept.detect { |accept_header|
+      type = types.detect { |entry|
+        MimeTypeEntry.new(entry).accepts?(accept_header)
+      }
+      return type if type
+    }
+  end
+
+  # ========================================================================= #
+  # === safe?
+  # ========================================================================= #
+  def safe?
+    get? || head? || options? || trace?
+  end
+
+  # ========================================================================= #
+  # === unlink?
+  # ========================================================================= #
+  def unlink?
+    request_method == 'UNLINK'
+  end
+
+  # ========================================================================= #
+  # === accept?
+  # ========================================================================= #
+  def accept?(type)
+    preferred_type(type).to_s.include?(type)
+  end
+
+  # ========================================================================= #
+  # === link?
+  # ========================================================================= #
+  def link?
+    request_method == 'LINK'
+  end
+
+  # ========================================================================= #
+  # === idempotent?
+  # ========================================================================= #
+  def idempotent?
+    safe? || put? || delete? || link? || unlink?
+  end
+
+  # ========================================================================= #
+  # === accept
+  #
+  # This method will return an array of acceptable media types for the
+  # given response.
+  # ========================================================================= #
+  def accept
+    @env['rest.accept'] ||= if @env.include?('HTTP_ACCEPT') && (@env['HTTP_ACCEPT'].to_s != '')
+                               @env['HTTP_ACCEPT']
+                                 .to_s
+                                 .scan(HEADER_VALUE_WITH_PARAMS)
+                                 .map! { |e| AcceptEntry.new(e) }
+                                 .sort
+                            else
+                              [AcceptEntry.new('*/*')]
+                            end
+    end
+
+end; end; end
+
+if __FILE__ == $PROGRAM_NAME
+  request = Cyberweb::REST::Request.new
+  pp request
+  pp request.params
+end

data/lib/cyberweb/REST/base/response.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Cyberweb::REST::Response
+#
+# The response object. See Rack::Response and Rack::Response::Helpers for
+# more info:
+#
+#   https://rubydoc.info/github/rack/rack/master/Rack/Response
+#   https://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+#
+# =========================================================================== #
+# require 'cyberweb/REST/base/response.rb'
+# =========================================================================== #
+module Cyberweb
+
+module REST
+
+begin
+  require 'rack'
+rescue LoadError; end
+
+class Response < Rack::Response # === Cyberweb::REST::Response
+
+  # ========================================================================= #
+  # === DROP_BODY_RESPONSES
+  # ========================================================================= #
+  DROP_BODY_RESPONSES = [204, 304]
+
+  # ========================================================================= #
+  # === body=
+  # ========================================================================= #
+  def body=(value)
+    value = value.body while Rack::Response === value
+    @body = String === value ? [value.to_str] : value
+  end
+
+  # ========================================================================= #
+  # === each
+  # ========================================================================= #
+  def each
+    block_given? ? super : enum_for(:each)
+  end
+
+  # ========================================================================= #
+  # === finish
+  # ========================================================================= #
+  def finish
+    result = body
+
+    if drop_content_info?
+      headers.delete 'Content-Length'
+      headers.delete 'Content-Type'
+    end
+
+    if drop_body?
+      close
+      result = []
+    end
+
+    if calculate_content_length?
+      # if some other code has already set Content-Length, don't muck with it
+      # currently, this would be the static file-handler
+      headers['Content-Length'] = body.map(&:bytesize).reduce(0, :+).to_s
+    end
+
+    [status, headers, result]
+  end
+
+  private
+
+  # ========================================================================= #
+  # === calculate_content_length?
+  # ========================================================================= #
+  def calculate_content_length?
+    headers['Content-Type'] && !headers['Content-Length'] && (Array === body)
+  end
+
+  # ========================================================================= #
+  # === drop_content_info?
+  # ========================================================================= #
+  def drop_content_info?
+    informational? || drop_body?
+  end
+
+  # ========================================================================= #
+  # === drop_body?
+  # ========================================================================= #
+  def drop_body?
+    DROP_BODY_RESPONSES.include?(status)
+  end
+
+end; end; end

data/lib/cyberweb/REST/base/templates/templates.rb

@@ -0,0 +1,208 @@
+module Cyberweb
+
+module REST
+
+# === Cyberweb::REST::Templates
+#
+# Template rendering methods. Each method takes the name of a template
+# to render as a Symbol and returns a String with the rendered output,
+# as well as an optional hash with additional options.
+#
+# `template` is either the name or path of the template as symbol
+# (Use `:'subdir/myview'` for views in subdirectories), or a string
+# that will be rendered.
+#
+# Possible options are:
+#   :content_type   The content type to use, same arguments as content_type.
+#   :layout         If set to something falsy, no layout is rendered, otherwise
+#                   the specified layout is used
+#   :layout_engine  Engine to use for rendering the layout.
+#   :locals         A hash with local variables that should be available
+#                   in the template
+#   :scope          If set, template is evaluate with the binding of the given
+#                   object rather than the application instance.
+#   :views          Views directory to use.
+module Templates
+  module ContentTyped
+    attr_accessor :content_type
+  end
+
+  def initialize
+    super
+    @default_layout = :layout
+    @preferred_extension = nil
+  end
+
+  # === ebr
+  def erb(template, options = {}, locals = {}, &block)
+    render(:erb, template, options, locals, &block)
+  end
+
+  def haml(template, options = {}, locals = {}, &block)
+    render(:haml, template, options, locals, &block)
+  end
+
+  def builder(template = nil, options = {}, locals = {}, &block)
+    options[:default_content_type] = :xml
+    render_ruby(:builder, template, options, locals, &block)
+  end
+
+  def liquid(template, options = {}, locals = {}, &block)
+    render(:liquid, template, options, locals, &block)
+  end
+
+  def markdown(template, options = {}, locals = {})
+    options[:exclude_outvar] = true
+    render :markdown, template, options, locals
+  end
+
+  def rdoc(template, options = {}, locals = {})
+    render :rdoc, template, options, locals
+  end
+
+  def asciidoc(template, options = {}, locals = {})
+    render :asciidoc, template, options, locals
+  end
+
+  def markaby(template = nil, options = {}, locals = {}, &block)
+    render_ruby(:mab, template, options, locals, &block)
+  end
+
+  def nokogiri(template = nil, options = {}, locals = {}, &block)
+    options[:default_content_type] = :xml
+    render_ruby(:nokogiri, template, options, locals, &block)
+  end
+
+  def slim(template, options = {}, locals = {}, &block)
+    render(:slim, template, options, locals, &block)
+  end
+
+  def yajl(template, options = {}, locals = {})
+    options[:default_content_type] = :json
+    render :yajl, template, options, locals
+  end
+
+  def rabl(template, options = {}, locals = {})
+    Rabl.register!
+    render :rabl, template, options, locals
+  end
+
+  # Calls the given block for every possible template file in views,
+  # named name.ext, where ext is registered on engine.
+  def find_template(views, name, engine)
+    yield ::File.join(views, "#{name}.#{@preferred_extension}")
+
+    Tilt.default_mapping.extensions_for(engine).each do |ext|
+      yield ::File.join(views, "#{name}.#{ext}") unless ext == @preferred_extension
+    end
+  end
+
+  private
+
+  # logic shared between builder and nokogiri
+  def render_ruby(engine, template, options = {}, locals = {}, &block)
+    if template.is_a?(Hash)
+       options = template
+       template = nil
+    end
+    template = proc { block } if template.nil?
+    render engine, template, options, locals
+  end
+
+  # === render
+  def render(engine, data, options = {}, locals = {}, &block)
+    # merge app-level options
+    engine_options = settings.respond_to?(engine) ? settings.send(engine) : {}
+    options.merge!(engine_options) { |_key, v1, _v2| v1 }
+
+    # extract generic options
+    locals          = options.delete(:locals) || locals         || {}
+    views           = options.delete(:views)  || settings.views || './views'
+    layout          = options[:layout]
+    layout          = false if layout.nil? && options.include?(:layout)
+    eat_errors      = layout.nil?
+    layout          = engine_options[:layout] if layout.nil? || (layout == true && engine_options[:layout] != false)
+    layout          = @default_layout         if layout.nil? || (layout == true)
+    layout_options  = options.delete(:layout_options) || {}
+    content_type    = options.delete(:default_content_type)
+    content_type    = options.delete(:content_type)   || content_type
+    layout_engine   = options.delete(:layout_engine)  || engine
+    scope           = options.delete(:scope)          || self
+    exclude_outvar  = options.delete(:exclude_outvar)
+    options.delete(:layout)
+
+      # set some defaults
+      options[:outvar] ||= '@_out_buf' unless exclude_outvar
+      options[:default_encoding] ||= settings.default_encoding
+
+      # compile and render template
+      begin
+        layout_was      = @default_layout
+        @default_layout = false
+        template        = compile_template(engine, data, options, views)
+        output          = template.render(scope, locals, &block)
+      ensure
+        @default_layout = layout_was
+      end
+
+      # render layout
+      if layout
+        extra_options = { views: views, layout: false, eat_errors: eat_errors, scope: scope }
+        options = options.merge(extra_options).merge!(layout_options)
+
+        catch(:layout_missing) { return render(layout_engine, layout, options, locals) { output } }
+      end
+
+      output.extend(ContentTyped).content_type = content_type if content_type
+      output
+    end
+
+    def compile_template(engine, data, options, views)
+      eat_errors = options.delete :eat_errors
+      template = Tilt[engine]
+      raise "Template engine not found: #{engine}" if template.nil?
+
+      case data
+      when Symbol
+        template_cache.fetch engine, data, options, views do
+          body, path, line = settings.templates[data]
+          if body
+            body = body.call if body.respond_to?(:call)
+            template.new(path, line.to_i, options) { body }
+          else
+            found = false
+            @preferred_extension = engine.to_s
+            find_template(views, data, template) do |file|
+              path ||= file # keep the initial path rather than the last one
+              found = File.exist?(file)
+              if found
+                path = file
+                break
+              end
+            end
+            throw :layout_missing if eat_errors && !found
+            template.new(path, 1, options)
+          end
+        end
+      when Proc
+        compile_block_template(template, options, &data)
+      when String
+        template_cache.fetch engine, data, options, views do
+          compile_block_template(template, options) { data }
+        end
+      else
+        raise ArgumentError, "Sorry, don't know how to render #{data.inspect}."
+      end
+    end
+
+    def compile_block_template(template, options, &body)
+      first_location = caller_locations.first
+      path = first_location.path
+      line = first_location.lineno
+      path = options[:path] || path
+      line = options[:line] || line
+      template.new(path, line.to_i, options, &body)
+    end
+  end
+
+end; end

data/lib/cyberweb/REST/base/wrapper.rb

@@ -0,0 +1,28 @@
+module Cyberweb
+
+module REST
+
+class Wrapper
+
+  def initialize(stack, instance)
+    @stack = stack
+    @instance = instance
+  end
+
+  def settings
+    @instance.settings
+  end
+
+  def helpers
+    @instance
+  end
+
+  def call(env)
+    @stack.call(env)
+  end
+
+  def inspect
+    "#<#{@instance.class} app_file=#{settings.app_file.inspect}>"
+  end
+
+end; end; end

data/lib/cyberweb/{constants/nl.rb → REST/constants.rb}

@@ -2,21 +2,20 @@
 # Encoding: UTF-8
 # frozen_string_literal: true
 # =========================================================================== #
-# require 'cyberweb/constants/nl.rb'
+# require 'cyberweb/rest/constants.rb'
 # =========================================================================== #
 module Cyberweb
 
+module REST
+
   # ========================================================================= #
-  # === N
-  #
-  # Note that NL is an alias to this, but this may change eventually.
-  # (NL could be N+BR, actually).
+  # === Cyberweb::REST::HEADER_PARAM
   # ========================================================================= #
-  N = "\n"
+  HEADER_PARAM = /\s*[\w.]+=(?:[\w.]+|"(?:[^"\\]|\\.)*")?\s*/
 
   # ========================================================================= #
-  # === NL
+  # === Cyberweb::REST::HEADER_VALUE_WITH_PARAMS
   # ========================================================================= #
-  NL = N
+  HEADER_VALUE_WITH_PARAMS = %r{(?:(?:\w+|\*)/(?:\w+(?:\.|-|\+)?|\*)*)\s*(?:;#{HEADER_PARAM})*}
 
-end
+end; end