erector-rails4 0.0.1

data/lib/erector/after_initialize.rb

@@ -0,0 +1,29 @@
+module Erector
+  module AfterInitialize
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      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
+  end
+end

data/lib/erector/attributes.rb

@@ -0,0 +1,29 @@
+module Erector
+  module Attributes
+    def format_attributes(attributes)
+      return "" if !attributes || attributes.empty?
+
+      results = ['']
+
+      attributes.each do |key, value|
+        if value
+          if value.is_a?(Array)
+            value = value.flatten
+            next if value.empty?
+            value = value.join(' ')
+          end
+
+          if value.is_a?(TrueClass)
+            results << "#{key}"
+          elsif value.nil? || value.is_a?(FalseClass)
+            # Nothing is generated in this case
+          else
+            results << "#{key}=\"#{h(value)}\""
+          end
+        end
+      end
+
+      results.join(' ')
+    end
+  end
+end

data/lib/erector/cache.rb

@@ -0,0 +1,37 @@
+require 'singleton'
+
+module Erector
+  class Cache
+    include Singleton
+
+    def []=(*args)
+      value = args.pop
+      ::Rails.cache.write(transform_key(args), value.to_s)
+    end
+
+    def [](*args)
+      ::Rails.cache.read(transform_key(args))
+    end
+
+    def delete(*args)
+      ::Rails.cache.delete(transform_key(args))
+    end
+
+    def transform_key(args)
+      ['erector'] + args.reject { |x| x.nil? }.map { |x|
+        if x.is_a?(Hash)
+          transformed = {}
+
+          x.each do |k, v|
+            transformed[k] = v.respond_to?(:cache_key) ? v.cache_key : v
+          end
+
+          transformed
+        else
+          x
+        end
+      }
+    end
+
+  end
+end

data/lib/erector/caching.rb

@@ -0,0 +1,65 @@
+module Erector
+  module Caching
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def cacheable(value = true)
+        @cachable = value
+
+        if value && value != true
+          @cache_version = value
+        end
+      end
+
+      alias_method :cachable, :cacheable
+
+      def cachable?
+        if @cachable.nil?
+          superclass.respond_to?(:cachable?) && superclass.cachable?
+        else
+          @cachable
+        end
+      end
+
+      def cache_version
+        @cache_version || nil
+      end
+
+      def cache
+        Erector::Cache.instance
+      end
+    end
+
+    def cache
+      self.class.cache
+    end
+
+    def should_cache?
+      if block.nil? && self.class.cachable?
+        true
+      else
+        false
+      end
+    end
+
+    protected
+    def _emit(options = {})
+      if should_cache?
+        cache[self.class, self.class.cache_version, assigns, options[:content_method_name]] ||= super
+      else
+        super
+      end
+    end
+
+    def _emit_via(parent, options = {})
+      if should_cache?
+        parent.output << cache[self.class, self.class.cache_version, assigns, options[:content_method_name]] ||= parent.capture_content { super }
+        parent.output.widgets << self.class # todo: test!!!
+      else
+        super
+      end
+    end
+  end
+end

data/lib/erector/convenience.rb

@@ -0,0 +1,98 @@
+module Erector
+  module Convenience
+    # Render (like to_html) but adding newlines and indentation.
+    # You may just want to call to_html(:prettyprint => true)
+    # so you can pass in other rendering options as well.
+    def to_pretty(options = {})
+      emit(options.merge(:prettyprint => true))
+    end
+
+    # Render (like to_html) but stripping all tags and inserting some
+    # appropriate formatting. Currently we format p, br, ol, ul, and li
+    # tags.
+    def to_text(options = {})
+      # TODO: make text output a first class rendering strategy, like HTML is now,
+      # so we can do things like nested lists and numbered lists
+      html = to_html(options.merge(:prettyprint => false))
+      html.gsub!(/^<p[^>]*>/m, '')
+      html.gsub!(/(<(ul|ol)>)?<li>/, "\n* ")
+      html.gsub!(/<(\/?(ul|ol|p|br))[^>]*( \/)?>/, "\n")
+      CGI.unescapeHTML(html.gsub(/<[^>]*>/, ''))
+    end
+
+    # Emits the result of joining the elements in array with the separator.
+    # The array elements and separator can be Erector::Widget objects,
+    # which are rendered, or strings, which are html-escaped and output.
+    def join(array, separator)
+      first = true
+      array.each do |item|
+        if !first
+          if separator.is_a? Widget
+            widget separator
+          else
+            text separator
+          end
+        end
+        first = false
+        if item.is_a? Widget
+          widget item
+        else
+          text item
+        end
+      end
+    end
+
+    # Convenience method to emit a css file link, which looks like this:
+    # <link href="erector.css" rel="stylesheet" type="text/css" />
+    # The parameter is the full contents of the href attribute, including any ".css" extension.
+    #
+    # If you want to emit raw CSS inline, use the #style method instead.
+    def css(href, options = {})
+      link({:rel => 'stylesheet', :type => 'text/css', :href => href}.merge(options))
+    end
+
+    # Convenience method to emit an anchor tag whose href and text are the same,
+    # e.g. <a href="http://example.com">http://example.com</a>
+    def url(href, options = {})
+      a href, ({:href => href}.merge(options))
+    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
+
+
+    # makes a unique id based on the widget's class name and object id
+    # that you can use as the HTML id of an emitted element
+    def dom_id
+      "#{self.class.name.gsub(/:+/,"_")}_#{self.object_id}"
+    end
+  end
+end

