honkster-erector 0.8.1

data/lib/erector/inline.rb

@@ -0,0 +1,37 @@
+module Erector
+  def self.inline(*args, &block)
+    InlineWidget.new(*args, &block)
+  end
+  
+  module Inline
+    # Executes the widget's block (the one that was passed in the
+    # constructor). Since "self" is pointing to the new widget, the block does
+    # not naturally have access to parent method methods, so an
+    # Erector::Inline widget uses some method_missing black magic to propagate
+    # messages to the parent object. Since it executes inside the *called*
+    # widget's context, when the block refers to instance variables, it's
+    # talking about those of this widget, not the caller. It does, of course,
+    # have access to bound local variables of the caller, so you can use those
+    # to smuggle in instance variables.
+    def call_block
+      # note that instance_eval seems to pass in self as a parameter to the block
+      instance_eval(&block) if block
+    end
+    
+    private
+    # This is part of the sub-widget/parent feature (see #widget method).
+    def method_missing(name, *args, &block)
+      if parent && parent.respond_to?(name)
+        block ||= lambda {} # captures self HERE
+        parent.send(name, *args, &block)
+      else
+        super
+      end
+    end
+  end
+
+  class InlineWidget < Erector::Widget
+    include Inline
+  end
+
+end

data/lib/erector/jquery.rb

@@ -0,0 +1,36 @@
+module Erector
+  module JQuery
+    # Emits a jQuery script, inside its own script tag, that is to be run on document ready or load.
+    #
+    # Usage (from inside a widget method):
+    # jquery "alert('hi')" :: a jquery ready handler
+    # jquery "alert('hi')", :id => 'foo' :: a jquery ready handler, with attributes in the script tag
+    # jquery :load, "alert('hi')" :: a jquery load handler
+    #
+    def jquery(*args)
+      event = if args.first.is_a? Symbol
+        args.shift
+      else
+        :ready
+      end
+      txt = args.shift
+      attributes = args.shift || {}
+
+      javascript attributes do
+        rawtext "\n"
+        rawtext "jQuery(document).#{event}(function($){\n"
+        rawtext txt
+        rawtext "\n});"
+      end
+    end
+
+    def jquery_load(text)    #:nodoc:
+      $stderr.puts "jquery_load is deprecated; use jquery(:load, text) instead"
+    end
+
+    def jquery_ready(text)    #:nodoc:
+      $stderr.puts "jquery_ready is deprecated; use jquery(:ready, text) instead"
+    end
+
+  end
+end

data/lib/erector/mixin.rb

@@ -0,0 +1,12 @@
+module Erector
+  module Mixin
+    # Executes the block as if it were the content body of a fresh Erector::Inline,
+    # and returns the #to_html value. Since it executes inside the new widget it does not
+    # have access to instance variables of the caller, although it does
+    # have access to bound variables. Funnily enough, the options are passed in to both
+    # to_html *and* to the widget itself, so they show up as instance variables.
+    def erector(options = {}, &block)
+      Erector.inline(options, &block).to_html(options)
+    end
+  end
+end

data/lib/erector/needs.rb

