manveru-innate 2009.02.06

data/lib/innate/options.rb

@@ -0,0 +1,91 @@
+require 'innate/options/dsl'
+
+module Innate
+  @options = Options.new(:innate)
+
+  def self.options; @options end
+
+  # This has to speak for itself.
+
+  options.dsl do
+    o "IP address or hostname that Ramaze will respond to - 0.0.0.0 for all",
+      :host, "0.0.0.0", :short => :H
+
+    o "Port for the server",
+      :port, 7000, :short => :p
+
+    o "Indicate that calls Innate::start will be ignored",
+      :started, false
+
+    o "Web server to run on",
+      :adapter, :webrick, :short => :a
+
+    o "Will send ::setup to each element during Innate::start",
+      :setup, [Innate::Cache, Innate::Node]
+
+    o "Headers that will be merged into the response before Node::call",
+      :header, {'Content-Type' => 'text/html'}
+
+    o "Trap this signal to issue shutdown, nil/false to disable trap",
+      :trap, 'SIGINT'
+
+    o "Keep state in Thread or Fiber, fall back to Thread if Fiber not available",
+      :state, :Fiber
+
+    sub :log do
+      o "Array of parameters for Logger.new, default to stderr for CGI",
+        :params, [$stderr]
+      o "Use ANSI colors for logging, nil does auto-detection by checking for #tty?",
+        :color, nil
+    end
+
+    sub :redirect do
+      o "Default response HTTP status on redirect",
+        :status, 302
+    end
+
+    sub :env do
+      o "Hostname of this machine",
+        :host, ENV['HOSTNAME'] # FIXME: cross-platform
+      o "Username executing the application",
+        :user, ENV['USER'] # FIXME: cross-platform
+    end
+
+    sub :app do
+      o "Unique identifier for this application",
+        :name, 'pristine'
+      o "Root directory containing the application",
+        :root, File.dirname($0)
+      o "Root directory for view templates, relative to app subdir",
+        :view, '/view'
+      o "Root directory for layout templates, relative to app subdir",
+        :layout, '/layout'
+    end
+
+    sub :session do
+      o "Key for the session cookie",
+        :key, 'innate.sid'
+      o "Domain the cookie relates to, unspecified if false",
+        :domain, false
+      o "Path the cookie relates to",
+        :path, '/'
+      o "Use secure cookie",
+        :secure, false
+      o "Time of cookie expiration",
+        :expires, Time.at(2147483647)
+    end
+
+    sub :cache do
+      o "Assign a cache to each of these names on Innate::Cache::setup",
+        :names, [:session]
+
+      default "If no option for the cache name exists, fall back to this",
+        Innate::Cache::Memory
+    end
+
+    sub :action do
+      o "wish => Action#method",
+        :wish, {'json' => :as_json, 'html' => :as_html, 'yaml' => :as_yaml}
+    end
+  end
+end

data/lib/innate/options/dsl.rb

