erector 0.8.3 → 0.9.0.pre1

data/lib/erector/caching.rb

@@ -73,6 +73,7 @@ module Erector
       cache && block.nil? && self.class.cachable?
     end
 
+protected
     def _render(options = {})
       if should_cache?
         cache[self.class, assigns, options[:content_method_name]] ||= super

data/lib/erector/convenience.rb

@@ -4,7 +4,7 @@ module Erector
     # You may just want to call to_html(:prettyprint => true)
     # so you can pass in other rendering options as well.
     def to_pretty(options = {})
-      to_html(options.merge(:prettyprint => true))
+      render(options.merge(:prettyprint => true))
     end
 
     # Render (like to_html) but stripping all tags and inserting some
@@ -25,12 +25,20 @@ module Erector
     # which are rendered, or strings, which are html-escaped and output.
     def join(array, separator)
       first = true
-      array.each do |widget_or_text|
+      array.each do |item|
         if !first
-          text separator
+          if separator.is_a? Widget
+            widget separator
+          else
+            text separator
+          end
         end
         first = false
-        text widget_or_text
+        if item.is_a? Widget
+          widget item
+        else
+          text item
+        end
       end
     end
 

data/lib/erector/dependency.rb

@@ -23,7 +23,8 @@ module Erector
     end
 
     def hash
-      # this is a fairly inefficient hash function but it does the trick for now
+      # this is a fairly inefficient hash function but it does the trick for
+      # now
       "#{type}#{text}#{options}".hash
     end
   end

data/lib/erector/element.rb

@@ -0,0 +1,113 @@
+require 'erector/abstract_widget'
+require 'erector/promise'
+
+# todo: unit test
+module Erector
+  module Element
+    # Internal method used to emit an HTML/XML element, including an open tag,
+    # attributes (optional, via the default hash), contents (also optional),
+    # and close tag.
+    #
+    # Using the arcane powers of Ruby, there are magic methods that call
+    # +element+ for all the standard HTML tags, like +a+, +body+, +p+, and so
+    # forth. Look at the source of erector/html.rb for the full list.
+    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
+    # in this rdoc page, but trust us, they're there.
+    #
+    # 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 +output+ string. See
+    # how elegant it is? Not confusing at all if you don't think about it.
+    #
+    def element(*args, &block)
+      _element(*args, &block)
+    end
+
+    # Internal method used to emit a self-closing HTML/XML element, including
+    # a tag name and optional attributes (passed in via the default hash).
+    #
+    # Using the arcane powers of Ruby, there are magic methods that call
+    # +empty_element+ for all the standard HTML tags, like +img+, +br+, and so
+    # forth. Look at the source of #self_closing_tags for the full list.
+    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
+    # in this rdoc page, but trust us, they're there.
+    #
+    def empty_element(*args, &block)
+      _empty_element(*args, &block)
+    end
+
+    # moved to Promise
+    # # Emits an open tag, comprising '<', tag name, optional attributes, and '>'
+    # def open_tag(promise)
+    #   output.newline if newliney?(promise._tag_name) && !output.at_line_start?
+    #   output << promise._open_tag
+    #   output.indent
+    # end
+    #
+    # # Emits a close tag, consisting of '<', '/', tag name, and '>'
+    # def close_tag(promise)
+    #   output.undent
+    #   output << promise._close_tag
+    #   if newliney?(promise._tag_name)
+    #     output.newline
+    #   end
+    # end
+    #
+    # def inside_tag value, block
+    #   if block
+    #     block.call
+    #   else
+    #     text value
+    #   end
+    # end
+
+    def _element(tag_name, *args, &block)
+      if args.length > 2
+        raise ArgumentError, "too many args"
+      end
+      attributes, value = nil, nil
+      arg0 = args[0]
+      if arg0.is_a?(Hash)
+        attributes = arg0
+      else
+        value = arg0
+        arg1 = args[1]
+        if arg1.is_a?(Hash)
+          attributes = arg1
+        end
+      end
+
+      if block && value
+        raise ArgumentError, "You can't pass both a block and a value to #{tag_name} -- please choose one."
+      end
+
+      attributes ||= {}
+      promise = if !value.nil?
+        Promise.new(output, tag_name,  attributes, false, newliney?(tag_name)) do
+          if value.is_a? AbstractWidget
+            widget value
+          else
+            text value
+          end
+        end
+      elsif block
+        Promise.new(output, tag_name, attributes, false, newliney?(tag_name), &block)
+      else
+        Promise.new(output, tag_name, attributes, false, newliney?(tag_name))
+      end
+      promise._render
+      promise
+    end
+
+    def _empty_element(tag_name, attributes={})
+      promise = Promise.new(output, tag_name, attributes, true, newliney?(tag_name))
+      promise._render
+      promise
+    end
+
+
+  end
+end

