erector 0.3.110 → 0.4.191

data/lib/erector/unicode_builder.rb

@@ -0,0 +1,67 @@
+# Note that this class is only used in building erector itself
+# (and even then, only needs to be run when there is a new
+# UnicodeData.txt file from unicode.org).
+class Erector::UnicodeBuilder
+
+  def initialize(input, output)
+    @input = input
+    @output = output
+    @first = true
+  end
+  
+  def generate()
+    @output.puts "Erector::CHARACTERS = {"
+    process_file
+    @output.puts "}"
+  end
+
+  def process_file()
+    while !@input.eof
+      line = @input.gets.strip
+      if (line == "")
+        next;
+      end
+      
+      process_line(line)
+    end
+    if (!@first)
+      @output.puts
+    end
+  end
+  
+  def output_line(line)
+    if (!@first)
+      @output.puts(',')
+    end
+    
+    @output.print(line)
+
+    @first = false
+  end
+  
+  def process_line(line)
+    fields = line.split(';')
+    code_point = fields[0]
+    name = fields[1]
+    alternate_name = fields[10]
+
+    if /^</.match(name)
+      return ""
+    end
+
+    output name, code_point
+    if (!alternate_name.nil? && alternate_name != "")
+      output alternate_name, code_point
+    end
+  end
+  
+  def output(name, code_point)
+    output_line "  :#{namify(name)} => 0x#{code_point.downcase}"
+  end
+  
+  def namify(name)
+    name.downcase.gsub(/[- ]/, '_')
+  end
+
+end
+

data/lib/erector/widget.rb

@@ -1,5 +1,3 @@
-require 'cgi'
-
 module Erector
   
   # A Widget is the center of the Erector universe. 
@@ -14,11 +12,11 @@ module Erector
   # To render a widget from the outside, instantiate it and call its +to_s+ method.
   # 
   # To call one widget from another, inside the parent widget's render method, instantiate the child widget and call 
-  # its +render_to+ method, passing in +self+ (or self.doc if you prefer). This assures that the same HtmlParts stream
+  # its +render_to+ method, passing in +self+ (or self.doc if you prefer). This assures that the same Doc stream
   # is used, which gives better performance than using +capture+ or +to_s+.
   # 
   # In this documentation we've tried to keep the distinction clear between methods that *emit* text and those that
-  # *return* text. "Emit" means that it writes HtmlParts to the doc stream; "return" means that it returns a string 
+  # *return* text. "Emit" means that it writes Doc to the doc stream; "return" means that it returns a string
   # like a normal method and leaves it up to the caller to emit that string if it wants.
   class Widget
     class << self
@@ -45,23 +43,41 @@ module Erector
         ]
       end
 
+      def after_initialize(instance=nil, &blk)
+        if blk
+          after_initialize_parts << blk
+        elsif instance
+          if superclass.respond_to?(:after_initialize)
+            superclass.after_initialize instance
+          end
+          after_initialize_parts.each do |part|
+            instance.instance_eval &part
+          end
+        else
+          raise ArgumentError, "You must provide either an instance or a block"
+        end
+      end
+
+      protected
+      def after_initialize_parts
+        @after_initialize_parts ||= []
+      end
     end
 
-    include ActionController::UrlWriter
-    include Helpers
     attr_reader :helpers
     attr_reader :assigns
     attr_reader :doc
     attr_reader :block
     attr_reader :parent
 
-    def initialize(helpers=nil, assigns={}, doc = HtmlParts.new, &block)
+    def initialize(helpers=nil, assigns={}, io = StringIO.new(""), &block)
       @assigns = assigns
       assign_locals(assigns)
       @helpers = helpers
       @parent = block ? eval("self", block.binding) : nil
-      @doc = doc
+      @doc = Doc.new(io)
       @block = block
+      self.class.after_initialize self
     end
 
 #-- methods for other classes to call, left public for ease of testing and documentation
@@ -75,26 +91,42 @@ module Erector
         end
       end
     end
+    
+    # Set whether Erector should add newlines and indentation in to_s.
+    # This is an experimental feature and is subject to change
+    # (either in terms of how it is enabled, or in terms of
+    # what decisions Erector makes about where to add whitespace).
+    # This flag should be set prior to any rendering being done
+    # (for example, calls to to_s or to_pretty).
+    def enable_prettyprint(enable)
+      @doc.enable_prettyprint = enable
+      self
+    end
+
+    # Render (like to_s) but adding newlines and indentation.
+    def to_pretty
+      enable_prettyprint(true).to_s
+    end
 