@@ -0,0 +1,155 @@
+module Innate
+  # Provides a minimal DSL to describe options with defaults and metadata.
+  #
+  # The example below should demonstrate the major features, note that key
+  # lookup wanders up the hierarchy until there is a match found or the parent
+  # of the Options class is itself, in which case nil will be returned.
+  #
+  # Usage:
+  #
+  #   class Calculator
+  #     @options = Options.new(:foo)
+  #     def self.options; @options; end
+  #
+  #     options.dsl do
+  #       o "Which method to use", :method, :plus
+  #       o "Default arguments", :args, [1, 2]
+  #       sub(:minus){ o("Default arguments", :args, [4, 3]) }
+  #     end
+  #
+  #     def self.calculate(method = nil, *args)
+  #       method ||= options[:method]
+  #       args = args.empty? ? options[method, :args] : args
+  #       self.send(method, *args)
+  #     end
+  #
+  #     def self.plus(n1, n2)
+  #       n1 + n2
+  #     end
+  #
+  #     def self.minus(n1, n2)
+  #       n1 - n2
+  #     end
+  #   end
+  #
+  #   Calculator.calculate
+  #   # => 3
+  #   Calculator.options[:method] = :minus
+  #   # => :minus
+  #   Calculator.calculate
+  #   # => 1
+  #   Calculator.calculate(:plus, 4, 5)
+  #   # => 9
+  #
+  class Options
+    def initialize(name, parent = self, &block)
+      @name, @parent, = name, parent
+      @hash = {}
+      yield(self) if block_given?
+    end
+
+    # Shortcut for instance_eval
+    def dsl(&block)
+      instance_eval(&block) if block
+      self
+    end
+
+    # Create a new Options instance with +name+ and pass +block+ on to its #dsl.
+    # Assigns the new instance to the +name+ Symbol on current instance.
+    def sub(name, &block)
+      name = name.to_sym
+
+      case found = @hash[name]
+      when Options
+        found.dsl(&block)
+      else
+        found = @hash[name] = Options.new(name, self).dsl(&block)
+      end
+
+      found
+    end
+
+    # Store an option in the Options instance.
+    #
+    # +doc+   should be a String describing the purpose of this option
+    # +key+   should be a Symbol used to access
+    # +value+ may be any object
+    # +other+ optional Hash that may contain meta-data and should not have :doc
+    #         or :value keys
+    def o(doc, key, value, other = {})
+      @hash[key.to_sym] = other.merge(:doc => doc, :value => value)
+    end
+
+    # To avoid lookup on the parent, we can set a default to the internal Hash.
+    # Parameters as in #o, but without the +key+.
+    def default(doc, value, other = {})
+      @hash.default = other.merge(:doc => doc, :value => value)
+    end
+
+    # Try to retrieve the corresponding Hash for the passed keys, will try to
+    # retrieve the key from a parent if no match is found on the current
+    # instance. If multiple keys are passed it will try to find a matching
+    # child and pass the request on to it.
+    def get(key, *keys)
+      if keys.empty?
+        if value = @hash[key.to_sym]
+          value
+        elsif @parent != self
+          @parent.get(key)
+        else
+          nil
+        end
+      elsif sub_options = get(key)
+        sub_options.get(*keys)
+      end
+    end
+
+    # Retrieve only the :value from the value hash if found via +keys+.
+    def [](*keys)
+      if value = get(*keys)
+        value.is_a?(Hash) ? value[:value] : value
+      end
+    end
+
+    # Assign new :value to the value hash on the current instance.
+    #
+    # TODO: allow arbitrary assignments
+
+    def []=(key, value)
+      if ns = @hash[key.to_sym]
+        ns[:value] = value
+      else
+        raise(ArgumentError, "No key for %p exists" % [key])
+      end
+    end
+
+    def method_missing(meth, *args)
+      case meth.to_s
+      when /^(.*)=$/
+        self[$1] = args.first
+      else
+        self[meth]
+      end
+    end
+
+    def merge!(hash)
+      hash.each do |key, value|
+        self[key] = value
+      end
+    end
+
+    include Enumerable
+
+    def each(&block)
+      @hash.each(&block)
+    end
+
+    def inspect
+      @hash.inspect
+    end
+
+    def pretty_print(q)
+      q.pp_hash @hash
+    end
+  end
+end

data/lib/innate/request.rb

