rabl-rails 0.3.4 → 0.4.0

data/lib/rabl-rails/visitors/visitor.rb

@@ -0,0 +1,17 @@
+module Visitors
+  class Visitor
+    def visit(node)
+      dispatch node
+    end
+
+    private
+
+    DISPATCH = Hash.new do |hash, node_class|
+      hash[node_class] = "visit_#{node_class.name.split('::').last}"
+    end
+
+    def dispatch(node)
+      send DISPATCH[node.class], node
+    end
+  end
+end

data/rabl-rails.gemspec

@@ -15,9 +15,7 @@ Gem::Specification.new do |s|
   s.test_files    = `git ls-files -- test/*`.split("\n")
   s.require_paths = ["lib"]
 
-  s.add_dependency "activesupport", ">= 3.1"
-  s.add_dependency "railties", ">= 3.1"
-
-  s.add_development_dependency "actionpack", ">= 3.1"
-  s.add_development_dependency "rspec-mocks"
+  s.add_dependency 'activesupport', '>= 3.1'
+  s.add_dependency 'railties', '>= 3.1'
+  s.add_dependency 'thread_safe', '~> 0.3.1'
 end

data/test/helper.rb

@@ -0,0 +1,75 @@
+ENV['RAILS_ENV'] = 'test'
+$:.unshift File.expand_path('../../lib', __FILE__)
+
+# require 'rspec/mocks'
+require 'minitest/mock'
+require 'minitest/autorun'
+
+require 'rabl-rails'
+require 'plist'
+
+if RUBY_ENGINE == 'jruby'
+  require 'nokogiri'
+elsif RUBY_ENGINE == 'ruby'
+  require 'libxml'
+end
+
+MINITEST_TEST_CLASS = if defined?(Minitest::Test)
+  Minitest::Test
+else
+  Minitest::Unit::TestCase
+end
+
+module Configurable
+  def with_configuration(key, value)
+    accessor = "#{key}="
+    old_value = RablRails.configuration.send(key)
+    RablRails.configuration.send(accessor, value)
+    yield
+  ensure
+    RablRails.configuration.send(accessor, old_value)
+  end
+end
+MINITEST_TEST_CLASS.send(:include, Configurable)
+
+module Rails
+  def self.cache
+  end
+end
+
+module ActionController
+  module Base
+    def self.perform_caching
+      false
+    end
+  end
+end
+
+class Context
+  attr_writer :virtual_path
+
+  def initialize
+    @_assigns = {}
+    @virtual_path = nil
+  end
+
+  def assigns
+    @_assigns
+  end
+
+  def params
+    {}
+  end
+
+  def context_method
+  end
+end
+
+class User
+  attr_accessor :id, :name
+
+  def initialize(id = nil, name = nil)
+    @id = id
+    @name = name
+  end
+end