-    # Entry point for rendering a widget (and all its children). This method creates a new HtmlParts doc stream,
-    # calls this widget's #render method, converts the HtmlParts to a string, and returns the string. 
+    # Entry point for rendering a widget (and all its children). This method creates a new Doc doc stream,
+    # calls this widget's #render method, converts the Doc to a string, and returns the string.
     #
     # If it's called again later 
     # then it returns the earlier rendered string, which leads to higher performance, but may have confusing
     # effects if some underlying state has changed. In general we recommend you create a new instance of every
     # widget for each render, unless you know what you're doing.
-    def to_s(&blk)
+    def to_s(render_method_name=:render, &blk)
       # The @__to_s variable is used as a cache. 
       # If it's useful we should add a test for it.  -ac
       return @__to_s if @__to_s
-      render(&blk)
+      send(render_method_name, &blk)
       @__to_s = @doc.to_s
     end
-
+    
     alias_method :inspect, :to_s
 
     # Template method which must be overridden by all widget subclasses. Inside this method you call the magic
-    # #element methods which emit HTML and text to the HtmlParts stream.
+    # #element methods which emit HTML and text to the Doc stream.
     def render
       if @block
         instance_eval(&@block)
@@ -102,7 +134,7 @@ module Erector
     end
 
     # To call one widget from another, inside the parent widget's render method, instantiate the child widget and call 
-    # its +render_to+ method, passing in +self+ (or self.doc if you prefer). This assures that the same HtmlParts stream
+    # its +render_to+ method, passing in +self+ (or self.doc if you prefer). This assures that the same Doc stream
     # is used, which gives better performance than using +capture+ or +to_s+.
     def render_to(doc_or_widget)
       if doc_or_widget.is_a?(Widget)
@@ -114,9 +146,12 @@ module Erector
       render
     end
 
-    # Convenience method for on-the-fly widgets. (Should we make this hidden? How is it used?)
+    # Convenience method for on-the-fly widgets. This is a way of making
+    # a sub-widget which still has access to the methods of the parent class.
+    # This is an experimental erector feature which may disappear in future
+    # versions of erector (see #widget in widget_spec in the Erector tests).
     def widget(widget_class, assigns={}, &block)
-      child = widget_class.new(helpers, assigns, doc, &block)
+      child = widget_class.new(helpers, assigns, doc.output, &block)
       child.render
     end
 
@@ -139,7 +174,7 @@ module Erector
     # When calling one of these magic methods, put attributes in the default hash. If there is a string parameter,
     # then it is used as the contents. If there is a block, then it is executed (yielded), and the string parameter is ignored.
     # The block will usually be in the scope of the child widget, which means it has access to all the 
-    # methods of Widget, which will eventually end up appending text to the +doc+ HtmlParts stream. See how 
+    # methods of Widget, which will eventually end up appending text to the +doc+ Doc stream. See how
     # elegant it is? Not confusing at all if you don't think about it.
     #
     def element(*args, &block)
@@ -158,7 +193,7 @@ module Erector
       __empty_element__(*args, &block)
     end
 
-    # Returns an HTML-escaped version of its parameter. Leaves the HtmlParts stream untouched. Note that
+    # Returns an HTML-escaped version of its parameter. Leaves the Doc stream untouched. Note that
     # the #text method automatically HTML-escapes its parameter, so be careful *not* to do something like
     # text(h("2<4")) since that will double-escape the less-than sign (you'll get "2&amp;lt;4" instead of
     # "2&lt;4").
@@ -168,13 +203,16 @@ module Erector
 
     # Emits an open tag, comprising '<', tag name, optional attributes, and '>'
     def open_tag(tag_name, attributes={})
-      @doc << {:type => :open, :tagName => tag_name, :attributes => attributes}
+      @doc.open_tag tag_name, attributes
     end
 
-    # Emits text which will be HTML-escaped.
+    # Emits text.  If a string is passed in, it will be HTML-escaped.
+    # If a widget or the result of calling methods such as raw
+    # is passed in, the HTML will not be HTML-escaped again.
+    # If another kind of object is passed in, the result of calling
+    # its to_s method will be treated as a string would be.
     def text(value)
