erector 0.8.2 → 0.8.3

data/lib/erector/rails/railtie.rb

@@ -0,0 +1,11 @@
+module Erector
+  class Railtie < ::Rails::Railtie
+    # config.generators.template_engine :rb
+
+    # TODO: automatically add app directory to app.config.autoload_paths,
+    # so that Views::Foo::Bar autoloads, and 'require "views/foo/bar.html"'
+    # works. For now, you must add the following to config/application.rb:
+    #
+    #     config.autoload_paths += %W(#{config.root}/app)
+  end
+end

data/lib/erector/rails/template_handler.rb

@@ -0,0 +1,16 @@
+module Erector
+  module Rails
+    class TemplateHandler
+      def call(template)
+        require_dependency template.identifier
+        widget_class_name = "views/#{template.identifier =~ %r(views/([^.]*)(\..*)?\.rb) && $1}".camelize
+        is_partial = File.basename(template.identifier) =~ /^_/
+        <<-SRC
+        Erector::Rails.render(#{widget_class_name}, self, local_assigns, #{!!is_partial})
+        SRC
+      end
+    end
+  end
+end
+
+ActionView::Template.register_template_handler :rb, Erector::Rails::TemplateHandler.new

data/lib/erector/rails/widget_renderer.rb

@@ -0,0 +1,6 @@
+require 'action_controller/metal/renderers'
+
+ActionController.add_renderer :widget do |widget, options|
+  self.content_type ||= options[:content_type] || Mime[:html]
+  Erector::Rails.render(widget, view_context, {}, false, options)
+end

data/lib/erector/rails2.rb

@@ -0,0 +1,27 @@
+require "action_controller"
+require "erector/rails2/rails_version"
+require "erector/rails2/rails_form_builder"
+require "erector/rails2/extensions/action_controller"
+require "erector/rails2/extensions/rails_helpers"
+require "erector/rails2/extensions/rails_widget"
+require "erector/rails2/template_handlers/rb_handler"
+require "erector/rails2/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.load_paths       << view_path unless config.load_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.load_paths.include?(view_path)
+        ActiveSupport::Dependencies.load_paths << view_path
+      end
+    end
+  end
+end

data/lib/erector/{rails → rails2}/extensions/action_controller.rb

@@ -1,6 +1,6 @@
 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

data/lib/erector/{rails → rails2}/extensions/rails_helpers.rb

@@ -13,6 +13,7 @@ module Erector
       def self.def_simple_rails_helper(method_name)
         module_eval(<<-METHOD_DEF, __FILE__, __LINE__+1)
           def #{method_name}(*args, &block)
+            # i wonder why this is text and not rawtext
             text parent.#{method_name}(*args, &block)
           end
         METHOD_DEF
@@ -93,20 +94,32 @@ module Erector
             if block_given?
               parent.#{method_name}(*args, &block)
             else
-              text parent.#{method_name}(*args, &block)
+              rails_helper_output = parent.#{method_name}(*args, &block)
+              # i wonder why this is text and not rawtext
+              text rails_helper_output
             end
           end
         METHOD_DEF
       end
 
-      [:link_to,
-       :form_tag,
+      [:form_tag,
        :field_set_tag,
        :form_remote_tag,
        :javascript_tag].each do |method_name|
         def_block_rails_helper(method_name)
       end
 
+      def link_to(*args, &block)
+        if block_given?
+          parent.link_to(*args, &block)
+        else
+          args[0] = CGI.escapeHTML(args[0])
+          rails_helper_output = parent.link_to(*args, &block)
+          # i wonder why this is text and not rawtext
+          text rails_helper_output
+        end
+      end
+
       # Delegate to non-markup producing helpers via method_missing,
       # returning their result directly.
       def method_missing(name, *args, &block)
@@ -144,7 +157,7 @@ module Erector
         args.push(options)
         parent.fields_for(record_or_name_or_array, *args, &proc)
       end
-      
+
       def flash
         parent.controller.send(:flash)
       end

data/lib/erector/{rails → rails2}/extensions/rails_widget.rb

@@ -43,11 +43,14 @@ module Erector
 
       view.send(:_evaluate_assigns_and_ivars)
 
-      view.with_output_buffer do
+      output_buffer = view.with_output_buffer do
         # Set parent to the view and use Rails's output buffer.
+        new_output = Output.new { view.output_buffer }
         widget.to_html(options.merge(:parent => view,
-                                  :output => Output.new { view.output_buffer }))
+                                  :output => new_output))
       end