data/test/renderers/test_hash_renderer.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+class TestHashRenderer < MINITEST_TEST_CLASS
+  describe 'hash renderer' do
+    def render(locals = nil)
+      RablRails::Renderers::Hash.render(@template, @context, locals)
+    end
+
+    def with_cache
+      ActionController::Base.stub :perform_caching, true do
+        Rails.stub :cache, @cache do
+          yield
+        end
+      end
+    end
+
+    before do
+      @cache    = MiniTest::Mock.new
+      @resource = User.new(1, 'Marty')
+      @context  = Context.new
+      @context.assigns['user'] = @resource
+      @template = RablRails::CompiledTemplate.new
+      @template.data = :@user
+      @template.add_node RablRails::Nodes::Attribute.new(name: :name)
+    end
+
+    describe 'cache' do
+      it 'uses resource cache_key by default' do
+        def @resource.cache_key; 'marty_cache' end
+        @template.cache_key = nil
+        @cache.expect :fetch, { user: 'Marty' }, ['marty_cache']
+        with_cache {
+          assert_equal({ user: 'Marty' }, render)
+        }
+        @cache.verify
+      end
+
+      it 'uses template cache_key if present' do
+        @template.cache_key = ->(u) { u.name }
+        @cache.expect :fetch, { user: 'Marty' }, ['Marty']
+        with_cache {
+          assert_equal({ user: 'Marty' }, render)
+        }
+        @cache.verify
+      end
+    end
+
+    it 'uses a to_hash visitor' do
+      visitor = MiniTest::Mock.new
+      visitor.expect :instance_variable_get, @resource, [:@user]
+      visitor.expect :reset_for, nil, [@resource]
+      visitor.expect :visit, nil, [Array]
+      visitor.expect :result, { some: 'result' }
+
+      Visitors::ToHash.stub :new, visitor do
+        assert_equal({ some: 'result' }, render)
+      end
+
+      visitor.verify
+    end
+
+    it 'retrieves data from context if exist' do
+      @template.data = :context_method
+      resource = User.new(2, 'Biff')
+      @context.stub :context_method, resource do
+        assert_equal({ name: 'Biff' }, render)
+      end
+    end
+
+    it 'uses assigns from context if context has no data method' do
+      assert_equal({ name: 'Marty' }, render)
+    end
+
+    it "uses resource passed in locals if template don't have data" do
+      @template.data = nil
+      resource = User.new(2, 'Biff')
+      assert_equal({ name: 'Biff' }, render(resource: resource))
+    end
+
+    it 'uses template root_name option' do
+      @template.root_name = :user
+      assert_equal({ user: { name: 'Marty' } }, render)
+    end
+
+    it 'renders collection' do
+      @context.assigns['user'] = [@resource]
+      assert_equal([{ name: 'Marty' }], render)
+    end
+  end
+end

data/test/renderers/test_json_renderer.rb

@@ -0,0 +1,46 @@
+require 'helper'
+
+class TestJSONRenderer < MINITEST_TEST_CLASS
+  describe 'JSON renderer' do
+    def render
+      RablRails::Renderers::JSON.render(@template, @context)
+    end
+
+    before do
+      @resource = User.new(1, 'Marty')
+      @context  = Context.new
+      @context.assigns['user'] = @resource
+      @template = RablRails::CompiledTemplate.new
+      @template.data = :@user
+      @template.add_node RablRails::Nodes::Attribute.new(name: :name)
+    end
+
+    it 'extends hash renderer' do
+      RablRails::Renderers::JSON.ancestors.include?(RablRails::Renderers::Hash)
+    end
+
+    it 'renders JSON' do
+      assert_equal %q({"name":"Marty"}), render
+    end
+
+    it 'uses template root_name option' do
+      @template.root_name = :user
+      assert_equal %q({"user":{"name":"Marty"}}), render
+    end
+
+    it 'ignores template root_name option if include_json_root is disabled' do
+      @template.root_name = :user
+      with_configuration :include_json_root, false do
+        assert_equal %q({"name":"Marty"}), render
+      end
+    end
+
+    it 'renders jsonp callback' do
+      @context.stub :params, { callback: 'some_callback' } do
+        with_configuration :enable_jsonp_callbacks, true do
+          assert_equal %q[some_callback({"name":"Marty"})], render
+        end
+      end
+    end
+  end
+end

data/test/renderers/test_plist_renderer.rb

