rocketio 0.3.0 → 0.4.0

data/lib/rocketio/exceptions.rb

@@ -1,4 +0,0 @@
-module RocketIO
-  class TemplateError < RuntimeError;  end
-  class LayoutError < RuntimeError;  end
-end

data/test/render/b.erb

@@ -1 +0,0 @@
-<%= @var %>

data/test/render/c.erb

@@ -1 +0,0 @@
-<%= var %>

data/test/render/engine_test.rb

@@ -1,71 +0,0 @@
-require 'setup'
-
-spec :engine do
-  it 'inherits engine from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-    }
-    assert(b.new.engine) == [:SlimTemplate, []]
-  end
-
-  it 'overrides engine inherited from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine :Turbo
-    }
-    assert(b.new.engine) == [:TurboTemplate, []]
-  end
-
-  it 'can use include to override engine inherited from superclass' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine :Turbo
-    }
-    c = mock_controller(a) {
-      import :engine, from: b
-    }
-    assert(c.new.engine) == [:TurboTemplate, []]
-  end
-
-  it 'uses a block (that runs at instance level) to define engine' do
-    app mock_controller {
-      engine {@x = 'x'; :Slim}
-      def index; engine[0].to_s + @x end
-    }
-    get
-    assert(last_response.body) == 'SlimTemplatex'
-  end
-
-  it 'can accept engine options when a block used' do
-    c = mock_controller {
-      engine {[:Slim, {pretty_print: true}]}
-    }
-    e,o = c.allocate.engine
-    assert(e) == :SlimTemplate
-    assert(o) == [{pretty_print: true}]
-  end
-
-  it 'uses inherited engine if given block returns no engine' do
-    a = mock_controller {
-      engine :Slim
-    }
-    b = mock_controller(a) {
-      engine {
-        :ERB if env['IAMABOT']
-      }
-      def index; engine[0].to_s end
-    }
-    app b
-    get
-    assert(last_response.body) == 'SlimTemplate'
-    env['IAMABOT'] = true
-    get
-    assert(last_response.body) == 'ERBTemplate'
-  end
-end

data/test/render/index.erb

@@ -1 +0,0 @@
-<%= url %>

data/test/render/items.erb

@@ -1 +0,0 @@
-items

data/test/render/layout.erb

@@ -1 +0,0 @@
-=<%= yield %>=

data/test/render/layout_test.rb