@@ -0,0 +1,165 @@
+module Innate
+
+  # Subclass Rack::Request and add some convenient methods.
+  #
+  # An instance is available via the #request method in your Node.
+  #
+  # NOTE:
+  #   Please make sure to read the documentation of Rack::Request together with
+  #   this, as there are a lot of features available.
+  #
+  # A list of methods from Rack::Request so you get a gist of it:
+  #
+  # ## Generally
+  #
+  # * body
+  # * cookies
+  # * env
+  # * fullpath
+  # * host
+  # * port
+  # * scheme
+  # * url
+  #
+  # ## ENV shortcuts
+  #
+  # * accept_encoding
+  # * content_charset
+  # * content_length
+  # * content_type
+  # * ip
+  # * media_type
+  # * media_type_params
+  # * path_info
+  # * path_info=
+  # * query_string
+  # * referrer
+  # * script_name
+  # * script_name=
+  # * xhr?
+  #
+  # ## Query request method
+  #
+  # * delete?
+  # * get?
+  # * head?
+  # * post?
+  # * put?
+  # * request_method
+  #
+  # ## parameter handling
+  #
+  # * []
+  # * []=
+  # * form_data?
+  # * params
+  # * values_at
+
+  class Request < Rack::Request
+    # Currently handled request from Innate::STATE[:request]
+    # Call it from anywhere via Innate::Request.current
+    def self.current
+      Current.request
+    end
+
+    # Let's allow #[] to act like #values_at.
+    #
+    # Usage given a GET request like /hey?foo=duh&bar=doh
+    #
+    #   request[:foo, :bar] # => ['duh', 'doh']
+    #
+    # Both +value+ and the elements of +keys+ will be turned into String by #to_s.
+    def [](value, *keys)
+      return super(value) if keys.empty?
+      [value, *keys].map{|k| super(k) }
+    end
+
+    # the full request URI provided by Rack::Request
+    # e.g. "http://localhost:7000/controller/action?foo=bar.xhtml"
+    def request_uri
+      env['REQUEST_URI'] || env['PATH_INFO']
+    end
+
+    # Answers with a subset of request.params with only the key/value pairs for
+    # which you pass the keys.
+    # Valid keys are objects that respond to :to_s
+    #
+    # Example:
+    #   request.params
+    #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
+    #   request.subset('name')
+    #   # => {'name' => 'jason'}
+    #   request.subset(:name, :job)
+    #   # => {'name' => 'jason', 'job' => 'lumberjack'}
+
+    def subset(*keys)
+      keys = keys.map{|k| k.to_s }
+      params.reject{|k,v| not keys.include?(k) }
+    end
+
+    # Try to figure out the domain we are running on, this might work for some
+    # deployments but fail for others, given the combination of servers in
+    # front.
+
+    def domain(path = '/')
+      scheme = self.scheme || 'http'
+      host   = env['HTTP_HOST']
+
+      URI("#{scheme}://#{host}#{path}")
+    end
+
+    # Try to find out which languages the client would like to have.
+    # Returns and array of locales from env['HTTP_ACCEPT_LANGUAGE].
+    # e.g. ["fi", "en", "ja", "fr", "de", "es", "it", "nl", "sv"]
+
+    def accept_language
+      env['HTTP_ACCEPT_LANGUAGE'].to_s.split(/(?:,|;q=[\d.,]+)/)
+    end
+    alias locales accept_language
+
+    ipv4 = %w[ 127.0.0.1/32 192.168.0.0/16 172.16.0.0/12 10.0.0.0/8 169.254.0.0/16 ]
+    ipv6 = %w[ fc00::/7 fe80::/10 fec0::/10 ::1 ]
+    LOCAL = (ipv4 + ipv6).map{|a| IPAddr.new(a)} unless defined?(LOCAL)
+
+    # Request is from a local network?
+    # Checks both IPv4 and IPv6
+    # Answer is true if the IP address making the request is from local network.
+    # Optional argument address can be used to check any IP address.
+
+    def local_net?(address = ip)
+      addr = IPAddr.new(address)
+      LOCAL.find{|range| range.include?(addr) }
+    rescue ArgumentError => ex
+      raise ArgumentError, ex unless ex.message == 'invalid address'
+    end
+
+    INTERESTING_HTTP_VARIABLES =
+      (/USER|HOST|REQUEST|REMOTE|FORWARD|REFER|PATH|QUERY|VERSION|KEEP|CACHE/)
+
+    # Interesting HTTP variables from env
+    def http_variables
+      env.reject{|key, value| key.to_s !~ INTERESTING_HTTP_VARIABLES }
+    end
+    alias http_vars http_variables
+
+    REQUEST_STRING_FORMAT = "#<%s params=%p cookies=%p env=%p>"
+
+    def to_s
+      REQUEST_STRING_FORMAT % [self.class, params, cookies, http_variables]
+    end
+    alias inspect to_s
+
+    # Pretty prints current action with parameters, cookies and enviroment
+    # variables.
+    def pretty_print(pp)
+      pp.object_group(self){
+        group = { 'params' => params, 'cookies' => cookies, 'env' => http_vars }
+        group.each do |name, hash|
+          pp.breakable
+          pp.text " @#{name}="
+          pp.nest(name.size + 3){ pp.pp_hash(hash) }
+        end
+      }
+    end
+  end
+end

