ezml 0.1.1

data/lib/ezml/escapable.rb

@@ -0,0 +1,46 @@
+module EZML
+
+  class Escapable < Temple::Filter
+    def initialize(*)
+      super
+      @escape_code = "::EZML::Helpers.html_escape((%s))"
+      @escaper = eval("proc {|v| #{@escape_code % 'v'} }")
+      @once_escape_code = "::EZML::Helpers.escape_once((%s))"
+      @once_escaper = eval("proc {|v| #{@once_escape_code % 'v'} }")
+      @escape = false
+    end
+
+    def on_escape(flag, exp)
+      old = @escape
+      @escape = flag
+      compile(exp)
+    ensure
+      @escape = old
+    end
+
+    def on_static(value)
+      [:static,
+       if @escape == :once
+         @once_escaper[value]
+       elsif @escape
+         @escaper[value]
+       else
+         value
+       end
+      ]
+    end
+
+    def on_dynamic(value)
+      [:dynamic,
+       if @escape == :once
+         @once_escape_code % value
+       elsif @escape
+         @escape_code % value
+       else
+         "(#{value}).to_s"
+       end
+      ]
+    end
+  end
+
+end

data/lib/ezml/exec.rb

@@ -0,0 +1,348 @@
+# frozen_string_literal: true
+require 'optparse'
+require 'rbconfig'
+require 'pp'
+
+module EZML
+  # This module handles the various EZML executables (`ezml` and `ezml-convert`).
+  module Exec
+    # An abstract class that encapsulates the executable code for all three executables.
+    class Generic
+      # @param args [Array<String>] The command-line arguments
+      def initialize(args)
+        @args = args
+        @options = {:for_engine => {}}
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      # Calls `Kernel#exit` at the end, so it never returns.
+      #
+      # @see #parse
+      def parse!
+        begin
+          parse
+        rescue Exception => e
+          raise e if @options[:trace] || e.is_a?(SystemExit)
+
+          $stderr.print "#{e.class}: " unless e.class == RuntimeError
+          $stderr.puts "#{e.message}"
+          $stderr.puts "  Use --trace for backtrace."
+          exit 1
+        end
+        exit 0
+      end
+
+      # Parses the command-line arguments and runs the executable.
+      # This does not handle exceptions or exit the program.
+      #
+      # @see #parse!
+      def parse
+        @opts = OptionParser.new(&method(:set_opts))
+        @opts.parse!(@args)
+
+        process_result
+
+        @options
+      end
+
+      # @return [String] A description of the executable
+      def to_s
+        @opts.to_s
+      end
+
+      protected
+
+      # Finds the line of the source template
+      # on which an exception was raised.
+      #
+      # @param exception [Exception] The exception
+      # @return [String] The line number
+      def get_line(exception)
+        # SyntaxErrors have weird line reporting
+        # when there's trailing whitespace,
+        # which there is for EZML documents.
+        return (exception.message.scan(/:(\d+)/).first || ["??"]).first if exception.is_a?(::SyntaxError)
+        (exception.backtrace[0].scan(/:(\d+)/).first || ["??"]).first
+      end
+
+      # Tells optparse how to parse the arguments
+      # available for all executables.
+      #
+      # This is meant to be overridden by subclasses
+      # so they can add their own options.
+      #
+      # @param opts [OptionParser]
+      def set_opts(opts)
+        opts.on('-s', '--stdin', :NONE, 'Read input from standard input instead of an input file') do
+          @options[:input] = $stdin
+        end
+
+        opts.on('--trace', :NONE, 'Show a full traceback on error') do
+          @options[:trace] = true
+        end
+
+        opts.on('--unix-newlines', 'Use Unix-style newlines in written files.') do
+          # Note that this is the preferred way to check for Windows, since
+          # JRuby and Rubinius also run there.
+          if RbConfig::CONFIG['host_os'] =~ /mswin|windows|mingw/i
+            @options[:unix_newlines] = true
+          end
+        end
+
+        opts.on_tail("-?", "-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("-v", "--version", "Print version") do
+          puts("EZML #{::EZML::VERSION}")
+          exit
+        end
+      end
+
+      # Processes the options set by the command-line arguments.
+      # In particular, sets `@options[:input]` and `@options[:output]`
+      # to appropriate IO streams.
+      #
+      # This is meant to be overridden by subclasses
+      # so they can run their respective programs.
+      def process_result
+        input, output = @options[:input], @options[:output]
+        args = @args.dup
+        input ||=
+          begin
+            filename = args.shift
+            @options[:filename] = filename
+            open_file(filename) || $stdin
+          end
+        output ||= open_file(args.shift, 'w') || $stdout
+
+        @options[:input], @options[:output] = input, output
+      end
+
+      COLORS = { :red => 31, :green => 32, :yellow => 33 }
+
+      # Prints a status message about performing the given action,
+      # colored using the given color (via terminal escapes) if possible.
+      #
+      # @param name [#to_s] A short name for the action being performed.
+      #   Shouldn't be longer than 11 characters.
+      # @param color [Symbol] The name of the color to use for this action.
+      #   Can be `:red`, `:green`, or `:yellow`.
+      def puts_action(name, color, arg)
+        return if @options[:for_engine][:quiet]
+        printf color(color, "%11s %s\n"), name, arg
+      end
+
+      # Same as `Kernel.puts`, but doesn't print anything if the `--quiet` option is set.
+      #
+      # @param args [Array] Passed on to `Kernel.puts`
+      def puts(*args)
+        return if @options[:for_engine][:quiet]
+        Kernel.puts(*args)
+      end
+
+      # Wraps the given string in terminal escapes
+      # causing it to have the given color.
+      # If terminal esapes aren't supported on this platform,
+      # just returns the string instead.
+      #
+      # @param color [Symbol] The name of the color to use.
+      #   Can be `:red`, `:green`, or `:yellow`.
+      # @param str [String] The string to wrap in the given color.
+      # @return [String] The wrapped string.
+      def color(color, str)
+        raise "[BUG] Unrecognized color #{color}" unless COLORS[color]
+
+        # Almost any real Unix terminal will support color,
+        # so we just filter for Windows terms (which don't set TERM)
+        # and not-real terminals, which aren't ttys.
+        return str if ENV["TERM"].nil? || ENV["TERM"].empty? || !STDOUT.tty?
+        return "\e[#{COLORS[color]}m#{str}\e[0m"
+      end
+
+      private
+
+      def open_file(filename, flag = 'r')
+        return if filename.nil?
+        flag = 'wb' if @options[:unix_newlines] && flag == 'w'
+        File.open(filename, flag)
+      end
+
+      def handle_load_error(err)
+        dep = err.message[/^no such file to load -- (.*)/, 1]
+        raise err if @options[:trace] || dep.nil? || dep.empty?
+        $stderr.puts <<MESSAGE
+Required dependency #{dep} not found!
+    Run "gem install #{dep}" to get it.
+  Use --trace for backtrace.
+MESSAGE
+        exit 1
+      end
+    end
+
+    # The `ezml` executable.
+    class EZML < Generic
+      # @param args [Array<String>] The command-line arguments
+      def initialize(args)
+        super
+        @options[:for_engine] = {}
+        @options[:requires] = []
+        @options[:load_paths] = []
+      end
+
+      # Tells optparse how to parse the arguments.
+      #
+      # @param opts [OptionParser]
+      def set_opts(opts)
+        super
+
+        opts.banner = <<END
+Usage: ezml [options] [INPUT] [OUTPUT]
+
+Description:
+  Converts EZML files to HTML.
+
+Options:
+END
+
+        opts.on('-c', '--check', "Just check syntax, don't evaluate.") do
+          require 'stringio'
+          @options[:check_syntax] = true
+          @options[:output] = StringIO.new
+        end
+
+        opts.on('-f', '--format NAME',
+                'Output format. Can be html5 (default), xhtml, or html4.') do |name|
+          @options[:for_engine][:format] = name.to_sym
+        end
+
+        opts.on('-e', '--escape-html',
+                'Escape HTML characters (like ampersands and angle brackets) by default.') do
+          @options[:for_engine][:escape_html] = true
+        end
+
+        opts.on('--no-escape-attrs',
+                "Don't escape HTML characters (like ampersands and angle brackets) in attributes.") do
+          @options[:for_engine][:escape_attrs] = false
+        end
+
+        opts.on('-q', '--double-quote-attributes',
+                'Set attribute wrapper to double-quotes (default is single).') do
+          @options[:for_engine][:attr_wrapper] = '"'
+        end
+
+        opts.on('--remove-whitespace',
+                'Remove whitespace surrounding and within tags') do
+          @options[:for_engine][:remove_whitespace] = true
+        end
+
+        opts.on('--cdata',
+                'Always add CDATA sections to javascript and css blocks.') do
+          @options[:for_engine][:cdata] = true
+        end
+
+        opts.on('--autoclose LIST',
+                'Comma separated list of elements to be automatically self-closed.') do |list|
+          @options[:for_engine][:autoclose] = list.split(',')
+        end
+
+        opts.on('--suppress-eval',
+                'Don\'t evaluate Ruby scripts.') do
+          @options[:for_engine][:suppress_eval] = true
+        end
+
+        opts.on('-r', '--require FILE', "Same as 'ruby -r'.") do |file|
+          @options[:requires] << file
+        end
+
+        opts.on('-I', '--load-path PATH', "Same as 'ruby -I'.") do |path|
+          @options[:load_paths] << path
+        end
+
+        opts.on('-E ex[:in]', 'Specify the default external and internal character encodings.') do |encoding|
+          external, internal = encoding.split(':')
+          Encoding.default_external = external if external && !external.empty?
+          Encoding.default_internal = internal if internal && !internal.empty?
+        end
+
+        opts.on('-d', '--debug', "Print out the precompiled Ruby source, and show syntax errors in the Ruby code.") do
+          @options[:debug] = true
+        end
+
+        opts.on('-p', '--parse', "Print out EZML parse tree.") do
+          @options[:parse] = true
+        end
+
+      end
+
+      # Processes the options set by the command-line arguments,
+      # and runs the EZML compiler appropriately.
+      def process_result
+        super
+        @options[:for_engine][:filename] = @options[:filename]
+        input = @options[:input]
+        output = @options[:output]
+
+        template = input.read()
+        input.close() if input.is_a? File
+
+        @options[:load_paths].each {|p| $LOAD_PATH << p}
+        @options[:requires].each {|f| require f}
+
+        begin
+
+          if @options[:parse]
+            parser = ::EZML::Parser.new(::EZML::Options.new(@options))
+            pp parser.call(template)
+            return
+          end
+
+          engine = ::EZML::Engine.new(template, @options[:for_engine])
+
+          if @options[:check_syntax]
+            error = validate_ruby(engine.precompiled)
+            if error
+              puts error.message.split("\n").first
+              exit 1
+            end
+            puts "Syntax OK"
+            return
+          end
+
+          if @options[:debug]
+            puts engine.precompiled
+            error = validate_ruby(engine.precompiled)
+            if error
+              puts '=' * 100
+              puts error.message.split("\n")[0]
+              exit 1
+            end
+            return
+          end
+
+          result = engine.to_html
+        rescue Exception => e
+          raise e if @options[:trace]
+
+          case e
+          when ::EZML::SyntaxError; raise "Syntax error on line #{get_line e}: #{e.message}"
+          when ::EZML::Error;       raise "EZML error on line #{get_line e}: #{e.message}"
+          else raise "Exception on line #{get_line e}: #{e.message}"
+          end
+        end
+
+        output.write(result)
+        output.close() if output.is_a? File
+      end
+
+      def validate_ruby(code)
+        begin
+          eval("BEGIN {return nil}; #{code}", binding, @options[:filename] || "")
+        rescue ::SyntaxError # Not to be confused with EZML::SyntaxError
+          $!
+        end
+      end
+    end
+  end
+end

data/lib/ezml/filters.rb

@@ -0,0 +1,249 @@
+require "tilt"
+
+module EZML
+  module Filters
+
+    extend self
+
+    attr_reader :defined
+    @defined = {}
+
+    def register_tilt_filter(name, options = {})
+      if constants.map(&:to_s).include?(name.to_s)
+        raise "#{name} filter already defined"
+      end
+
+      filter = const_set(name, Module.new)
+      filter.extend const_get(options[:extend] || "Plain")
+      filter.extend TiltFilter
+      filter.extend PrecompiledTiltFilter if options.has_key? :precompiled
+
+      if options.has_key? :template_class
+        filter.template_class = options[:template_class]
+      else
+        filter.tilt_extension = options.fetch(:extension) { name.downcase }
+      end
+
+      # All ":coffeescript" as alias for ":coffee", etc.
+      if options.has_key?(:alias)
+        [options[:alias]].flatten.each {|x| Filters.defined[x.to_s] = filter}
+      end
+      filter
+    end
+
+    def remove_filter(name)
+      defined.delete name.to_s.downcase
+      if constants.map(&:to_s).include?(name.to_s)
+        remove_const name.to_sym
+      end
+    end
+
+    module Base
+
+      def self.included(base)
+        Filters.defined[base.name.split("::").last.downcase] = base
+        base.extend(base)
+      end
+
+      def render(text)
+        raise Error.new("#{self.inspect}#render not defined!")
+      end
+
+      def render_with_options(text, options)
+        render(text)
+      end
+
+      def internal_compile(*args)
+        compile(*args)
+      end
+
+      def compile(compiler, text)
+        filter = self
+        compiler.instance_eval do
+          if contains_interpolation?(text)
+            return if options[:suppress_eval]
+
+            text = unescape_interpolation(text, options[:escape_html]).gsub(/(\\+)n/) do |s|
+              escapes = $1.size
+              next s if escapes % 2 == 0
+              "#{'\\' * (escapes - 1)}\n"
+            end
+            text = %[\n#{text.sub(/\n"\Z/, "\\n\"")}]
+            push_script <<RUBY.rstrip, :escape_html => false
+find_and_preserve(#{filter.inspect}.render_with_options(#{text}, _ezmlout.options))
+RUBY
+            return
+          end
+
+          rendered = EZML::Helpers::find_and_preserve(filter.render_with_options(text.to_s, compiler.options), compiler.options[:preserve])
+          push_text("#{rendered.rstrip}\n")
+        end
+      end
+    end
+
+    module Plain
+      include Base
+
+      def render(text); text; end
+    end
+
+    module Javascript
+      include Base
+
+      # @see Base#render_with_options
+      def render_with_options(text, options)
+        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
+        if options[:format] == :html5
+          type = ''
+        else
+          type = " type=#{options[:attr_wrapper]}text/javascript#{options[:attr_wrapper]}"
+        end
+
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
+
+        %!<script#{type}>\n#{"  //<![CDATA[\n" if options[:cdata]}#{indent}#{text}\n#{"  //]]>\n" if options[:cdata]}</script>!
+      end
+    end
+
+    module Css
+      include Base
+
+      # @see Base#render_with_options
+      def render_with_options(text, options)
+        indent = options[:cdata] ? '    ' : '  ' # 4 or 2 spaces
+        if options[:format] == :html5
+          type = ''
+        else
+          type = " type=#{options[:attr_wrapper]}text/css#{options[:attr_wrapper]}"
+        end
+
+        text = text.rstrip
+        text.gsub!("\n", "\n#{indent}")
+
+        %(<style#{type}>\n#{"  /*<![CDATA[*/\n" if options[:cdata]}#{indent}#{text}\n#{"  /*]]>*/\n" if options[:cdata]}</style>)
+      end
+    end
+
+    module Cdata
+      include Base
+
+      # @see Base#render
+      def render(text)
+        "<![CDATA[#{"\n#{text.rstrip}".gsub("\n", "\n    ")}\n]]>"
+      end
+    end
+
+    module Escaped
+      include Base
+
+      # @see Base#render
+      def render(text)
+        EZML::Helpers.html_escape text
+      end
+    end
+
+    module Ruby
+      include Base
+      require 'stringio'
+
+      # @see Base#compile
+      def compile(compiler, text)
+        return if compiler.options[:suppress_eval]
+        compiler.instance_eval do
+          push_silent "#{<<-FIRST.tr("\n", ';')}#{text}#{<<-LAST.tr("\n", ';')}"
+            begin
+              ezml_io = StringIO.new(_ezmlout.buffer, 'a')
+          FIRST
+            ensure
+              ezml_io.close
+              ezml_io = nil
+            end
+          LAST
+        end
+      end
+    end
+
+    module Preserve
+      include Base
+
+      # @see Base#render
+      def render(text)
+        EZML::Helpers.preserve text
+      end
+    end
+
+    module TiltFilter
+      extend self
+      attr_accessor :tilt_extension, :options
+      attr_writer :template_class
+
+      def template_class
+        (@template_class if defined? @template_class) or begin
+          @template_class = Tilt["t.#{tilt_extension}"] or
+            raise Error.new(Error.message(:cant_run_filter, tilt_extension))
+        rescue LoadError => e
+          dep = e.message.split('--').last.strip
+          raise Error.new(Error.message(:gem_install_filter_deps, tilt_extension, dep))
+        end
+      end
+
+      def self.extended(base)
+        base.options = {}
+        base.instance_eval %Q{
+          include Base
+
+          def render_with_options(text, compiler_options)
+            text = template_class.new(nil, 1, options) {text}.render
+            super(text, compiler_options)
+          end
+        }
+      end
+    end
+
+    module PrecompiledTiltFilter
+      def precompiled(text)
+        template_class.new(nil, 1, options) { text }.send(:precompiled, {}).first
+      end
+
+      def compile(compiler, text)
+        return if compiler.options[:suppress_eval]
+        compiler.send(:push_script, precompiled(text))
+      end
+    end
+
+    # @!parse module Sass; end
+    register_tilt_filter "Sass", :extend => "Css"
+
+    # @!parse module Scss; end
+    register_tilt_filter "Scss", :extend => "Css"
+
+    # @!parse module Less; end
+    register_tilt_filter "Less", :extend => "Css"
+
+    # @!parse module Markdown; end
+    register_tilt_filter "Markdown"
+
+    # @!parse module Erb; end
+    register_tilt_filter "Erb", :precompiled => true
+
+    # @!parse module Coffee; end
+    register_tilt_filter "Coffee", :alias => "coffeescript", :extend => "Javascript"
+
+    module Erb
+      class << self
+        def precompiled(text)
+          #workaround for https://github.com/rtomayko/tilt/pull/183
+          require 'erubis' if (defined?(::Erubis) && !defined?(::Erubis::Eruby))
+          super.sub(/^#coding:.*?\n/, '')
+        end
+      end
+    end
+  end
+end
+
+begin
+  #{}require_relative "filters/maruku"
+  #{}require_relative "filters/textile"
+rescue LoadError
+end