rocketio-views 0.4.0

data/lib/rocketio-views/template_vars.rb

@@ -0,0 +1,34 @@
+module RocketIO
+  class Controller
+
+    # define variables to be used on templates alongside provided locals.
+    #
+    # @param name
+    # @param value
+    #
+    def self.define_template_var name, value = nil, &block
+      value || block || raise(ArgumentError, 'A value or a block expected')
+      (@__template_vars__ ||= {})[name.to_sym] = (block || value).freeze
+      define_template_vars_methods
+    end
+
+    def self.define_template_vars_methods source = self
+      return unless source.instance_variables.include?(:@__template_vars__)
+      vars = source.instance_variable_get(:@__template_vars__).each_with_object(allocate.__template_vars__.dup) do |(name,value),o|
+        o[name] = :"__#{name}_template_var__"
+        if value.is_a?(Proc)
+          api.delete define_method(o[name], &value)
+        else
+          api.delete define_method(o[name]) {value}
+        end
+      end.freeze
+      api.delete define_method(:__template_vars__) {vars}
+    end
+
+    def __template_vars__; RocketIO::EMPTY_HASH end
+
+    def template_vars
+      __template_vars__.each_with_object({}) {|(k,v),o| o[k] = __send__(v)}
+    end
+  end
+end

data/lib/rocketio-views/templates.rb

@@ -0,0 +1,83 @@
+module RocketIO
+  class Controller
+
+    # if only name given it will search for a file with same name in controller's dirname
+    #
+    # if file name differs from template name pass it as :file option.
+    # file path should be relative to controller's dirname.
+    # also a block accepted for :file option. the block will be executed at controllers's instance level
+    # and should return path to template file.
+    # file name should NOT include extension.
+    #
+    # if a block given NO file will be searched and returned value will be used as template.
+    #
+    # @note files will be searched relative to controller's dirname,
+    #   that's it, the folder controller was defined in and operates from.
+    #
+    # @note when searching for file multiple extensions will be tried,
+    #   that's it, all extensions controller's engine actually supports.
+    #
+    # @note controllers that inherits named templates will always search for files in own dirname.
+    #   controllers that inherits :file templates will search files in the original controller's dirname.
+    #
+    # @example define :items template.
+    #   ./items.erb file will be used
+    #   define_template :items
+    #
+    # @example define :items template.
+    #   ../shared_templates/items.erb file will be used
+    #   define_template :items, file: '../shared_templates/items'
+    #
+    # @example define :items template.
+    #   ./admin-items.erb file to be used when user logged in and ./items.erb otherwise
+    #
+    #   define_template :items, file: -> {user? ? 'admin-items' : 'items'}
+    #
+    # @example define :items template using a block that returns the template string.
+    #   no file will be used.
+    #
+    #   define_template(:items) do
+    #     template = Templates.find_by(id: params[:template_id]) || halt(400, 'Template not found')
+    #     template.source
+    #   end
+    #
+    # @param name
+    # @param file
+    # @param block
+    #
+    def self.define_template name, file: nil, &block
+      file && block && raise(ArgumentError, 'both file and block given, please use either one')
+      (@__templates__ ||= {})[name.to_sym] = {block: block, root: dirname, file: file, name: name}.freeze
+      define_templates_methods
+    end
+
+    def self.define_templates_methods source = self
+      return unless source.instance_variables.include?(:@__templates__)
+      templates = source.instance_variable_get(:@__templates__).each_with_object(allocate.templates.dup) do |(name,setup),o|
+        o[name] = :"__#{name}_template__"
+        if setup[:block]
+          # block given, do not search for file, use returned value instead
+          api.delete define_method(o[name], &setup[:block])
+        elsif setup[:file]
+          # file given, search the file in original controller dirname
+          meth_name = :"__#{name}_template_file__"
+          meth_proc = setup[:file].is_a?(Proc) ? setup[:file] : -> {setup[:file]}
+          api.delete define_method(meth_name, &meth_proc)
+          api.delete define_method(o[name]) {
+            engine, * = resolve_engine
+            read_template(find_template(setup[:root], __send__(meth_name), engine))
+          }
+        else
+          # only name given, search for a file with same name in controller's dirname
+          api.delete define_method(o[name]) {
+            engine, * = resolve_engine
+            read_template(find_template(self.dirname, setup[:name], engine))
+          }
+        end
+      end.freeze
+      api.delete define_method(:templates) {templates}
+    end
+
+    def templates; RocketIO::EMPTY_HASH end
+  end
+end

data/lib/rocketio-views/version.rb

@@ -0,0 +1,5 @@
+module RocketIO
+  module Views
+    VERSION = '0.4.0'.freeze
+  end
+end

data/rocketio.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+require File.expand_path('../lib/rocketio-views/version', __FILE__)
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rocketio-views'
+  spec.version       = String.new(RocketIO::Views::VERSION)
+  spec.authors       = ['Slee Woo']
+  spec.email         = ['mail@sleewoo.com']
+  spec.summary       = [spec.name, spec.version]*'-',
+  spec.description   = 'View layer for RocketIO'
+  spec.homepage      = 'https://github.com/rocketio/' + spec.name
+  spec.license       = 'MIT'
+
+  spec.files = Dir['**/{*,.[a-z]*}'].reject {|e| e =~ /(gem|lock)\z/}
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = '~> 2.2'
+
+  spec.add_runtime_dependency 'rocketio', '>= 0.4'
+  spec.add_runtime_dependency 'tilt', '~> 2'
+
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.5'
+  spec.add_development_dependency 'tokyo', '~> 0'
+  spec.add_development_dependency 'rack-radar', '~> 0'
+  spec.add_development_dependency 'pry', '~> 0'
+  spec.add_development_dependency 'pry-byebug', '~> 3'
+end

data/test/b.erb

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

data/test/c.erb

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

data/test/engine_test.rb

@@ -0,0 +1,71 @@
+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/index.erb

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

data/test/items.erb

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

data/test/layout.erb

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

data/test/layout_test.rb

@@ -0,0 +1,123 @@
+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/layouts/master.erb

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

data/test/layouts_test.rb

@@ -0,0 +1,145 @@
+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