@@ -1,123 +0,0 @@
-require 'setup'
-
-spec :Views do
-  context :layouts do
-    it 'inherits layout from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-      }
-      assert(b.new.layout) == :master
-    end
-
-    it 'overrides layout inherited from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-        layout :baster
-      }
-      assert(b.new.layout) == :baster
-    end
-
-    it 'can use `inherit` to override layout inherited from superclass' do
-      a = mock_controller {
-        layout :master
-      }
-      b = mock_controller(a) {
-        layout :baster
-      }
-      c = mock_controller(a) {
-        import :layout, from: b
-      }
-      assert(c.new.layout) == :baster
-    end
-
-    it 'renders without layout if no default layout set' do
-      app mock_controller {
-        def index; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-    end
-
-    it 'renders without layout if default layout set to false' do
-      app mock_controller {
-        layout false
-        def index; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-    end
-
-    it 'renders without layout if layout option set to nil or false' do
-      app mock_controller {
-        layout :layout
-        def var; @var end
-        def index; render(layout: nil); end
-        def b; @var = 'x'; render(layout: false); end
-        def c; @var = 'y'; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('/')
-
-      get :b
-      assert(last_response).is_ok_with_body('x')
-
-      get :c
-      assert(last_response).is_ok_with_body("=y=\n")
-    end
-
-    it 'renders with a defined layout' do
-      app mock_controller {
-        define_layout(:master) {'=<%= yield %>='}
-        layout :master
-        def index; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('=/=')
-    end
-
-    it 'prefers defined layouts over files' do
-      app mock_controller {
-        define_layout(:layout) {'-<%= yield %>-'}
-        layout :layout
-        def index; render; end
-      }
-      get
-      assert(last_response).is_ok_with_body('-/-')
-    end
-
-    it 'prefers explicit layouts over implicit ones' do
-      app mock_controller {
-        define_layout(:x) {'x<%= yield %>'}
-        define_layout(:y) {'y<%= yield %>'}
-        layout :x
-        def index; render {''}; end
-        def b; render(layout: :y) {''}; end
-      }
-
-      get
-      assert(last_response).is_ok_with_body('x')
-
-      get :b
-      assert(last_response).is_ok_with_body('y')
-    end
-
-    it 'accepts layout as :template option' do
-      app mock_controller {
-        def index; render_layout(template: '+<%= yield %>+') {'='}; end
-      }
-      get
-      assert(last_response).is_ok_with_body('+=+')
-    end
-
-    it 'raises ArgumentError if both layout name and :template option given' do
-      app mock_controller {
-        def index; render_layout(:x, template: '+<%= yield %>+') {'='}; end
-      }
-      assert {get}.raise ArgumentError, /both/i
-    end
-  end
-end

data/test/render/layouts/master.erb

@@ -1 +0,0 @@
-outside <%= yield %> layout

data/test/render/layouts_test.rb

@@ -1,145 +0,0 @@
-require 'setup'
-
-spec :layouts do
-  context :compositing do
-    it 'inherits layouts from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-      }.new
-      assert(b.__send__ b.layouts[:a]) == 'a'
-    end
-
-    it 'complements layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:b) {'b'}
-      }.new
-      assert(b.__send__ b.layouts[:a]) == 'a'
-      assert(b.__send__ b.layouts[:b]) == 'b'
-    end
-
-    it 'overrides layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:x) {'b'}
-      }.new
-      assert(b.__send__ b.layouts[:x]) == 'b'
-    end
-
-    test '`inherit` overrides layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:x) {'b'}
-      }
-      c = mock_controller(a) {
-        import :layouts, from: b
-      }.new
-      assert(c.__send__ c.layouts[:x]) == 'b'
-    end
-
-    test '`inherit` complements layouts inherited from superclass' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller(a) {
-        define_layout(:b) {'b'}
-      }
-      c = mock_controller(a) {
-        import :layouts, from: b
-      }.new
-      assert(c.__send__ c.layouts[:a]) == 'a'
-      assert(c.__send__ c.layouts[:b]) == 'b'
-    end
-
-    test '`inherit` overrides defined layouts' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller {
-        define_layout(:x) {'b'}
-        import :layouts, from: a
-      }.new
-      assert(b.__send__ b.layouts[:x]) == 'a'
-    end
-
-    test '`inherit` complements defined layouts' do
-      a = mock_controller {
-        define_layout(:a) {'a'}
-      }
-      b = mock_controller {
-        define_layout(:b) {'b'}
-        import :layouts, from: a
-      }.new
-      assert(b.__send__ b.layouts[:a]) == 'a'
-      assert(b.__send__ b.layouts[:b]) == 'b'
-    end
-
-    it 'overrides layouts inherited via `inherit`' do
-      a = mock_controller {
-        define_layout(:x) {'a'}
-      }
-      b = mock_controller {
-        import :layouts, from: a
-        define_layout(:x) {'b'}
-      }.new
-      assert(b.__send__ b.layouts[:x]) == 'b'
-    end
-  end
-
-  context :rendering do
-    it 'uses a file with same name if only name given' do
-      c = mock_controller {
-        define_layout :master
-      }.new
-      assert(c.render_layout(:master) {'yo'}) == "master yo layout\n"
-    end
-
-    it 'raises a TemplateError if there is no file with same name' do
-      layout = rand.to_s
-      c = mock_controller {
-        define_layout layout
-      }.new
-      assert {c.render_layout(layout) {}}.raise RocketIO::TemplateError
-    end
-
-    it 'uses given file - file resides in controller dirname' do
-      c = mock_controller {
-        define_layout :master, file: :layout
-      }.new
-      assert(c.render_layout(:master) {'yo'}) == "=yo=\n"
-    end
-
-    it 'uses given file - file resides outside controller dirname' do
-      c = mock_controller {
-        define_layout :master, file: './layouts/master'
-      }.new
-      assert(c.render_layout(:master) {'yo'}) == "outside yo layout\n"
-    end
-
-    it 'accepts a block for given file' do
-      c = mock_controller {
-        define_layout :master, file: -> {@outside ? './layouts/master' : :master}
-      }.new
-      assert(c.render_layout(:master) {'yo'}) == "master yo layout\n"
-      c.instance_variable_set(:@outside, true)
-      assert(c.render_layout(:master) {'yo'}) == "outside yo layout\n"
-    end
-
-    it 'accepts a block and uses returned value as layout without searching for file' do
-      c = mock_controller {
-        define_layout(:master) {@admin ? ':<%= yield %>:' : '|<%= yield %>|'}
-      }.new
-      assert(c.render_layout(:master) {'yo'}) == "|yo|"
-      c.instance_variable_set(:@admin, true)
-      assert(c.render_layout(:master) {'yo'}) == ":yo:"
-    end
-  end
-end

data/test/render/master.erb

@@ -1 +0,0 @@
-master <%= yield %> layout

data/test/render/render_test.rb

@@ -1,104 +0,0 @@
-require 'setup'
-
-spec :Views do
-  context :cache do
-
-    engine = Tilt::ERBTemplate
-    path = File.expand_path('../templates/a', __FILE__)
-    define_method(:file) {mock_controller(:a).new.send(:find_template, path, 'get', engine)}
-    define_method(:read) {mock_controller(:a).new.send(:read_template, file).__id__}
-    define_method(:compile) {|tpl| mock_controller(:a).new.send(:compile_template, tpl, engine).__id__}
-
-    it 'resolves template path only once' do
-      cache_id = file.__id__
-      assert(file.__id__) == cache_id
-    end
-
-    it 'rereads templates only when template file modified' do
-      cache_id = read
-      assert(read) == cache_id
-      FileUtils.touch(file)
-      refute(read) == cache_id
-    end
-
-    it 'recompiles template only if it was modified' do
-      cache_id = compile('')
-      assert(compile('')) == cache_id
-      refute(compile('changed')) == cache_id
-    end
-  end
-
-  context :scope do
-
-    it 'uses controller instance for scope' do
-      app mock_controller {
-        before {@var = :val}
-        def b; render; end
-      }
-      get :b
-      assert(last_response).is_ok_with_body('val')
-    end
-
-    it 'uses custom scope' do
-      app mock_controller {
-        before {@var = :val}
-        def b
-          scope = Class.new {def initialize; @var = :vax; end}.new
-          render(scope: scope)
-        end
-      }
-      get :b
-      assert(last_response).is_ok_with_body('vax')
-    end
-  end
-
-  context :locals do
-    it 'makes :locals accessible via attributes' do
-      app mock_controller {
-        def c; render(locals: {var: :val}); end
-      }
-      get :c
-      assert(last_response).is_ok_with_body('val')
-    end
-  end
-
-  context 'implicit templates' do
-    it 'uses the folder controller resides in as default path' do
-      app controller = mock_controller(:a) {
-        def index; render end
-      }
-      get
-      assert(last_response).is_ok_with_body '/a'
-    end
-  end
-
-  context 'defined templates' do
-    it 'prefers defined templates over files' do
-      app mock_controller {
-        define_template(:index) {'x'}
-        def index; render end
-      }
-      get
-      assert(last_response).is_ok_with_body 'x'
-    end
-
-    it 'renders defined template with defined layout' do
-      app mock_controller {
-        define_template(:t) {'t'}
-        define_layout(:x) {'x<%= yield %>x'}
-        layout(:x)
-        def index; render(:t) end
-      }
-      get
-      assert(last_response).is_ok_with_body 'xtx'
-    end
-  end
-
-  it 'uses given block for template' do
-    app mock_controller {
-      def index; render {'x'} end
-    }
-    get
-    assert(last_response).is_ok_with_body 'x'
-  end
-end