manveru-innate 2009.02.25 → 2009.03.24

data/lib/innate/options/dsl.rb

@@ -42,7 +42,7 @@ module Innate
   #   # => 9
   #
   class Options
-    def initialize(name, parent = self, &block)
+    def initialize(name, parent = self)
       @name, @parent, = name, parent
       @hash = {}
       yield(self) if block_given?
@@ -76,11 +76,12 @@ module Innate
     # @param [Object]  value may be anything
     # @param [Hash]    other optional Hash containing meta-data
     #                        :doc, :value keys will be ignored
-    def o(doc, key, value, other = {}, &block)
+    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+.
@@ -111,6 +112,12 @@ module Innate
       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)
@@ -125,6 +132,8 @@ module Innate
       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
@@ -140,17 +149,25 @@ module Innate
     end
 
     def merge!(hash)
-      hash.each do |key, value|
-        self[key] = value
+      hash.each_pair do |key, value|
+        set_value(key.to_s.split('.'), value)
       end
     end
 
-    include Enumerable
+    def to_hash
+      @hash
+    end
 
-    def each(&block)
+    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
@@ -159,4 +176,27 @@ module Innate
       q.pp_hash @hash
     end
   end
+
+  # extend your class with this
+  module Optional
+    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/options.rb

@@ -1,116 +1,37 @@
-require 'innate/options/dsl'
-
 module Innate
-  @options = Options.new(:innate)
-
-  # attr_accessor is faster
-  class << self; attr_accessor :options; end
+  # this has to be run after a couple of other files have been required
 
-  # This has to speak for itself.
   options.dsl do
-    o "IP address or hostname that we 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
+    o "The compiler for middleware",
+      :middleware_compiler, Innate::MiddlewareCompiler
 
     o "Indicates which default middleware to use, (:dev|:live)",
       :mode, :dev
 
-    trigger(:mode){|v| Innate.middleware_recompile(v) }
-
-    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
+    o "The directories this application resides in",
+      :roots, [File.dirname($0)]
 
-    sub :app do
-      o "Unique identifier for this application",
-        :name, 'pristine'
+    o "The directories containing static files to be served",
+      :publics, ['public']
 
-      o "Root directory containing the application",
-        :root, File.dirname($0)
+    o "Directories containing the view templates",
+      :views, ['view']
 
-      o "Root directory for view templates, relative to app subdir",
-        :view, '/view'
+    o "Directories containing the layout templates",
+      :layouts, ['layout']
 
-      o "Root directory for layout templates, relative to app subdir",
-        :layout, '/layout'
+    o "Prefix used to create relative links",
+      :prefix, '/'
 
-      o "Prefix of this application",
-        :prefix, '/'
-
-      o "Root directory for static public files",
-        :public, '/public'
-
-      trigger(:public){|v| Innate.middleware_recompile }
-    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}
-
-      o "Create actions that have no method associated",
-        :needs_method, false
-    end
+    trigger(:mode){|v| Innate.middleware_recompile(v) }
   end
 end

data/lib/innate/request.rb

@@ -84,7 +84,8 @@ module Innate
     # which you pass the keys.
     # Valid keys are objects that respond to :to_s
     #
-    # @usage
+    # @example usage
+    #
     #   request.params
     #   # => {'name' => 'jason', 'age' => '45', 'job' => 'lumberjack'}
     #   request.subset('name')
@@ -100,12 +101,25 @@ module Innate
     # 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}")
+    #
+    # @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
 
     # Try to find out which languages the client would like to have and sort

data/lib/innate/response.rb

@@ -5,6 +5,13 @@ module Innate
   # just do this.
 
   class Response < Rack::Response
+    include Optional
+
+    options.dsl do
+      o "Default headers, will not override headers already set",
+        :headers, {'Content-Type' => 'text/html'}
+    end
+
     attr_accessor :length
 
     def reset
@@ -14,5 +21,10 @@ module Innate
       self.length = 0
       self
     end
+
+    def finish
+      options.headers.each{|key, value| self[key] ||= value }
+      super
+    end
   end
 end

data/lib/innate/route.rb

@@ -64,6 +64,7 @@ module Innate
       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
 
@@ -71,15 +72,13 @@ module Innate
     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)