+      output_buffer
+
     end
 
     module WidgetExtensions
@@ -100,7 +103,7 @@ module Erector
           @controller_assigns_propagate_to_partials = (new_value ? :true : :false)
         end
       end
-      
+
       def self.included(base)
         base.extend(ClassMethods)
       end

data/lib/erector/rails2/rails_version.rb

@@ -0,0 +1,6 @@
+module Erector
+  module Rails
+    RAILS_VERSION = "2.3.11"
+    RAILS_VERSION_TAG = "v2.3.11"
+  end
+end

data/lib/erector/{rails → rails2}/template_handlers/rb_handler.rb

@@ -18,7 +18,7 @@ end
 
 # Out of the box, the Cells plugin for Rails (http://cells.rubyforge.org/)
 # does not work with Erector, because Erector tries to grab instance variables
-# off the controller, rather than the cell itself. 
+# off the controller, rather than the cell itself.
 #
 # This code patches up Cell::View to make it work, but only if the Cells plugin
 # is installed. (That's the bare "Cell::View" at the top, and rescue NameError
@@ -28,7 +28,7 @@ end
 # loaded at all.
 begin
   Cell::View
-  
+
   class Cell::View < ActionView::Base
     def instance_variables_for_widget_assignment
       instance_variables_for_widget_assignment_for(cell)

data/lib/erector/rails3.rb

