innate 2009.04

data/lib/innate/options.rb

@@ -0,0 +1,37 @@
+module Innate
+  # this has to be run after a couple of other files have been required
+
+  options.dsl do
+    o "Innate::start will not start an adapter if true",
+      :started, false
+
+    o "Will send ::setup to each element during Innate::start",
+      :setup, [Innate::Cache, Innate::Node]
+
+    o "Trap this signal to issue shutdown, nil/false to disable trap",
+      :trap, 'SIGINT'
+
+    o "The compiler for middleware",
+      :middleware_compiler, Innate::MiddlewareCompiler
+
+    o "Indicates which default middleware to use, (:dev|:live)",
+      :mode, :dev
+
+    o "The directories this application resides in",
+      :roots, [File.dirname($0)]
+
+    o "The directories containing static files to be served",
+      :publics, ['public']
+
+    o "Directories containing the view templates",
+      :views, ['view']
+
+    o "Directories containing the layout templates",
+      :layouts, ['layout']
+
+    o "Prefix used to create relative links",
+      :prefix, '/'
+
+    trigger(:mode){|v| Innate.middleware_recompile(v) }
+  end
+end

data/lib/innate/options/dsl.rb

@@ -0,0 +1,202 @@
+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)
+      @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.
+    #
+    # @param [#to_s]   doc   describing the purpose of this option
+    # @param [#to_sym] key   used to access
+    # @param [Object]  value may be anything
+    # @param [Hash]    other optional Hash containing meta-data
+    #                        :doc, :value keys will be ignored
+    def option(doc, key, value, other = {}, &block)
+      trigger = block || other[:trigger]
+      convert = {:doc => doc.to_s, :value => value, :trigger => trigger}
+      @hash[key.to_sym] = other.merge(convert)
+    end
+    alias o option
+
+    # To avoid lookup on the parent, we can set a default to the internal Hash.
+    # Parameters as in {Options#o}, but without the +key+.
+    def default(doc, value, other = {})
+      @hash.default = other.merge(:doc => doc, :value => value)
+    end
+
+    # Add a block that will be called when a new value is set.
+    def trigger(key, &block)
+      @hash[key.to_sym][:trigger] = block
+    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
+
+    # @param [Array] keys
+    # @param [Object] value
+    def set_value(keys, value)
+      get(*keys)[:value] = value
+    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
+        ns[:trigger].call(value) if ns[:trigger].respond_to?(:call)
+      elsif existing = get(key)
+        option(existing[:doc].to_s.dup, key, 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_pair do |key, value|
+        set_value(key.to_s.split('.'), value)
+      end
+    end
+
+    def to_hash
+      @hash
+    end
+
+    def each_option(&block)
+      @hash.each(&block)
+    end
+
+    def each_pair
+      @hash.each do |key, values|
+        yield(key, self[key])
+      end
+    end
+
+    def inspect
+      @hash.inspect
+    end
+
+    def pretty_print(q)
+      q.pp_hash @hash
+    end
+  end
+
+  # extend your class with this
+  module Optioned
+    def self.included(into)
+      into.extend(SingletonMethods)
+
+      snaked = into.name.split('::').last
+      snaked = snaked.gsub(/\B[A-Z][^A-Z]/, '_\&').downcase.gsub(' ', '_')
+
+      options = Innate.options.sub(snaked)
+      into.instance_variable_set(:@options, options)
+    end
+
+    module SingletonMethods
+      attr_reader :options
+    end
+
+    private
+
+    def options
+      self.class.options
+    end
+  end
+end

data/lib/innate/options/stub.rb

@@ -0,0 +1,7 @@
+module Innate
+  # this is just a stub so other modules can register their options in here,
+  # the real options are set in lib/innate.rb
+
+  class << self; attr_reader :options; end
+  @options = Options.new('Innate')
+end

data/lib/innate/request.rb

@@ -0,0 +1,141 @@
+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{|key| super(key) }
+    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 usage
+    #
+    #   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{|key| key.to_s }
+      params.reject{|key, value| not keys.include?(key) }
+    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.
+    #
+    # @example usage
+    #
+    #   domain
+    #   # => #<URI::HTTPS:0xb769ecb0 URL:https://localhost:7000/>
+    #   domain('/foo')
+    #   # => #<URI::HTTPS:0xb769ecb0 URL:https://localhost:7000/foo>
+    #
+    # @param [#to_s] path
+    #
+    # @return [URI]
+    #
+    # @api external
+    # @author manveru
+    def domain(path = nil, options = {})
+      uri = URI(self.url)
+      uri.path = path.to_s if path
+      uri.query = nil unless options[:keep_query]
+      uri
+    end
+
+    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
+  end
+end

data/lib/innate/response.rb

@@ -0,0 +1,23 @@
+module Innate
+  class Response < Rack::Response
+    include Optioned
+
+    options.dsl do
+      o "Default headers, will not override headers already set",
+        :headers, {'Content-Type' => 'text/html'}
+    end
+
+    def reset
+      self.status = 200
+      self.header.delete('Content-Type')
+      body.clear
+      self.length = 0
+      self
+    end
+
+    def finish
+      options.headers.each{|key, value| self[key] ||= value }
+      super
+    end
+  end
+end

data/lib/innate/route.rb

@@ -0,0 +1,110 @@
+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)
+        Log.debug("%s routes %p to %p" % [self.class.name, path, modified])
+        env['PATH_INFO'] = modified
+      end
+
+      @app.call(env)
+    end
+
+    def resolve(path)
+      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, Current.request)
+          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
+
+  module SingletonMethods
+    def Route(key, value = nil, &block)
+      Route[key] = value || block
+    end
+
+    def Rewrite(key, value = nil, &block)
+      Rewrite[key] = value || block
+    end
+  end
+end