manveru-innate 2009.04.18 → 2009.05

data/lib/innate/options/dsl.rb

@@ -78,7 +78,8 @@ module Innate
     #                        :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}
+      convert = {:doc => doc.to_s, :value => value}
+      convert[:trigger] = trigger if trigger
       @hash[key.to_sym] = other.merge(convert)
     end
     alias o option
@@ -115,7 +116,9 @@ module Innate
     # @param [Array] keys
     # @param [Object] value
     def set_value(keys, value)
-      get(*keys)[:value] = value
+      got = get(*keys)
+      return got[:value] = value if got
+      raise(IndexError, "There is no option available for %p" % [keys])
     end
 
     # Retrieve only the :value from the value hash if found via +keys+.

data/lib/innate/request.rb

@@ -56,7 +56,7 @@ module Innate
   # * values_at
 
   class Request < Rack::Request
-    # Currently handled request from Innate::STATE[:request]
+    # Currently handled request from Thread.current[:request]
     # Call it from anywhere via Innate::Request.current
     def self.current
       Current.request

data/lib/innate/response.rb

@@ -17,6 +17,7 @@ module Innate
 
     def finish
       options.headers.each{|key, value| self[key] ||= value }
+      Current.session.flush(self)
       super
     end
   end

data/lib/innate/route.rb

@@ -5,6 +5,10 @@ module Innate
   #
   # This middleware should wrap Innate::DynaMap.
   #
+  # Please note that Rack::File is put before Route and Rewrite, that means
+  # that you cannot apply routes to static files unless you add your own route
+  # middleware before.
+  #
   # String routers are the simplest way to route in Innate. One path is
   # translated into another:
   #

data/lib/innate/session.rb

@@ -9,12 +9,12 @@ module Innate
   # 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 *
-  #
+  # 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.
-
+  #
+  # The Session instance is compatible with the specification of rack.session.
   class Session
     include Optioned
 
@@ -40,13 +40,17 @@ module Innate
       @flash = Flash.new(self)
     end
 
-    def []=(key, value)
+    # Rack interface
+
+    def store(key, value)
       cache_sid[key] = value
     end
+    alias []= store
 
-    def [](key)
+    def fetch(key, value = nil)
       cache_sid[key]
     end
+    alias [] fetch
 
     def delete(key)
       cache_sid.delete(key)
@@ -57,9 +61,7 @@ module Innate
       @cache_sid = nil
     end
 
-    def cache_sid
-      @cache_sid ||= cache[sid] || {}
-    end
+    # Additional interface
 
     def flush(response = @response)
       return if !@cache_sid or @cache_sid.empty?
@@ -70,6 +72,12 @@ module Innate
       set_cookie(response)
     end
 
+    private
+
+    def cache_sid
+      @cache_sid ||= cache[sid] || {}
+    end
+
     def sid
       @sid ||= cookie || generate_sid
     end
@@ -78,12 +86,6 @@ module Innate
       @request.cookies[options.key]
     end
 
-    def inspect
-      cache.inspect
-    end
-
-    private
-
     def cache
       Innate::Cache.session
     end

data/lib/innate/state.rb

@@ -1,12 +1,6 @@
-module Innate
-  begin
-    require 'innate/state/fiber'
-    STATE = State::Fiber.new
-  rescue LoadError
-    require 'innate/state/thread'
-    STATE = State::Thread.new
-  end
+require 'thread'
 
+module Innate
   module SingletonMethods
     # Use this method to achieve thread-safety for sensitive operations.
     #
@@ -17,11 +11,16 @@ module Innate
     # @param [Proc] block the things you want to execute
     # @see State::Thread#sync State::Fiber#sync
     def sync(&block)
-      STATE.sync(&block)
+      Thread.exclusive(&block)
     end
 
-    def defer(&block)
-      STATE.defer(&block)
+    def defer
+      outer = ::Thread.current
+      ::Thread.new{
+        inner = ::Thread.current
+        outer.keys.each{|k| inner[k] = outer[k] }
+        yield
+      }
     end
   end
 end

data/lib/innate/state/accessor.rb

@@ -1,5 +1,5 @@
 module Innate
-  # Simplify accessing STATE variables.
+  # Simplify accessing Thread.current variables.
   #
   # Example:
   #
@@ -54,7 +54,7 @@ module Innate
       state_reader(*names, &initializer)
     end
 
-    # Writer accessor to STATE[key]=
+    # Writer accessor to Thread.current[key]=
     #
     #   Example:
     #
@@ -81,11 +81,11 @@ module Innate
 
     def state_writer(*names)
       StateAccessor.each(*names) do |key, meth|
-        class_eval("def %s=(obj) STATE[%p] = obj; end" % [meth, key])
+        class_eval("def %s=(obj) Thread.current[%p] = obj; end" % [meth, key])
       end
     end
 
