honkster-erector 0.8.1

data/lib/erector/widgets/table.rb

@@ -0,0 +1,104 @@
+begin
+ require "active_support/inflector"
+
+ module Erector
+  module Widgets #:nodoc:
+
+
+    # The Table widget provides the ability to render a table from a 
+    # list of objects (one for each row).
+    #
+    # Because the default for the column titles utilizes the ActiveSupport
+    # Inflector#titleize method, this widget requires active_support to be loaded.
+    #
+    #   class UsersTable < Erector::Widgets::Table
+    #     column :first_name
+    #     column :last_name
+    #     column :email
+    #     row_classes :even, :odd
+    #   end
+    #
+    #   widget UsersTable, :row_objects => [user_1, user_2, user_3]
+    class Table < Erector::Widget
+      ColumnDefinition = Struct.new(:id, :name, :cell_proc)
+      class << self
+        # Define a column, optionally specifying the name (the heading
+        # that the user sees) and a block which renders the cell given
+        # a row object.  If the block is not specified, the cell contains
+        # the result of calling a method whose name is id.
+        # 
+        # The name can be a string or a proc.
+        def column(id, name=id.to_s.titleize, &cell_proc)
+          cell_proc ||= proc {|object| text object.__send__(id)}
+          column_definitions << ColumnDefinition.new(id, name, cell_proc)
+        end
+
+        def column_definitions #:nodoc:
+          @column_definitions ||= []
+        end
+
+        # A list of HTML classes to apply to the rows in turn.  After the
+        # list is exhausted, start again at the start.  The most
+        # common use for this is to specify one class for odd rows
+        # and a different class for even rows.
+        def row_classes(*row_classes)
+          @row_class_list = row_classes
+        end
+        attr_reader :row_class_list
+      end
+
+      # The standard erector content method.
+      def content
+        table do
+          thead do
+            tr do
+              column_definitions.each do |column_def|
+                th do
+                  if column_def.name.is_a?(Proc)
+                    self.instance_exec(column_def.id, &column_def.name)
+                  else
+                    text column_def.name
+                  end
+                end
+              end
+            end
+          end
+          tbody do
+            @row_objects.each_with_index do |object, index|
+              row object, index
+            end
+          end
+        end
+      end
+
+      protected
+      def row(object, index) #:nodoc:
+        tr(:class => row_css_class(object, index)) do
+          column_definitions.each do |column_def|
+            td do
+              self.instance_exec(object, &column_def.cell_proc)
+            end
+          end
+        end
+      end
+
+      # You can override this method to provide a class for a row
+      # (as an alternative to calling row_classes).
+      def row_css_class(object, index)
+        cycle(index)
+      end
+
+      def column_definitions #:nodoc:
+        self.class.column_definitions
+      end
+
+      def cycle(index) #:nodoc:
+        list = self.class.row_class_list
+        list ? list[index % list.length] : ''
+      end
+    end
+  end
+ end
+rescue LoadError => e
+  $stderr.puts "Erector::Widgets::Table requires active_support"
+end

data/rails/init.rb

@@ -0,0 +1,4 @@
+require "erector"
+require "erector/rails"
+
+Erector.init_rails(binding)

