ezml 0.1.1

data/lib/ezml/compiler.rb

@@ -0,0 +1,322 @@
+require_relative 'attribute_builder'
+require_relative 'attribute_compiler'
+require_relative 'temple_line_counter'
+
+module EZML
+
+  class Compiler
+    include EZML::Util
+
+    attr_accessor :options
+
+    def initialize(options)
+      @options     = Options.wrap(options)
+      @to_merge    = []
+      @temple      = [:multi]
+      @node        = nil
+      @filters     = Filters.defined.merge(options[:filters])
+      @attribute_compiler = AttributeCompiler.new(@options)
+    end
+
+    def call(node)
+      compile(node)
+      @temple
+    end
+
+    def compile(node)
+      parent, @node = @node, node
+      if node.children.empty?
+        send(:"compile_#{node.type}")
+      else
+        send(:"compile_#{node.type}") {node.children.each {|c| compile c}}
+      end
+    ensure
+      @node = parent
+    end
+
+    private
+
+    def compile_root
+      @output_line = 1
+      yield if block_given?
+      flush_merged_text
+    end
+
+    def compile_plain
+      push_text("#{@node.value[:text]}\n")
+    end
+
+    def nuke_inner_whitespace?(node)
+      if node.value && node.value[:nuke_inner_whitespace]
+        true
+      elsif node.parent
+        nuke_inner_whitespace?(node.parent)
+      else
+        false
+      end
+    end
+
+    def compile_script(&block)
+      push_script(@node.value[:text],
+                  :preserve_script       => @node.value[:preserve],
+                  :escape_html           => @node.value[:escape_html],
+                  :nuke_inner_whitespace => nuke_inner_whitespace?(@node),
+                  &block)
+    end
+
+    def compile_silent_script
+      return if @options.suppress_eval
+      push_silent(@node.value[:text])
+      keyword = @node.value[:keyword]
+
+      if block_given?
+        yield
+        push_silent("end", :can_suppress) unless @node.value[:dont_push_end]
+      elsif keyword == "end"
+        if @node.parent.children.last.equal?(@node)
+          # Since this "end" is ending the block,
+          # we don't need to generate an additional one
+          @node.parent.value[:dont_push_end] = true
+        end
+        # Don't restore dont_* for end because it isn't a conditional branch.
+      end
+    end
+
+    def compile_ezml_comment; end
+
+    def compile_tag
+      t = @node.value
+
+      # Get rid of whitespace outside of the tag if we need to
+      rstrip_buffer! if t[:nuke_outer_whitespace]
+
+      if @options.suppress_eval
+        object_ref = :nil
+        parse = false
+        value = t[:parse] ? nil : t[:value]
+        dynamic_attributes = EZML::Parser::DynamicAttributes.new
+      else
+        object_ref = t[:object_ref]
+        parse = t[:parse]
+        value = t[:value]
+        dynamic_attributes = t[:dynamic_attributes]
+      end
+
+      if @options[:trace]
+        t[:attributes].merge!({"data-trace" => @options.filename.split('/views').last << ":" << @node.line.to_s})
+      end
+
+      push_text("<#{t[:name]}")
+      push_temple(@attribute_compiler.compile(t[:attributes], object_ref, dynamic_attributes))
+      push_text(
+        if t[:self_closing] && @options.xhtml?
+          " />#{"\n" unless t[:nuke_outer_whitespace]}"
+        else
+          ">#{"\n" unless (t[:self_closing] && @options.html?) ? t[:nuke_outer_whitespace] : (!block_given? || t[:preserve_tag] || t[:nuke_inner_whitespace])}"
+        end
+      )
+
+      if value && !parse
+        push_text("#{value}</#{t[:name]}>#{"\n" unless t[:nuke_outer_whitespace]}")
+      end
+
+      return if t[:self_closing]
+
+      if value.nil?
+        yield if block_given?
+        rstrip_buffer! if t[:nuke_inner_whitespace]
+        push_text("</#{t[:name]}>#{"\n" unless t[:nuke_outer_whitespace]}")
+        return
+      end
+
+      if parse
+        push_script(value, t.merge(:in_tag => true))
+        push_text("</#{t[:name]}>#{"\n" unless t[:nuke_outer_whitespace]}")
+      end
+    end
+
+    def compile_comment
+      condition = "#{@node.value[:conditional]}>" if @node.value[:conditional]
+      revealed = @node.value[:revealed]
+
+      open = "<!--#{condition}#{'<!-->' if revealed}"
+
+      close = "#{'<!--' if revealed}#{'<![endif]' if condition}-->"
+
+      unless block_given?
+        push_text("#{open} ")
+
+        if @node.value[:parse]
+          push_script(@node.value[:text], :in_tag => true, :nuke_inner_whitespace => true)
+        else
+          push_text(@node.value[:text])
+        end
+
+        push_text(" #{close}\n")
+        return
+      end
+
+      push_text("#{open}\n")
+      yield if block_given?
+      push_text("#{close}\n")
+    end
+
+    def compile_doctype
+      doctype = text_for_doctype
+      push_text("#{doctype}\n") if doctype
+    end
+
+    def compile_filter
+      unless filter = @filters[@node.value[:name]]
+        name = @node.value[:name]
+        if ["maruku", "textile"].include?(name)
+          raise Error.new(Error.message(:install_ezml_contrib, name), @node.line - 1)
+        else
+          raise Error.new(Error.message(:filter_not_defined, name), @node.line - 1)
+        end
+      end
+      filter.internal_compile(self, @node.value[:text])
+    end
+
+    def text_for_doctype
+      if @node.value[:type] == "xml"
+        return nil if @options.html?
+        wrapper = @options.attr_wrapper
+        return "<?xml version=#{wrapper}1.0#{wrapper} encoding=#{wrapper}#{@node.value[:encoding] || "utf-8"}#{wrapper} ?>"
+      end
+
+      if @options.html5?
+        '<!DOCTYPE html>'
+      else
+        if @options.xhtml?
+          if @node.value[:version] == "1.1"
+            '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN" "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">'
+          elsif @node.value[:version] == "5"
+            '<!DOCTYPE html>'
+          else
+            case @node.value[:type]
+            when "strict";   '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+            when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Frameset//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-frameset.dtd">'
+            when "mobile";   '<!DOCTYPE html PUBLIC "-//WAPFORUM//DTD XHTML Mobile 1.2//EN" "http://www.openmobilealliance.org/tech/DTD/xhtml-mobile12.dtd">'
+            when "rdfa";     '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML+RDFa 1.0//EN" "http://www.w3.org/MarkUp/DTD/xhtml-rdfa-1.dtd">'
+            when "basic";    '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML Basic 1.1//EN" "http://www.w3.org/TR/xhtml-basic/xhtml-basic11.dtd">'
+            else             '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">'
+            end
+          end
+
+        elsif @options.html4?
+          case @node.value[:type]
+          when "strict";   '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">'
+          when "frameset"; '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Frameset//EN" "http://www.w3.org/TR/html4/frameset.dtd">'
+          else             '<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">'
+          end
+        end
+      end
+    end
+
+    def push_silent(text, can_suppress = false)
+      flush_merged_text
+      return if can_suppress && @options.suppress_eval?
+      newline = (text == "end") ? ";" : "\n"
+      @temple << [:code, "#{resolve_newlines}#{text}#{newline}"]
+      @output_line = @output_line + text.count("\n") + newline.count("\n")
+    end
+
+    def push_text(text)
+      @to_merge << [:text, text]
+    end
+
+    def push_temple(temple)
+      flush_merged_text
+      @temple.concat([[:newline]] * resolve_newlines.count("\n"))
+      @temple << temple
+      @output_line += TempleLineCounter.count_lines(temple)
+    end
+
+    def flush_merged_text
+      return if @to_merge.empty?
+
+      @to_merge.each do |type, val|
+        case type
+        when :text
+          @temple << [:static, val]
+        when :script
+          @temple << [:dynamic, val]
+        else
+          raise SyntaxError.new("[EZML BUG] Undefined entry in EZML::Compiler@to_merge.")
+        end
+      end
+
+      @to_merge = []
+    end
+
+    def push_script(text, opts = {})
+      return if @options.suppress_eval?
+
+      no_format = !(opts[:preserve_script] || opts[:preserve_tag] || opts[:escape_html])
+
+      unless block_given?
+        push_generated_script(no_format ? "(#{text}\n).to_s" : build_script_formatter("(#{text}\n)", opts))
+        push_text("\n") unless opts[:in_tag] || opts[:nuke_inner_whitespace]
+        return
+      end
+
+      flush_merged_text
+      push_silent "ezml_temp = #{text}"
+      yield
+      push_silent('end', :can_suppress) unless @node.value[:dont_push_end]
+      @temple << [:dynamic, no_format ? 'ezml_temp.to_s;' : build_script_formatter('ezml_temp', opts)]
+    end
+
+    def build_script_formatter(text, opts)
+      text = "(#{text}).to_s"
+      if opts[:escape_html]
+        text = "::EZML::Helpers.html_escape(#{text})"
+      end
+      if opts[:nuke_inner_whitespace]
+        text = "(#{text}).strip"
+      end
+      if opts[:preserve_tag]
+        text = "_ezmlout.fix_textareas!(::EZML::Helpers.preserve(#{text}))"
+      elsif opts[:preserve_script]
+        text = "_ezmlout.fix_textareas!(::EZML::Helpers.find_and_preserve(#{text}, _ezmlout.options[:preserve]))"
+      end
+      "#{text};"
+    end
+
+    def push_generated_script(text)
+      @to_merge << [:script, resolve_newlines + text]
+      @output_line += text.count("\n")
+    end
+
+    def resolve_newlines
+      diff = @node.line - @output_line
+      return "" if diff <= 0
+      @output_line = @node.line
+      "\n" * diff
+    end
+
+    def rstrip_buffer!(index = -1)
+      last = @to_merge[index]
+      if last.nil?
+        push_silent("_ezmlout.rstrip!", false)
+        return
+      end
+
+      case last.first
+      when :text
+        last[1] = last[1].rstrip
+        if last[1].empty?
+          @to_merge.slice! index
+          rstrip_buffer! index
+        end
+      when :script
+        last[1].gsub!(/\(ezml_temp, (.*?)\);$/, '(ezml_temp.rstrip, \1);')
+        rstrip_buffer! index - 1
+      else
+        raise SyntaxError.new("[EZML BUG] Undefined entry in EZML::Compiler@to_merge.")
+      end
+    end
+  end
+
+end

