rabl-rails 0.3.4 → 0.4.0

data/lib/rabl-rails/nodes.rb

@@ -0,0 +1,6 @@
+require 'rabl-rails/nodes/node'
+require 'rabl-rails/nodes/attribute'
+require 'rabl-rails/nodes/glue'
+require 'rabl-rails/nodes/child'
+require 'rabl-rails/nodes/code'
+require 'rabl-rails/nodes/condition'

data/lib/rabl-rails/nodes/attribute.rb

@@ -0,0 +1,17 @@
+require 'forwardable'
+
+module RablRails
+  module Nodes
+    class Attribute
+      include Node
+      extend Forwardable
+
+      def_delegators :@hash, :[]=, :each
+      attr_reader :hash
+
+      def initialize(hash = {})
+        @hash = hash
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/child.rb

@@ -0,0 +1,12 @@
+module RablRails
+  module Nodes
+    class Child < Glue
+      attr_reader :name
+
+      def initialize(name, template)
+        super(template)
+        @name = name
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/code.rb

@@ -0,0 +1,19 @@
+module RablRails
+  module Nodes
+    class Code
+      include Node
+
+      attr_reader :name, :block, :condition
+
+      def initialize(name, block, condition = nil)
+        @name = name
+        @block = block
+        @condition = condition
+      end
+
+      def merge?
+        !name
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/condition.rb

@@ -0,0 +1,14 @@
+module RablRails
+  module Nodes
+    class Condition
+      include Node
+
+      attr_reader :condition, :nodes
+
+      def initialize(condition, nodes)
+        @condition = condition
+        @nodes = nodes
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/glue.rb

@@ -0,0 +1,25 @@
+module RablRails
+  module Nodes
+    class Glue
+      include Node
+
+      attr_reader :template
+
+      def initialize(template)
+        @template = template
+      end
+
+      def data
+        @template.data
+      end
+
+      def nodes
+        @template.nodes
+      end
+
+      def instance_variable_data?
+        @instance_variable_data ||= data.to_s.start_with?('@')
+      end
+    end
+  end
+end

data/lib/rabl-rails/nodes/node.rb

@@ -0,0 +1,9 @@
+module RablRails
+  module Nodes
+    module Node
+      def accept(visitor)
+        visitor.visit(self)
+      end
+    end
+  end
+end

data/lib/rabl-rails/railtie.rb

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

data/lib/rabl-rails/renderer.rb

@@ -1,4 +1,4 @@
-require 'rabl-rails/renderers/base'
+require 'rabl-rails/renderers/hash'
 require 'rabl-rails/renderers/json'
 require 'rabl-rails/renderers/xml'
 require 'rabl-rails/renderers/plist'
@@ -6,16 +6,14 @@ require 'rabl-rails/renderers/plist'
 module RablRails
   module Renderer
     class TemplateNotFound < StandardError; end
-
-    mattr_reader :view_path
-    @@view_path = 'app/views'
+    class PartialError < StandardError; end
 
     class LookupContext
       T = Struct.new(:source)
 
       def initialize(view_path, format)
-        @view_path = view_path || RablRails::Renderer.view_path
-        @extension = format ? ".#{format.to_s.downcase}.rabl" : ".rabl"
+        @view_path = view_path || 'app/views'
+        @format = format.downcase
       end
 
       #
@@ -24,8 +22,14 @@ module RablRails
       # path is used
       #
       def find_template(name, opt, partial = false)
-        path = File.join(@view_path, "#{name}#{@extension}")
-        File.exists?(path) ? T.new(File.read(path)) : nil
+        paths = Dir["#@view_path/#{name}{.#@format,}.rabl"]
+        file_path = paths.find { |path| File.exists?(path) }
+
+        if file_path
+          T.new(File.read(file_path))
+        else
+          raise TemplateNotFound
+        end
       end
     end
 
@@ -33,12 +37,12 @@ module RablRails
     # Context class to emulate normal Rails view
     # context
     #
-    class Context
+    class ViewContext
       attr_reader :format
 
       def initialize(path, options)
         @virtual_path = path
-        @format = options.delete(:format) || (RablRails.allow_empty_format_in_template ? nil : 'json')
+        @format = options.delete(:format) || 'json'
         @_assigns = {}
         @options = options
 
@@ -80,11 +84,9 @@ module RablRails
     def render(object, template, options = {})
       object = options[:locals].delete(:object) if !object && options[:locals]
 
