rabl-rails 0.3.4 → 0.4.0

data/lib/rabl-rails/condition.rb

@@ -1,10 +0,0 @@
-module RablRails
-  class Condition
-    attr_reader :proc, :source
-
-    def initialize(proc, source)
-      @proc = proc
-      @source = source
-    end
-  end
-end

data/lib/rabl-rails/renderers/base.rb

@@ -1,171 +0,0 @@
-module RablRails
-  module Renderers
-    class PartialError < StandardError; end
-
-    class Base
-      attr_accessor :_options
-
-      def initialize(context, locals = nil) # :nodoc:
-        @_context = context
-        @_options = {}
-        @_resource = locals[:resource] if locals
-        setup_render_context
-      end
-
-      #
-      # Render a template.
-      # Uses the compiled template source to get a hash with the actual
-      # data and then format the result according to the `format_result`
-      # method defined by the renderer.
-      #
-      def render(template)
-        collection_or_resource = if template.data
-          if @_context.respond_to?(template.data)
-            @_context.send(template.data)
-          else
-            instance_variable_get(template.data)
-          end
-        end
-        collection_or_resource ||= @_resource
-
-        render_with_cache(template.cache_key, collection_or_resource) do
-          output_hash = collection_or_resource.respond_to?(:each) ? render_collection(collection_or_resource, template.source)
-                                                                  : render_resource(collection_or_resource, template.source)
-          _options[:root_name] = template.root_name
-          format_output(output_hash)
-        end
-      end
-
-      #
-      # Format a hash into the desired output.
-      # Renderer subclasses must implement this method
-      #
-      def format_output(hash)
-        raise "Muse be implemented by renderer"
-      end
-
-      protected
-
-      def render_with_cache(key, collection_or_resource, &block)
-        if !key.is_a?(FalseClass) && ActionController::Base.perform_caching
-          Rails.cache.fetch(resolve_cache_key(key, collection_or_resource)) do
-            yield
-          end
-        else
-          yield
-        end
-      end
-
-      #
-      # Render a single resource as a hash, according to the compiled
-      # template source passed.
-      #
-      def render_resource(data, source)
-        source.inject({}) { |output, (key, value)|
-
-          out = case value
-          when Symbol
-            data.send(value) # attributes
-          when Proc
-            result = instance_exec data, &value
-
-            if key.to_s.start_with?('_') # merge
-              raise PartialError, '`merge` block should return a hash' unless result.is_a?(Hash)
-              output.merge!(result)
-              next output
-            else # node
-              result
-            end
-          when Array # node with condition
-            next output if !instance_exec data, &(value.first)
-            instance_exec data, &(value.last)
-          when Hash
-            current_value = value.dup
-            object = object_from_data(data, current_value.delete(:_data))
-
-            if key.to_s.start_with?('_') # glue
-              output.merge!(render_resource(object, current_value))
-              next output
-            else # child
-              if object
-                object.respond_to?(:each) ? render_collection(object, current_value) : render_resource(object, current_value)
-              else
-                nil
-              end
-            end
-          when Condition
-            if instance_exec data, &(value.proc)
-              output.merge!(render_resource(data, value.source))
-            end
-            next output
-          end
-          output[key] = out
-          output
-        }
-      end
-
-      def params
-        @_context.params
-      end
-
-      #
-      # Call the render_resource mtehod on each object of the collection
-      # and return an array of the returned values.
-      #
-      def render_collection(collection, source)
-        collection.map { |o| render_resource(o, source) }
-      end
-
-      #
-      # Allow to use partial inside of node blocks (they are evaluated at)
-      # rendering time.
-      #
-      def partial(template_path, options = {})
-        raise PartialError.new("No object was given to partial #{template_path}") unless options[:object]
-        object = options[:object]
-
-        return [] if object.respond_to?(:empty?) && object.empty?
-
-        template = Library.instance.compile_template_from_path(template_path)
-        object.respond_to?(:each) ? render_collection(object, template.source) : render_resource(object, template.source)
-      end
-
-      #
-      # If a method is called inside a 'node' property or a 'if' lambda
-      # it will be passed to context if it exists or treated as a standard
-      # missing method.
-      #
-      def method_missing(name, *args, &block)
-        @_context.respond_to?(name) ? @_context.send(name, *args, &block) : super
-      end
-
-      def resolve_cache_key(key, data)
-        return data.cache_key unless key
-        key.is_a?(Proc) ? instance_exec(data, &key) : key
-      end
-
-      private
-
-      def object_from_data(data, symbol)
-        return data if symbol == nil
-
-        if symbol.to_s.start_with?('@')
-          instance_variable_get(symbol)
-        else
-          data.respond_to?(symbol) ? data.send(symbol) : send(symbol)
-        end
-      end
-
-      #
-      # Copy assigns from controller's context into this
-      # renderer context to include instances variables when
-      # evaluating 'node' properties.
-      #
-      def setup_render_context
-        @_context.instance_variable_get(:@_assigns).each_pair { |k, v|
-          instance_variable_set("@#{k}", v) unless k.to_s.start_with?('_')
-        }
-      end
-    end
-  end
-end

