innate 2009.04

data/spec/innate/action/layout/file_layout.xhtml

@@ -0,0 +1 @@
+<p>#{ @content }</p>

data/spec/innate/cache/common.rb

@@ -0,0 +1,47 @@
+require 'spec/helper'
+
+Innate::Cache.options.names = [:one, :two]
+Innate::Cache.options.one = $common_cache_class
+Innate::Cache.options.two = $common_cache_class
+Innate.setup_dependencies
+
+describe $common_cache_class do
+  cache = Innate::Cache.one
+
+  @hello = 'Hello, World!'
+
+  should 'store without ttl' do
+    cache.store(:hello, @hello).should == @hello
+  end
+
+  should 'fetch' do
+    cache.fetch(:hello).should == @hello
+  end
+
+  should 'delete' do
+    cache.delete(:hello)
+    cache.fetch(:hello).should == nil
+  end
+
+  should 'delete two key/value pairs at once' do
+    cache.store(:hello, @hello).should == @hello
+    cache.store(:innate, 'innate').should == 'innate'
+    cache.delete(:hello, :innate)
+    cache.fetch(:hello).should == nil
+    cache.fetch(:innate).should == nil
+  end
+
+  should 'store with ttl' do
+    cache.store(:hello, @hello, :ttl => 0.2)
+    cache.fetch(:hello).should == @hello
+    sleep 0.3
+    cache.fetch(:hello).should == nil
+  end
+
+  should 'clear' do
+    cache.store(:hello, @hello)
+    cache.fetch(:hello).should == @hello
+    cache.clear
+    cache.fetch(:hello).should == nil
+  end
+end

data/spec/innate/cache/marshal.rb

@@ -0,0 +1,5 @@
+require 'spec/helper'
+
+$common_cache_class = Innate::Cache::Marshal
+
+require 'spec/innate/cache/common'

data/spec/innate/cache/memory.rb

@@ -0,0 +1,5 @@
+require 'spec/helper'
+
+$common_cache_class = Innate::Cache::Memory
+
+require 'spec/innate/cache/common'

data/spec/innate/cache/yaml.rb

@@ -0,0 +1,5 @@
+require 'spec/helper'
+
+$common_cache_class = Innate::Cache::YAML
+
+require 'spec/innate/cache/common'

data/spec/innate/dynamap.rb

@@ -0,0 +1,22 @@
+require 'spec/helper'
+
+describe Innate::DynaMap do
+  @app = lambda{|env| [200, {}, ['pass']] }
+
+  should 'raise if nothing is mapped' do
+    lambda{ Innate::DynaMap.call({}) }.should.raise(RuntimeError)
+  end
+
+  should 'not raise if nothing is mapped' do
+    Innate.map('/', &@app)
+    Innate::DynaMap.call('SCRIPT_NAME' => '/').should == [200, {}, ['pass']]
+  end
+
+  should 'return mapped object' do
+    Innate.at('/').should == @app
+  end
+
+  should 'return path to object' do
+    Innate.to(@app).should == '/'
+  end
+end

data/spec/innate/helper.rb

@@ -0,0 +1,86 @@
+require 'spec/helper'
+require 'innate/helper'
+
+module Innate
+  module Helper
+    module SmileHelper
+      EXPOSE << self
+
+      def smile
+        ':)'
+      end
+    end
+
+    module FrownHelper
+      def frown
+        ':('
+      end
+    end
+  end
+end
+
+class HelperNodeExpose
+  include Innate::Node
+  map '/'
+
+  helper :smile_helper, :frown_helper
+
+  def frowny
+    "Oh, hi #{frown}"
+  end
+end
+
+describe HelperNodeExpose do
+  should 'expose an action' do
+    Innate::Mock.get('/smile').body.should == ':)'
+    Innate::Mock.get('/frown').status.should == 404
+    Innate::Mock.get('/frowny').body.should == "Oh, hi :("
+  end
+end
+
+class FooNodeLink
+  include Innate::Node
+  map '/foo'
+
+  helper :link, :cgi
+end
+
+describe Innate::Helper::Link do
+  FNL = FooNodeLink
+
+  should 'construct URI from ::r' do
+    FNL.r(:index).should == URI('/foo/index')
+    FNL.r(:/).should == URI('/foo/')
+    FNL.r(:index, :foo => :bar).should == URI('/foo/index?foo=bar')
+
+    uri = FNL.r(:index, :a => :b, :x => :y)
+    uri.query.split(';').sort.should == %w[a=b x=y]
+  end
+
+  should 'construct link from ::a' do
+    FNL.a(:index).should == '<a href="/foo/index">index</a>'
+    FNL.a('index', :index, :x => :y).should == '<a href="/foo/index?x=y">index</a>'
+    FNL.a('duh/bar', 'duh/bar', :x => :y).should == '<a href="/foo/duh/bar?x=y">duh/bar</a>'
+    FNL.a('foo', :/, :x => :y).should == '<a href="/foo/?x=y">foo</a>'
+  end
+
+  should 'return module when Module is given to #each' do
+    Innate::HelpersHelper.each_extend(self, Innate::Helper::Link) do |p|
+      p.should == Innate::Helper::Link
+    end
+  end
+
+  should 'raise if helpers are not found' do
+    lambda{
+      Innate::HelpersHelper.each(:foo, :bar)
+    }.should.raise(LoadError).
+      message.should == "Helper foo not found"
+  end
+
+  should 'raise if helper is not found' do
+    lambda{
+      Innate::HelpersHelper.try_require(:foo)
+    }.should.raise(LoadError).
+      message.should == "Helper foo not found"
+  end
+end

