representative 0.2.5 → 0.3.0

data/Rakefile

@@ -1,6 +1,8 @@
-require "rubygems"
 require "rake"
-require "rake/clean"
+
+require 'bundler'
+
+Bundler::GemHelper.install_tasks
 
 require "spec/rake/spectask"
 
@@ -19,10 +21,3 @@ Spec::Rake::SpecTask.new(:rcov) do |spec|
   spec.rcov = true
 end
 
-require "yard"
-
-YARD::Rake::YardocTask.new(:yardoc) do |t|
-  t.files   = FileList['lib/**/*.rb']
-end
-
-CLEAN << "doc"

data/lib/representative/abstract_xml.rb

@@ -0,0 +1,119 @@
+require "representative/base"
+
+module Representative
+  
+  class AbstractXml < Base
+
+    # Generate an element.
+    #
+    # With two arguments, it generates an element with the specified text content.
+    # 
+    #   r.element :size, 42
+    #   # => <size>42</size>
+    #
+    # More commonly, though, the second argument is omitted, in which case the 
+    # element content is assumed to be the named property of the current #subject.
+    #
+    #   r.representing my_shoe do
+    #     r.element :size
+    #   end
+    #   # => <size>9</size>
+    #
+    # If a block is attached, nested elements can be generated.  The element "value"
+    # (whether explicitly provided, or derived from the current subject) becomes the
+    # subject during evaluation of the block.
+    #
+    #   r.element :book, book do
+    #     r.title
+    #     r.author
+    #   end
+    #   # => <book><title>Whatever</title><author>Whoever</author></book>
+    #
+    # Providing a final Hash argument specifies element attributes.
+    #
+    #   r.element :size, :type => "integer"
+    #   # => <size type="integer">9</size>
+    #
+    def element(name, *args, &block)
+
+      metadata = @inspector.get_metadata(current_subject, name)
+      attributes = args.extract_options!.merge(metadata)
+
+      subject_of_element = if args.empty? 
+        lambda do |subject|
+          @inspector.get_value(current_subject, name)
+        end
+      else 
+        args.shift
+      end
+
+      raise ArgumentError, "too many arguments" unless args.empty?
+
+      representing(subject_of_element) do
+
+        resolved_attributes = resolve_attributes(attributes)
+        content_string = content_block = nil
+        
+        unless current_subject.nil?
+          if block
+            unless block == Representative::EMPTY
+              content_block = Proc.new { block.call(current_subject) }
+            end
+          else
+            content_string = current_subject.to_s
+          end
+        end
+      
+        generate_element(name.to_s.dasherize, resolved_attributes, content_string, &content_block)
+
+      end
+
+    end
+
+    # Generate a list of elements from Enumerable data.
+    #
+    #   r.list_of :books, my_books do
+    #     r.element :title
+    #   end
+    #   # => <books type="array">
+    #   #      <book><title>Sailing for old dogs</title></book>
+    #   #      <book><title>On the horizon</title></book>
+    #   #      <book><title>The Little Blue Book of VHS Programming</title></book>
+    #   #    </books>
+    #
+    # Like #element, the value can be explicit, but is more commonly extracted
+    # by name from the current #subject.
+    #
+    def list_of(name, *args, &block)
+
+      options = args.extract_options!
+      list_subject = args.empty? ? name : args.shift
+      raise ArgumentError, "too many arguments" unless args.empty?
+
+      list_attributes = options[:list_attributes] || {}
+      item_name = options[:item_name] || name.to_s.singularize
+      item_attributes = options[:item_attributes] || {}
+
+      items = resolve_value(list_subject)
+      element(name, items, list_attributes.merge(:type => proc{"array"})) do
+        items.each do |item|
+          element(item_name, item, item_attributes, &block)
+        end
+      end
+
+    end
+
+    # Return a magic value that, when passed to #element as a block, forces
+    # generation of an empty element.
+    #
+    #   r.element(:link, :rel => "me", :href => "http://dogbiscuit.org", &r.empty)
+    #   # => <link rel="parent" href="http://dogbiscuit.org"/>
+    #
+    def empty
+      Representative::EMPTY
+    end
+        
+  end
+  
+end
+    

data/lib/representative/json.rb

@@ -5,15 +5,20 @@ require "json"
 module Representative
   
   class Json < Base