data/lib/erector/erect/erect.rb

@@ -1,5 +1,4 @@
 require "optparse"
-require "rake"
 require "erector/erect/erected"  # pull this out so we don't recreate the grammar every time
 
 module Erector
@@ -70,23 +69,27 @@ module Erector
 
     #todo: unit test
     def explode_dirs
-      exploded_files = FileList.new
+      exploded_files = []
       files.each do |file|
         if File.directory?(file)
-          exploded_files.add(explode(file))
+          exploded_files << explode(file)
         else
-          exploded_files.add(file)
+          exploded_files << file
         end
       end
-      @files = exploded_files
+      @files = exploded_files.flatten
     end
 
     def explode(dir)
       case mode
       when :to_erector
-        FileList["#{dir}/**/*.rhtml", "#{dir}/**/*.html", "#{dir}/**/*.html.erb"]
+        ["#{dir}/**/*.rhtml",
+          "#{dir}/**/*.html",
+          "#{dir}/**/*.html.erb"].map do |pattern|
+          Dir.glob pattern
+        end.flatten
       when :to_html
-        FileList["#{dir}/**/*.rb"]
+        Dir.glob "#{dir}/**/*.rb"
       end
     end
 

data/lib/erector/externals.rb

@@ -87,7 +87,8 @@ module Erector
       output = Erector::Output.new
       self.to_a(:output => output) # render all the externals onto this new output buffer
       nested_widgets = output.widgets.to_a
-      renderer = ExternalRenderer.new({:classes => nested_widgets}.merge(options_to_external_renderer))
+      options_to_external_renderer = {:classes => nested_widgets}.merge(options_to_external_renderer)
+      renderer = ExternalRenderer.new(options_to_external_renderer)
       externals = renderer.to_a(:output => output)
       output.to_a
     end

data/lib/erector/html.rb

@@ -1,346 +1,12 @@
+require "erector/element"
+require "erector/attributes"
+require "erector/promise"
+require "erector/text"
+require "erector/tag"
+
 module Erector
   module HTML