@@ -0,0 +1,42 @@
+require 'helper'
+
+class TestPListRenderer < MINITEST_TEST_CLASS
+  INDENT_REGEXP = /\n(\s)*/
+  HEADER_REGEXP = /<\?[^>]+><![^>]+>/
+
+   describe 'PList renderer' do
+    def render
+      output = RablRails::Renderers::PLIST.render(@template, @context).to_s.gsub!(INDENT_REGEXP, '')
+      output.sub!(HEADER_REGEXP, '').gsub!(%r(</?plist[^>]*>), '').sub!(%r(<dict/?>), '').sub(%r(</dict>), '')
+    end
+
+    before do
+      @resource = User.new(1, 'Marty')
+      @context  = Context.new
+      @context.assigns['user'] = @resource
+      @template = RablRails::CompiledTemplate.new
+      @template.data = :@user
+      @template.add_node RablRails::Nodes::Attribute.new(name: :name)
+    end
+
+    it 'extends hash renderer' do
+      RablRails::Renderers::PLIST.ancestors.include?(RablRails::Renderers::Hash)
+    end
+
+    it 'renders PList' do
+      assert_equal %q(<key>name</key><string>Marty</string>), render
+    end
+
+    it 'uses template root_name option if include_plist_root is set' do
+      @template.root_name = :user
+      with_configuration :include_plist_root, true do
+        assert_equal %q(<key>user</key><dict><key>name</key><string>Marty</string></dict>), render
+      end
+    end
+
+    it 'ignores template root_name by default' do
+      @template.root_name = :user
+      assert_equal %q(<key>name</key><string>Marty</string>), render
+    end
+  end
+end

data/test/renderers/test_xml_renderer.rb

@@ -0,0 +1,37 @@
+require 'helper'
+
+class TestXMLRenderer < MINITEST_TEST_CLASS
+  INDENT_REGEXP = /\n(\s)*/
+  HEADER_REGEXP = /<[^>]+>/
+
+  describe 'XML renderer' do
+    def render
+      RablRails::Renderers::XML.render(@template, @context).to_s.gsub!(INDENT_REGEXP, '').sub!(HEADER_REGEXP, '')
+    end
+
+    before do
+      @resource = User.new(1, 'Marty')
+      @context  = Context.new
+      @context.assigns['user'] = @resource
+      @template = RablRails::CompiledTemplate.new
+      @template.data = :@user
+      @template.add_node RablRails::Nodes::Attribute.new(name: :name)
+    end
+
+    it 'extends hash renderer' do
+      RablRails::Renderers::XML.ancestors.include?(RablRails::Renderers::Hash)
+    end
+
+    it 'uses global XML options' do
+      @template.nodes = [RablRails::Nodes::Attribute.new(first_name: :name)]
+      with_configuration :xml_options, { dasherize: false, skip_types: false } do
+        assert_equal %q(<hash><first_name>Marty</first_name></hash>), render
+      end
+    end
+
+    it 'uses template root_name option' do
+      @template.root_name = :user
+      assert_equal %q(<user><name>Marty</name></user>), render
+    end
+  end
+end

data/test/test_compiler.rb