@@ -0,0 +1,94 @@
+module Erector
+  module Needs
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      # Class method by which widget classes can declare that they need certain
+      # parameters. If needed parameters are not passed in to #new, then an
+      # exception will be thrown (with a hopefully useful message about which
+      # parameters are missing). This is intended to catch silly bugs like
+      # passing in a parameter called 'name' to a widget that expects a
+      # parameter called 'title'.
+      #
+      # You can also declare default values for parameters using hash syntax.
+      # You can put #needs declarations on multiple lines or on the same line;
+      # the only caveat is that if there are default values, they all have to be
+      # at the end of the line (so they go into the magic hash parameter).
+      #
+      # If a widget has no #needs declaration then it will accept any
+      # combination of parameters just like normal. If a widget wants to declare
+      # that it takes no parameters, use the special incantation "needs nil"
+      # (and don't declare any other needs, or kittens will cry).
+      #
+      # Usage:
+      #    class FancyForm < Erector::Widget
+      #      needs :title, :show_okay => true, :show_cancel => false
+      #      ...
+      #    end
+      #
+      # That means that
+      #   FancyForm.new(:title => 'Login')
+      # will succeed, as will
+      #   FancyForm.new(:title => 'Login', :show_cancel => true)
+      # but
+      #   FancyForm.new(:name => 'Login')
+      # will fail.
+      #
+      def needs(*args)
+        args.each do |arg|
+          (@needs ||= []) << (arg.nil? ? nil : (arg.is_a? Hash) ? arg : arg.to_sym)
+        end
+      end
+
+      def get_needs
+        @needs ||= []
+
+        ancestors[1..-1].inject(@needs.dup) do |needs, ancestor|
+          needs.push(*ancestor.get_needs) if ancestor.respond_to?(:get_needs)
+          needs
+        end
+      end
+
+      def needed_variables
+        @needed_variables ||= get_needs.map{|need| need.is_a?(Hash) ? need.keys : need}.flatten
+      end
+
+      def needed_defaults
+        @needed_defaults ||= get_needs.inject({}) do |defaults, need|
+          defaults = need.merge(defaults) if need.is_a? Hash
+          defaults
+        end
+      end
+
+      def needs?(name)
+        needed_variables.empty? || needed_variables.include?(name)
+      end
+    end
+
+    def initialize(assigns = {})
+      super
+
+      assigned = assigns.keys
+
+      # set variables with default values
+      self.class.needed_defaults.each do |name, value|
+        unless assigned.include?(name)
+          instance_variable_set("@#{name}", value)
+          assigned << name
+        end
+      end
+
+      missing = self.class.needed_variables - assigned
+      unless missing.empty? || missing == [nil]
+        raise "Missing parameter#{missing.size == 1 ? '' : 's'}: #{missing.join(', ')}"
+      end
+
+      excess = assigned - self.class.needed_variables
+      unless self.class.needed_variables.empty? || excess.empty?
+        raise("Excess parameter#{excess.size == 1 ? '' : 's'}: #{excess.join(', ')}")
+      end
+    end
+  end
+end

data/lib/erector/output.rb

@@ -0,0 +1,117 @@
+module Erector
+  class Output
+    SPACES_PER_INDENT = 2
+
+    attr_reader :prettyprint, :widgets, :indentation, :max_length
+
+    def initialize(options = {}, & get_buffer)
+      @prettyprint = options.fetch(:prettyprint, Widget.prettyprint_default)
+      @indentation = options.fetch(:indentation, 0)
+      @current_line_length = 0
+      @max_length = options[:max_length]
+      @widgets = []
+      if get_buffer
+        @get_buffer = get_buffer
+      elsif buffer = options[:output]
+        @get_buffer = lambda { buffer }
+      else
+        buffer = []
+        @get_buffer = lambda { buffer }
+      end
+    end
+
+    def buffer
+      @get_buffer.call
+    end
+
+    def <<(s)
+      s = s.to_s unless s.is_a? String
+      append_indentation
+      if @max_length && s.length + @current_line_length > @max_length
+        leading_spaces = s =~ /^( +)/ ? $1.size : 0
+        trailing_spaces = s =~ /( +)$/ ? $1.size : 0 
+
+        append(" " * leading_spaces)
+        need_space = false
+        words = s.split(/ /)
+        words.each do |word|
+          if (need_space ? 1 : 0) + word.length > space_left
+            append_newline
+            append_indentation
+            need_space = false
+          end
+          append(" ") if need_space
+          append(word)
+          need_space = true
+        end
+        append(" " * trailing_spaces)
+      else
+        append(s)
+      end
+      self
+    end
+
+    # Inserts a blank string into the output stream and returns a pointer to it.
+    # If the caller holds on to this pointer, she can later go back and insert text
+    # earlier in the stream. This is used for, e.g., inserting stuff inside the
+    # HEAD element that is not known until after the entire page renders.
+    def placeholder
+      s = ""
+      buffer << s
+      s
+    end
+
+    def to_s
+      RawString.new(buffer.kind_of?(String) ? buffer : buffer.join)
+    end
+
+    def to_a
+      buffer.kind_of?(Array) ? buffer : [buffer]
+    end
+
+    def newline
+      if prettyprint
+        append_newline
+      end
+    end
+
+    def at_line_start?
+      @current_line_length == 0
+    end
+
+    def indent
+      @indentation += 1 if prettyprint
+    end
+
+    def undent
+      @indentation -= 1 if prettyprint
+    end
+
+    # always append a newline, regardless of prettyprint setting
+    #todo: test
+    def append_newline
+      buffer << "\n"
+      @current_line_length = 0
+    end
+
+    protected
+
+    def append(s)
+      buffer << s
+      @current_line_length += s.length
+    end
+
+    def space_left
+      @max_length - @current_line_length
+    end
+
+    def append_indentation
+      if prettyprint and at_line_start?
+        spaces = " " * ([@indentation, 0].max * SPACES_PER_INDENT)
+        buffer << spaces
+        @current_line_length += spaces.length
+      end
+    end
+
+  end
+end