data/spec/innate/helper/aspect.rb

@@ -0,0 +1,75 @@
+require 'spec/helper'
+
+class AspectSpec
+  Innate.node('/', self).provide(:html, :None)
+
+  before(:with_before){ $aspect_spec_before += 40 }
+  def with_before; $aspect_spec_before += 2; end
+
+  after(:with_after){ $aspect_spec_after  += 40 }
+  def with_after; $aspect_spec_after += 2; end
+
+  wrap(:with_wrap){ $aspect_spec_wrap += 20 }
+  def with_wrap; $aspect_spec_wrap += 2; end
+
+  before(:with_instance_var){ @foo = 'Hello'; @bar = 'World' }
+  def with_instance_var; "#{@foo} #{@bar}"; end
+end
+
+class AspectAllSpec
+  Innate.node('/all', self).provide(:html, :None)
+
+  before_all{ $aspect_spec_before_all += 40; @foo = 'Hello'; @bar = 'World' }
+  after_all{  $aspect_spec_after_all += 40 }
+  def before_first; $aspect_spec_before_all +=2 ; end
+  def before_second; $aspect_spec_before_all +=2; end
+  def with_instance_var_first; "#{@foo} #{@bar}"; end
+  def with_instance_var_second; "#{@foo} to the #{@bar}"; end
+end
+
+class AspecNoMethodSpec
+  Innate.node('/without_method', self)
+  include Innate::Node
+  map '/without_method'
+  map_views '/'
+  before_all{ @foo = 'Hello'; @bar = 'World'}
+end
+
+describe Innate::Helper::Aspect do
+  behaves_like :mock
+
+  it 'executes before aspect' do
+    $aspect_spec_before = 0
+    get('/with_before').body.should == '42'
+    $aspect_spec_before.should == 42
+  end
+
+  it 'executes after asepct' do
+    $aspect_spec_after = 0
+    get('/with_after').body.should == '2'
+    $aspect_spec_after.should == 42
+  end
+
+  it 'executes wrap aspects' do
+    $aspect_spec_wrap = 0
+    get('/with_wrap').body.should == '22'
+    $aspect_spec_wrap == 42
+  end
+
+  it 'calls before_all and after_all' do
+    $aspect_spec_before_all = $aspect_spec_after_all = 0
+    get('/all/before_first').body.should == '42'
+    $aspect_spec_before_all.should == 42
+    $aspect_spec_after_all.should == 40
+    get('/all/before_second').body.should == '84'
+    $aspect_spec_before_all.should == 84
+    $aspect_spec_after_all.should == 80
+  end
+
+  it 'makes instance variables in blocks available to view/method' do
+    get('/with_instance_var').body.should == 'Hello World'
+    get('/all/with_instance_var_first').body.should == 'Hello World'
+    get('/all/with_instance_var_second').body.should == 'Hello to the World'
+    get('/without_method/aspect_hello').body.should == "Hello World!"
+  end
+end

data/spec/innate/helper/cgi.rb

