ezml 0.1.1

data/lib/ezml/generator.rb

@@ -0,0 +1,38 @@
+module EZML
+  class Generator
+    include Temple::Mixins::CompiledDispatcher
+    include Temple::Mixins::Options
+
+    define_options freeze_static: RUBY_VERSION >= '2.1'
+
+    def call(exp)
+      compile(exp)
+    end
+
+    def on_multi(*exp)
+      exp.map { |e| compile(e) }.join('; ')
+    end
+
+    def on_static(text)
+      concat(options[:freeze_static] ? "#{Util.inspect_obj(text)}.freeze" : Util.inspect_obj(text))
+    end
+
+    def on_dynamic(code)
+      concat(code)
+    end
+
+    def on_code(exp)
+      exp
+    end
+
+    def on_newline
+      "\n"
+    end
+
+    private
+
+    def concat(str)
+      "_ezmlout.buffer << (#{str});"
+    end
+  end
+end

data/lib/ezml/helpers.rb

@@ -0,0 +1,299 @@
+require 'erb'
+
+module EZML
+  module Helpers
+
+    class ErrorReturn
+      def initialize(method)
+        @message = <<MESSAGE
+#{method} outputs directly to the EZML template.
+Disregard its return value and use the - operator,
+or use capture_ezml to get the value as a String.
+MESSAGE
+      end
+
+      def to_s
+        raise EZML::Error.new(@message)
+      rescue EZML::Error => e
+        e.backtrace.shift
+
+        if e.backtrace.first =~ /^\(eval\):\d+:in `format_script/
+          e.backtrace.shift
+          e.backtrace.first.gsub!(/^\(ezml\):(\d+)/) {|s| "(ezml):#{$1.to_i - 1}"}
+        end
+        raise e
+      end
+
+      def inspect
+        "EZML::Helpers::ErrorReturn(#{@message.inspect})"
+      end
+    end
+
+    self.extend self
+
+    @@action_view_defined = false
+
+    def self.action_view?
+      @@action_view_defined
+    end
+
+    def init_ezml_helpers
+      @ezml_buffer = EZML::Buffer.new(ezml_buffer, Options.new.for_buffer)
+      nil
+    end
+
+    def non_ezml
+      was_active = @ezml_buffer.active?
+      @ezml_buffer.active = false
+      yield
+    ensure
+      @ezml_buffer.active = was_active
+    end
+
+    def find_and_preserve(input = nil, tags = ezml_buffer.options[:preserve], &block)
+      return find_and_preserve(capture_ezml(&block), input || tags) if block
+      tags = tags.map { |tag| Regexp.escape(tag) }.join('|')
+      re = /<(#{tags})([^>]*)>(.*?)(<\/\1>)/im
+      input.to_s.gsub(re) do |s|
+        s =~ re # Can't rely on $1, etc. existing since Rails' SafeBuffer#gsub is incompatible
+        "<#{$1}#{$2}>#{preserve($3)}</#{$1}>"
+      end
+    end
+
+    def preserve(input = nil, &block)
+      return preserve(capture_ezml(&block)) if block
+      s = input.to_s.chomp("\n")
+      s.gsub!(/\n/, '&#x000A;')
+      s.delete!("\r")
+      s
+    end
+    alias_method :flatten, :preserve
+
+    def list_of(enum, opts={}, &block)
+      opts_attributes = opts.map { |k, v| " #{k}='#{v}'" }.join
+      enum.map do |i|
+        result = capture_ezml(i, &block)
+
+        if result.count("\n") > 1
+          result.gsub!("\n", "\n  ")
+          result = "\n  #{result.strip}\n"
+        else
+          result.strip!
+        end
+
+        %Q!<li#{opts_attributes}>#{result}</li>!
+      end.join("\n")
+    end
+
+    def html_attrs(lang = 'en-US')
+      if ezml_buffer.options[:format] == :xhtml
+        {:xmlns => "http://www.w3.org/1999/xhtml", 'xml:lang' => lang, :lang => lang}
+      else
+        {:lang => lang}
+      end
+    end
+
+    def tab_up(i = 1)
+      ezml_buffer.tabulation += i
+    end
+
+    def tab_down(i = 1)
+      ezml_buffer.tabulation -= i
+    end
+
+    def with_tabs(i)
+      old_tabs = ezml_buffer.tabulation
+      ezml_buffer.tabulation = i
+      yield
+    ensure
+      ezml_buffer.tabulation = old_tabs
+    end
+
+    def surround(front, back = front, &block)
+      output = capture_ezml(&block)
+
+      "#{front}#{output.chomp}#{back}\n"
+    end
+
+    def precede(str, &block)
+      "#{str}#{capture_ezml(&block).chomp}\n"
+    end
+
+    def succeed(str, &block)
+      "#{capture_ezml(&block).chomp}#{str}\n"
+    end
+
+    def capture_ezml(*args, &block)
+      buffer = eval('if defined? _ezmlout then _ezmlout else nil end', block.binding) || ezml_buffer
+      with_ezml_buffer(buffer) do
+        position = ezml_buffer.buffer.length
+
+        ezml_buffer.capture_position = position
+        value = block.call(*args)
+
+        captured = ezml_buffer.buffer.slice!(position..-1)
+
+        if captured == '' and value != ezml_buffer.buffer
+          captured = (value.is_a?(String) ? value : nil)
+        end
+
+        captured
+      end
+    ensure
+      ezml_buffer.capture_position = nil
+    end
+
+    def ezml_concat(text = "")
+      ezml_internal_concat text
+      ErrorReturn.new("ezml_concat")
+    end
+
+    def ezml_internal_concat(text = "", newline = true, indent = true)
+      if ezml_buffer.tabulation == 0
+        ezml_buffer.buffer << "#{text}#{"\n" if newline}"
+      else
+        ezml_buffer.buffer << %[#{ezml_indent if indent}#{text.to_s.gsub("\n", "\n#{ezml_indent}")}#{"\n" if newline}]
+      end
+    end
+    private :ezml_internal_concat
+
+    alias :ezml_internal_concat_raw :ezml_internal_concat
+
+    def ezml_indent
+      '  ' * ezml_buffer.tabulation
+    end
+
+    def ezml_tag(name, *rest, &block)
+      ret = ErrorReturn.new("ezml_tag")
+
+      text = rest.shift.to_s unless [Symbol, Hash, NilClass].any? {|t| rest.first.is_a? t}
+      flags = []
+      flags << rest.shift while rest.first.is_a? Symbol
+      attrs = (rest.shift || {})
+      attrs.keys.each {|key| attrs[key.to_s] = attrs.delete(key)} unless attrs.empty?
+      name, attrs = merge_name_and_attributes(name.to_s, attrs)
+
+      attributes = EZML::AttributeBuilder.build_attributes(ezml_buffer.html?,
+        ezml_buffer.options[:attr_wrapper],
+        ezml_buffer.options[:escape_attrs],
+        ezml_buffer.options[:hyphenate_data_attrs],
+        attrs)
+
+      if text.nil? && block.nil? && (ezml_buffer.options[:autoclose].include?(name) || flags.include?(:/))
+        ezml_internal_concat_raw "<#{name}#{attributes}#{' /' if ezml_buffer.options[:format] == :xhtml}>"
+        return ret
+      end
+
+      if flags.include?(:/)
+        raise Error.new(Error.message(:self_closing_content)) if text
+        raise Error.new(Error.message(:illegal_nesting_self_closing)) if block
+      end
+
+      tag = "<#{name}#{attributes}>"
+      end_tag = "</#{name}>"
+      if block.nil?
+        text = text.to_s
+        if text.include?("\n")
+          ezml_internal_concat_raw tag
+          tab_up
+          ezml_internal_concat text
+          tab_down
+          ezml_internal_concat_raw end_tag
+        else
+          ezml_internal_concat_raw tag, false
+          ezml_internal_concat text, false, false
+          ezml_internal_concat_raw end_tag, true, false
+        end
+        return ret
+      end
+
+      if text
+        raise Error.new(Error.message(:illegal_nesting_line, name))
+      end
+
+      if flags.include?(:<)
+        ezml_internal_concat_raw tag, false
+        ezml_internal_concat "#{capture_ezml(&block).strip}", false, false
+        ezml_internal_concat_raw end_tag, true, false
+        return ret
+      end
+
+      ezml_internal_concat_raw tag
+      tab_up
+      block.call
+      tab_down
+      ezml_internal_concat_raw end_tag
+
+      ret
+    end
+
+    def ezml_tag_if(condition, *tag)
+      if condition
+        ezml_tag(*tag){ yield }
+      else
+        yield
+      end
+      ErrorReturn.new("ezml_tag_if")
+    end
+
+    HTML_ESCAPE = { '&' => '&amp;', '<' => '&lt;', '>' => '&gt;', '"' => '&quot;', "'" => '&#39;' }
+
+    HTML_ESCAPE_REGEX = /['"><&]/
+
+    def html_escape(text)
+      ERB::Util.html_escape(text)
+    end
+
+    HTML_ESCAPE_ONCE_REGEX = /['"><]|&(?!(?:[a-zA-Z]+|#(?:\d+|[xX][0-9a-fA-F]+));)/
+
+    def escape_once(text)
+      text = text.to_s
+      text.gsub(HTML_ESCAPE_ONCE_REGEX, HTML_ESCAPE)
+    end
+
+    def is_ezml?
+      !@ezml_buffer.nil? && @ezml_buffer.active?
+    end
+
+    def block_is_ezml?(block)
+      eval('!!defined?(_ezmlout)', block.binding)
+    end
+
+    private
+
+    def merge_name_and_attributes(name, attributes_hash = {})
+      return name, attributes_hash unless name =~ /^(.+?)?([\.#].*)$/
+
+      return $1 || "div", AttributeBuilder.merge_attributes!(
+        EZML::Parser.parse_class_and_id($2), attributes_hash)
+    end
+
+    def with_ezml_buffer(buffer)
+      @ezml_buffer, old_buffer = buffer, @ezml_buffer
+      old_buffer.active, old_was_active = false, old_buffer.active? if old_buffer
+      @ezml_buffer.active, was_active = true, @ezml_buffer.active?
+      yield
+    ensure
+      @ezml_buffer.active = was_active
+      old_buffer.active = old_was_active if old_buffer
+      @ezml_buffer = old_buffer
+    end
+
+    def ezml_buffer
+      @ezml_buffer if defined? @ezml_buffer
+    end
+
+    def ezml_bind_proc(&proc)
+      _ezmlout = ezml_buffer
+      #double assignment is to avoid warnings
+      _erbout = _erbout = _ezmlout.buffer
+      proc { |*args| proc.call(*args) }
+    end
+  end
+end
+
+class Object
+  def is_ezml?
+    false
+  end
+end

data/lib/ezml/options.rb

@@ -0,0 +1,142 @@
+module EZML
+
+  class Options
+
+    @valid_formats = [:html4, :html5, :xhtml]
+
+    @buffer_option_keys = [:autoclose, :preserve, :attr_wrapper, :format,
+      :encoding, :escape_html, :escape_attrs, :hyphenate_data_attrs, :cdata]
+
+    def self.defaults
+      @defaults ||= EZML::TemplateEngine.options.to_hash.merge(encoding: 'UTF-8')
+    end
+
+    def self.valid_formats
+      @valid_formats
+    end
+
+    def self.buffer_option_keys
+      @buffer_option_keys
+    end
+
+    def self.buffer_defaults
+      @buffer_defaults ||= buffer_option_keys.inject({}) do |hash, key|
+        hash.merge(key => defaults[key])
+      end
+    end
+
+    def self.wrap(options)
+      if options.is_a?(Options)
+        options
+      else
+        Options.new(options)
+      end
+    end
+
+    attr_reader :attr_wrapper
+    attr_accessor :autoclose
+    attr_reader :encoding
+    attr_accessor :escape_attrs
+    attr_accessor :escape_html
+    attr_accessor :filename
+    attr_accessor :hyphenate_data_attrs
+    attr_accessor :line
+    attr :format
+    attr_accessor :mime_type
+    attr_accessor :preserve
+    attr_reader :remove_whitespace
+    attr_accessor :suppress_eval
+    attr_accessor :cdata
+    attr_accessor :parser_class
+    attr_accessor :compiler_class
+    attr_accessor :trace
+    attr_accessor :filters
+
+    def initialize(values = {}, &block)
+      defaults.each {|k, v| instance_variable_set :"@#{k}", v}
+      values.each {|k, v| send("#{k}=", v) if defaults.has_key?(k) && !v.nil?}
+      yield if block_given?
+    end
+
+    def [](key)
+      send key
+    end
+
+    def []=(key, value)
+      send "#{key}=", value
+    end
+
+    [:escape_attrs, :hyphenate_data_attrs, :remove_whitespace, :suppress_eval].each do |method|
+      class_eval(<<-END)
+        def #{method}?
+          !! @#{method}
+        end
+      END
+    end
+
+    def xhtml?
+      not html?
+    end
+
+    def html?
+      html4? or html5?
+    end
+
+    def html4?
+      format == :html4
+    end
+
+    def html5?
+      format == :html5
+    end
+
+    def attr_wrapper=(value)
+      @attr_wrapper = value || self.class.defaults[:attr_wrapper]
+    end
+
+    undef :format
+    def format
+      mime_type == "text/xml" ? :xhtml : @format
+    end
+
+    def format=(value)
+      unless self.class.valid_formats.include?(value)
+        raise EZML::Error, "Invalid output format #{value.inspect}"
+      end
+      @format = value
+    end
+
+    undef :cdata
+    def cdata
+      xhtml? || @cdata
+    end
+
+    def remove_whitespace=(value)
+      @remove_whitespace = value
+    end
+
+    def encoding=(value)
+      return unless value
+      @encoding = value.is_a?(Encoding) ? value.name : value.to_s
+      @encoding = "UTF-8" if @encoding.upcase == "US-ASCII"
+    end
+
+    def for_buffer
+      self.class.buffer_option_keys.inject({}) do |hash, key|
+        value = public_send(key)
+        if self.class.buffer_defaults[key] != value
+          hash[key] = value
+        end
+        hash
+      end
+    end
+
+    private
+
+    def defaults
+      self.class.defaults
+    end
+
+  end
+
+end