data/lib/erector/dependencies.rb

@@ -0,0 +1,24 @@
+module Erector
+  class Dependencies < Array
+    def push(*new_dependencies_args)
+      new_dependencies = new_dependencies_args.select do |new_dependency|
+        !include?(new_dependency)
+      end
+      new_dependencies.each do |dep|
+        unless dep.is_a? Erector::Dependency
+          raise "expected Dependency, got #{dep.class}: #{dep.inspect}"
+        end
+      end
+      super(*new_dependencies)
+    end
+
+    alias_method :<<, :push
+
+    def uniq
+      inject(self.class.new) do |memo, item|
+        memo << item unless memo.any? {|memo_item| memo_item == item}
+        memo
+      end
+    end
+  end
+end

data/lib/erector/dependency.rb

@@ -0,0 +1,31 @@
+module Erector
+  class Dependency
+    attr_reader :type, :text, :options
+
+    def initialize(type, text, options = {})
+      text = text.read if text.is_a? IO
+      text = self.class.interpolate(text) if options[:interpolate] # todo: test
+      @type, @text, @options = type, text, options
+    end
+
+    def self.interpolate(s)
+      eval("<<INTERPOLATE\n" + s + "\nINTERPOLATE").chomp
+    end
+
+    def ==(other)
+      (self.type == other.type and
+       self.text == other.text and
+       self.options == other.options) ? true : false
+    end
+
+    def eql?(other)
+      self == other
+    end
+
+    def hash
+      # this is a fairly inefficient hash function but it does the trick for
+      # now
+      "#{type}#{text}#{options}".hash
+    end
+  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/externals.rb

@@ -0,0 +1,104 @@
+module Erector
+
+  # Externals are a mechanism by which a widget can declare page-level
+  # resources upon which it depends. They are not emitted during the widget's
+  # normal emiting process. Rather, the Erector::Widget::Page keeps track of
+  # all the widgets it emits, then goes back and inserts the proper tags for
+  # all the externals inside its HEAD element.
+  module Externals
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+
+      # Express a dependency of this widget
+      # Multiple forms:
+      #   depends_on(type, text, options = {})
+      # for example
+      #   depends_on(:js, '/foo.js', :embed=>true)
+      #
+      # Other variants:
+      #   depends_on(type, an_io, ... # file to be read
+      #   depends_on('blah.js' ... infer :js
+      #   depends_on('blah.css' ... infer :css
+      #   depends on :js, 'file1.js', 'file2.js'... [options]
+      #   depends_on :js => ["foo.js", "bar.js"], :css=>['file.css']
+      #   depends_on :js => ["foo.js", "bar.js"], other_option=>:blah
+      def depends_on(*args)
+        x = interpret_args(*args)
+        my_dependencies.push(x)
+      end
+
+      # deprecated in favor of #depends_on
+      # todo: warning
+      def external(type, value, options = {})
+        type = type.to_sym
+        x = Dependency.new(type, value, options)
+        my_dependencies << x unless my_dependencies.include?(x)
+      end
+
+      # returns all dependencies of the given type from this class and all its
+      # superclasses
+      def dependencies(type)
+        type = type.to_sym
+        deps = Dependencies.new
+        deps.push(*superclass.dependencies(type)) if superclass.respond_to?(:dependencies)
+        deps.push(*my_dependencies.select { |x| x.type == type })
+        deps.uniq
+      end
+
+      def my_dependencies
+        @my_dependencies ||= Dependencies.new
+      end
+
+      private
+      INFERABLE_TYPES = [:css, :js]
+
+      def interpret_args(*args)
+        options =  {}
+        options = args.pop if args.last.is_a?(::Hash)
+        if args.empty? && options.any?
+          deps = []
+          texts_hash = {}
+          INFERABLE_TYPES.each do |t|
+            texts_hash[t] = options.delete(t) if options.has_key? t
+          end
+          texts_hash.each do |t, texts|
+            [texts].flatten.each do |text|
+              deps << interpret_args(t, text, options)
+            end
+          end
+          return deps
+        elsif args[0].class == Symbol
+          type = args.shift
+        else
+          type = /.+\.js/.match(args[0]) ? :js : :css
+        end
+
+        deps = args.map do |text|
+          Dependency.new(type, text, options)
+        end
+        deps.size == 1 ? deps.first : deps
+      end
+    end
+
+    def render_with_externals(options_to_external_emiter = {})
+      output = Erector::Output.new
+      self.to_a(:output => output) # emit all the externals onto this new output buffer
+      nested_widgets = output.widgets.to_a
+      options_to_external_emiter = {:classes => nested_widgets}.merge(options_to_external_emiter)
+      emiter = ExternalRenderer.new(options_to_external_emiter)
+      externals = emiter.to_a(:output => output)
+      output.to_a
+    end
+
+    def render_externals(options_to_external_emiter = {})
+      output_for_externals = Erector::Output.new
+      nested_widgets = output.widgets
+      externalizer = ExternalRenderer.new({:classes => nested_widgets}.merge(options_to_external_emiter))
+      externalizer._emit(:output => output_for_externals)
+      output_for_externals.to_a
+    end
+  end
+end