-    # Reader accessor for STATE[key]
+    # Reader accessor for Thread.current[key]
     #
     # Example:
     #
@@ -115,14 +115,14 @@ module Innate
       StateAccessor.each(*names) do |key, meth|
         if initializer
           define_method(meth) do
-            unless STATE.key?(key)
-              STATE[key] = instance_eval(&initializer)
+            unless Thread.current.key?(key)
+              Thread.current[key] = instance_eval(&initializer)
             else
-              STATE[key]
+              Thread.current[key]
             end
           end
         else
-          class_eval("def %s; STATE[%p]; end" % [meth, key])
+          class_eval("def %s; Thread.current[%p]; end" % [meth, key])
         end
       end
     end

data/lib/innate/traited.rb

@@ -26,7 +26,7 @@ module Innate
   #   foo.trait[:hello] # => "World!"
   #   foo.show          # => ["Hello", "World!", "World!"]
   module Traited
-    TRAITS = {}
+    TRAITS, ANCESTRAL_TRAITS, ANCESTRAL_VALUES = {}, {}, {}
 
     def self.included(into)
       into.extend(self)
@@ -35,7 +35,10 @@ module Innate
     def trait(hash = nil)
       if hash
         TRAITS[self] ||= {}
-        TRAITS[self].merge!(hash)
+        result = TRAITS[self].merge!(hash)
+        ANCESTRAL_VALUES.clear
+        ANCESTRAL_TRAITS.clear
+        result
       else
         TRAITS[self] || {}
       end
@@ -60,21 +63,23 @@ module Innate
     # Foobar.ancestral_trait
     # # => {:three => :drei, :two => :zwei, :one => :eins, :first => :overwritten}
     def ancestral_trait
-      result = {}
-      each_ancestral_trait{|trait| result.merge!(trait) }
-      result
+      klass = self.kind_of?(Module) ? self : self.class
+      ANCESTRAL_TRAITS[klass] ||=
+        each_ancestral_trait({}){|hash, trait| hash.update(trait) }
     end
 
     def ancestral_trait_values(key)
-      result = []
-      each_ancestral_trait{|trait| result << trait[key] if trait.key?(key) }
-      result
+      klass = self.kind_of?(Module) ? self : self.class
+      cache = ANCESTRAL_VALUES[klass] ||= {}
+      cache[key] ||= each_ancestral_trait([]){|array, trait|
+        array << trait[key] if trait.key?(key) }
     end
 
-    def each_ancestral_trait
+    def each_ancestral_trait(obj)
       ancs = respond_to?(:ancestors) ? ancestors : self.class.ancestors
       ancs.unshift(self)
-      ancs.reverse_each{|anc| yield(TRAITS[anc]) if TRAITS.key?(anc) }
+      ancs.reverse_each{|anc| yield(obj, TRAITS[anc]) if TRAITS.key?(anc) }
+      obj
     end
 
     # trait for self.class if we are an instance

data/lib/innate/version.rb

@@ -1,3 +1,3 @@
 module Innate
-  VERSION = "2009.04.18"
+  VERSION = "2009.05"
 end

data/lib/innate/view.rb

@@ -2,12 +2,32 @@ module Innate
 
   # This is a container module for wrappers of templating engines and handles
   # lazy requiring of needed engines.
-
   module View
+    include Optioned
+
     ENGINE, TEMP = {}, {}
 
+    options.dsl do
+      o "Cache compiled templates",
+        :cache, true
+
+      o "Cache template files after they're read to prevent additional filesystem calls",
+        :read_cache, false
+    end
+
+    # In order to be able to render actions without running
+    # Innate::setup_dependencies we have to add the cache here already.
+    Cache.add(:view)
+
     module_function
 
+    def compile(string)
+      return yield(string.to_s) unless View.options.cache
+      string = string.to_s
+      checksum = Digest::MD5.hexdigest(string)
+      Cache.view[checksum] ||= yield(string)
+    end
+
     def exts_of(engine)
       name = engine.to_s
       ENGINE.reject{|k,v| v != name }.keys
@@ -29,10 +49,27 @@ module Innate
     # on the first request (before TEMP is set).
     # No mutex is used in Fiber environment, see Innate::State and subclasses.
     def obtain(klass, root = Object)
-      STATE.sync do
+      Thread.exclusive{
         klass.to_s.scan(/\w+/){|part| root = root.const_get(part) }
-        root
-      end
+        return root
+      }
+    end
+
+    # Reads the specified view template from the filesystem. When the read_cache
+    # option is enabled, templates will be cached to prevent unnecessary
+    # filesystem reads in the future.
+    #
+    # @example usage
+    #
+    #   View.read('some/file.xhtml')
+    #
+    # @param [#to_str] view
+    #
+    # @api private
+    # @see Action#render
+    def read(view)
+      return Cache.view[view] ||= ::File.read(view) if View.options.read_cache
+      ::File.read(view)
     end
 
     # Register given templating engine wrapper and extensions for later usage.

