innate 2009.04

data/lib/innate/state/thread.rb

@@ -0,0 +1,47 @@
+require 'thread'
+
+module Innate
+  module State
+    # In case fibers are not available we fall back to this wrapper.
+    #
+    # It will raise errors happening inside the wrapping Thread even if
+    # 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.
+
+    class Thread
+      SEMAPHORE = Mutex.new
+
+      def [](key)
+        ::Thread.current[key]
+      end
+
+      def []=(key, value)
+        ::Thread.current[key] = value
+      end
+
+      # 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
+        return value
+      end
+
+      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/traited.rb

@@ -0,0 +1,85 @@
+module Innate
+  # Traited helps you doing configuration similar to class variables.
+  #
+  # It's built on a simple Hash, where keys are objects and the values the
+  # configuration.
+  # By using {Traited#ancestral_trait} you will get nicely inherited
+  # configuration, where keys later in the ancestors will take precedence.
+  #
+  # @example usage
+  #
+  #   class Foo
+  #     include Innate::Traited
+  #     trait :hello => 'Hello'
+  #
+  #     def initialize
+  #       trait :hello => 'World!'
+  #     end
+  #
+  #     def show
+  #       [class_trait[:hello], trait[:hello], ancestral_trait[:hello]]
+  #     end
+  #   end
+  #
+  #   Foo.trait[:hello] # => "Hello"
+  #   foo = Foo.new
+  #   foo.trait[:hello] # => "World!"
+  #   foo.show          # => ["Hello", "World!", "World!"]
+  module Traited
+    TRAITS = {}
+
+    def self.included(into)
+      into.extend(self)
+    end
+
+    def trait(hash = nil)
+      if hash
+        TRAITS[self] ||= {}
+        TRAITS[self].merge!(hash)
+      else
+        TRAITS[self] || {}
+      end
+    end
+
+    # Builds a trait from all the ancestors, closer ancestors overwrite distant
+    # ancestors
+    #
+    # class Foo
+    #   include Innate::Traited
+    #   trait :one => :eins, :first => :erstes
+    # end
+    #
+    # class Bar < Foo
+    #   trait :two => :zwei
+    # end
+    #
+    # class Foobar < Bar
+    #   trait :three => :drei, :first => :overwritten
+    # end
+    #
+    # Foobar.ancestral_trait
+    # # => {:three => :drei, :two => :zwei, :one => :eins, :first => :overwritten}
+    def ancestral_trait
+      result = {}
+      each_ancestral_trait{|trait| result.merge!(trait) }
+      result
+    end
+
+    def ancestral_trait_values(key)
+      result = []
+      each_ancestral_trait{|trait| result << trait[key] if trait.key?(key) }
+      result
+    end
+
+    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
+    def class_trait
+      respond_to?(:ancestors) ? trait : self.class.trait
+    end
+  end
+end

data/lib/innate/trinity.rb

@@ -0,0 +1,18 @@
+require 'innate/state/accessor'
+require 'innate/request'
+
+module Innate
+  # The module to be included into the Controller it basically just provides
+  # #request, #response and #session, each accessing Thread.current to
+  # retrieve the demanded object
+
+  module Trinity
+    extend StateAccessor
+
+    state_accessor :request, :response, :session, :actions
+
+    def action
+      actions.last
+    end
+  end
+end

data/lib/innate/version.rb

@@ -0,0 +1,3 @@
+module Innate
+  VERSION = "2009.04"
+end

data/lib/innate/view.rb