+          new_path = value.call(path, Current.request)
           return new_path if new_path
 
         elsif value.respond_to?(:to_str)

data/lib/innate/session.rb

@@ -3,16 +3,34 @@ module Innate
   # Mostly ported from Ramaze, but behaves lazy, no session will be created if
   # no session is used.
   #
-  # The way we do it is to keep session data in memory until #flush is called,
-  # at which point it will be persisted completely into the cache, no question
-  # asked.
+  # We keep session data in memory until #flush is called, at which point it
+  # will be persisted completely into the cache, no question asked.
   #
-  # NOTE:
-  #   * You may store anything in here that you may also store in the
-  #     corresponding store, usually it's best to keep it to things that are
-  #     safe to Marshal.
+  # You may store anything in here that you may also store in the corresponding
+  # store, usually it's best to keep it to things that are safe to Marshal.
+  #
+  # The default time of expiration is *
+  #
+  #   Time.at(2147483647) # => Tue Jan 19 12:14:07 +0900 2038
+  #
+  # Hopefully we all have 64bit systems by then.
 
   class Session
+    include Optional
+
+    options.dsl 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((1 << 31) - 1)
+    end
+
     attr_reader :cookie_set, :request, :response, :flash
 
     def initialize(request, response)
@@ -71,10 +89,6 @@ module Innate
       Innate::Cache.session
     end
 
-    def options
-      Innate.options[:session]
-    end
-
     def set_cookie(response)
       return if @cookie_set || cookie
 
@@ -90,16 +104,19 @@ module Innate
         :expires => options.expires }
     end
 
-    def entropy
-      [ srand, rand, Time.now.to_f, rand, $$, rand, object_id ]
-    end
-
     def generate_sid
-      begin
-        sid = Digest::SHA1.hexdigest(entropy.join)
-      end while cache[sid]
-
-      return sid
+      begin sid = sid_algorithm end while cache[sid]
+      sid
+    end
+
+    begin
+      require 'securerandom'
+      def sid_algorithm; SecureRandom.hex(32); end
+    rescue LoadError
+      def sid_algorithm
+        entropy = [ srand, rand, Time.now.to_f, rand, $$, rand, object_id ]
+        Digest::SHA2.hexdigest(entropy.join)
+      end
     end
   end
 end

data/lib/innate/spec.rb

@@ -37,8 +37,12 @@ shared :session do
 end
 
 shared :mock do
+  Innate.setup_dependencies
+
   def get(*args) Innate::Mock.get(*args) end
   def post(*args) Innate::Mock.post(*args) end
+  def put(*args) Innate::Mock.put(*args) end
+  def delete(*args) Innate::Mock.delete(*args) end
 end
 
 shared :multipart do

data/lib/innate/state/fiber.rb

@@ -9,11 +9,6 @@ module Innate
   # necessary right now but may be added.
   #
   # We subclass to keep your Ruby clean and polished.
-  #
-  # TODO:
-  #   * 1.9.1 includes a patch from matz that will call #initialize, so we can
-  #     remove our ::new hack, just have to get my hands on a properly
-  #     compiling version of 1.9.1
   class Fiber < ::Fiber
     attr_accessor :state
 
@@ -33,6 +28,10 @@ module Innate
     def key?(key)
       state.key?(key)
     end
+
+    def keys
+      state.keys
+    end
   end
 
   module State
@@ -41,11 +40,11 @@ module Innate
     # available.
     class Fiber
       def [](key)
-        Innate::Fiber.current[key]
+        ::Fiber.current[key]
       end
 
       def []=(key, value)
-        Innate::Fiber.current[key] = value
+        ::Fiber.current[key] = value
       end
 
       # We don't use Fiber in a concurrent manner and they don't run
@@ -62,6 +61,14 @@ module Innate
       def sync
         yield
       end
+
+      def defer
+        a = Innate::Fiber.current
+        ::Thread.new do
+          b = Innate::Fiber.new{ a.keys.each{|k| b[k] = a[k] }; yield }
+          b.resume
+        end
+      end
     end
   end
 end

data/lib/innate/state/thread.rb

@@ -5,7 +5,7 @@ module Innate
     # In case fibers are not available we fall back to this wrapper.
     #
     # It will raise errors happening inside the wrapping Thread even if