data/spec/erect/erect_rails_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+require "erector/rails"
+require "rails/version"
+
+# backport mktmpdir so this test will work on Ruby 1.8.6
+unless Dir.respond_to?(:mktmpdir)
+  def Dir.mktmpdir(prefix_suffix=nil, tmpdir=nil)
+    case prefix_suffix
+    when nil
+      prefix = "d"
+      suffix = ""
+    when String
+      prefix = prefix_suffix
+      suffix = ""
+    when Array
+      prefix = prefix_suffix[0]
+      suffix = prefix_suffix[1]
+    else
+      raise ArgumentError, "unexpected prefix_suffix: #{prefix_suffix.inspect}"
+    end
+    tmpdir ||= Dir.tmpdir
+    t = Time.now.strftime("%Y%m%d")
+    n = nil
+    begin
+      path = "#{tmpdir}/#{prefix}#{t}-#{$$}-#{rand(0x100000000).to_s(36)}"
+      path << "-#{n}" if n
+      path << suffix
+      Dir.mkdir(path, 0700)
+    rescue Errno::EEXIST
+      n ||= 0
+      n += 1
+      retry
+    end
+
+    if block_given?
+      begin
+        yield path
+      ensure
+        FileUtils.remove_entry_secure path
+      end
+    else
+      path
+    end
+  end
+end
+
+# Note: this is *not* inside the rails_root since we're not testing 
+# Erector inside a rails app. We're testing that we can use the command-line
+# 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
+    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(/^/, '  ')
+    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")
+
+        FileUtils.mkdir_p(app_dir + "/vendor/gems")
+        FileUtils.cp_r(erector_dir, "#{app_dir}/vendor/gems/erector")
+
+        FileUtils.cd(app_dir) do
+          run "script/generate scaffold post title:string body:text published:boolean"
+
+          # 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.rm_f("app/views/posts/*.erb")
+          run "rake --trace db:migrate"
+
+          # run "script/server" # todo: launch in background; use mechanize or something to crawl it; then kill it
+          # perhaps use open4?
+          # open http://localhost:3000/posts
+        end
+      end
+    end
+  end
+end

data/spec/erect/erect_spec.rb

