rabl-rails 0.1.0

data/lib/rabl-rails/handler.rb

@@ -0,0 +1,15 @@
+module RablRails
+  module Handlers
+    class Rabl
+      cattr_accessor :default_format
+      self.default_format = 'application/json'
+
+      def self.call(template)
+        %{
+          RablRails::Library.instance.
+            get_rendered_template(#{template.source.inspect}, self)
+        }
+      end
+    end
+  end
+end

data/lib/rabl-rails/library.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+
+module RablRails
+  class Library
+    include Singleton
+
+    def initialize
+      @cached_templates = {}
+    end
+
+    def get_rendered_template(source, context)
+      path = context.instance_variable_get(:@virtual_path)
+      @lookup_context = context.lookup_context
+
+      compiled_template = compile_template_from_source(source, path)
+
+      format = context.params[:format] || 'json'
+      Renderers.const_get(format.upcase!).new(context).render(compiled_template)
+    end
+
+    def compile_template_from_source(source, path = nil)
+      if path && RablRails.cache_templates?
+        @cached_templates[path] ||= Compiler.new.compile_source(source)
+        @cached_templates[path].dup
+      else
+        Compiler.new.compile_source(source)
+      end
+    end
+
+    def compile_template_from_path(path)
+      template = @cached_templates[path]
+      return template if template
+      t = @lookup_context.find_template(path, [], false)
+      compile_template_from_source(t.source, path)
+    end
+  end
+end

data/lib/rabl-rails/railtie.rb

@@ -0,0 +1,9 @@
+module RablRails
+  class Railtie < Rails::Railtie
+    initializer "rabl.initialize" do |app|
+      ActiveSupport.on_load(:action_view) do
+        ActionView::Template.register_template_handler :rabl, RablRails::Handlers::Rabl
+      end
+    end
+  end
+end

data/lib/rabl-rails/renderer.rb

@@ -0,0 +1,2 @@
+require 'rabl-rails/renderers/base'
+require 'rabl-rails/renderers/json'

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

@@ -0,0 +1,116 @@
+module RablRails
+  module Renderers
+    class PartialError < StandardError; end
+
+    class Base
+      attr_accessor :options
+
+      def initialize(context) # :nodoc:
+        @_context = context
+        @options = {}
+        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 = @_context.instance_variable_get(template.data) if template.data
+        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
+
+      #
+      # 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
+
+      #
+      # Render a single resource as a hash, according to the compiled
+      # template source passed.
+      #
+      def render_resource(data, source)
+        source.inject({}) { |output, current|
+          key, value = current
+
+          out = case value
+          when Symbol
+            data.send(value) # attributes
+          when Proc
+            instance_exec data, &value # node
+          when Array # node with condition
+            next output if !instance_exec data, &(value.first)
+            instance_exec data, &(value.last)
+          when Hash
+            current_value = value.dup
+            data_symbol = current_value.delete(:_data)
+            object = data_symbol.nil? ? data : data_symbol.to_s.start_with?('@') ? @_context.instance_variable_get(data_symbol) : data.send(data_symbol)
+
+            if key.to_s.start_with?('_') # glue
+              current_value.each_pair { |k, v|
+                output[k] = object.send(v)
+              }
+              next output
+            else # child
+              object.respond_to?(:each) ? render_collection(object, current_value) : render_resource(object, current_value)
+            end
+          end
+          output[key] = out
+          output
+        }
+      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
+
+      #
+      # 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.start_with?('_') || k == @data
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module RablRails
+  module Renderers
+    class JSON < Base
+      def format_output(hash)
+        hash = { options[:root_name] => hash } if options[:root_name] && RablRails.include_json_root
+        MultiJson.encode(hash)
+      end
+    end
+  end
+end

data/lib/rabl-rails/template.rb

@@ -0,0 +1,11 @@
+module RablRails
+  class CompiledTemplate
+    attr_accessor :source, :data, :root_name
+
+    delegate :[], :[]=, :merge!, :to => :source
+
+    def initialize
+      @source = {}
+    end
+  end
+end

data/lib/rabl-rails/version.rb

@@ -0,0 +1,3 @@
+module RablRails
+  VERSION = '0.1.0'
+end

data/lib/tasks/rabl-rails.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :rabl-rails do
+#   # Task goes here
+# end

data/rabl-rails.gemspec

@@ -0,0 +1,23 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "rabl-rails/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rabl-rails"
+  s.version     = RablRails::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Christopher Cocchi-Perrier"]
+  s.email       = ["cocchi.c@gmail.com"]
+  s.homepage    = "https://github.com/ccocchi/rabl-rails"
+  s.summary     = "Fast Rails 3+ templating system with JSON and XML support"
+  s.description = "Fast Rails 3+ templating system with JSON and XML support"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- test/*`.split("\n")
+  s.require_paths = ["lib"]
+
+  s.add_dependency "activesupport", "~> 3.0"
+  s.add_dependency "railties", "~> 3.0"
+
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "actionpack", "~> 3.0"
+end

data/test/cache_templates_test.rb

@@ -0,0 +1,34 @@
+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)
+    @library.compile_template_from_source('', 'some/path')
+    t = @library.compile_template_from_source("attribute :id", 'some/path')
+
+    assert_equal({}, t.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

@@ -0,0 +1,163 @@
+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 "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
+
+  # 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 "extends use other template source as itself" do
+    template = mock('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 "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 "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