+
+    DEFAULT_ATTRIBUTE_PREFIX = "@".freeze
     
     def initialize(subject = nil, options = {})
       super(subject, options)
       @buffer = ""
       @indent_level = 0
+      @attribute_prefix = options[:attribute_prefix] || DEFAULT_ATTRIBUTE_PREFIX
       now_at :beginning_of_buffer
       yield self if block_given?
     end
     
+    attr_reader :attribute_prefix
+    
     def element(name, *args, &block)
 
       metadata = @inspector.get_metadata(current_subject, name)
@@ -30,10 +35,14 @@ module Representative
       raise ArgumentError, "too many arguments" unless args.empty?
 
       label(name)
-      value(subject_of_element, &block)
+      value(subject_of_element, attributes, &block)
       
     end
 
+    def attribute(name, value_generator = name)
+      element(attribute_prefix + name.to_s, value_generator)
+    end
+    
     def list_of(name, *args, &block)
       list_subject = args.empty? ? name : args.shift
       items = resolve_value(list_subject)
@@ -46,10 +55,13 @@ module Representative
       end
     end
 
-    def value(subject)
+    def value(subject, attributes = {})
       representing(subject) do
         if block_given? && !current_subject.nil?
           inside "{", "}" do
+            attributes.each do |name, value_generator|
+              attribute(name, value_generator)
+            end
             yield current_subject
           end
         else

data/lib/representative/nokogiri.rb

@@ -0,0 +1,61 @@
+require "active_support/core_ext"
+require "nokogiri"
+require "representative/abstract_xml"
+require "representative/empty"
+
+module Representative
+  
+  # Easily generate XML while traversing an object-graph.
+  #
+  class Nokogiri < AbstractXml
+    
+    def initialize(subject = nil, options = {})
+      super(subject, options)
+      @doc = ::Nokogiri::XML::Document.new
+      @current_element = @doc
+      yield self if block_given?
+    end
+
+    attr_reader :doc, :current_element
+
+    # Serialize the generated document as XML
+    #
+    def to_xml(*args)
+      doc.to_xml(*args)
+    end
+
+    # Generate a comment
+    #
+    def comment(text)
+      comment_node = ::Nokogiri::XML::Comment.new(doc, " #{text} ")
+      current_element.add_child(comment_node)
+    end
+    
+    def attribute(name, value_generator = name)
+      attribute_name = name.to_s.dasherize
+      value = resolve_value(value_generator)
+      unless value.nil?
+        current_element[attribute_name] = value.to_s
+      end
+    end
+
+    private
+    
+    def generate_element(name, resolved_attributes, content_string)
+      tag_args = [content_string, resolved_attributes].compact
+      new_element = doc.create_element(name, *tag_args)
+      current_element.add_child(new_element)
+      if block_given?
+        old_element = @current_element
+        begin
+          @current_element = new_element
+          yield 
+        ensure
+          @current_element = old_element
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/representative/tilt_integration.rb

@@ -0,0 +1,56 @@
+require "tilt"
+
+module Representative
+  module Tilt
+
+    class NokogiriTemplate < ::Tilt::Template
+
+      def initialize_engine
+        return if defined?(Representative::Nokogiri)
+        require_template_library 'representative/nokogiri'
+      end
+
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        r = Representative::Nokogiri.new
+        locals[:r] = r
+        super(scope, locals, &block)
+        r.to_xml
+      end
+
+      def precompiled_template(locals)
+        data.to_str
+      end
+
+    end
+    
+    class JsonTemplate < ::Tilt::Template
+
+      def initialize_engine
+        return if defined?(Representative::Json)
+        require_template_library 'representative/json'
+      end
+
+      def prepare
+      end
+
+      def evaluate(scope, locals, &block)
+        r = Representative::Json.new
+        locals[:r] = r
+        super(scope, locals, &block)
+        r.to_json
+      end
+
+      def precompiled_template(locals)
+        data.to_str
+      end
+
+    end
+
+  end
+end
+
+Tilt.register 'xml.rep', Representative::Tilt::NokogiriTemplate
+Tilt.register 'json.rep', Representative::Tilt::JsonTemplate

data/lib/representative/version.rb

@@ -1,3 +1,3 @@
 module Representative
-  VERSION = "0.2.5".freeze
+  VERSION = "0.3.0".freeze
 end

data/lib/representative/xml.rb