data/lib/ezml/engine.rb

@@ -0,0 +1,107 @@
+require 'forwardable'
+
+require_relative 'parser'
+require_relative 'compiler'
+require_relative 'options'
+require_relative 'helpers'
+require_relative 'buffer'
+require_relative 'filters'
+require_relative 'error'
+require_relative 'template_engine'
+
+module EZML
+
+  class Engine
+    extend Forwardable
+    include EZML::Util
+
+    attr_accessor :options
+
+    attr_accessor :indentation
+
+    def_delegators :compiler, :precompiled, :precompiled_method_return_value
+
+    def options_for_buffer
+      @options.for_buffer
+    end
+
+    def initialize(template, options = {})
+      @options = Options.new(options)
+
+      @template = check_ezml_encoding(template) do |msg, line|
+        raise EZML::Error.new(msg, line)
+      end
+
+      @template_engine = TemplateEngine.new(options)
+      @template_engine.compile(@template)
+    end
+
+    #Deprecated
+    def compiler
+      @template_engine
+    end
+
+    def render(scope = Object.new, locals = {}, &block)
+      parent = scope.instance_variable_defined?(:@ezml_buffer) ? scope.instance_variable_get(:@ezml_buffer) : nil
+      buffer = EZML::Buffer.new(parent, @options.for_buffer)
+
+      if scope.is_a?(Binding)
+        scope_object = eval("self", scope)
+        scope = scope_object.instance_eval{binding} if block_given?
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      set_locals(locals.merge(:_ezmlout => buffer, :_erbout => buffer.buffer), scope, scope_object)
+
+      scope_object.extend(EZML::Helpers)
+      scope_object.instance_variable_set(:@ezml_buffer, buffer)
+      begin
+        eval(@template_engine.precompiled_with_return_value, scope, @options.filename, @options.line)
+      rescue ::SyntaxError => e
+        raise SyntaxError, e.message
+      end
+    ensure
+      scope_object.instance_variable_set(:@ezml_buffer, buffer.upper) if buffer
+    end
+    alias_method :to_html, :render
+
+    def render_proc(scope = Object.new, *local_names)
+      if scope.is_a?(Binding)
+        scope_object = eval("self", scope)
+      else
+        scope_object = scope
+        scope = scope_object.instance_eval{binding}
+      end
+
+      begin
+        str = @template_engine.precompiled_with_ambles(local_names)
+        eval(
+          "Proc.new { |*_ezml_locals| _ezml_locals = _ezml_locals[0] || {}; #{str}}\n",
+          scope,
+          @options.filename,
+          @options.line
+        )
+      rescue ::SyntaxError => e
+        raise SyntaxError, e.message
+      end
+    end
+
+    def def_method(object, name, *local_names)
+      method = object.is_a?(Module) ? :module_eval : :instance_eval
+
+      object.send(method, "def #{name}(_ezml_locals = {}); #{@template_engine.precompiled_with_ambles(local_names)}; end",
+                  @options.filename, @options.line)
+    end
+
+    private
+
+    def set_locals(locals, scope, scope_object)
+      scope_object.instance_variable_set :@_ezml_locals, locals
+      set_locals = locals.keys.map { |k| "#{k} = @_ezml_locals[#{k.inspect}]" }.join("\n")
+      eval(set_locals, scope)
+    end
+  end
+
+end

