honkster-erector 0.8.1

data/lib/erector/convenience.rb

@@ -0,0 +1,58 @@
+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 = {})
+      to_html(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 |widget_or_text|
+        if !first
+          text separator
+        end
+        first = false
+        text widget_or_text
+      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
+
+    # 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,30 @@
+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/erect/erect.rb

@@ -0,0 +1,160 @@
+require "optparse"
+require "rake"
+require "erector/erect/erected"  # pull this out so we don't recreate the grammar every time
+
+module Erector
+  class Erect
+    attr_reader :files, :verbose, :mode, :output_dir, :superklass, :method_name
+    def initialize(args)
+      @verbose = true
+      @mode = :to_erector
+      @output_dir = nil
+      @superklass = 'Erector::Widget'
+      @method_name = 'content'
+      
+      opts = OptionParser.new do |opts|
+        opts.banner = "Usage: erector [options] [file|dir]*"
+
+        opts.separator "Converts from html/rhtml files to erector widgets, or from erector widgets to html files"
+        opts.separator ""
+        opts.separator "Options:"
+
+        opts.on("-q", "--quiet",
+                "Operate silently except in case of error") do |quiet|
+          @verbose = !quiet
+        end
+        
+        opts.on("--to-erector", "(default) Convert from html/rhtml to erector classes") do
+          @mode = :to_erector
+        end
+
+        opts.on("--to-html", "Convert from erector to html") do
+          @mode = :to_html
+        end
+        
+        opts.on("--superclass SUPERCLASS", "Superclass for new widget (default Erector::Widget)") do |superklass|
+          @superklass = superklass
+        end
+        
+        opts.on("--method METHOD", "Method containing content for widget (default 'content')") do |method_name|
+          @method_name = method_name
+        end
+        
+        opts.on("-o", "--output-dir DIRECTORY", "Output files to DIRECTORY (default: output files go next to input files)") do |dir|
+          @output_dir = dir
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          @mode = :help
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Show version") do
+          puts Erector::VERSION
+          exit
+        end
+        
+      end
+      opts.parse!(args)
+      @files = args
+      explode_dirs
+    end
+    
+    def say(msg)
+      print msg if verbose
+    end
+    
+    #todo: unit test
+    def explode_dirs
+      exploded_files = FileList.new
+      files.each do |file|
+        if File.directory?(file)
+          exploded_files.add(explode(file))
+        else
+          exploded_files.add(file)
+        end
+      end
+      @files = exploded_files
+    end
+    
+    def explode(dir)
+      case mode
+      when :to_erector
+        FileList["#{dir}/**/*.rhtml", "#{dir}/**/*.html", "#{dir}/**/*.html.erb"]
+      when :to_html
+        FileList["#{dir}/**/*.rb"]
+      end
+    end
+    
+    def run
+      @success = true
+      self.send(mode)
+      @success
+    end
+    
+    def to_erector
+      files.each do |file|
+        say "Erecting #{file}... "
+        begin
+          e = Erector::Erected.new(file, @superklass, @method_name)
+          e.convert
+          say " --> #{e.filename}\n"
+        rescue => e
+          puts e
+          puts e.backtrace.join("\n\t")
+          @success = false
+        end
+      end
+    end
+
+    def to_html
+      files.each do |file|
+        say "Erecting #{file}... "
+        #todo: move this into Erected with better tests for the naming methods
+        begin
+          #todo: fail if file isn't a .rb file
+          require file
+          filename = file.split('/').last.gsub(/\.rb$/, '')
+          widget_name = camelize(filename)
+          widget_class = constantize(widget_name)
+          
+          if widget_class < Erector::Widget
+            widget = widget_class.new
+            #todo: skip if it's missing a no-arg constructor
+            dir = output_dir || File.dirname(file)
+            FileUtils.mkdir_p(dir)
+            output_file = "#{dir}/#{filename}.html"
+            File.open(output_file, "w") do |f|
+              f.puts widget.to_html
+            end
+            say " --> #{output_file}\n"
+          else
+            say " -- not a widget, skipping\n"
+          end
+        rescue => e
+          puts e
+          puts e.backtrace.join("\n\t")
+          @success = false
+        end
+      end
+    end
+    
+    # stolen from activesuppport/lib/inflector.rb
+    def camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
+      if first_letter_in_uppercase
+        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      else
+        lower_case_and_underscored_word.first + camelize(lower_case_and_underscored_word)[1..-1]
+      end
+    end
+    def constantize(camel_cased_word)
+      unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+        raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+      end
+      Object.module_eval("::#{$1}", __FILE__, __LINE__)
+    end
+    
+
+  end
+end

data/lib/erector/erect/erected.rb

@@ -0,0 +1,75 @@
+require 'rubygems'
+require 'treetop'
+
+require "#{File.dirname(__FILE__)}/indenting"
+Treetop.load("#{File.dirname(__FILE__)}/rhtml.treetop")
+
+module Erector
+  class Erected
+    
+    def initialize(in_file, superklass = 'Erector::Widget', method_name = 'content')
+      @in_file = in_file
+      @superklass = superklass
+      @method_name = method_name
+    end
+
+    def filename
+      dir + basename + ".rb"
+    end
+
+    def classnames
+      base = classize(basename)
+      parent = File.dirname(@in_file)
+      grandparent = File.dirname(parent)
+      if File.basename(grandparent) == "views"
+        ["Views::" + classize(File.basename(parent)) + "::" + base, @superklass]
+      else
+        [base, @superklass]
+      end
+    end
+
+    def classname
+      classnames[0]
+    end
+    
+    def parent_class
+      classnames[1]
+    end
+
+    def text
+      File.read(@in_file)
+    end
+
+    def convert
+      parser = RhtmlParser.new
+      parsed = parser.parse(File.read(@in_file))
+      if parsed.nil?
+        raise "Could not parse #{@in_file}\n" +
+          parser.failure_reason
+      else
+        File.open(filename, "w") do |f|
+          f.puts("class #{classname} < #{parent_class}")
+          f.puts("  def #{@method_name}")
+          f.puts(parsed.set_indent(2).convert)
+          f.puts("  end")
+          f.puts("end")
+        end
+      end
+    end
+
+    protected
+
+    def basename
+      @in_file.split("/").last.gsub(/\..*$/, '')
+    end
+
+    def dir
+      x = File.dirname(@in_file)
+      return (x == ".") ? "" : "#{x}/"
+    end
+
+    def classize(filename)
+      filename.split("_").map{|part| part.capitalize}.join
+    end
+  end
+end

data/lib/erector/erect/indenting.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'treetop'
+
+module Erector
+  class Indenting < Treetop::Runtime::SyntaxNode #:nodoc:
+    @@indent = 0
+
+    def set_indent(x)
+      @@indent = x
+      self
+    end
+
+    def indent
+      [0, @@indent].max
+    end
+
+    def indented(s)
+      "  " * indent + s + "\n"
+    end
+
+    def line(s)
+      indented(s)
+    end
+
+    def line_in(s)
+      s = indented(s)
+      @@indent += 1
+      s
+    end
+
+    def line_out(s)
+      @@indent -= 1
+      indented(s)
+    end
+  end
+end

data/lib/erector/erect/rhtml.treetop

@@ -0,0 +1,233 @@
+grammar Rhtml
+
+  rule doc
+    space node space x:doc? <Erector::Indenting> {
+      def convert
+        if x.empty?
+          node.convert
+        else
+          node.convert + x.convert
+        end
+      end
+    }
+  end
+
+  rule node
+    yield_with_name / yield / hprintlet / printlet / scriptlet / doctype / directive / self_closing_tag / imgtag / closetag / opentag / text
+  end
+
+  # Argh. For some reason I can't get this to work, so I split it into two rules
+  # rule yield
+  #   '<%=' space 'yield' space (':' varname space)? '%>' <Erector::Indenting> {
+  #     def convert
+  #       var = "@content_for_" + varname.nil? ? "layout" : varname.text_value
+  #       line "rawtext #{var} # Note: you must define #{var} elsewhere"
+  #     end
+  #   }
+  # end
+
+  rule yield_with_name
+    '<%=' space 'yield' space ':' varname space '%>' <Erector::Indenting> {
+      def convert
+        var = "@content_for_" + varname.text_value
+        line "rawtext #{var} # Note: you must define #{var} elsewhere"
+      end
+    }
+  end
+
+  rule yield
+    '<%=' space 'yield' space '%>' <Erector::Indenting> {
+      def convert
+        var = "@content_for_layout"
+        line "rawtext #{var} # Note: you must define #{var} elsewhere"
+      end
+    }
+  end
+
+  rule scriptlet
+    '<%' space code space '%>' <Erector::Indenting> {
+      def convert
+        text = code.text_value_removing_trims.strip
+        if text =~ /\bdo( |.*|)?$/
+          line_in text
+        elsif text == "end"
+          line_out text
+        else
+          line text
+        end
+      end
+    }
+  end
+
+  rule printlet
+    '<%=' space code space '%>' <Erector::Indenting> {
+      def convert
+        line "rawtext #{code.convert_removing_trims}"
+      end
+    }
+  end
+
+  rule hprintlet
+    '<%=' space 'h' ' '+ code space '%>' <Erector::Indenting> {
+      def convert
+        line "text #{code.convert_removing_trims}"
+      end
+    }
+  end
+
+  rule code
+    (('%' !'>') /  [^%])* <Erector::Indenting> {
+      def convert_removing_trims
+        convert.gsub(/\s*\-\s*$/, '')
+      end
+      
+      def text_value_removing_trims
+        text_value.gsub(/\s*\-\s*$/, '')
+      end
+      
+      def convert
+        code = text_value.strip
+        # matches a word, followed by either a word, a string, or a symbol
+        result = code.gsub(/^(\w+) ([\w:"'].*)$/, '\1(\2)')
+        result
+      end
+    }
+  end
+
+	rule doctype
+		'<!DOCTYPE' [^>]* '>' <Erector::Indenting> {
+			def convert
+				line "rawtext '#{text_value}'"
+			end
+		}
+	end
+	
+	rule directive
+	  '<!' [^>]* '>' <Erector::Indenting> {
+			def convert
+				line "rawtext '#{text_value}'"
+			end
+		}
+	end
+
+  rule tagname
+    [A-Za-z0-9_:-]+
+  end
+  
+  rule varname
+    [A-Za-z0-9_]+
+  end
+
+  rule self_closing_tag
+    '<' tag_name:tagname attrs:attributes? space '/>' <Erector::Indenting> {
+      def convert
+        line "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert}"
+      end
+    }
+  end
+
+  rule opentag
+   '<' tag_name:tagname attrs:attributes? space '>' <Erector::Indenting> {
+      def convert
+        line_in "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert} do"
+      end
+    }
+  end
+
+  rule imgtag
+   '<' tag_name:'img' attrs:attributes? space '>' <Erector::Indenting> {
+      def convert
+        line "#{tag_name.text_value}#{attrs.empty? ? "" : attrs.convert}"
+      end
+    }
+  end
+
+  rule closetag
+   '</' tag_name:tagname '>' <Erector::Indenting> {
+      def convert
+        line_out "end"
+      end
+    }
+  end
+
+  rule text
+    (([<>] !(tagname / [/%!])) / [^<>])+ <Erector::Indenting> {
+      def convert
+        stripped = text_value.strip
+        if stripped.empty?
+          ""
+        else
+          line "text '#{stripped.html_unescape.gsub(/\'/, "\\\\'")
+          }'"
+        end
+      end
+    }
+  end
+
+  rule attributes
+		first:attribute rest:attributes* {
+			def convert(internal = false)
+  			out = " " + first.convert +
+  				if rest.empty?
+  					""
+  				else
+  				  ",#{rest.elements.first.convert(true)}"  # this is hacky -- is there a better way?
+  				end
+
+  			if (! internal) && out =~ /[\(\)]/ && out =~ /^(\s*)(.*?)(\s*)$/
+    			out = "(#{$2})#{$3}"
+  			end
+
+  			out
+			end
+		}
+	end
+
+  rule attribute
+		space n:(tagname) space '=' space v:quoted space {
+      def convert
+        attr_name = (n.text_value =~ /[-:]/) ? "'#{n.text_value}'" : ":#{n.text_value}"
+        "#{attr_name} => #{v.convert}"
+      end
+    }
+  end
+
+  rule quoted
+    (('"' val:([^"]*) '"') / ('\'' val:([^']*) '\'')) {
+      def value
+        val.text_value
+      end
+    
+      def convert
+        extract_erb(val.text_value)
+      end
+      
+      def parenthesize_if_necessary(s)
+        return s if s.strip =~ /^\(.*\)$/ || s =~ /^[A-Z0-9_]*$/i
+        "(" + s + ")"
+      end
+      
+      def extract_erb(s, parenthesize = true)
+        if s =~ /^(.*?)<%=(.*?)%>(.*?)$/
+          pre, code, post = $1.html_unescape.escape_single_quotes, $2, $3.html_unescape.escape_single_quotes
+          out = ""
+          out = "'#{pre}' + " unless pre.length == 0
+          out += parenthesize_if_necessary(code.strip)
+          unless post.length == 0
+            post = extract_erb(post, false)
+            out += " + #{post}"
+          end
+          out = parenthesize_if_necessary(out) if parenthesize
+          out
+        else
+          "'" + s.html_unescape.escape_single_quotes + "'"
+        end
+      end
+    }
+  end
+
+  rule space
+    [ \n\t]*
+  end
+
+end