@@ -0,0 +1,208 @@
+require "erector/rails/template_handler"
+require "erector/rails/railtie"
+require "erector/rails/widget_renderer"
+require "erector/rails/form_builder"
+
+module Erector
+  module Rails
+    class << self
+      def should_assign?(name, widget_class, is_partial)
+        (!widget_class.ignore_extra_controller_assigns || widget_class.needs?(name)) &&
+          (!is_partial || widget_class.controller_assigns_propagate_to_partials)
+      end
+
+      def assigns_for(widget_class, view, local_assigns, is_partial)
+        assigns = {}
+
+        view.assigns.each do |name, value|
+          name = name.to_sym
+          assigns[name] = value if should_assign?(name, widget_class, is_partial)
+        end
+
+        assigns.merge!(filter_local_assigns_for_partial(widget_class, local_assigns)) if is_partial
+
+        assigns
+      end
+
+      def filter_local_assigns_for_partial(widget_class, local_assigns)
+        widget_class_variable_name = widget_class.name.underscore
+        widget_class_variable_name = $1 if widget_class_variable_name =~ %r{.*/(.*?)$}
+
+        local_assigns.reject do |name, value|
+          name == :object || name == widget_class_variable_name.to_sym
+        end
+      end
+
+      def render(widget, view, local_assigns = {}, is_partial = false, options = {})
+        widget = widget.new(assigns_for(widget, view, local_assigns, is_partial)) if widget.is_a?(Class)
+        view.with_output_buffer do
+          # Set parent and helpers to the view and use Rails's output buffer.
+          widget.to_html(options.merge(:helpers => view,
+                                       :parent  => view,
+                                       :output  => Output.new { view.output_buffer }))
+        end
+      end
+
+      # Wrappers for rails helpers that produce markup. Erector needs to
+      # manually emit their result.
+      def def_simple_rails_helper(method_name)
+        module_eval <<-METHOD_DEF, __FILE__, __LINE__+1
+          def #{method_name}(*args, &block)
+            text helpers.#{method_name}(*args, &block)
+          end
+        METHOD_DEF
+      end
+
+      def def_rails_form_helper(method_name)
+        module_eval <<-METHOD_DEF, __FILE__, __LINE__+1
+          def #{method_name}(*args, &block)
+            options = args.extract_options!
+            args << options.merge(:builder => FormBuilder.wrapping(options[:builder]))
+            text helpers.#{method_name}(*args, &block)
+          end
+        METHOD_DEF
+      end
+    end
+
+    extend ActiveSupport::Concern
+
+    included do
+      # Often, large Rails applications will assign many controller instance variables.
+      # Sometimes these aren't used by a view: ApplicationController might assign
+      # variables that are used by many, but not all, views; and various other things
+      # may accumulate, especially if you've been using templating systems that are
+      # more forgiving than Erector. If you then migrate to Erector, you're stuck using
+      # no "needs" declaration at all, because it needs to contain every assigned
+      # variable, or Erector will raise an exception.
+      #
+      # If you set this to true (and it's inherited through to subclasses), however,
+      # then "needs" declarations on the widget will cause excess controller variables
+      # to be ignored -- they'll be unavailable to the widget (so 'needs' still means
+      # something), but they won't cause widget instantiation to fail, either. This
+      # can let a large Rails project transition to Erector more smoothly.
+      class_attribute :ignore_extra_controller_assigns
+      self.ignore_extra_controller_assigns = true
+
+      # In ERb templates, controller instance variables are available to any partial
+      # that gets rendered by the view, no matter how deeply-nested. This effectively
+      # makes controller instance variables "globals". In small view hierarchies this
+      # probably isn't an issue, but in large ones it can make debugging and
+      # reasoning about the code very difficult.
+      #
+      # If you set this to true (and it's inherited through to subclasses), then any
+      # widget that's getting rendered as a partial will only have access to locals
+      # explicitly passed to it (render :partial => ..., :locals => ...). (This
+      # doesn't change the behavior of widgets that are explicitly rendered, as they
+      # don't have this issue.) This can allow for cleaner encapsulation of partials,
+      # as they must be passed everything they use and can't rely on controller
+      # instance variables.
+      class_attribute :controller_assigns_propagate_to_partials
+      self.controller_assigns_propagate_to_partials = true
+    end
+
+    # We need to delegate #capture to helpers.capture, so that when
+    # the captured block is executed, both erector and Rails output
+    # from within the block go to the appropriate buffer.
+    def capture(&block)
+      if helpers.respond_to?(:capture)
+        raw(helpers.capture(&block).to_s)
+      else
+        super
+      end
+    end
+
+    def render(*args, &block)
+      captured = helpers.capture do
+        helpers.concat(helpers.render(*args, &block))
+        helpers.output_buffer.to_s
+      end
+      rawtext(captured)
+    end
+
+    # Delegate to non-markup producing helpers via method_missing,
+    # returning their result directly.
+    def method_missing(name, *args, &block)
+      if helpers.respond_to?(name)
+        helpers.send(name, *args, &block)
+      else
+        super
+      end
+    end
+
+    # Since we delegate method_missing to helpers, we need to delegate
+    # respond_to? as well.
+    def respond_to?(name)
+      super || helpers.respond_to?(name)
+    end
+
+    [
+      # UrlHelper
+      :link_to,
+      :button_to,
+      :link_to_unless_current,
+      :link_to_unless,
+      :link_to_if,
+      :mail_to,
+
+      # FormTagHelper
+      :form_tag,
+      :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,
+
+      # 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,
+
+      # JavaScriptHelper
+      :javascript_tag,
+
+      # CsrfHelper
+      :csrf_meta_tag
+    ].each do |method_name|
+      def_simple_rails_helper(method_name)
+    end
+
+    [:form_for, :fields_for].each do |method_name|
+      def_rails_form_helper(method_name)
+    end
+
+    Erector::Widget.send :include, self
+  end
+end

data/lib/erector/raw_string.rb

@@ -4,5 +4,9 @@ module Erector
     def html_safe?
       true
     end
+
+    def to_s
+      self
+    end
   end
 end

data/lib/erector/widgets/external_renderer.rb

@@ -33,6 +33,14 @@ class ExternalRenderer < Erector::Widget
         rawtext external.text
       end
     end
+
+    if Object.const_defined?(:Sass)
+      rendered_externals(:scss).each do |external|
+        style({:type => "text/css", 'xml:space' => 'preserve'}.merge(external.options)) do
+          rawtext Sass.compile(external.text)
+        end
+      end
+    end
   end
   
   def inline_scripts

data/spec/erect/erect_rails_spec.rb

@@ -1,6 +1,4 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
-require "erector/rails"
-require "rails/version"
+require File.expand_path("../../spec_helper", __FILE__)
 
 # backport mktmpdir so this test will work on Ruby 1.8.6
 unless Dir.respond_to?(:mktmpdir)
@@ -49,60 +47,47 @@ end
 # converter tool on a newly generated scaffold app (like we brag about in the 
 # user guide).
 #