-    # Thread::raise_on_exception is false.
+    # Thread::abort_on_exception is false.
     #
     # For things that require a mutex in a threaded environment, use
     # STATE#sync, if Fiber is available no mutex will be used.
@@ -24,7 +24,10 @@ module Innate
       # Execute given block in a new Thread and rescue any exceptions before
       # they reach Thread::new, so in case Thread::raise_on_exception is false
       # we can still reraise the error outside of the Thread.
-
+      #
+      # This is not meant to be concurrent, we only use Thread as a wrapping
+      # context so we can store objects in Thread::current and access them from
+      # anywhere within this thread.
       def wrap
         value = ::Thread.new{ begin; yield; rescue Exception => ex; ex; end }.value
         raise(value) if Exception === value
@@ -34,6 +37,11 @@ module Innate
       def sync(&block)
         SEMAPHORE.synchronize(&block)
       end
+
+      def defer
+        a = ::Thread.current
+        ::Thread.new{ b = ::Thread.current; a.keys.each{|k| b[k] = a[k] }; yield }
+      end
     end
   end
 end

data/lib/innate/state.rb

@@ -1,15 +1,8 @@
 module Innate
-  state = options[:state]
-
-  if state == :Fiber
-    begin
-      require 'innate/state/fiber'
-      STATE = State::Fiber.new
-    rescue LoadError
-      require 'innate/state/thread'
-      STATE = State::Thread.new
-    end
-  else
+  begin
+    require 'innate/state/fiber'
+    STATE = State::Fiber.new
+  rescue LoadError
     require 'innate/state/thread'
     STATE = State::Thread.new
   end
@@ -26,5 +19,9 @@ module Innate
     def sync(&block)
       STATE.sync(&block)
     end
+
+    def defer(&block)
+      STATE.defer(&block)
+    end
   end
 end

data/lib/innate/traited.rb

@@ -6,7 +6,8 @@ module Innate
   # By using {Traited#ancestral_trait} you will get nicely inherited
   # configuration, where keys later in the ancestors will take precedence.
   #
-  # @usage
+  # @example usage
+  #
   #   class Foo
   #     include Innate::Traited
   #     trait :hello => 'Hello'
@@ -60,13 +61,20 @@ module Innate
     # # => {:three => :drei, :two => :zwei, :one => :eins, :first => :overwritten}
     def ancestral_trait
       result = {}
+      each_ancestral_trait{|trait| result.merge!(trait) }
+      result
+    end
 
-      ancs = respond_to?(:ancestors) ? ancestors : self.class.ancestors
-      ancs.reverse_each do |anc|
-        result.update(anc.trait) if anc.respond_to?(:trait)
-      end
+    def ancestral_trait_values(key)
+      result = []
+      each_ancestral_trait{|trait| result << trait[key] if trait.key?(key) }
+      result
+    end
 
-      result.merge!(trait)
+    def each_ancestral_trait
+      ancs = respond_to?(:ancestors) ? ancestors : self.class.ancestors
+      ancs.unshift(self)
+      ancs.reverse_each{|anc| yield(TRAITS[anc]) if TRAITS.key?(anc) }
     end
 
     # trait for self.class if we are an instance

data/lib/innate/trinity.rb

@@ -14,9 +14,5 @@ module Innate
     def action
       actions.last
     end
-
-    def action=(arg)
-      raise "You have to modify Current::actions or use Current::action.wrap"
-    end
   end
 end

data/lib/innate/version.rb

@@ -1,3 +1,3 @@
 module Innate
-  VERSION = "2009.02.25"
+  VERSION = "2009.03.24"
 end

data/lib/innate/view/erb.rb

@@ -3,14 +3,16 @@ require 'erb'
 module Innate
   module View
     module ERB
-      def self.render(action, string)
+      def self.call(action, string)
         return unless string.respond_to?(:to_str)
 
         action.copy_variables
 
         erb = ::ERB.new(string.to_str, nil, '%<>')
         erb.filename = (action.view || action.method).to_s
-        erb.result(action.binding)
+        html = erb.result(action.binding)
+
+        return html, 'text/html'
       end
     end
   end

data/lib/innate/view/none.rb

@@ -1,8 +1,8 @@
 module Innate
   module View
     module None
-      def self.render(action, string)
-        string
+      def self.call(action, string)
+        return string, 'text/html'
       end
     end
   end