@@ -0,0 +1,60 @@
+module Innate
+
+  # This is a container module for wrappers of templating engines and handles
+  # lazy requiring of needed engines.
+
+  module View
+    ENGINE, TEMP = {}, {}
+
+    module_function
+
+    def exts_of(engine)
+      name = engine.to_s
+      ENGINE.reject{|k,v| v != name }.keys
+    end
+
+    # Try to obtain given engine by its registered name.
+    def get(engine)
+      if klass = TEMP[engine]
+        return klass
+      elsif klass = ENGINE[engine]
+        TEMP[engine] = obtain(klass)
+      else
+        TEMP[engine] = obtain(engine, View)
+      end
+    end
+
+    # We need to put this in a Mutex because simultanous calls for the same
+    # class will cause race conditions and one call may return the wrong class
+    # 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
+        klass.to_s.scan(/\w+/){|part| root = root.const_get(part) }
+        root
+      end
+    end
+
+    # Register given templating engine wrapper and extensions for later usage.
+    #
+    # +name+ : the class name of the templating engine wrapper
+    # +exts+ : any number of arguments will be turned into strings via #to_s
+    #          that indicate which filename-extensions the templates may have.
+    def register(klass, *exts)
+      exts.each do |ext|
+        ext = ext.to_s
+        engine = ENGINE[ext]
+        Log.warn("overwriting %p, was set to %p" % [ext, engine]) if engine
+        ENGINE[ext] = klass
+      end
+    end
+
+    autoload :None,   'innate/view/none'
+    autoload :ERB,    'innate/view/erb'
+    autoload :Etanni, 'innate/view/etanni'
+
+    register 'Innate::View::None',   :css, :html, :htm
+    register 'Innate::View::ERB',    :erb
+    register 'Innate::View::Etanni', :xhtml
+  end
+end

data/lib/innate/view/erb.rb

@@ -0,0 +1,15 @@
+require 'erb'
+
+module Innate
+  module View
+    module ERB
+      def self.call(action, string)
+        erb = ::ERB.new(string.to_s, nil, '%<>')
+        erb.filename = (action.view || action.method).to_s
+        html = erb.result(action.binding)
+
+        return html, 'text/html'
+      end
+    end
+  end
+end

data/lib/innate/view/etanni.rb

@@ -0,0 +1,36 @@
+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))
+        return html, 'text/html'
+      end
+    end
+  end
+
+  class Etanni
+    def initialize(template)
+      @template = template
+      compile
+    end
+
+    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_"
+    end
+
+    def result(binding, filename = '<Etanni>')
+      eval(@compiled, binding, filename).to_s.strip
+    end
+  end
+end

data/lib/innate/view/none.rb

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

data/spec/example/app/retro_games.rb

@@ -0,0 +1,30 @@
+require 'spec/helper'
+require 'example/app/retro_games'
+
+describe 'Retro-games app' do
+  behaves_like :mock
+
+  it 'lists the first game' do
+    get '/'
+    last_response.should =~ /1 => Pacman/
+  end
+
+  it 'has a form to add another game' do
+    get '/'
+    last_response.should =~ /<form/
+  end
+
+  it 'allows you to add another game' do
+    post '/create', :name => 'Street Fighter II'
+    follow_redirect!
+    last_response.should =~ /0 =&gt; Street Fighter II/
+  end
+
+  it 'allows you to vote for a game' do
+    get '/vote/Street+Fighter+II'
+    follow_redirect!
+    last_response.should =~ /1 =&gt; Street Fighter II/
+  end
+
+  FileUtils.rm_f('games.yaml')
+end

data/spec/example/hello.rb

@@ -0,0 +1,13 @@
+require 'spec/helper'
+require 'example/hello'
+
+describe 'example/hello' do
+  behaves_like :mock
+
+  should 'have index action' do
+    got = get('/')
+    got.status.should == 200
+    got['Content-Type'].should == 'text/html'
+    got.body.should == 'Hello, World!'
+  end
+end

data/spec/example/link.rb

@@ -0,0 +1,25 @@
+require 'spec/helper'
+require 'example/link'
+
+describe 'example/link' do
+  behaves_like :mock
+
+  should 'have index on Linking' do
+    get('/').body.should == 'Index links to <a href="/help">Help?</a>'
+  end
+
+  should 'have help on Linking' do
+    get('/help').body.should ==
+      "Help links to <a href=\"/link_to/another\">A Different Node</a>"
+  end
+
+  should 'have another on Different' do
+    get('/link_to/another').body.
+      should == "<a href=\"/link_to/and/deeper\">Another links even deeper</a>"
+  end
+
+  should 'have and__deeper on Different' do
+    get('/link_to/and/deeper').body.
+      should == "<a href=\"/index\">Back to Linking Node</a>"
+  end
+end