@@ -0,0 +1,175 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+require "erector/erect/erect"
+
+module Erector
+  describe Erect do
+    it "parses an empty command line" do
+      erect = Erect.new([])
+      erect.files.should == []
+    end
+    
+    it "parses a command line with one filename on it" do
+      erect = Erect.new(["foo.html"])
+      erect.files.should == ["foo.html"]
+    end
+    
+    it "parses a command line with several filenames on it" do
+      erect = Erect.new(["foo.html", "bar/baz.html"])
+      erect.files.should == ["foo.html", "bar/baz.html"]
+    end
+    
+    it "is verbose by default, but quiet when told" do
+      Erect.new([]).verbose.should be_true
+      Erect.new(["-q"]).verbose.should be_false
+    end
+    
+    it "sets the superclass to what you tell it" do
+      Erect.new([]).superklass.should == 'Erector::Widget'
+      Erect.new(['--superclass', 'Foo::Bar']).superklass.should == 'Foo::Bar'
+    end
+    
+    it "sets the method name to what you tell it" do
+      Erect.new([]).method_name.should == 'content'
+      Erect.new(['--method', 'my_content']).method_name.should == 'my_content'
+    end
+
+    it "parses a command line with several filenames and an option on it" do
+      erect = Erect.new(["-q", "foo.html", "bar/baz.html"])
+      erect.files.should == ["foo.html", "bar/baz.html"]
+    end
+ 
+    def capturing_output
+      output = StringIO.new
+      $stdout = output
+      yield
+      output.string
+    ensure
+      $stdout = STDOUT
+    end
+    
+    it "exits immediately from help" do
+      output = capturing_output do
+        lambda {
+          erect = Erect.new(["-h"])
+        }.should raise_error(SystemExit)
+      end
+      output.should =~ /^Usage/
+    end
+    
+    it "exits immediately from --version" do
+      output = capturing_output do
+        lambda {
+          erect = Erect.new(["--version"])
+        }.should raise_error(SystemExit)
+      end
+      output.should == Erector::VERSION + "\n"
+    end
+    
+    it "changes to html output" do
+      erect = Erect.new(["--to-html"])
+      erect.mode.should == :to_html
+    end
+
+    it "changes to html output when passed a .rb file" do
+      pending do
+        erect = Erect.new(["foo.rb"])
+        erect.mode.should == :to_html
+      end
+    end
+
+    it "fails when given both .rb and .html files" do
+      pending do
+        lambda {
+          erect = Erect.new(["foo.rb", "bar.html"])
+        }.should raise_error
+      end
+    end
+    
+    it "returns false when there's an error during run" do
+      capturing_output do
+        Erect.new(["MISSINGFILE"]).run.should == false
+      end
+        
+    end
+    
+  end
+  
+  describe "Erect functionally" do
+    
+    attr_reader :dir, :fred_html, :wilma_rhtml, :barney_html_erb, :fred_rb
+    
+    def create(file, body="hi")
+      File.open(file, "w") do |f|
+        f.puts(body)
+      end
+    end
+    
+    before :all do
+      @dir = Dir.tmpdir + "/#{Time.now.to_i}" + "/explode"
+      @fred_html = "#{dir}/fred.html"
+      @wilma_rhtml = "#{dir}/wilma.rhtml"
+      @barney_html_erb = "#{dir}/barney.html.erb"
+      @fred_rb = "#{dir}/fred.rb"
+
+      FileUtils.mkdir_p(dir)
+      create(fred_html)
+      create(wilma_rhtml)
+      create(barney_html_erb)
+      create(fred_rb, "class Fred < Erector::Widget\ndef content\ndiv 'dino'\nend\nend")
+    end
+    
+    it "explodes dirs into .html etc. files when in to-rb mode" do
+      erect = Erect.new(["--to-erector", dir])
+      erect.files.sort.should == [barney_html_erb, fred_html, wilma_rhtml]
+    end
+    
+    it "explodes dirs into .rb files when in to-html mode" do    
+      erect = Erect.new(["--to-html", dir])
+      erect.files.should == [fred_rb]
+    end
+    
+    it "outputs .rb files in the same directory as the input .html files" do
+      erect = Erect.new(["--to-erector", "-q", fred_html])
+      erect.run
+      File.exist?(fred_rb).should be_true
+      File.read(fred_rb).should include("text 'hi'")
+    end
+    
+    it "outputs .html files in the same directory as the input .rb files" do
+      betty_rb = "#{dir}/betty.rb"
+      betty_html = "#{dir}/betty.html"
+      create(betty_rb, "class Betty < Erector::Widget\ndef content\ndiv 'bam bam'\nend\nend")
+
+      erect = Erect.new(["--to-html", "-q", betty_rb])
+      erect.run
+      File.exist?(betty_html).should be_true
+      File.read(betty_html).should == "<div>bam bam</div>\n"
+    end
+    
+    it "outputs .html files in the given directory" do
+      create(fred_rb, "class Fred < Erector::Widget\ndef content\ndiv 'dino'\nend\nend")
+      out_dir = "#{dir}/out"
+      out_file = "#{out_dir}/fred.html"
+
+      Erect.new([]).output_dir.should be_nil
+      erect = Erect.new(["--to-html", "-o", "#{out_dir}", "-q", fred_rb])
+      erect.output_dir.should == out_dir
+      erect.run
+      File.exist?(out_file).should be_true
+      File.read(out_file).should == "<div>dino</div>\n"
+    end
+    
+    it "skips rendering classes that aren't widgets" do
+      mr_slate_rb = "#{dir}/mr_slate.rb"
+      mr_slate_html = "#{dir}/mr_slate.html"
+      create(mr_slate_rb, "class MrSlate\nend")
+      erect = Erect.new(["-q", "--to-html", mr_slate_rb])
+      erect.run
+      File.exist?(mr_slate_html).should be_false
+    end
+    
+    # it "properly indents lines beginning with for, unless, etc."
+  end
+
+end

data/spec/erect/erected_spec.rb