-module Erector
-  describe "the Rails version" do
-    it "should be #{Erector::Rails::RAILS_VERSION}" do
-      ::Rails::VERSION::STRING.should == Erector::Rails::RAILS_VERSION
+describe "the 'erector' command" do
+  def run(cmd)
+    stderr_file = Dir.tmpdir + "/stderr.txt"
+    stdout = IO.popen(cmd + " 2>#{stderr_file}") do |pipe|
+      pipe.read
     end
-  end
-
-  describe "Erect in a Rails app" do
-    def run(cmd)
-      stderr_file = Dir.tmpdir + "/stderr.txt"
-      stdout = IO.popen(cmd + " 2>#{stderr_file}") do |pipe|
-        pipe.read
-      end
-      stderr = File.open(stderr_file) {|f| f.read}
-      FileUtils.rm_f(stderr_file)
-      if $?.exitstatus != 0
-        raise "Command #{cmd} failed\nDIR:\n  #{Dir.getwd}\nSTDOUT:\n#{indent stdout}\nSTDERR:\n#{indent stderr}"
-      else
-        return stdout
-      end
-    end
-    
-    def indent(s)
-      s.gsub(/^/, '  ')
+    stderr = File.open(stderr_file) {|f| f.read}
+    FileUtils.rm_f(stderr_file)
+    if $?.exitstatus != 0 || stdout =~ /\berror\b/
+      run_info = "Command #{cmd} failed\nDIR:\n  #{Dir.getwd}\nSTDOUT:\n#{indent stdout}\nSTDERR:\n#{indent stderr}"
+      raise run_info
+    else
+      return stdout
     end
+  end
 
-    it "works like we say it does in the user guide" do
-      erector_dir = File.expand_path("#{File.dirname(__FILE__)}/../..")
-
-      # We add the paths to our vendored copy of rails to the load paths, so
-      # that this spec can be run without having a version of Rails (which may
-      # not match the version we wish to test against) installed.
-      rails_libs_argument = "-I'#{RAILS_LOAD_PATHS.join("':'")}'"
-
-      Dir.mktmpdir do |app_dir|
-        run "ruby #{rails_libs_argument} '#{VENDOR_RAILS}/railties/bin/rails' '#{app_dir}'"
-
-        FileUtils.cp_r(VENDOR_RAILS, "#{app_dir}/vendor/rails")
+  def indent(s)
+    s.gsub(/^/, '  ')
+  end
 
-        FileUtils.mkdir_p(app_dir + "/vendor/gems")
-        FileUtils.cp_r(erector_dir, "#{app_dir}/vendor/gems/erector")
+  it "works like we say it does in the user guide" do
+    erector_dir = File.expand_path("../../..", __FILE__)
+    Dir.mktmpdir do |app_dir|
+      FileUtils.cd(app_dir) do
+        run "bundle exec rails new dummy"
 
-        FileUtils.cd(app_dir) do
-          run "script/generate scaffold post title:string body:text published:boolean"
+        File.open('dummy/Gemfile', 'a+') do |gemfile|
+          require 'rails/version'
+          gemfile.write <<-GEMFILE.strip
+            gem "erector", :path => "#{erector_dir}"
+          GEMFILE
+        end
 
-          # The 'erector' binary would normally have been installed through rubygems,
-          # providing it with a wrapper script which requires rubygems. But here we
-          # run it directly, so we need to require rubygems explicitly before running
-          # the main script.
-          run "ruby #{rails_libs_argument} -I'#{erector_dir}/lib' " +
-            "-e \"require 'rubygems'; load '#{erector_dir}/bin/erector'\" app/views/posts"
+        FileUtils.cd('dummy') do
+          # puts File.read("./Gemfile")
+          run "BUNDLE_GEMFILE=./Gemfile bundle install"
+          run "BUNDLE_GEMFILE=./Gemfile bundle exec rails generate scaffold post title:string body:text published:boolean"
+          run "BUNDLE_GEMFILE=./Gemfile bundle exec #{erector_dir}/bin/erector ./app/views/posts"
 
           FileUtils.rm_f("app/views/posts/*.erb")
-          run "rake --trace db:migrate"
+          run "BUNDLE_GEMFILE=./Gemfile bundle exec rake --trace db:migrate"
 
           # run "script/server" # todo: launch in background; use mechanize or something to crawl it; then kill it
           # perhaps use open4?