data/lib/erector/rails.rb

@@ -0,0 +1,27 @@
+require "action_controller"
+require "erector/rails/rails_version"
+require "erector/rails/rails_form_builder"
+require "erector/rails/extensions/action_controller"
+require "erector/rails/extensions/rails_helpers"
+require "erector/rails/extensions/rails_widget"
+require "erector/rails/template_handlers/rb_handler"
+require "erector/rails/template_handlers/ert_handler"
+
+module Erector
+  def self.init_rails(binding)
+    # Rails defaults do not include app/views in the eager load path.
+    # It needs to be there, because erector views are .rb files.
+    if config = eval("config if defined? config", binding)
+      view_path = config.view_path
+      config.autoload_paths       << view_path unless config.autoload_paths.include?(view_path)
+      config.eager_load_paths << view_path unless config.eager_load_paths.include?(view_path)
+
+      # Rails probably already ran Initializer#set_load_path and
+      # #set_autoload_paths by the time we got here.
+      $LOAD_PATH.unshift(view_path) unless $LOAD_PATH.include?(view_path)
+      unless ActiveSupport::Dependencies.autoload_paths.include?(view_path)
+        ActiveSupport::Dependencies.autoload_paths << view_path
+      end
+    end
+  end
+end

data/lib/erector/rails/extensions/action_controller.rb

@@ -0,0 +1,16 @@
+ActionController::Base.class_eval do
+  class_inheritable_accessor :ert_template_base_class
+  
+  def render_widget(widget_class, assigns=nil, options={})
+    render options.merge(:text => Erector::Rails.render(widget_class, response.template, assigns, options))
+  end
+
+  def render_with_erector_widget(*options, &block)
+    if options.first.is_a?(Hash) && widget = options.first.delete(:widget)
+      render_widget widget, @assigns, options.first
+    else
+      render_without_erector_widget *options, &block
+    end
+  end
+  alias_method_chain :render, :erector_widget
+end

data/lib/erector/rails/extensions/rails_helpers.rb