@@ -1,14 +1,13 @@
 require "active_support/core_ext"
-require "active_support/core_ext"
 require "builder"
-require "representative/base"
+require "representative/abstract_xml"
 require "representative/empty"
 
 module Representative
 
   # Easily generate XML while traversing an object-graph.
   #
-  class Xml < Base
+  class Xml < AbstractXml
 
     # Create an XML-generating Representative.  The first argument should be an instance of
     # Builder::XmlMarkup (or something that implements it's interface).  The second argument
@@ -20,124 +19,19 @@ module Representative
       yield self if block_given?
     end
 
-    # Generate an element.
-    #
-    # With two arguments, it generates an element with the specified text content.
-    # 
-    #   r.element :size, 42
-    #   # => <size>42</size>
-    #
-    # More commonly, though, the second argument is omitted, in which case the 
-    # element content is assumed to be the named property of the current #subject.
-    #
-    #   r.representing my_shoe do
-    #     r.element :size
-    #   end
-    #   # => <size>9</size>
-    #
-    # If a block is attached, nested elements can be generated.  The element "value"
-    # (whether explicitly provided, or derived from the current subject) becomes the
-    # subject during evaluation of the block.
-    #
-    #   r.element :book, book do
-    #     r.title
-    #     r.author
-    #   end
-    #   # => <book><title>Whatever</title><author>Whoever</author></book>
-    #
-    # Providing a final Hash argument specifies element attributes.
-    #
-    #   r.element :size, :type => "integer"
-    #   # => <size type="integer">9</size>
-    #
-    def element(name, *args, &block)
-
-      metadata = @inspector.get_metadata(current_subject, name)
-      attributes = args.extract_options!.merge(metadata)
-
-      subject_of_element = if args.empty? 
-        lambda do |subject|
-          @inspector.get_value(current_subject, name)
-        end
-      else 
-        args.shift
-      end
-
-      raise ArgumentError, "too many arguments" unless args.empty?
-
-      representing(subject_of_element) do
-
-        content_string = content_block = nil
-
-        unless current_subject.nil?
-          if block
-            unless block == Representative::EMPTY
-              content_block = Proc.new do
-                block.call(current_subject) 
-              end
-            end
-          else
-            content_string = current_subject.to_s
-          end
-        end
-      
-        resolved_attributes = resolve_attributes(attributes)
-        tag_args = [content_string, resolved_attributes].compact
-
-        @xml.tag!(name.to_s.dasherize, *tag_args, &content_block)
-
-      end
-
-    end
-
-    # Generate a list of elements from Enumerable data.
-    #
-    #   r.list_of :books, my_books do
-    #     r.element :title
-    #   end
-    #   # => <books type="array">
-    #   #      <book><title>Sailing for old dogs</title></book>
-    #   #      <book><title>On the horizon</title></book>
-    #   #      <book><title>The Little Blue Book of VHS Programming</title></book>
-    #   #    </books>
-    #
-    # Like #element, the value can be explicit, but is more commonly extracted
-    # by name from the current #subject.
-    #
-    def list_of(name, *args, &block)
-
-      options = args.extract_options!
-      list_subject = args.empty? ? name : args.shift
-      raise ArgumentError, "too many arguments" unless args.empty?
-
-      list_attributes = options[:list_attributes] || {}
-      item_name = options[:item_name] || name.to_s.singularize
-      item_attributes = options[:item_attributes] || {}
-
-      items = resolve_value(list_subject)
-      element(name, items, list_attributes.merge(:type => proc{"array"})) do
-        items.each do |item|
-          element(item_name, item, item_attributes, &block)
-        end
-      end
-
-    end
-
-    # Return a magic value that, when passed to #element as a block, forces
-    # generation of an empty element.
-    #
-    #   r.element(:link, :rel => "me", :href => "http://dogbiscuit.org", &r.empty)
-    #   # => <link rel="parent" href="http://dogbiscuit.org"/>
-    #
-    def empty
-      Representative::EMPTY
-    end
-    
     # Generate a comment
+    #
     def comment(text)
       @xml.comment!(text)
     end
     
+    protected
+    
+    def generate_element(name, resolved_attributes, content_string, &content_block)
+      tag_args = [content_string, resolved_attributes].compact
+      @xml.tag!(name, *tag_args, &content_block)
+    end
+    
   end
 
 end