html2fortitude 0.0.1

data/lib/html2fortitude/html/erb.rb

@@ -0,0 +1,156 @@
+require 'cgi'
+require 'erubis'
+require 'ruby_parser'
+
+module Html2fortitude
+  class HTML
+    # A class for converting ERB code into a format that's easier
+    # for the {Html2fortitude::HTML} Nokogiri-based parser to understand.
+    #
+    # Uses [Erubis](http://www.kuwata-lab.com/erubis)'s extensible parsing powers
+    # to parse the ERB in a reliable way,
+    # and [ruby_parser](http://parsetree.rubyforge.org/)'s Ruby knowledge
+    # to figure out whether a given chunk of Ruby code starts a block or not.
+    #
+    # The ERB tags are converted to HTML tags in the following way.
+    # `<% ... %>` is converted into `<fortitude_silent> ... </fortitude_silent>`.
+    # `<%= ... %>` is converted into `<fortitude_loud> ... </fortitude_loud>`.
+    # `<%== ... %>` is converted into `<fortitude_loud raw=raw> ... </fortitude_loud>`.
+    # Finally, if either of these opens a Ruby block,
+    # `<fortitude_block> ... </fortitude_block>` will wrap the entire contents of the block -
+    # that is, everything that should be indented beneath the previous silent or loud tag.
+    class ERB < Erubis::Basic::Engine
+      # Compiles an ERB template into a HTML document containing `fortitude_*` tags.
+      #
+      # @param template [String] The ERB template
+      # @return [String] The output document
+      # @see Html2fortitude::HTML::ERB
+      def self.compile(template)
+        new(template).src
+      end
+
+      # The ERB-to-Fortitudeized-HTML conversion has no preamble.
+      def add_preamble(src); end
+
+      # The ERB-to-Fortitudeized-HTML conversion has no postamble.
+      def add_postamble(src); end
+
+      # Concatenates the text onto the source buffer.
+      #
+      # @param src [String] The source buffer
+      # @param text [String] The raw text to add to the buffer
+      def add_text(src, text)
+        src << text
+      end
+
+      # Concatenates a silent Ruby statement onto the source buffer.
+      # This uses the `<fortitude_silent>` tag,
+      # and may close and/or open a Ruby block with the `<fortitude_block>` tag.
+      #
+      # In particular, a block is closed if this statement is some form of `end`,
+      # opened if it's a block opener like `do`, `if`, or `begin`,
+      # and both closed and opened if it's a mid-block keyword
+      # like `else` or `when`.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby statement to add to the buffer
+      def add_stmt(src, code)
+        src << '</fortitude_block>' if block_closer?(code) || mid_block?(code)
+        src << '<fortitude_silent>' << h(code) << '</fortitude_silent>' unless code.strip == "end"
+        src << '<fortitude_block>' if block_opener?(code) || mid_block?(code)
+      end
+
+      # Concatenates a Ruby expression that's printed to the document
+      # onto the source buffer.
+      # This uses the `<fortitude:silent>` tag,
+      # and may open a Ruby block with the `<fortitude:block>` tag.
+      # An expression never closes a block.
+      #
+      # @param src [String] The source buffer
+      # @param code [String] The Ruby expression to add to the buffer
+      def add_expr_literal(src, code)
+        src << '<fortitude_loud>' << h(code) << '</fortitude_loud>'
+        src << '<fortitude_block>' if block_opener?(code)
+      end
+
+      def add_expr_escaped(src, code)
+        src << "<fortitude_loud raw=raw>" << h(code) << "</fortitude_loud>"
+      end
+
+      # `html2fortitude` doesn't support debugging expressions.
+      def add_expr_debug(src, code)
+        # TODO ageweke
+        # raise Haml::Error.new("html2haml doesn't support debugging expressions.")
+      end
+
+      private
+
+      # HTML-escaped some text (in practice, always Ruby code).
+      # A utility method.
+      #
+      # @param text [String] The text to escape
+      # @return [String] The escaped text
+      def h(text)
+        CGI.escapeHTML(text)
+      end
+
+      # Returns whether the code is valid Ruby code on its own.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def valid_ruby?(code)
+        RubyParser.new.parse(code)
+      rescue Racc::ParseError, RubyParser::SyntaxError
+        false
+      end
+
+      # Returns whether the code has any content
+      # This is used to test whether lines have been removed by erubis, such as comments
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def has_code?(code)
+        return false if code == "\n"
+        return false if valid_ruby?(code) == nil
+        true
+      end
+
+      # Checks if a string of Ruby code opens a block.
+      # This could either be something like `foo do |a|`
+      # or a keyword that requires a matching `end`
+      # like `if`, `begin`, or `case`.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_opener?(code)
+        return unless has_code?(code)
+        valid_ruby?(code + "\nend") ||
+          valid_ruby?(code + "\nwhen foo\nend")
+      end
+
+      # Checks if a string of Ruby code closes a block.
+      # This is always `end` followed optionally by some method calls.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def block_closer?(code)
+        return unless has_code?(code)
+        valid_ruby?("begin\n" + code)
+      end
+
+      # Checks if a string of Ruby code comes in the middle of a block.
+      # This could be a keyword like `else`, `rescue`, or `when`,
+      # or even `end` with a method call that takes a block.
+      #
+      # @param code [String] Ruby code to check
+      # @return [Boolean]
+      def mid_block?(code)
+        return unless has_code?(code)
+        return if valid_ruby?(code)
+        valid_ruby?("if foo\n#{code}\nend") || # else, elsif
+          valid_ruby?("begin\n#{code}\nend") || # rescue, ensure
+          valid_ruby?("case foo\n#{code}\nend") # when
+      end
+    end
+  end
+end