-      c = Context.new(template, options)
+      c = ViewContext.new(template, options)
       t = c.lookup_context.find_template(template, [], false)
 
-      raise TemplateNotFound unless t
-
       Library.instance.get_rendered_template(t.source, c, resource: object)
     end
   end

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

@@ -0,0 +1,85 @@
+module RablRails
+  module Renderers
+    module Hash
+      include ::RablRails::Helpers
+      extend self
+
+      #
+      # 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, context, locals = nil)
+        visitor = Visitors::ToHash.new(context)
+
+        collection_or_resource = if template.data
+          if context.respond_to?(template.data)
+            context.send(template.data)
+          else
+            visitor.instance_variable_get(template.data)
+          end
+        end
+        collection_or_resource ||= locals[:resource] if locals
+
+        render_with_cache(template.cache_key, collection_or_resource) do
+          output_hash = if collection?(collection_or_resource)
+            render_collection(collection_or_resource, template.nodes, visitor)
+          else
+            render_resource(collection_or_resource, template.nodes, visitor)
+          end
+
+          format_output(output_hash, root_name: template.root_name, params: context.params)
+        end
+      end
+
+      protected
+
+      #
+      # Format a hash into the desired output.
+      # Renderer subclasses must implement this method
+      #
+      def format_output(hash, options = {})
+        hash = { options[:root_name] => hash } if options[:root_name]
+        hash
+      end
+
+      private
+
+      #
+      # Render a single resource as a hash, according to the compiled
+      # template source passed.
+      #
+      def render_resource(resource, nodes, visitor)
+        visitor.reset_for resource
+        visitor.visit nodes
+        visitor.result
+      end
+
+      #
+      # Call the render_resource mtehod on each object of the collection
+      # and return an array of the returned values.
+      #
+      def render_collection(collection, nodes, visitor)
+        collection.map { |o| render_resource(o, nodes, visitor) }
+      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 render_with_cache(key, collection_or_resource)
+        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
+    end
+  end
+end

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

@@ -1,11 +1,15 @@
 module RablRails
   module Renderers
-    class JSON < Base
-      def format_output(hash)
-        hash = { _options[:root_name] => hash } if _options[:root_name] && RablRails.include_json_root
-        json = MultiJson.encode(hash)
+    module JSON
+      include Renderers::Hash
+      extend self
 
-        RablRails.enable_jsonp_callbacks && params.has_key?(:callback) ? "#{params[:callback]}(#{json})" : json
+      def format_output(hash, options = {})
+        hash = { options[:root_name] => hash } if options[:root_name] && RablRails.configuration.include_json_root
+        json = RablRails.configuration.json_engine.dump(hash)
+        params = options.fetch(:params, {})
+
+        RablRails.configuration.enable_jsonp_callbacks && params.has_key?(:callback) ? "#{params[:callback]}(#{json})" : json
       end
 
       def resolve_cache_key(key, data)

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

@@ -1,10 +1,12 @@
 module RablRails
   module Renderers
-    class PLIST < Base
+    module PLIST
+      include Renderers::Hash
+      extend self
 
-      def format_output(hash)
-        hash = { _options[:root_name] => hash } if _options[:root_name] && RablRails.include_plist_root
-        RablRails.plist_engine.dump(hash)
+      def format_output(hash, options = {})
+        hash = { options[:root_name] => hash } if options[:root_name] && RablRails.configuration.include_plist_root
+        RablRails.configuration.plist_engine.dump(hash)
       end
 
       def resolve_cache_key(key, data)

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

@@ -2,9 +2,12 @@ require 'active_support/core_ext/hash/conversions'
 
 module RablRails
   module Renderers
-    class XML < Base
-      def format_output(hash)
-      	xml_options = { root: _options[:root_name] }.merge!(RablRails.xml_options)
+    module XML
+      include Renderers::Hash
+      extend self
+
+      def format_output(hash, options = {})
+      	xml_options = { root: options[:root_name] }.merge!(RablRails.configuration.xml_options)
 				hash.to_xml(xml_options)
       end
 

data/lib/rabl-rails/responder.rb

@@ -31,7 +31,7 @@ module RablRails
         template = if controller.respond_to?(:responder_default_template, true)
           controller.send(:responder_default_template)
         else
-          RablRails.responder_default_template
+          RablRails.configuration.responder_default_template
         end
         options[:prefixes] = controller._prefixes
         options[:template] ||= template

data/lib/rabl-rails/template.rb