@@ -0,0 +1,283 @@
+require 'helper'
+
+class TestCompiler < MINITEST_TEST_CLASS
+  describe 'compiler' do
+    def extract_attributes(nodes)
+      nodes.map(&:hash)
+    end
+
+    before do
+      @view = Context.new
+      @compiler = RablRails::Compiler.new(@view)
+    end
+
+    it "returns a compiled template instance" do
+      assert_instance_of RablRails::CompiledTemplate, @compiler.compile_source("")
+    end
+
+    describe '#object' do
+      it "sets data for the template" do
+        t = @compiler.compile_source(%{ object :@user })
+        assert_equal :@user, t.data
+        assert_equal([], t.nodes)
+      end
+
+      it "can define root name" do
+        t = @compiler.compile_source(%{ object :@user => :author })
+        assert_equal :@user, t.data
+        assert_equal :author, t.root_name
+        assert_equal([], t.nodes)
+      end
+    end
+
+    describe '#root' do
+      it "defines root via keyword" do
+        t = @compiler.compile_source(%{ root :author })
+        assert_equal :author, t.root_name
+      end
+
+      it "overrides object root" do
+        t = @compiler.compile_source(%{ object :@user ; root :author })
+        assert_equal :author, t.root_name
+      end
+
+      it "can set root to false via options" do
+        t = @compiler.compile_source(%( object :@user, root: false))
+        assert_equal false, t.root_name
+      end
+    end
+
+    describe '#collection' do
+      it "sets the data for the template" do
+        t = @compiler.compile_source(%{ collection :@user })
+        assert_equal :@user, t.data
+        assert_equal([], t.nodes)
+      end
+
+      it "can define root name" do
+        t = @compiler.compile_source(%{ collection :@user => :users })
+        assert_equal :@user, t.data
+        assert_equal :users, t.root_name
+        assert_equal([], t.nodes)
+      end
+
+      it "can define root name via options" do
+        t = @compiler.compile_source(%{ collection :@user, :root => :users })
+        assert_equal :@user, t.data
+        assert_equal :users, t.root_name
+      end
+    end
+
+    it "should not have a cache key if cache is not enable" do
+      t = @compiler.compile_source('')
+      assert_equal false, t.cache_key
+    end
+
+    describe '#cache' do
+      it "can take no argument" do
+        t = @compiler.compile_source(%{ cache })
+        assert_nil t.cache_key
+      end
+
+      it "sets the given block as cache key" do
+        t = @compiler.compile_source(%( cache { 'foo' }))
+        assert_instance_of Proc, t.cache_key
+      end
+    end
+
+    # Compilation
+
+    it "compiles single attributes" do
+      t = @compiler.compile_source(%{ attributes :id, :name })
+      assert_equal([{ :id => :id, :name => :name }], extract_attributes(t.nodes))
+    end
+
+    it "compiles attributes with the same name once" do
+      skip('Failing')
+      t = @compiler.compile_source(%{ attribute :id ; attribute :id })
+      assert_equal([{ :id => :id }], extract_attributes(t.nodes))
+    end
+
+    it "aliases attributes through :as option" do
+      t = @compiler.compile_source(%{ attribute :foo, :as => :bar })
+      assert_equal([{ :bar => :foo }], extract_attributes(t.nodes))
+    end
+
+    it "aliases attributes through a hash" do
+      t = @compiler.compile_source(%{ attribute :foo => :bar })
+      assert_equal([{ :bar => :foo }], extract_attributes(t.nodes))
+    end
+
+    it "aliases multiple attributes" do
+      t = @compiler.compile_source(%{ attributes :foo => :bar, :id => :uid })
+      assert_equal([{ :bar => :foo, :uid => :id }], extract_attributes(t.nodes))
+    end
+
+    it "compiles child with record association" do
+      t = @compiler.compile_source(%{ child :address do attributes :foo end})
+
+      assert_equal(1, t.nodes.size)
+      child_node = t.nodes.first
+
+      assert_equal(:address, child_node.name)
+      assert_equal(:address, child_node.data)
+      assert_equal([{ foo: :foo }], extract_attributes(child_node.nodes))
+    end
+
+    it "compiles child with association aliased" do
+      t = @compiler.compile_source(%{ child :address => :bar do attributes :foo end})
+      child_node = t.nodes.first
+
+      assert_equal(:bar, child_node.name)
+      assert_equal(:address, child_node.data)
+    end
+
+    it "compiles child with root name defined as option" do
+      t = @compiler.compile_source(%{ child(:user, :root => :author) do attributes :foo end })
+      child_node = t.nodes.first
+
+      assert_equal(:author, child_node.name)
+      assert_equal(:user, child_node.data)
+    end
+
+    it "compiles child with arbitrary source" do
+      t = @compiler.compile_source(%{ child :@user => :author do attribute :name end })
+      child_node = t.nodes.first
+
+      assert_equal(:author, child_node.name)
+      assert_equal(:@user, child_node.data)
+    end
+
+    it "compiles child with inline partial notation" do
+      mock_template = RablRails::CompiledTemplate.new
+      mock_template.add_node(RablRails::Nodes::Attribute.new(id: :id))
+
+      t = RablRails::Library.instance.stub :compile_template_from_path, mock_template do
+        @compiler.compile_source(%{child(:user, :partial => 'users/base') })
+      end
+
+      child_node = t.nodes.first
+
+      assert_equal(:user, child_node.name)
+      assert_equal(:user, child_node.data)
+      assert_equal([{ id: :id }], extract_attributes(child_node.nodes))
+    end
+
+    it "compiles glue as a child but without a name" do
+      t = @compiler.compile_source(%{ glue(:@user) do attribute :name end })
+
+      assert_equal(1, t.nodes.size)
+      glue_node = t.nodes.first
+
+      assert_equal(:@user, glue_node.data)
+      assert_equal([{ name: :name }], extract_attributes(glue_node.nodes))
+    end
+
+    it "allows multiple glue within same template" do
+      t = @compiler.compile_source(%{
+        glue :@user do attribute :name end
+        glue :@user do attribute :foo end
+      })
+
+      assert_equal(2, t.nodes.size)
+    end
+
+    it "compiles glue with RablRails DSL in its body" do
+      t = @compiler.compile_source(%{
+        glue :@user do node(:foo) { |u| u.name } end
+      })
+
+      glue_node = t.nodes.first
+      assert_equal(1, glue_node.nodes.size)
+
+      code_node = glue_node.nodes.first
+      assert_instance_of(RablRails::Nodes::Code, code_node)
+      assert_equal(:foo, code_node.name)
+    end
+
+    it "extends other template" do
+      template = RablRails::CompiledTemplate.new
+      template.add_node RablRails::Nodes::Attribute.new(id: :id)
+
+      library = MiniTest::Mock.new
+      library.expect :compile_template_from_path, template, ['users/base', @view]
+
+      t = RablRails::Library.stub :instance, library do
+        @compiler.compile_source(%{ extends 'users/base' })
+      end
+      assert_equal([{ :id => :id }], extract_attributes(t.nodes))
+      library.verify
+    end
+
+    it "compiles extend without overwriting nodes previously defined" do
+      template = RablRails::CompiledTemplate.new
+      template.add_node(RablRails::Nodes::Condition.new(->{ true }, ->{ 'foo' }))
+
+      t = RablRails::Library.instance.stub :compile_template_from_path, template do
+        @compiler.compile_source(%{
+          condition(-> { false }) { 'bar' }
+          extends('users/xtnd')
+        })
+      end
+      assert_equal(2, t.nodes.size)
+    end
+
+    it "compiles node" do
+      t = @compiler.compile_source(%{ node(:foo) { bar } })
+
+      assert_equal(1, t.nodes.size)
+      code_node = t.nodes.first
+
+      assert_equal(:foo, code_node.name)
+      assert_instance_of Proc, code_node.block
+    end
+
+    it "compiles node with condition option" do
+      t = @compiler.compile_source(%{ node(:foo, :if => lambda { |m| m.foo.present? }) do |m| m.foo end })
+      code_node = t.nodes.first
+      assert_instance_of Proc, code_node.condition
+    end
+
+    it "compiles node with no argument" do
+      t = @compiler.compile_source(%{ node do |m| m.foo end })
+      node = t.nodes.first
+      assert_nil node.name
+    end
+
+    it "compiles merge like a node but with a reserved keyword as name" do
+      t = @compiler.compile_source(%{ merge do |m| m.foo end })
+      node = t.nodes.first
+      assert_instance_of RablRails::Nodes::Code, node
+      assert_nil node.name
+    end
+
+    it "compiles condition" do
+      t = @compiler.compile_source(%{ condition(->(u) {}) do attributes :secret end })
+
+      assert_equal(1, t.nodes.size)
+      node = t.nodes.first
+
+      assert_instance_of RablRails::Nodes::Condition, node
+      assert_equal([{ secret: :secret }], extract_attributes(node.nodes))
+    end
+
+    it "compiles with no object" do
+      t = @compiler.compile_source(%{
+       object false
+       child(:@user => :user) do
+         attribute :id
+       end
+      })
+
+      assert_equal false, t.data
+    end
+
+    describe '#extract_data_and_name' do
+      it "extracts name from argument" do
+        assert_equal [:@users, 'users'], @compiler.send(:extract_data_and_name, :@users)
+        assert_equal [:users, :users], @compiler.send(:extract_data_and_name, :users)
+        assert_equal [:@users, :authors], @compiler.send(:extract_data_and_name, :@users => :authors)
+      end
+    end
+  end
+end