data/test/base_renderer_test.rb

@@ -1,67 +0,0 @@
-require 'test_helper'
-
-class TestBaseRenderer < ActiveSupport::TestCase
-
-  RablRails::Renderers::Base.class_eval do
-    def format_output(hash)
-      hash
-    end
-  end
-
-  setup do
-    @data = User.new(1, 'foobar', 'male')
-
-    @context = Context.new
-    @context.assigns['data'] = @data
-
-    @template = RablRails::CompiledTemplate.new
-    @template.source = {}
-    @template.data = :@data
-
-    @cache = double
-    Rails.stub(:cache).and_return(@cache)
-  end
-
-  def render_hash
-    RablRails::Renderers::Base.new(@context).render(@template)
-  end
-
-  test "child with nil data should render nil" do
-    @template.source = { :author => { :_data => :@nil, :name => :name } }
-    assert_equal({ :author => nil }, render_hash)
-  end
-
-  test "properly handle assigns with symbol keys" do
-    @context.assigns[:foo] = 'bar'
-    assert_nothing_raised { render_hash }
-  end
-
-  test "cache should be applied if no cache key is given" do
-    @cache.should_not_receive(:fetch)
-    render_hash
-  end
-
-  test "cache should not be used if disabled in Rails configuration" do
-    ActionController::Base.stub(:perform_caching).and_return(false)
-    @cache.should_not_receive(:fetch)
-    @template.cache_key = 'something'
-    render_hash
-  end
-
-  test "cache shoud use #cache_key as default" do
-    ActionController::Base.stub(:perform_caching).and_return(true)
-    @data.stub(:cache_key).and_return('data_cache_key')
-    @cache.should_receive(:fetch).with('data_cache_key').and_return({ some: 'hash' })
-    @template.cache_key = nil
-
-    assert_equal({ some: 'hash' }, render_hash)
-  end
-
-  test "cache should use the proc if given" do
-    ActionController::Base.stub(:perform_caching).and_return(true)
-    @template.cache_key = ->(u) { 'proc_cache_key' }
-    @cache.should_receive(:fetch).with('proc_cache_key').and_return({ some: 'hash' })
-
-    assert_equal({ some: 'hash' }, render_hash)
-  end
-end

data/test/cache_templates_test.rb

@@ -1,35 +0,0 @@
-require 'test_helper'
-
-class CacheTemplatesTest < ActiveSupport::TestCase
-
-  setup do
-    RablRails::Library.reset_instance
-    @library = RablRails::Library.instance
-    RablRails.cache_templates = true
-  end
-
-  test "cache templates if perform_caching is active and cache_templates is enabled" do
-    ActionController::Base.stub(:perform_caching).and_return(true)
-    @library.compile_template_from_source('', 'some/path')
-    t = @library.compile_template_from_source("attribute :id", 'some/path')
-
-    assert_equal({}, t.source)
-  end
-
-  test "cached templates should not be modifiable in place" do
-    ActionController::Base.stub(:perform_caching).and_return(true)
-    t = @library.compile_template_from_source('', 'some/path')
-
-    t.merge!(:_data => :foo)
-
-    assert_equal({}, @library.compile_template_from_path('some/path').source)
-  end
-
-  test "don't cache templates cache_templates is enabled but perform_caching is not active" do
-    ActionController::Base.stub(:perform_caching).and_return(false)
-    @library.compile_template_from_source('', 'some/path')
-    t = @library.compile_template_from_source("attribute :id", 'some/path')
-
-    assert_equal({ :id => :id }, t.source)
-  end
-end