data/lib/innate/response.rb

@@ -0,0 +1,18 @@
+module Innate
+
+  # In order to reset the body contents we also need to reset the length set by
+  # Response#write - until I can submit a patch to Rack and the next release we
+  # just do this.
+
+  class Response < Rack::Response
+    attr_accessor :length
+
+    def reset
+      self.status = 200
+      self.header.delete('Content-Type')
+      body.clear
+      self.length = 0
+      self
+    end
+  end
+end

data/lib/innate/route.rb

@@ -0,0 +1,109 @@
+module Innate
+  # Innate support simple routing using string, regex and lambda based routers.
+  # Route are stored in a dictionary, which supports hash-like access but
+  # preserves order, so routes are evaluated in the order they are added.
+  #
+  # This middleware should wrap Innate::DynaMap.
+  #
+  # String routers are the simplest way to route in Innate. One path is
+  # translated into another:
+  #
+  #   Innate::Route[ '/foo' ] = '/bar'
+  #     '/foo'  =>  '/bar'
+  #
+  # Regex routers allow matching against paths using regex. Matches within
+  # your regex using () are substituted in the new path using printf-like
+  # syntax.
+  #
+  #   Innate::Route[ %r!^/(\d+)\.te?xt$! ] = "/text/%d"
+  #     '/123.txt'  =>  '/text/123'
+  #     '/789.text' =>  '/text/789'
+  #
+  # For more complex routing, lambda routers can be used. Lambda routers are
+  # passed in the current path and request object, and must return either a new
+  # path string, or nil.
+  #
+  #   Innate::Route[ 'name of route' ] = lambda{ |path, request|
+  #     '/bar' if path == '/foo' and request[:bar] == '1'
+  #   }
+  #     '/foo'        =>  '/foo'
+  #     '/foo?bar=1'  =>  '/bar'
+  #
+  # Lambda routers can also use this alternative syntax:
+  #
+  #   Innate::Route('name of route') do |path, request|
+  #     '/bar' if path == '/foo' and request[:bar] == '1'
+  #   end
+  #
+  # NOTE: Use self::ROUTES notation in singleton methods to force correct
+  #       lookup.
+
+  class Route
+    ROUTES = []
+
+    def self.[](key)
+      found = self::ROUTES.assoc(key)
+      found[1] if found
+    end
+
+    def self.[]=(key, value)
+      self::ROUTES.delete_if{|k,v| k == key }
+      self::ROUTES << [key, value]
+    end
+
+    def self.clear
+      self::ROUTES.clear
+    end
+
+    def initialize(app = Innate::DynaMap)
+      @app = app
+    end
+
+    def call(env)
+      path = env['PATH_INFO']
+      path << '/' if path.empty?
+
+      if modified = resolve(path)
+        env['PATH_INFO'] = modified
+      end
+
+      @app.call(env)
+    end
+
+    def resolve(path)
+      request = Current.request
+
+      self.class::ROUTES.each do |key, value|
+        if key.is_a?(Regexp)
+          md = path.match(key)
+          return value % md.to_a[1..-1] if md
+
+        elsif value.respond_to?(:call)
+          new_path = value.call(path, Request.current)
+          return new_path if new_path
+
+        elsif value.respond_to?(:to_str)
+          return value.to_str if path == key
+
+        else
+          Log.error("Invalid route %p => %p" % [key, value])
+        end
+      end
+
+      nil
+    end
+  end
+
+  # Identical with Innate::Route, but is called before any Node::call is made
+  class Rewrite < Route
+    ROUTES = []
+  end
+
+  def self.Route(key, value = nil, &block)
+    Route[key] = value || block
+  end
+
+  def self.Rewrite(key, value = nil, &block)
+    Rewrite[key] = value || block
+  end
+end