data/lib/html2fortitude/run.rb

@@ -0,0 +1,103 @@
+require 'trollop'
+require 'find'
+require 'html2fortitude/source_template'
+
+module Html2fortitude
+  class Run
+    def initialize(argv)
+      @argv = argv
+    end
+
+    def run!
+      parse_arguments!
+
+      for_each_input_file do |name_and_block|
+        name = name_and_block[:name]
+        block = name_and_block[:block]
+
+        contents = nil
+        block.call { |io| contents = io.read }
+
+        effective_options = trollop_options.select do |key, value|
+          %w{output class_name class_base superclass method assigns do_end new_style_hashes}.include?(key.to_s)
+        end
+
+        source_template = Html2fortitude::SourceTemplate.new(name, contents, effective_options)
+        source_template.write_transformed_content!
+
+        unless @argv.include?("-")
+          puts "#{source_template.filename} -> #{source_template.output_filename} (#{source_template.line_count} lines)"
+        end
+      end
+    end
+
+    private
+    def for_each_input_file(&block)
+      @argv.each do |file_or_directory|
+        if file_or_directory == '-'
+          block.call({ :name => '-', :block => lambda { |&block| block.call($stdin) } })
+          next
+        end
+
+        file_or_directory = File.expand_path(file_or_directory)
+        raise Errno::ENOENT, "No such file or directory: #{file_or_directory}" unless File.exist?(file_or_directory)
+
+        files = [ ]
+        if File.directory?(file_or_directory)
+          Find.find(file_or_directory) do |f|
+            f = File.expand_path(f, file_or_directory)
+            files << f if File.file?(f) && f =~ /\.r?html/
+          end
+        else
+          files << file_or_directory
+        end
+
+        files.each do |file|
+          block.call(:name => file, :block => lambda { |&block| File.open(file, &block) })
+        end
+      end
+    end
+
+    def parse_arguments!
+      trollop_options
+    end
+
+    def trollop_options
+      @trollop_parser ||= Trollop::Parser.new do
+        version "html2fortitude version #{Html2fortitude::VERSION}"
+        banner <<-EOS
+html2fortitude transforms HTML source files (with or without ERb embedded)
+into Fortitude (https://github.com/ageweke/fortitude) source code.
+
+Usage:
+  html2fortitude [options] file|directory [file|directory...]
+where [options] are:
+EOS
+
+        opt :output,     "Output file or directory", :type => String
+
+        opt :class_name, "Class name for created Fortitude class", :type => String
+        opt :class_base, "Base directory for input files (e.g., my_rails_app/app) to use when --class-name is not specified", :type => String, :short => 'b'
+        opt :superclass, "Name of the class to inherit the output class from", :type => String, :default => 'Fortitude::Widget::Html5'
+
+        opt :method,     "Name of method to write in widget (default 'content')", :type => String, :default => 'content'
+        opt :assigns,    %{Method for using assigns passed to the widget:
+  needs_defaulted_to_nil: (default) standard Fortitude 'needs', but with a default of 'nil', so all needs are optional
+  required_needs:         standard Fortitude 'needs', no default; widget will not render without all needs specified (dangerous)
+  instance_variables:     Ruby instance variables; requires that a base class of the widget sets 'use_instance_variables_for_assigns true'
+  no_needs:               Omit a 'needs' declaration entirely; requires that a base class sets 'extra_assigns :use'},
+            :type => String, :default => 'needs_defaulted_to_nil'
+
+        opt :do_end,     "Use do ... end for blocks passed to tag methods, not { ... } (does not affect blocks from ERb)", :type => :boolean
+        opt :new_style_hashes, "Use hash_style: ruby19 instead of :hash_style => :ruby_18", :type => :boolean
+      end
+
+      @trollop_options ||= begin
+        Trollop::with_standard_exception_handling(@trollop_parser) do
+          raise Trollop::HelpNeeded if @argv.empty? # show help screen
+          @trollop_parser.parse @argv
+        end
+      end
+    end
+  end
+end

data/lib/html2fortitude/source_template.rb

@@ -0,0 +1,93 @@
+require 'html2fortitude/html'
+
+module Html2fortitude
+  class SourceTemplate
+    attr_reader :filename, :line_count
+
+    def initialize(filename, contents, options)
+      options.assert_valid_keys(:output, :class_name, :class_base, :superclass, :method, :assigns,
+        :do_end, :new_style_hashes)
+
+      @filename = filename
+      @contents = contents
+      @options = options
+      @line_count = @contents.split(/(\r|\n|\r\n)/).length
+    end
+
+    def write_transformed_content!
+      html_options = {
+        :class_name => output_class_name,
+        :superclass => options[:superclass],
+        :method => options[:method],
+        :assigns => options[:assigns],
+        :do_end => options[:do_end],
+        :new_style_hashes => options[:new_style_hashes]
+      }
+
+      html = HTML.new(contents, html_options).render
+
+      if output_filename == '-'
+        puts html
+      else
+        FileUtils.mkdir_p(File.dirname(output_filename))
+        File.open(output_filename, 'w') { |f| f << html }
+      end
+    end
+
+    def output_filename
+      if (! options[:output]) && (filename == "-")
+        "-"
+      elsif (! options[:output])
+        if filename =~ /^(.*)\.html\.erb$/i || filename =~ /^(.*)\.rhtml$/i
+          "#{$1}.rb"
+        else
+          "#{filename}.rb"
+        end
+      elsif File.directory?(options[:output])
+        File.join(File.expand_path(options[:output]), "#{output_class_name.underscore}.rb")
+      else
+        File.expand_path(options[:output])
+      end
+    end
+
+    private
+    attr_reader :contents, :options
+
+    def output_class_name
+      if options[:class_name]
+        options[:class_name]
+      else
+        cb = class_base
+        if filename.start_with?("#{cb}/")
+          out = filename[(cb.length + 1)..-1].camelize
+          out = $1 if out =~ %r{^(.*?)\.[^/]+$}i
+          out
+        else
+          raise %{You specified a class base using the -b command-line option:
+  #{class_base}
+but the file you asked to parse is not underneath that directory:
+  #{filename}}
+        end
+      end
+    end
+
+    def class_base
+      File.expand_path(options[:class_base] || infer_class_base)
+    end
+
+    def infer_class_base
+      if filename =~ %r{^(.*app)/views/.*$}
+        File.expand_path($1)
+      elsif filename == "-"
+        raise %{When converting standard input, you must specify a name for the output class
+using the -c command-line option. (Otherwise, we have no way of knowing what to name this widget!)}
+      else
+        raise %{We can't figure out what the name of the widget class for this file should be:
+  #{filename}
+You must either specify an explicit name for the class, using the -c command-line option, or
+specify a base directory to infer the class name from, using the -b command-line option
+(e.g., "-b my_rails_app/app").}
+      end
+    end
+  end
+end

data/lib/html2fortitude/version.rb

@@ -0,0 +1,3 @@
+module Html2fortitude
+  VERSION = "0.0.1"
+end

data/spec/helpers/global_helper.rb

@@ -0,0 +1,6 @@
+require 'html2fortitude'
+require 'helpers/standard_helper'
+
+RSpec.configure do |c|
+  c.include StandardHelper
+end

data/spec/helpers/html2fortitude_result.rb

@@ -0,0 +1,71 @@
+class Html2FortitudeResult
+  attr_reader :needs, :class_name, :superclass, :method_name
+
+  def initialize(text)
+    lines = text.split(/[\r\n]/)
+    if lines.shift =~ /^\s*class\s*(\S+)\s+<\s+(\S+)\s*$/i
+      @class_name = $1
+      @superclass = $2
+    else
+      raise "Can't find 'class' declaration in: #{text}"
+    end
+
+    @needs = { }
+
+    lines.shift while lines[0] =~ /^\s*$/i
+
+    while lines[0] =~ /^\s*needs\s*(.*?)\s*$/i
+      need_name = $1
+      need_value = nil
+
+      if need_name =~ /^(.*?)\s*=>\s*(.*?)\s*$/i
+        need_name = $1
+        need_value = $2
+      end
+
+      @needs[need_name] = need_value
+
+      lines.shift
+    end
+
+    lines.shift while lines[0] =~ /^\s*$/i
+
+    if lines[0] =~ /^\s+def\s+(\S+)\s*$/i
+      @method_name = $1
+      lines.shift
+    else
+      raise "Can't find 'def' in: #{text}"
+    end
+
+    lines.pop while lines[-1] =~ /^\s*$/i
+    if lines[-1] =~ /^\s*end\s*$/i
+      lines.pop
+    else
+      raise "Can't find last 'end' in: #{text}"
+    end
+
+    lines.pop while lines[-1] =~ /^\s*$/i
+    if lines[-1] =~ /^\s*end\s*$/i
+      lines.pop
+    else
+      raise "Can't find last 'end' in: #{text}"
+    end
+
+    @content_lines = lines
+    @content_lines = @content_lines.map do |content_line|
+      content_line = content_line.rstrip
+      if content_line[0..3] == '    '
+        content_line[4..-1]
+      else
+        content_line
+      end
+    end
+  end
+
+  def content_text
+    @content_lines.join("\n")
+  end
+
+  private
+  attr_reader :text
+end

data/spec/helpers/standard_helper.rb

@@ -0,0 +1,70 @@
+require 'helpers/html2fortitude_result'
+require 'html2fortitude/html'
+
+module StandardHelper
+  def default_html_options
+    {
+      :class_name => "SpecClass",
+      :superclass => "Fortitude::Widget::Html5",
+      :method => "content",
+      :assigns => :needs_defaulted_to_nil,
+      :do_end => false,
+      :new_style_hashes => false
+    }
+  end
+
+  def h2f(input, options = { })
+    Html2FortitudeResult.new(Html2fortitude::HTML.new(input, default_html_options.merge(options)).render)
+  end
+
+  def h2f_content(input, options = { })
+    h2f(input, options).content_text
+  end
+
+  def h2f_from(filename)
+    Html2FortitudeResult.new(get(filename))
+  end
+
+  def invoke(*args)
+    cmd = "#{binary_path} #{args.join(" ")} 2>&1"
+    output = `#{cmd}`
+    unless $?.success?
+      raise "Invocation failed: ran: #{cmd}\nin: #{Dir.pwd}\nand got: #{$?.inspect}\nwith output:\n#{output}"
+    end
+    output
+  end
+
+  def splat!(filename, data)
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename, 'w') { |f| f << data }
+  end
+
+  def get(filename)
+    raise Errno::ENOENT, "No such file: #{filename.inspect}" unless File.file?(filename)
+    File.read(filename).strip
+  end
+
+  def with_temp_directory(name, &block)
+    directory = File.join(temp_directory_base, name)
+    FileUtils.rm_rf(directory) if File.exist?(directory)
+    FileUtils.mkdir_p(directory)
+    Dir.chdir(directory, &block)
+  end
+
+  private
+  def temp_directory_base
+    @temp_directory_base ||= begin
+      out = File.join(gem_root, 'tmp', 'specs')
+      FileUtils.mkdir_p(out)
+      out
+    end
+  end
+
+  def gem_root
+    @gem_root ||= File.expand_path(File.join(File.dirname(__FILE__), '..', '..'))
+  end
+
+  def binary_path
+    @binary_path ||= File.join(gem_root, 'bin', 'html2fortitude')
+  end
+end