data/lib/ezml/error.rb

@@ -0,0 +1,59 @@
+module EZML
+
+  class Error < StandardError
+    MESSAGES = {
+      :bad_script_indent            => '"%s" is indented at wrong level: expected %d, but was at %d.',
+      :cant_run_filter              => 'Can\'t run "%s" filter; you must require its dependencies first',
+      :cant_use_tabs_and_spaces     => "Indentation can't use both tabs and spaces.",
+      :deeper_indenting             => "The line was indented %d levels deeper than the previous line.",
+      :filter_not_defined           => 'Filter "%s" is not defined.',
+      :gem_install_filter_deps      => '"%s" filter\'s %s dependency missing: try installing it or adding it to your Gemfile',
+      :illegal_element              => "Illegal element: classes and ids must have values.",
+      :illegal_nesting_content      => "Illegal nesting: nesting within a tag that already has content is illegal.",
+      :illegal_nesting_header       => "Illegal nesting: nesting within a header command is illegal.",
+      :illegal_nesting_line         => "Illegal nesting: content can't be both given on the same line as %%%s and nested within it.",
+      :illegal_nesting_plain        => "Illegal nesting: nesting within plain text is illegal.",
+      :illegal_nesting_self_closing => "Illegal nesting: nesting within a self-closing tag is illegal.",
+      :inconsistent_indentation     => "Inconsistent indentation: %s used for indentation, but the rest of the document was indented using %s.",
+      :indenting_at_start           => "Indenting at the beginning of the document is illegal.",
+      :install_ezml_contrib         => 'To use the "%s" filter, please install the ezml-contrib gem.',
+      :invalid_attribute_list       => 'Invalid attribute list: %s.',
+      :invalid_filter_name          => 'Invalid filter name ":%s".',
+      :invalid_tag                  => 'Invalid tag: "%s".',
+      :missing_if                   => 'Got "%s" with no preceding "if"',
+      :no_ruby_code                 => "There's no Ruby code for %s to evaluate.",
+      :self_closing_content         => "Self-closing tags can't have content.",
+      :unbalanced_brackets          => 'Unbalanced brackets.',
+      :no_end                       => <<-END
+You don't need to use "- end" in EZML. Un-indent to close a block:
+- if foo?
+  %strong Foo!
+- else
+  Not foo.
+%p This line is un-indented, so it isn't part of the "if" block
+END
+    }
+
+    def self.message(key, *args)
+      string = MESSAGES[key] or raise "[EZML BUG] No error messages for #{key}"
+      (args.empty? ? string : string % args).rstrip
+    end
+
+    # The line of the template on which the error occurred.
+    #
+    # @return [Fixnum]
+    attr_reader :line
+
+    # @param message [String] The error message
+    # @param line [Fixnum] See \{#line}
+    def initialize(message = nil, line = nil)
+      super(message)
+      @line = line
+    end
+  end
+
+  class SyntaxError < Error; end
+
+  class InvalidAttributeNameError < SyntaxError; end
+
+end