@@ -0,0 +1,37 @@
+require 'spec/helper'
+require 'innate/helper/cgi'
+
+describe "url encode" do
+  extend Innate::Helper::CGI
+
+  it 'should url_encode strings' do
+    # ok, I believe that the web is dumb for this
+    # but this probably is a SHOULD thingy in the HTTP RFC
+    url_encode('title with spaces').should == 'title+with+spaces'
+    url_encode('[foo]').should == '%5Bfoo%5D'
+    u('//').should == '%2F%2F'
+  end
+  it 'should url_decode strings' do
+    url_decode('title%20with%20spaces').should == 'title with spaces'
+    url_decode('title+with+spaces').should == 'title with spaces'
+  end
+  it 'should be reversible' do
+    url_decode(u('../ etc/passwd')).should == '../ etc/passwd'
+  end
+end
+
+describe 'html escape' do
+  extend Innate::Helper::CGI
+
+  it 'should escape html' do
+    html_escape('& < >').should == '&amp; &lt; &gt;'
+    h('<&>').should == '&lt;&amp;&gt;'
+  end
+  it 'should unescape html' do
+    html_unescape('&lt; &amp; &gt;').should == '< & >'
+  end
+  it 'should be reversible' do
+    html_unescape(html_escape('2 > b && b <= 0')).should == '2 > b && b <= 0'
+  end
+end
+

data/spec/innate/helper/flash.rb

@@ -0,0 +1,118 @@
+#          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
+  include Innate::Node
+  map '/'
+
+  def welcome
+    flash[:name] = 'manveru'
+    "Welcome #{flash[:name]}"
+  end
+
+  def bye
+    "Bye #{flash[:name]}"
+  end
+
+  def check_empty
+    flash.empty?.to_s
+  end
+
+  def set_delete_key
+    flash[:name] = 'manveru'
+    flash.delete(:name)
+    flash[:name].to_s
+  end
+
+  def delete_key
+    flash.delete(:name)
+    "Bye #{flash[:name]}"
+  end
+
+  def merge!
+    flash.merge!(:name => 'feagliir').inspect
+  end
+
+  def merge
+    flash.merge(:name => 'feagliir').inspect
+  end
+
+  def inspect
+    flash[:yes] = :yeah
+    flash.inspect
+  end
+
+  def iterate
+    flash[:yes] = :yeah
+    elems = []
+    flash.each{|k,v| elems << [k,v] }
+    elems.inspect
+  end
+end
+
+class SpecFlashSub < SpecFlash
+  map '/sub'
+end
+
+describe Innate::Helper::Flash do
+  behaves_like :mock
+
+  should 'set and forget flash twice' do
+    get('/welcome').body.should == 'Welcome manveru'
+    get('/bye').body.should == 'Bye manveru'
+    get('/bye').body.should == 'Bye'
+
+    get('/welcome').body.should == 'Welcome manveru'
+    get('/bye').body.should == 'Bye manveru'
+    get('/bye').body.should == 'Bye'
+  end
+
+  should 'work over multiple nodes' do
+    get('/welcome').body.should == 'Welcome manveru'
+    get('/sub/bye').body.should == 'Bye manveru'
+    get('/sub/bye').body.should == 'Bye'
+
+    get('/sub/welcome').body.should == 'Welcome manveru'
+    get('/bye').body.should == 'Bye manveru'
+    get('/bye').body.should == 'Bye'
+  end
+
+  should 'check if flash is empty' do
+    get('/welcome').body.should == 'Welcome manveru'
+    get('/check_empty').body.should == 'false'
+    get('/check_empty').body.should == 'true'
+  end
+
+  should 'set and delete key within one request' do
+    get('/set_delete_key').body.should == ''
+  end
+
+  should 'set and delete key over two request' do
+    get('/welcome').body.should == 'Welcome manveru'
+    get('/delete_key').body.should == 'Bye'
+  end
+
+  should 'merge with hash' do
+    get('/merge').body.should == {:name => 'feagliir'}.inspect
+    get('/bye').body.should == 'Bye'
+  end
+
+  should 'merge! with hash' do
+    get('/merge!').body.should == {:name => 'feagliir'}.inspect
+    get('/bye').body.should == 'Bye feagliir'
+  end
+
+  should 'inspect combined' do
+    get('/welcome')
+    get('/inspect').body.should == {:name => 'manveru', :yes => :yeah}.inspect
+  end
+
+  should 'iterate over combined' do
+    get('/welcome')
+
+    hash = {:yes => :yeah, :name => 'manveru'}
+    Hash[*eval(get('/iterate').body).flatten].should == hash
+  end
+end

data/spec/innate/helper/link.rb