-    module ClassMethods
-      # Tags which are always self-closing. Click "[show source]" to see the full list.
-      def empty_tags
-        ['area', 'base', 'br', 'col', 'embed', 'frame',
-        'hr', 'img', 'input', 'link', 'meta', 'param']
-      end
-
-      # Tags which can contain other stuff. Click "[show source]" to see the full list.
-      def full_tags
-        [
-          'a', 'abbr', 'acronym', 'address', 'article', 'aside', 'audio',
-          'b', 'bdo', 'big', 'blockquote', 'body', 'button',
-          'canvas', 'caption', 'center', 'cite', 'code', 'colgroup', 'command',
-          'datalist', 'dd', 'del', 'details', 'dfn', 'dialog', 'div', 'dl', 'dt',
-          'em',
-          'fieldset', 'figure', 'footer', 'form', 'frameset',
-          'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'html', 'i',
-          'iframe', 'ins', 'keygen', 'kbd', 'label', 'legend', 'li',
-          'map', 'mark', 'meter',
-          'nav', 'noframes', 'noscript',
-          'object', 'ol', 'optgroup', 'option',
-          'p', 'pre', 'progress',
-          'q', 'ruby', 'rt', 'rp', 's',
-          'samp', 'script', 'section', 'select', 'small', 'source', 'span', 'strike',
-          'strong', 'style', 'sub', 'sup',
-          'table', 'tbody', 'td', 'textarea', 'tfoot',
-          'th', 'thead', 'time', 'title', 'tr', 'tt',
-          'u', 'ul',
-          'var', 'video'
-        ]
-      end
-
-      def all_tags
-        full_tags + empty_tags
-      end
-
-      def def_empty_tag_method(tag_name)
-        self.class_eval(<<-SRC, __FILE__, __LINE__ + 1)
-          def #{tag_name}(*args, &block)
-            __empty_element__('#{tag_name}', *args, &block)
-          end
-        SRC
-      end
-
-      def def_full_tag_method(tag_name)
-        self.class_eval(<<-SRC, __FILE__, __LINE__ + 1)
-          def #{tag_name}(*args, &block)
-              __element__(false, '#{tag_name}', *args, &block)
-          end
-
-          def #{tag_name}!(*args, &block)
-            __element__(true, '#{tag_name}', *args, &block)
-          end
-        SRC
-      end
-    end
-
-    def self.included(base)
-      base.extend ClassMethods
-
-      base.full_tags.each do |tag_name|
-        base.def_full_tag_method(tag_name)
-      end
-
-      base.empty_tags.each do |tag_name|
-        base.def_empty_tag_method(tag_name)
-      end
-    end
-
-    # Internal method used to emit an HTML/XML element, including an open tag,
-    # attributes (optional, via the default hash), contents (also optional),
-    # and close tag.
-    #
-    # Using the arcane powers of Ruby, there are magic methods that call
-    # +element+ for all the standard HTML tags, like +a+, +body+, +p+, and so
-    # forth. Look at the source of #full_tags for the full list.
-    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
-    # in this rdoc page, but trust us, they're there.
-    #
-    # 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 +output+ string. See
-    # how elegant it is? Not confusing at all if you don't think about it.
-    #
-    def element(*args, &block)
-      __element__(false, *args, &block)
-    end
-
-    # Like +element+, but string parameters are not escaped.
-    def element!(*args, &block)
-      __element__(true, *args, &block)
-    end
-
-    # Internal method used to emit a self-closing HTML/XML element, including
-    # a tag name and optional attributes (passed in via the default hash).
-    #
-    # Using the arcane powers of Ruby, there are magic methods that call
-    # +empty_element+ for all the standard HTML tags, like +img+, +br+, and so
-    # forth. Look at the source of #empty_tags for the full list.
-    # Unfortunately, this big mojo confuses rdoc, so we can't see each method
-    # in this rdoc page, but trust us, they're there.
-    #
-    def empty_element(*args, &block)
-      __empty_element__(*args, &block)
-    end
-
-    # Returns an HTML-escaped version of its parameter. Leaves the output
-    # string untouched. This method is idempotent: h(h(text)) will not
-    # double-escape text. This means that it is safe to do something like
-    # text(h("2<4")) -- it will produce "2&lt;4", not "2&amp;lt;4".
-    def h(content)
-      if content.respond_to?(:html_safe?) && content.html_safe?
-        content
-      else
-        raw(CGI.escapeHTML(content.to_s))
-      end
-    end
-
-    # Emits an open tag, comprising '<', tag name, optional attributes, and '>'
-    def open_tag(tag_name, attributes={})
-      output.newline if newliney?(tag_name) && !output.at_line_start?
-      output << raw("<#{tag_name}#{format_attributes(attributes)}>")
-      output.indent
-    end
-
-    # Emits a close tag, consisting of '<', '/', tag name, and '>'
-    def close_tag(tag_name)
-      output.undent
-      output << raw("</#{tag_name}>")
-      if newliney?(tag_name)
-        output.newline
-      end
-    end
-
-    # Returns text which will *not* be HTML-escaped.
-    def raw(value)
-      RawString.new(value.to_s)
-    end
-
-    # Emits text.  If a string is passed in, it will be HTML-escaped. If 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.
-    #
-    # You shouldn't pass a widget in to this method, as that will cause
-    # performance problems (as well as being semantically goofy). Use the
-    # #widget method instead.
-    def text(value)
-      if value.is_a? Widget
-        widget value
-      else
-        output << h(value)
-      end
-      nil
-    end
-
-    # Emits text which will *not* be HTML-escaped. Same effect as text(raw(s))
-    def text!(value)
-      text raw(value)
-    end
-
-    alias rawtext text!
-
-    # Returns a copy of value with spaces replaced by non-breaking space characters.
-    # 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 = " ")
-      raw(h(value).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)
-        require "erector/unicode"
-        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 an XML instruction, which looks like this: <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    def instruct(attributes={:version => "1.0", :encoding => "UTF-8"})
-      output << raw("<?xml#{format_sorted(sort_for_xml_declaration(attributes))}?>")
-    end
-
-    # Emits an HTML comment (&lt;!-- ... --&gt;) surrounding +text+ and/or the output of +block+.
-    # see http://www.w3.org/TR/html4/intro/sgmltut.html#h-3.2.4
-    #
-    # If +text+ is an Internet Explorer conditional comment condition such as "[if IE]",
-    # the output includes the opening condition and closing "[endif]". See
-    # http://www.quirksmode.org/css/condcom.html
-    #
-    # Since "Authors should avoid putting two or more adjacent hyphens inside comments,"
-    # we emit a warning if you do that.
-    def comment(text = '')
-      puts "Warning: Authors should avoid putting two or more adjacent hyphens inside comments." if text =~ /--/
-
-      conditional = text =~ /\[if .*\]/
-
-      rawtext "<!--"
-      rawtext text
-      rawtext ">" if conditional
-
-      if block_given?
-        rawtext "\n"
-        yield
-        rawtext "\n"
-      end
-
-      rawtext "<![endif]" if conditional
-      rawtext "-->\n"
-    end
-
-    # Emits a javascript block inside a +script+ tag, wrapped in CDATA
-    # doohickeys like all the cool JS kids do.
-    def javascript(value = nil, attributes = {})
-      if value.is_a?(Hash)
-        attributes = value
-        value      = nil
-      elsif block_given? && value
-        raise ArgumentError, "You can't pass both a block and a value to javascript -- please choose one."
-      end
-
-      script(attributes.merge(:type => "text/javascript")) do
-        # Shouldn't this be a "cdata" HtmlPart?
-        # (maybe, but the syntax is specific to javascript; it isn't
-        # really a generic XML CDATA section.  Specifically,
-        # ]]> within value is not treated as ending the
-        # CDATA section by Firefox2 when parsing text/html,
-        # although I guess we could refuse to generate ]]>
-        # there, for the benefit of XML/XHTML parsers).
-        output << raw("\n// <![CDATA[\n")
-        if block_given?
-          yield
-        else
-          output << raw(value)
-        end
-        output << raw("\n// ]]>")
-        output.append_newline # this forces a newline even if we're not in pretty mode
-      end
-
-      output << raw("\n")
-    end
-
-    protected
-    def __element__(raw, tag_name, *args, &block)
-      if args.length > 2
-        raise ArgumentError, "Cannot accept more than four arguments"
-      end
-      attributes, value = nil, nil
-      arg0 = args[0]
-      if arg0.is_a?(Hash)
-        attributes = arg0
-      else
-        value = arg0
-        arg1 = args[1]
-        if arg1.is_a?(Hash)
-          attributes = arg1
-        end
-      end
-      attributes ||= {}
-      open_tag tag_name, attributes
-      begin
-        if block && value
-          raise ArgumentError, "You can't pass both a block and a value to #{tag_name} -- please choose one."
-        end
-        if block
-          block.call
-        elsif raw
-          text! value
-        else
-          text value
-        end
-      ensure
-        close_tag tag_name
-      end
-    end
-
-    def __empty_element__(tag_name, attributes={})
-      output << raw("<#{tag_name}#{format_attributes(attributes)} />")
-      output.newline if newliney?(tag_name)
-    end
-
-    def format_attributes(attributes)
-      if !attributes || attributes.empty?
-        ""
-      else
-        format_sorted(sorted(attributes))
-      end
-    end
-
-    def format_sorted(sorted)
-      results = ['']
-      sorted.each do |key, value|
-        if value
-          if value.is_a?(Array)
-            value = value.flatten
-            next if value.empty?
-            value = value.join(' ')
-          end
-          results << "#{key}=\"#{h(value)}\""
-        end
-      end
-      results.join(' ')
-    end
-
-    def sorted(attributes)
-      stringized = []
-      attributes.each do |key, value|
-        stringized << [key.to_s, value]
-      end
-      stringized.sort
-    end
-
-    def sort_for_xml_declaration(attributes)
-      # correct order is "version, encoding, standalone" (XML 1.0 section 2.8).
-      # But we only try to put version before encoding for now.
-      stringized = []
-      attributes.each do |key, value|
-        stringized << [key.to_s, value]
-      end
-      stringized.sort{|a, b| b <=> a}
-    end
 
-    NON_NEWLINEY = {'i' => true, 'b' => true, 'small' => true,
-      'img' => true, 'span' => true, 'a' => true,
-      'input' => true, 'textarea' => true, 'button' => true, 'select' => true
-    }
 
-    def newliney?(tag_name)
-      !NON_NEWLINEY.include?(tag_name)
-    end
   end
 end