@@ -0,0 +1,159 @@
+module Erector
+  module Rails
+    module Helpers
+      # Set up URL helpers so that both helpers.users_url and users_url can be called.
+      include ActionController::UrlWriter
+
+      def url_for(*args)
+        parent.url_for(*args)
+      end
+
+      # Wrappers for rails helpers that produce markup. Erector needs to
+      # manually emit their result.
+      def self.def_simple_rails_helper(method_name)
+        module_eval(<<-METHOD_DEF, __FILE__, __LINE__+1)
+          def #{method_name}(*args, &block)
+            text parent.#{method_name}(*args, &block)
+          end
+        METHOD_DEF
+      end
+
+      [
+        # UrlHelper
+        :link_to,
+        :button_to,
+        :link_to_unless_current,
+        :link_to_unless,
+        :link_to_if,
+        :mail_to,
+
+        # JavaScriptHelper
+        :link_to_function,
+        :button_to_function,
+
+        # FormTagHelper
+        :select_tag,
+        :text_field_tag,
+        :label_tag,
+        :hidden_field_tag,
+        :file_field_tag,
+        :password_field_tag,
+        :text_area_tag,
+        :check_box_tag,
+        :radio_button_tag,
+        :submit_tag,
+        :image_submit_tag,
+        :field_set_tag,
+
+        # FormHelper
+        :form_for,
+        :text_field,
+        :password_field,
+        :hidden_field,
+        :file_field,
+        :text_area,
+        :check_box,
+        :radio_button,
+
+        # ActiveRecordHelper
+        :error_message_on,
+        :error_messages_for,
+
+        # AssetTagHelper
+        :auto_discovery_link_tag,
+        :javascript_include_tag,
+        :stylesheet_link_tag,
+        :image_tag,
+
+        # ScriptaculousHelper
+        :sortable_element,
+        :sortable_element_js,
+        :text_field_with_auto_complete,
+        :draggable_element,
+        :drop_receiving_element,
+
+        # PrototypeHelper
+        :link_to_remote,
+        :button_to_remote,
+        :periodically_call_remote,
+        :form_remote_tag,
+        :submit_to_remote,
+        :update_page_tag
+      ].each do |method_name|
+        def_simple_rails_helper(method_name)
+      end
+
+      # Wrappers for rails helpers that produce markup, concatenating
+      # directly to the output buffer if given a block, returning a
+      # string otherwise. In the latter case, Erector needs to manually
+      # output their result.
+      def self.def_block_rails_helper(method_name)
+        module_eval(<<-METHOD_DEF, __FILE__, __LINE__+1)
+          def #{method_name}(*args, &block)
+            if block_given?
+              parent.#{method_name}(*args, &block)
+            else
+              text parent.#{method_name}(*args, &block)
+            end
+          end
+        METHOD_DEF
+      end
+
+      [:link_to,
+       :form_tag,
+       :field_set_tag,
+       :form_remote_tag,
+       :javascript_tag].each do |method_name|
+        def_block_rails_helper(method_name)
+      end
+
+      # Delegate to non-markup producing helpers via method_missing,
+      # returning their result directly.
+      def method_missing(name, *args, &block)
+        if parent.respond_to?(name)
+          parent.send(name, *args, &block)
+        else
+          super
+        end
+      end
+
+      # Since we delegate method_missing to parent, we need to delegate
+      # respond_to? as well.
+      def respond_to?(name)
+        super || parent.respond_to?(name)
+      end
+
+      def render(*args, &block)
+        captured = parent.capture do
+          parent.concat(parent.render(*args, &block))
+          parent.output_buffer.to_s
+        end
+        rawtext(captured)
+      end
+
+      def form_for(record_or_name_or_array, *args, &proc)
+        options = args.extract_options!
+        options[:builder] ||= ::Erector::RailsFormBuilder
+        args.push(options)
+        parent.form_for(record_or_name_or_array, *args, &proc)
+      end
+
+      def fields_for(record_or_name_or_array, *args, &proc)
+        options = args.extract_options!
+        options[:builder] ||= ::Erector::RailsFormBuilder
+        args.push(options)
+        parent.fields_for(record_or_name_or_array, *args, &proc)
+      end
+      
+      def flash
+        parent.controller.send(:flash)
+      end
+
+      def session
+        parent.controller.session
+      end
+    end
+
+    Erector::Widget.send :include, Helpers
+  end
+end