data/test/compiler_test.rb

@@ -1,233 +0,0 @@
-require 'test_helper'
-
-class CompilerTest < ActiveSupport::TestCase
-
-  setup do
-    @user = User.new
-    @compiler = RablRails::Compiler.new
-  end
-
-  test "compiler return a compiled template" do
-    assert_instance_of RablRails::CompiledTemplate, @compiler.compile_source("")
-  end
-
-  test "object set data for the template" do
-    t = @compiler.compile_source(%{ object :@user })
-    assert_equal :@user, t.data
-    assert_equal({}, t.source)
-  end
-
-  test "object property 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.source)
-  end
-
-  test "root can be defined via keyword" do
-    t = @compiler.compile_source(%{ root :author })
-    assert_equal :author, t.root_name
-  end
-
-  test "root keyword override object root" do
-    t = @compiler.compile_source(%{ object :@user ; root :author })
-    assert_equal :author, t.root_name
-  end
-
-  test "collection set the data for the template" do
-    t = @compiler.compile_source(%{ collection :@user })
-    assert_equal :@user, t.data
-    assert_equal({}, t.source)
-  end
-
-  test "collection property 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.source)
-  end
-
-  test "collection property 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
-
-  test "root can be set to false via options" do
-    t = @compiler.compile_source(%( object :@user, root: false))
-    assert_equal false, t.root_name
-  end
-
-  test "template should not have a cache key if cache is not enable" do
-    t = @compiler.compile_source('')
-    assert_equal false, t.cache_key
-  end
-
-  test "cache can take no argument" do
-    t = @compiler.compile_source(%{ cache })
-    assert_nil t.cache_key
-  end
-
-  test "cache can take a block" do
-    t = @compiler.compile_source(%( cache { 'foo' }))
-    assert_instance_of Proc, t.cache_key
-  end
-
-  # Compilation
-
-  test "simple attributes are compiled to hash" do
-    t = @compiler.compile_source(%{ attributes :id, :name })
-    assert_equal({ :id => :id, :name => :name}, t.source)
-  end
-
-  test "attributes appeared only once even if called mutiple times" do
-    t = @compiler.compile_source(%{ attribute :id ; attribute :id })
-    assert_equal({ :id => :id }, t.source)
-  end
-
-  test "attribute can be aliased through :as option" do
-    t = @compiler.compile_source(%{ attribute :foo, :as => :bar })
-    assert_equal({ :bar => :foo}, t.source)
-  end
-
-  test "attribute can be aliased through hash" do
-    t = @compiler.compile_source(%{ attribute :foo => :bar })
-    assert_equal({ :bar => :foo }, t.source)
-  end
-
-  test "multiple attributes can be aliased" do
-    t = @compiler.compile_source(%{ attributes :foo => :bar, :id => :uid })
-    assert_equal({ :bar => :foo, :uid => :id }, t.source)
-  end
-
-  test "child with association use association name as data" do
-    t = @compiler.compile_source(%{ child :address do attributes :foo end})
-    assert_equal({ :address => { :_data => :address, :foo => :foo } }, t.source)
-  end
-
-  test "child with association can be aliased" do
-    t = @compiler.compile_source(%{ child :address => :bar do attributes :foo end})
-    assert_equal({ :bar => { :_data => :address, :foo => :foo } }, t.source)
-  end
-
-  test "child with root name defined as option" do
-    t = @compiler.compile_source(%{ child(:user, :root => :author) do attributes :foo end })
-    assert_equal({ :author => { :_data => :user, :foo => :foo } }, t.source)
-  end
-
-  test "child with arbitrary source store the data with the template" do
-    t = @compiler.compile_source(%{ child :@user => :author do attribute :name end })
-    assert_equal({ :author => { :_data => :@user, :name => :name } }, t.source)
-  end
-
-  test "child with succint partial notation" do
-    mock_template = RablRails::CompiledTemplate.new
-    mock_template.source = { :id => :id }
-    RablRails::Library.reset_instance
-    RablRails::Library.instance.stub(:compile_template_from_path).with('users/base').and_return(mock_template)
-
-    t = @compiler.compile_source(%{child(:user, :partial => 'users/base') })
-    assert_equal({:user => { :_data => :user, :id => :id } }, t.source)
-  end
-
-  test "glue is compiled as a child but with anonymous name" do
-    t = @compiler.compile_source(%{ glue(:@user) do attribute :name end })
-    assert_equal({ :_glue0 => { :_data => :@user, :name => :name } }, t.source)
-  end
-
-  test "multiple glue don't come with name collisions" do
-    t = @compiler.compile_source(%{
-      glue :@user do attribute :name end
-      glue :@user do attribute :foo end
-    })
-
-    assert_equal({
-      :_glue0 => { :_data => :@user, :name => :name},
-      :_glue1 => { :_data => :@user, :foo => :foo}
-    }, t.source)
-  end
-
-  test "glue accepts all dsl in its body" do
-    t = @compiler.compile_source(%{
-      glue :@user do node(:foo) { |u| u.name } end
-    })
-
-    assert_not_nil(t.source[:_glue0])
-    s = t.source[:_glue0]
-
-    assert_equal(:@user, s[:_data])
-    assert_instance_of(Proc, s[:foo])
-  end
-
-  test "extends use other template source as itself" do
-    template = double('template', :source => { :id => :id })
-    RablRails::Library.reset_instance
-    RablRails::Library.instance.stub(:compile_template_from_path).with('users/base').and_return(template)
-    t = @compiler.compile_source(%{ extends 'users/base' })
-    assert_equal({ :id => :id }, t.source)
-  end
-
-  test "extends should not overwrite nodes previously defined" do
-    skip('Bug reported by @abrisse')
-
-    template = mock('file_template', :source => %(condition(-> { true }) { 'foo' }))
-    lookup_context = mock
-    lookup_context.stub(:find_template).with('users/xtnd', [], false).and_return(template)
-    RablRails::Library.reset_instance
-    RablRails::Library.instance.instance_variable_set(:@lookup_context, lookup_context)
-
-    t = @compiler.compile_source(%{
-      condition(-> { false }) { 'bar' }
-      extends('users/xtnd')
-    })
-
-    assert_equal 2, t.source.keys.size
-  end
-
-  test "node are compiled without evaluating the block" do
-    t = @compiler.compile_source(%{ node(:foo) { bar } })
-    assert_not_nil t.source[:foo]
-    assert_instance_of Proc, t.source[:foo]
-  end
-
-  test "node with condition are compiled as an array of procs" do
-    t = @compiler.compile_source(%{ node(:foo, :if => lambda { |m| m.foo.present? }) do |m| m.foo end })
-    assert_not_nil t.source[:foo]
-    assert_instance_of Array, t.source[:foo]
-    assert_equal 2, t.source[:foo].size
-  end
-
-  test "node can take no arguments and behave like a merge" do
-    t = @compiler.compile_source(%{ node do |m| m.foo end })
-    assert_instance_of Proc, t.source[:_merge0]
-  end
-
-  test "merge compile like a node but with a reserved keyword as name" do
-    t = @compiler.compile_source(%{ merge do |m| m.foo end })
-    assert_instance_of Proc, t.source[:_merge0]
-  end
-
-  test "conditionnal block compile nicely" do
-    t = @compiler.compile_source(%{ condition(->(u) {}) do attributes :secret end })
-    assert_instance_of RablRails::Condition, t.source[:_if0]
-    assert_equal({ :secret => :secret }, t.source[:_if0].source)
-  end
-
-  test "compile with no object" do
-    t = @compiler.compile_source(%{
-     object false
-     child(:@user => :user) do
-       attribute :id
-     end
-    })
-
-    assert_equal({ :user => { :_data => :@user, :id => :id } }, t.source)
-    assert_equal false, t.data
-  end
-
-  test "name extraction 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