data/spec/example/provides.rb

@@ -0,0 +1,16 @@
+require 'spec/helper'
+require 'example/provides'
+
+describe 'examples/provide' do
+  behaves_like :mock
+
+  it 'provides YAML representation' do
+    get '/list.yaml'
+    last_response.body.should == ARTICLES.to_yaml
+    last_response['Content-Type'].should == 'text/yaml'
+
+    get '/list'
+    last_response.body.should == ''
+    last_response['Content-Type'].should == 'text/html'
+  end
+end

data/spec/example/session.rb

@@ -0,0 +1,22 @@
+require 'spec/helper'
+require 'example/session'
+
+describe 'example/session' do
+  behaves_like :mock
+
+  it 'starts at 0' do
+    get('/').body.should =~ /Value is: 0/
+  end
+
+  it 'increments the counter' do
+    get('/increment').body.should =~ /Value is: 1/
+    get('/increment').body.should =~ /Value is: 2/
+    get('/increment').body.should =~ /Value is: 3/
+  end
+
+  it 'decrements the counter' do
+    get('/decrement').body.should =~ /Value is: 2/
+    get('/decrement').body.should =~ /Value is: 1/
+    get('/decrement').body.should =~ /Value is: 0/
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,10 @@
+if caller_line = caller.grep(%r!spec/innate/!).first
+  caller_file = caller_line.split(':', 2).first
+  caller_root = File.dirname(caller_file)
+  $0 = caller_file
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/innate'))
+require 'innate/spec'
+
+Innate.options.roots = [caller_root] if caller_root

data/spec/innate/action/layout.rb

@@ -0,0 +1,107 @@
+#          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
+  include Innate::Node
+  map_layouts '/'
+end
+
+class SpecActionLayoutMethod < SpecActionLayout
+  Innate.node('/from_method', self)
+  layout('method_layout')
+
+  def method_layout
+    '<pre>#{ @content }</pre>'
+  end
+
+  def index
+    'Method Layout'
+  end
+
+  def foo
+    "bar"
+  end
+end
+
+class SpecActionLayoutFile < SpecActionLayout
+  Innate.node('/from_file', self)
+  layout('file_layout')
+
+  def index
+    "File Layout"
+  end
+end
+
+class SpecActionLayoutSpecific < SpecActionLayout
+  Innate.node('/specific', self)
+  layout('file_layout'){|name, wish| name == 'index' }
+
+  def index
+    'Specific Layout'
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+class SpecActionLayoutDeny < SpecActionLayout
+  Innate.node('/deny', self)
+  layout('file_layout'){|name, wish| name != 'without' }
+
+  def index
+    "Deny Layout"
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+class SpecActionLayoutMulti < SpecActionLayout
+  Innate.node('/multi', self)
+  layout('file_layout'){|name, wish| name =~ /index|second/ }
+
+  def index
+    "Multi Layout Index"
+  end
+
+  def second
+    "Multi Layout Second"
+  end
+
+  def without
+    "Without wrapper"
+  end
+end
+
+describe 'Innate::Action#layout' do
+  behaves_like :mock
+
+  it 'uses a layout method' do
+    get('/from_method').body.should == '<pre>Method Layout</pre>'
+    get('/from_method/foo').body.should == '<pre>bar</pre>'
+  end
+
+  it 'uses a layout file' do
+    get('/from_file').body.strip.should == '<p>File Layout</p>'
+  end
+
+  it 'denies layout to some actions' do
+    get('/deny').body.strip.should == '<p>Deny Layout</p>'
+    get('/deny/without').body.strip.should == 'Without wrapper'
+  end
+
+  it 'uses layout only for specific action' do
+    get('/specific').body.strip.should == '<p>Specific Layout</p>'
+    get('/specific/without').body.strip.should == 'Without wrapper'
+  end
+
+  it 'uses layout only for specific actions' do
+    get('/multi').body.strip.should == '<p>Multi Layout Index</p>'
+    get('/multi/second').body.strip.should == '<p>Multi Layout Second</p>'
+    get('/multi/without').body.strip.should == 'Without wrapper'
+  end
+end