@@ -0,0 +1,164 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../spec_helper")
+
+require "erector/erect/erect"
+
+module Erector
+  describe Erected do
+
+    it "picks the right file name" do
+      Erected.new("foo.html.erb").filename.should == "foo.rb"
+      Erected.new("foo.html").filename.should == "foo.rb"
+      Erected.new("foo.bar.html").filename.should == "foo.rb"
+      Erected.new("foo_bar.html.erb").filename.should == "foo_bar.rb"
+      Erected.new("stuff/foo_bar.html.erb").filename.should == "stuff/foo_bar.rb"
+    end
+
+    it "picks a nice class name" do
+      Erected.new("foo.html.erb").classname.should == "Foo"
+      Erected.new("foo.html").classname.should == "Foo"
+      Erected.new("foo.bar.html").classname.should == "Foo"
+      Erected.new("foo_bar.html.erb").classname.should == "FooBar"
+      Erected.new("stuff/foo_bar.html.erb").classname.should == "FooBar"
+    end
+
+    it "picks an even nicer class name if it's in a views dir" do
+      Erected.new("app/views/stuff/foo_bar.html.erb").classname.should == "Views::Stuff::FooBar"
+      Erected.new("views/stuff/foo_bar.html.erb").classname.should == "Views::Stuff::FooBar"
+    end
+
+    it "uses Widget as the parent class" do
+      Erected.new("foo_bar.html").parent_class.should == "Erector::Widget"
+      Erected.new("foo_bar.html.erb").parent_class.should == "Erector::Widget"
+      Erected.new("stuff/foo_bar.html.erb").parent_class.should == "Erector::Widget"
+    end
+
+    it "uses Widget as the parent class if it's in a views dir" do
+      Erected.new("app/views/stuff/foo_bar.html.erb").parent_class.should == "Erector::Widget"
+      Erected.new("views/stuff/foo_bar.html.erb").parent_class.should == "Erector::Widget"
+    end
+
+    def convert(dir, input, output, superklass = nil, method_name = nil)
+      dir = Dir.tmpdir + "/#{Time.now.to_i}" + "/#{dir}"
+
+      FileUtils.mkdir_p(dir)
+      html = "#{dir}/dummy.html"
+      rb = "#{dir}/dummy.rb"
+
+      File.open(html, "w") do |f|
+        f.puts(input)
+      end
+      
+      args = [ html, superklass || 'Erector::Widget', method_name || 'content' ]
+      @e = Erected.new(*args)
+      @e.convert
+
+      File.read(rb).should == output
+    end
+
+    it "converts a normal file" do
+      convert(".",
+        "<div>hello</div>",
+        "class Dummy < Erector::Widget\n" +
+          "  def content\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n"
+      )
+    end
+
+    it "converts a views file" do
+      convert("app/views/foos",
+        "<div>hello</div>",
+        "class Views::Foos::Dummy < Erector::Widget\n" +
+          "  def content\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n"
+      )
+    end
+    
+    it "converts a normal file with a different superclass" do
+      convert(".",
+        "<div>hello</div>",
+        "class Dummy < Foo::Bar\n" +
+          "  def content\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n",
+        "Foo::Bar"
+      )
+    end
+    
+    it "converts a normal file with a different superclass and method name" do
+      convert(".",
+        "<div>hello</div>",
+        "class Dummy < Foo::Bar\n" +
+          "  def my_content\n" +
+          "    div do\n" +
+          "      text 'hello'\n" +
+          "    end\n" +
+          "  end\n" +
+          "end\n",
+        "Foo::Bar",
+        'my_content'
+      )
+    end
+    
+    it "ignores ERb trim markers" do
+      convert(".",
+        %{<div>
+<%= 1 + 3 -%>
+</div>},
+%{class Dummy < Erector::Widget
+  def content
+    div do
+      rawtext 1 + 3
+    end
+  end
+end
+})
+    end
+
+    it "converts ERb escapes in attributes" do
+      convert(".",
+        "<div id=\"foo_<%= bar %>_baz_<%= quux %>_marph\">hello</div>",
+%{class Dummy < Erector::Widget
+  def content
+    div(:id => ('foo_' + bar + '_baz_' + quux + '_marph')) do
+      text 'hello'
+    end
+  end
+end
+})
+    end
+
+    it "only parenthesizes ERb escapes in attributes if necessary" do
+      convert(".",
+        "<div id=\'<%= bar %>\'>hello</div>",
+%{class Dummy < Erector::Widget
+  def content
+    div :id => bar do
+      text 'hello'
+    end
+  end
+end
+})
+    end
+
+# todo: figure out if there is any such thing as unparsable HTML anymore
+#    it "raises an exception if given unparsable HTML" do
+#      begin
+#        convert(".", "<", "")
+#      rescue => e
+#        e.to_html.should include("Could not parse")
+#      end
+#    end
+    
+  end
+end