@@ -1,17 +1,23 @@
 module RablRails
   class CompiledTemplate
-    attr_accessor :source, :data, :root_name, :cache_key
-
-    delegate :[], :[]=, :merge!, :to => :source
+    attr_accessor :nodes, :data, :root_name, :cache_key
 
     def initialize
-      @source = {}
+      @nodes = []
       @cache_key = false
     end
 
     def initialize_dup(other)
       super
-      self.source = other.source.dup
+      self.nodes = other.nodes.dup
+    end
+
+    def add_node(n)
+      @nodes << n
+    end
+
+    def extends(template)
+      @nodes.concat template.nodes
     end
   end
 end

data/lib/rabl-rails/version.rb

@@ -1,3 +1,3 @@
 module RablRails
-  VERSION = '0.3.4'
+  VERSION = '0.4.0'
 end

data/lib/rabl-rails/visitors.rb

@@ -0,0 +1,2 @@
+require 'rabl-rails/visitors/visitor'
+require 'rabl-rails/visitors/to_hash'

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

@@ -0,0 +1,131 @@
+module Visitors
+  class ToHash < Visitor
+    include RablRails::Helpers
+
+    attr_reader :_resource
+
+    def initialize(view_context, resource = nil)
+      @_context  = view_context
+      @_result   = {}
+      @_resource = resource
+
+      copy_instance_variables_from_context
+    end
+
+    def reset_for(resource)
+      @_resource = resource
+      @_result = {}
+    end
+
+    def visit_Array n
+      n.each { |i| visit i }
+    end
+
+    def visit_Attribute n
+      n.each { |k, v| @_result[k] = _resource.send(v) }
+    end
+
+    def visit_Child n
+      object = object_from_data(_resource, n.data, n.instance_variable_data?)
+
+      @_result[n.name] = if object
+        collection?(object) ? object.map { |o| sub_visit(o, n.nodes) } : sub_visit(object, n.nodes)
+      else
+        nil
+      end
+    end
+
+    def visit_Code n
+      if !n.condition || instance_exec(_resource, &(n.condition))
+        result = instance_exec _resource, &(n.block)
+
+        if n.merge?
+          raise RablRails::Renderer::PartialError, '`merge` block should return a hash' unless result.is_a?(Hash)
+          @_result.merge!(result)
+        else
+          @_result[n.name] = result
+        end
+      end
+    end
+
+    def visit_Condition n
+      @_result.merge!(sub_visit(_resource, n.nodes)) if instance_exec _resource, &(n.condition)
+    end
+
+    def visit_Glue n
+      object = object_from_data(_resource, n.data, n.instance_variable_data?)
+      @_result.merge! sub_visit(object, n.template.nodes)
+    end
+
+    def result
+      case RablRails.configuration.result_flags
+      when 0
+        @_result
+      when 1
+        @_result.each { |k, v| @_result[k] = '' if v == nil }
+      when 2, 3
+        @_result.each { |k, v| @_result[k] = nil if v == '' }
+      when 4, 5
+        @_result.delete_if { |_, v| v == nil }
+      when 6
+        @_result.delete_if { |_, v| v == nil || v == '' }
+      end
+    end
+
+    protected
+
+    #
+    # 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
+
+    #
+    # Allow to use partial inside of node blocks (they are evaluated at
+    # rendering time).
+    #
+    def partial(template_path, options = {})
+      raise RablRails::Renderer::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 = RablRails::Library.instance.compile_template_from_path(template_path, @_context)
+      if object.respond_to?(:each)
+        object.map { |o| sub_visit o, template.nodes }
+      else
+        sub_visit object, template.nodes
+      end
+    end
+
+    private
+
+    def copy_instance_variables_from_context
+      @_context.instance_variable_get(:@_assigns).each_pair { |k, v|
+        instance_variable_set("@#{k}", v) unless k.to_s.start_with?('_')
+      }
+    end
+
+    def sub_visit(resource, nodes)
+      old_result, old_resource, @_result = @_result, @_resource, {}
+      reset_for resource
+      visit nodes
+      result
+    ensure
+      @_result, @_resource = old_result, old_resource
+    end
+
+    def object_from_data(resource, symbol, is_variable)
+      return resource if symbol == nil
+
+      if is_variable
+        instance_variable_get(symbol)
+      else
+        resource.respond_to?(symbol) ? resource.send(symbol) : @_context.send(symbol)
+      end
+    end
+  end
+end