-      @doc << {:type => :text, :value => value}
-      nil
+      @doc.text value
     end
 
     # Returns text which will *not* be HTML-escaped.
@@ -182,32 +220,46 @@ module Erector
       RawString.new(value.to_s)
     end
 
-    # Returns text which will *not* be HTML-escaped. Same effect as text(raw(s))
+    # Emits text which will *not* be HTML-escaped. Same effect as text(raw(s))
     def rawtext(value)
       text raw(value)
     end
 
     # Returns a copy of value with spaces replaced by non-breaking space characters.
-    # The output uses the entity-escaping format '&#160;' since that works
+    # With no arguments, return a single non-breaking space.
+    # The output uses the escaping format '&#160;' since that works
     # in both HTML and XML (as opposed to '&nbsp;' which only works in HTML).
-    def nbsp(value)
+    def nbsp(value = " ")
       raw(value.html_escape.gsub(/ /,'&#160;'))
     end
+    
+    # Return a character given its unicode code point or unicode name.
+    def character(code_point_or_name)
+      if code_point_or_name.is_a?(Symbol)
+        found = Erector::CHARACTERS[code_point_or_name]
+        if found.nil?
+          raise "Unrecognized character #{code_point_or_name}"
+        end
+        raw("&#x#{sprintf '%x', found};")
+      elsif code_point_or_name.is_a?(Integer)
+        raw("&#x#{sprintf '%x', code_point_or_name};")
+      else
+        raise "Unrecognized argument to character: #{code_point_or_name}"
+      end
+    end
 
     # Emits a close tag, consisting of '<', tag name, and '>'
     def close_tag(tag_name)
-      @doc << {:type => :close, :tagName => tag_name}
+      @doc.close_tag tag_name
     end
 
     # Emits an XML instruction, which looks like this: <?xml version=\"1.0\" encoding=\"UTF-8\"?>
     def instruct(attributes={:version => "1.0", :encoding => "UTF-8"})
-      @doc << {:type => :instruct, :attributes => attributes}
+      @doc.instruct attributes
     end
 
     # Deprecated synonym of instruct
-    def instruct!(attributes={:version => "1.0", :encoding => "UTF-8"})
-      @doc << {:type => :instruct, :attributes => attributes}
-    end
+    alias_method :instruct!, :instruct
 
     # Creates a whole new doc stream, executes the block, then converts the doc stream to a string and 
     # emits it as raw text. If at all possible you should avoid this method since it hurts performance,
@@ -215,7 +267,7 @@ module Erector
     def capture(&block)
       begin
         original_doc = @doc
-        @doc = HtmlParts.new
+        @doc = Doc.new(StringIO.new)
         yield
         raw(@doc.to_s)
       ensure
@@ -299,6 +351,7 @@ module Erector
 
 protected
 
+    # This is part of the sub-widget/parent feature (see #widget method).
     def method_missing(name, *args, &block)
       block ||= lambda {} # captures self HERE
       if @parent
@@ -308,55 +361,6 @@ protected
       end
     end
 
-    def fake_erbout(&blk)
-      # override concat on the helpers object (which is usually a Rails view object)
-      unless @helpers.respond_to?(:concat_without_erector)
-        @helpers.metaclass.class_eval do
-          alias_method :capture_without_erector, :capture
-          def capture(*args, &block)
-            result = nil
-            widget = @erector_widget_stack.first
-            begin
-              original_doc = widget.doc
-              widget.instance_eval do
-                @doc = HtmlParts.new
-              end
-              captured = capture_without_erector(*args, &block)
-              result = widget.raw(widget.doc.to_s)
-            ensure
-              widget.instance_eval do
-                @doc = original_doc
-              end
-            end
-            result
-          end
-
-          alias_method :concat_without_erector, :concat
-          define_method :concat do |*args|
-            some_text, binding = args
-            raise "widget stack too big" if  @erector_widget_stack.size > 10
-            if @erector_widget_stack.empty?
-              concat_without_erector(some_text, binding)
-            else
-              @erector_widget_stack.first.rawtext(some_text)
-            end
-          end
-          define_method :erector_widget_stack do
-            @erector_widget_stack ||= []
-          end
-        end
-      end
-
-      @helpers.erector_widget_stack.unshift(self)
-      yield
-    ensure
-      if @helpers.respond_to?(:concat_without_erector)
-        @helpers.erector_widget_stack.shift
-      end
-    end
-    
-private
-
     def __element__(tag_name, *args, &block)
       if args.length > 2
         raise ArgumentError, "Cannot accept more than three arguments"