@@ -0,0 +1,139 @@
+require 'spec/helper'
+
+class One
+  include Innate::Node
+  map '/'
+
+  def auto_route
+    UsingRouteSelf.new.route.to_s
+  end
+end
+
+class Two
+  include Innate::Node
+  map '/two'
+
+  def auto_route
+    UsingRouteSelf.new.route.to_s
+  end
+end
+
+class UsingRouteSelf
+  include Innate::Helper::Link
+
+  attr_reader :route
+
+  def initialize
+    @route = route_self(:elsewhere)
+  end
+end
+
+describe Innate::Helper::Link do
+  describe '#route' do
+    should 'respond with URI for node' do
+      One.route.should == URI('/')
+      Two.route.should == URI('/two/')
+    end
+
+    should 'respond with URI for node with path /' do
+      One.route('/').should == URI('/')
+      Two.route('/').should == URI('/two/')
+    end
+
+    should 'respond with URI for node with path /foo' do
+      One.route('/foo').should == URI('/foo')
+      One.route(:foo).should == URI('/foo')
+
+      Two.route('/foo').should == URI('/two/foo')
+      Two.route(:foo).should == URI('/two/foo')
+    end
+
+    should 'respond with URI for node with path /foo/bar' do
+      One.route('/foo/bar').should == URI('/foo/bar')
+      One.route(:foo, :bar).should == URI('/foo/bar')
+
+      Two.route('/foo/bar').should == URI('/two/foo/bar')
+      Two.route(:foo, :bar).should == URI('/two/foo/bar')
+    end
+
+    should 'respond with URI for node with path /foo/bar+baz' do
+      One.route('/foo/bar+baz').should == URI('/foo/bar+baz')
+      One.route(:foo, 'bar baz').should == URI('/foo/bar+baz')
+
+      Two.route('/foo/bar+baz').should == URI('/two/foo/bar+baz')
+      Two.route(:foo, 'bar baz').should == URI('/two/foo/bar+baz')
+    end
+
+    should 'respond with URI for node with GET params' do
+      One.route('/', :a => :b).should == URI('/?a=b')
+
+      One.route('/foo', :a => :b).should == URI('/foo?a=b')
+      One.route(:foo, :a => :b  ).should == URI('/foo?a=b')
+
+      One.route('/foo/bar', :a => :b).should == URI('/foo/bar?a=b')
+      One.route(:foo, :bar, :a => :b).should == URI('/foo/bar?a=b')
+
+      Two.route('/', :a => :b).should == URI('/two/?a=b')
+
+      Two.route('foo', :a => :b).should == URI('/two/foo?a=b')
+      Two.route(:foo, :a => :b ).should == URI('/two/foo?a=b')
+      Two.route('/foo/bar', :a => :b).should == URI('/two/foo/bar?a=b')
+      Two.route(:foo, :bar, :a => :b).should == URI('/two/foo/bar?a=b')
+    end
+
+    should 'prefix the links as defined in the options' do
+      Innate.options.prefix = '/bar'
+      One.route('/foo').should == URI('/bar/foo')
+      Innate.options.prefix = '/'
+    end
+  end
+
+  describe '#anchor' do
+    should 'respond with a tag with default text' do
+      One.anchor('hello').should == '<a href="/hello">hello</a>'
+      Two.anchor('hello').should == '<a href="/two/hello">hello</a>'
+    end
+
+    should 'respond with a tag with explicit text' do
+      One.anchor('hello', :foo).should == '<a href="/foo">hello</a>'
+      Two.anchor('hello', :foo).should == '<a href="/two/foo">hello</a>'
+    end
+
+    should 'pass parameters to #route' do
+      One.anchor('hello', :foo, :a => :b).
+        should == '<a href="/foo?a=b">hello</a>'
+      Two.anchor('hello', :foo, :a => :b).
+        should == '<a href="/two/foo?a=b">hello</a>'
+    end
+
+    should 'escape text' do
+      One.anchor('<blink> & <a>', :foo).
+        should == '<a href="/foo">&lt;blink&gt; &amp; &lt;a&gt;</a>'
+    end
+  end
+
+  describe 'combining #anchor and #route' do
+    should 'not escape twice' do
+      One.anchor('foo', One.route(:index, :bar => 'a/b/c')).
+        should == '<a href="/index?bar=a%2Fb%2Fc">foo</a>'
+    end
+
+    should 'handle complete uris gracefully' do
+      One.anchor('foo', 'http://example.com/?foo=bar&baz=qux').
+        should == '<a href="http://example.com/?foo=bar&amp;baz=qux">foo</a>'
+    end
+
+    should 'be able to route from one node to another' do
+      Two.anchor('foo', One.route(:index)).should == '<a href="/index">foo</a>'
+      One.anchor('foo', Two.route(:index)).should == '<a href="/two/index">foo</a>'
+    end
+  end
+
+  describe '#route_self' do
+    behaves_like :mock
+    should 'provide a route to the node of the currently active action' do
+      get('/auto_route').body.should == '/elsewhere'
+      get('/two/auto_route').body.should == '/two/elsewhere'
+    end
+  end
+end