data/lib/innate/view/erb.rb

@@ -4,10 +4,9 @@ module Innate
   module View
     module ERB
       def self.call(action, string)
-        erb = ::ERB.new(string.to_s, nil, '%<>')
+        erb = View.compile(string){|s| ::ERB.new(s, nil, '%<>') }
         erb.filename = (action.view || action.method).to_s
         html = erb.result(action.binding)
-
         return html, 'text/html'
       end
     end

data/lib/innate/view/etanni.rb

@@ -2,14 +2,19 @@ module Innate
   module View
     module Etanni
       def self.call(action, string)
-        template = Innate::Etanni.new(string.to_s)
-        html = template.result(action.binding, (action.view || action.method))
+        etanni = View.compile(string){|s| Innate::Etanni.new(s) }
+        html = etanni.result(action.binding, (action.view || action.method))
         return html, 'text/html'
       end
     end
   end
 
   class Etanni
+    SEPARATOR = "E69t116A65n110N78i105S83e101P80a97R82a97T84o111R82"
+    START = "\n<<#{SEPARATOR}.chomp\n"
+    STOP = "\n#{SEPARATOR}\n"
+    ADD = "_out_ << "
+
     def initialize(template)
       @template = template
       compile
@@ -17,16 +22,8 @@ module Innate
 
     def compile
       temp = @template.dup
-      start_heredoc = "T" << Digest::SHA1.hexdigest(temp)
-      start_heredoc, end_heredoc = "\n<<#{start_heredoc}.chomp\n", "\n#{start_heredoc}\n"
-      bufadd = "_out_ << "
-
-      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m,
-            "#{end_heredoc} \\1; #{bufadd} #{start_heredoc}")
-
-      @compiled = "_out_ = ''
-      #{bufadd} #{start_heredoc} #{temp} #{end_heredoc}
-      _out_"
+      temp.gsub!(/<\?r\s+(.*?)\s+\?>/m, "#{STOP} \\1; #{ADD} #{START}")
+      @compiled = "_out_ = #{START} #{temp} #{STOP} _out_"
     end
 
     def result(binding, filename = '<Etanni>')

data/spec/innate/action/layout.rb

@@ -1,6 +1,3 @@
-#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
 require 'spec/helper'
 
 class SpecActionLayout

data/spec/innate/helper/flash.rb

@@ -1,6 +1,3 @@
-#          Copyright (c) 2009 Michael Fellinger m.fellinger@gmail.com
-# All files in this distribution are subject to the terms of the Ruby license.
-
 require 'spec/helper'
 
 class SpecFlash

data/spec/innate/helper/redirect.rb

@@ -57,6 +57,11 @@ class SpecRedirectHelper
   def redirect_unmodified
     raw_redirect '/noop'
   end
+
+  def redirect_with_cookie
+    response.set_cookie('user', :value => 'manveru')
+    redirect r(:noop)
+  end
 end
 
 describe Innate::Helper::Redirect do
@@ -157,4 +162,10 @@ describe Innate::Helper::Redirect do
     last_response.status.should == 200
     last_response.body.should == 'no actual double redirect'
   end
+
+  should 'set cookie before redirect' do
+    get("#@uri/redirect_with_cookie")
+    follow_redirect!
+    last_request.cookies.should == {'user' => 'manveru'}
+  end
 end

data/spec/innate/helper/render.rb

@@ -74,6 +74,26 @@ class SpecHelperRenderMisc
   end
 end
 
+class SpecHelperRenderFile
+  Innate.node '/render_file'
+
+  layout :layout
+
+  def layout
+    '{ #{@content} }'
+  end
+
+  FILE = File.expand_path('../view/aspect_hello.xhtml', __FILE__)
+
+  def absolute
+    render_file(FILE)
+  end
+
+  def absolute_with(foo, bar)
+    render_file(FILE, :foo => foo, :bar => bar)
+  end
+end
+
 describe Innate::Helper::Render do
   describe '#render_full' do
     behaves_like :mock
@@ -130,4 +150,16 @@ describe Innate::Helper::Render do
       get('/misc/recursive').body.scan(/\S/).join.should == '{1{2{3{44}3}2}1}'
     end
   end
+
+  describe '#render_file' do
+    behaves_like :mock
+
+    it 'renders file from absolute path' do
+      get('/render_file/absolute').body.should == '{ ! }'
+    end
+
+    it 'renders file from absolute path with variables' do
+      get('/render_file/absolute_with/one/two').body.should == '{ one two! }'
+    end
+  end
 end