@@ -383,7 +387,7 @@ private
     end
 
     def __empty_element__(tag_name, attributes={})
-      @doc << {:type => :empty, :tagName => tag_name, :attributes => attributes}
+      @doc.empty_element tag_name, attributes
     end
     
   end

data/spec/core_spec_suite.rb

@@ -0,0 +1,3 @@
+dir = File.dirname(__FILE__)
+require "#{dir}/spec_suite"
+SpecSuite.core

data/spec/erect/erect_spec.rb

@@ -1,7 +1,4 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/../spec_helper"
-require "#{dir}/../../lib/erector/erect"
-require 'tempfile'
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 module Erector
   describe Erect do

data/spec/erect/erected_spec.rb

@@ -1,7 +1,4 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/../spec_helper"
-require "#{dir}/../../lib/erector/erected"
-require 'tempfile'
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 module Erector
   describe Erected do

data/spec/erect/rhtml_parser_spec.rb

@@ -1,10 +1,4 @@
-dir = File.dirname(__FILE__)
-require "#{dir}/../spec_helper"
-
-# require 'test/unit'
-require 'rubygems'
-require 'treetop'
-require "erector/erected"  # pull this out so we don't recreate the grammar every time
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
 
 module ParserTestHelper
   def assert_evals_to_self(input)
@@ -189,6 +183,7 @@ describe RhtmlParser do
     parse("<%= h hi \"mom\" %>").convert.should == "text hi(\"mom\")\n"
 
     parse("<%= \"mom\" %>").convert.should == "rawtext \"mom\"\n"
+    parse("<%= \"hi mom\" %>").convert.should == "rawtext \"hi mom\"\n"
     parse("<%= hi \"mom\" %>").convert.should == "rawtext hi(\"mom\")\n"
 
     parse("<%= link_to blah %>").convert.should == "rawtext link_to(blah)\n"
@@ -202,6 +197,13 @@ describe RhtmlParser do
     parse("<%= h foo / bar %>").convert.should == "text foo / bar\n"
   end
   
+  it "converts yield so layouts work" do
+    pending("easy enough to make this pass, but the result doesn't seem to work as a layout")
+    parse("<%= yield  %>").convert.should == "rawtext @content\n"
+    parse("<%= \"yield\" %>").convert.should == "rawtext \"yield\"\n"
+    parse("<%= \"the yield is good\" %>").convert.should == "rawtext \"the yield is good\"\n"
+  end
+  
   it "parses quoted strings" do
     @parser.root = :quoted
     parse("'foo'").value.should == "foo"

data/spec/erector/doc_spec.rb

@@ -0,0 +1,55 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+module Erector
+  describe Doc do
+    describe "#output" do
+      it "seeks to the end of the buffer" do
+        string = "Hello"
+        io = StringIO.new(string)
+        doc = Doc.new(io)
+
+        string.concat(" World")
+        doc.text " Again"
+
+        string.should == "Hello World Again"
+      end
+    end
+
+    describe "#method_missing" do
+      context "when passed in io object raises a NoMethodError" do
+        context "when the passed in io object respond_to? method is false" do
+          attr_reader :io
+          before do
+            @io = StringIO.new
+            io.should_not respond_to(:foo)
+            lambda {io.foo}.should raise_error(NoMethodError, /undefined method `foo' for #<StringIO/)
+          end
+
+          it "raises a NoMethodError that originates from within Doc#method_missing" do
+            doc = Doc.new(io)
+            lambda do
+              doc.foo
+            end.should raise_error(NoMethodError, /undefined method `foo' for #<Erector::Doc/)
+          end
+        end
+
+        context "when the passed in io object respond_to? method is true" do
+          attr_reader :io
+          before do
+            @io = StringIO.new
+            stub(io).foo {raise NoMethodError, "Stubbed NoMethodError"}
+            io.should respond_to(:foo)
+            lambda {io.foo}.should raise_error(NoMethodError, "Stubbed NoMethodError")
+          end
+
+          it "raises a NoMethodError that originates from within Doc#method_missing" do
+            doc = Doc.new(io)
+            lambda do
+              doc.foo
+            end.should raise_error(NoMethodError, /undefined method `foo' for #<Erector::Doc/)
+          end
+        end
+      end
+    end
+  end
+end