ezml 0.1.1

data/lib/ezml/attribute_compiler.rb

@@ -0,0 +1,172 @@
+require_relative 'attribute_parser'
+
+module EZML
+
+  class AttributeCompiler
+    class AttributeValue < Struct.new(:type, :key, :value)
+      # @return [String] A Ruby literal of value.
+      def to_literal
+        case type
+        when :static
+          EZML::Util.inspect_obj(value)
+        when :dynamic
+          value
+        end
+      end
+    end
+
+    def self.runtime_build(attributes, object_ref, dynamic_attributes)
+      "_ezmlout.attributes(#{EZML::Util.inspect_obj(attributes)}, #{object_ref},#{dynamic_attributes.to_literal})"
+    end
+
+    def initialize(options)
+      @is_html = [:html4, :html5].include?(options[:format])
+      @attr_wrapper = options[:attr_wrapper]
+      @escape_attrs = options[:escape_attrs]
+      @hyphenate_data_attrs = options[:hyphenate_data_attrs]
+    end
+
+    def compile(attributes, object_ref, dynamic_attributes)
+      if object_ref != :nil || !AttributeParser.available?
+        return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
+      end
+
+      parsed_hashes = [dynamic_attributes.new, dynamic_attributes.old].compact.map do |attribute_hash|
+        unless (hash = AttributeParser.parse(attribute_hash))
+          return [:dynamic, AttributeCompiler.runtime_build(attributes, object_ref, dynamic_attributes)]
+        end
+        hash
+      end
+      attribute_values = build_attribute_values(attributes, parsed_hashes)
+      AttributeBuilder.verify_attribute_names!(attribute_values.map(&:key))
+
+      [:multi, *group_values_for_sort(attribute_values).map { |value_group|
+        compile_attribute_values(value_group)
+      }]
+    end
+
+    private
+
+    def group_values_for_sort(values)
+      sorted_values = values.sort_by(&:key)
+      [].tap do |value_groups|
+        until sorted_values.empty?
+          key = sorted_values.first.key
+          value_group, sorted_values = sorted_values.partition { |v| v.key.start_with?(key) }
+          value_groups << value_group
+        end
+      end
+    end
+
+    def build_attribute_values(attributes, parsed_hashes)
+      [].tap do |attribute_values|
+        attributes.each do |key, static_value|
+          attribute_values << AttributeValue.new(:static, key, static_value)
+        end
+        parsed_hashes.each do |parsed_hash|
+          parsed_hash.each do |key, dynamic_value|
+            attribute_values << AttributeValue.new(:dynamic, key, dynamic_value)
+          end
+        end
+      end
+    end
+
+    def compile_attribute_values(values)
+      if values.map(&:key).uniq.size == 1
+        compile_attribute(values.first.key, values)
+      else
+        runtime_build(values)
+      end
+    end
+
+    def runtime_build(values)
+      hash_content = values.group_by(&:key).map do |key, values_for_key|
+        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
+      end.join(', ')
+      [:dynamic, "_ezmlout.attributes({ #{hash_content} }, nil)"]
+    end
+
+    def static_build(values)
+      hash_content = values.group_by(&:key).map do |key, values_for_key|
+        "#{frozen_string(key)} => #{merged_value(key, values_for_key)}"
+      end.join(', ')
+
+      arguments = [@is_html, @attr_wrapper, @escape_attrs, @hyphenate_data_attrs]
+      code = "::EZML::AttributeBuilder.build_attributes"\
+        "(#{arguments.map { |a| EZML::Util.inspect_obj(a) }.join(', ')}, { #{hash_content} })"
+      [:static, eval(code).to_s]
+    end
+
+    def merged_value(key, values)
+      if values.size == 1
+        values.first.to_literal
+      else
+        "::EZML::AttributeBuilder.merge_values(#{frozen_string(key)}, #{values.map(&:to_literal).join(', ')})"
+      end
+    end
+
+    def frozen_string(str)
+      "#{EZML::Util.inspect_obj(str)}.freeze"
+    end
+
+    def compile_attribute(key, values)
+      if values.all? { |v| Temple::StaticAnalyzer.static?(v.to_literal) }
+        return static_build(values)
+      end
+
+      case key
+      when 'id', 'class'
+        compile_id_or_class_attribute(key, values)
+      else
+        compile_common_attribute(key, values)
+      end
+    end
+
+    def compile_id_or_class_attribute(id_or_class, values)
+      var = unique_name
+      [:multi,
+       [:code, "#{var} = (#{merged_value(id_or_class, values)})"],
+       [:case, var,
+        ['Hash, Array', runtime_build([AttributeValue.new(:dynamic, id_or_class, var)])],
+        ['false, nil', [:multi]],
+        [:else, [:multi,
+                 [:static, " #{id_or_class}=#{@attr_wrapper}"],
+                 [:escape, @escape_attrs, [:dynamic, var]],
+                 [:static, @attr_wrapper]],
+        ]
+       ],
+      ]
+    end
+
+    def compile_common_attribute(key, values)
+      var = unique_name
+      [:multi,
+       [:code, "#{var} = (#{merged_value(key, values)})"],
+       [:case, var,
+        ['Hash', runtime_build([AttributeValue.new(:dynamic, key, var)])],
+        ['true', true_value(key)],
+        ['false, nil', [:multi]],
+        [:else, [:multi,
+                 [:static, " #{key}=#{@attr_wrapper}"],
+                 [:escape, @escape_attrs, [:dynamic, var]],
+                 [:static, @attr_wrapper]],
+        ]
+       ],
+      ]
+    end
+
+    def true_value(key)
+      if @is_html
+        [:static, " #{key}"]
+      else
+        [:static, " #{key}=#{@attr_wrapper}#{key}#{@attr_wrapper}"]
+      end
+    end
+
+    def unique_name
+      @unique_name ||= 0
+      "_ezml_attribute_compiler#{@unique_name += 1}"
+    end
+  end
+
+end

data/lib/ezml/attribute_parser.rb

@@ -0,0 +1,133 @@
+begin
+  require 'ripper'
+rescue LoadError
+end
+
+module EZML
+
+  module AttributeParser
+    class UnexpectedTokenError < StandardError; end
+    class UnexpectedKeyError < StandardError; end
+
+    TYPE = 1
+    TEXT = 2
+
+    IGNORED_TYPES = %i[on_sp on_ignored_nl]
+
+    class << self
+      def available?
+        defined?(Ripper) && Temple::StaticAnalyzer.available?
+      end
+
+      def parse(exp)
+        return nil unless hash_literal?(exp)
+
+        hash = {}
+        each_attribute(exp) do |key, value|
+          hash[key] = value
+        end
+        hash
+      rescue UnexpectedTokenError, UnexpectedKeyError
+        nil
+      end
+
+      private
+
+      def hash_literal?(exp)
+        return false if Temple::StaticAnalyzer.syntax_error?(exp)
+        sym, body = Ripper.sexp(exp)
+        sym == :program && body.is_a?(Array) && body.size == 1 && body[0] && body[0][0] == :hash
+      end
+
+      def shift_key!(tokens)
+        while !tokens.empty? && IGNORED_TYPES.include?(tokens.first[TYPE])
+          tokens.shift # ignore spaces
+        end
+
+        _, type, first_text = tokens.shift
+        case type
+        when :on_label # `key:`
+          first_text.tr(':', '')
+        when :on_symbeg # `:key =>`, `:'key' =>` or `:"key" =>`
+          key = tokens.shift[TEXT]
+          if first_text != ':' # `:'key'` or `:"key"`
+            expect_string_end!(tokens.shift)
+          end
+          shift_hash_rocket!(tokens)
+          key
+        when :on_tstring_beg # `"key":`, `'key':` or `"key" =>`
+          key = tokens.shift[TEXT]
+          next_token = tokens.shift
+          if next_token[TYPE] != :on_label_end # on_label_end is `":` or `':`, so `"key" =>`
+            expect_string_end!(next_token)
+            shift_hash_rocket!(tokens)
+          end
+          key
+        else
+          raise UnexpectedKeyError.new("unexpected token is given!: #{first_text} (#{type})")
+        end
+      end
+
+      def expect_string_end!(token)
+        if token[TYPE] != :on_tstring_end
+          raise UnexpectedTokenError
+        end
+      end
+
+      def shift_hash_rocket!(tokens)
+        until tokens.empty?
+          _, type, str = tokens.shift
+          break if type == :on_op && str == '=>'
+        end
+      end
+
+      def each_attribute(hash_literal, &block)
+        all_tokens = Ripper.lex(hash_literal.strip)
+        all_tokens = all_tokens[1...-1] || [] # strip tokens for brackets
+
+        each_balanced_tokens(all_tokens) do |tokens|
+          key   = shift_key!(tokens)
+          value = tokens.map {|t| t[2] }.join.strip
+          block.call(key, value)
+        end
+      end
+
+      def each_balanced_tokens(tokens, &block)
+        attr_tokens = []
+        open_tokens = Hash.new { |h, k| h[k] = 0 }
+
+        tokens.each do |token|
+          case token[TYPE]
+          when :on_comma
+            if open_tokens.values.all?(&:zero?)
+              block.call(attr_tokens)
+              attr_tokens = []
+              next
+            end
+          when :on_lbracket
+            open_tokens[:array] += 1
+          when :on_rbracket
+            open_tokens[:array] -= 1
+          when :on_lbrace
+            open_tokens[:block] += 1
+          when :on_rbrace
+            open_tokens[:block] -= 1
+          when :on_lparen
+            open_tokens[:paren] += 1
+          when :on_rparen
+            open_tokens[:paren] -= 1
+          when :on_embexpr_beg
+            open_tokens[:embexpr] += 1
+          when :on_embexpr_end
+            open_tokens[:embexpr] -= 1
+          when *IGNORED_TYPES
+            next if attr_tokens.empty?
+          end
+
+          attr_tokens << token
+        end
+        block.call(attr_tokens) unless attr_tokens.empty?
+      end
+    end
+  end
+end

data/lib/ezml/buffer.rb

@@ -0,0 +1,166 @@
+module EZML
+
+  class Buffer
+    include EZML::Helpers
+    include EZML::Util
+
+    attr_accessor :buffer
+    attr_accessor :options
+    attr_accessor :upper
+    attr_accessor :capture_position
+    attr_writer :active
+
+    def xhtml?
+      not html?
+    end
+
+    def html?
+      html4? or html5?
+    end
+
+    def html4?
+      @options[:format] == :html4
+    end
+
+    def html5?
+      @options[:format] == :html5
+    end
+
+    def toplevel?
+      upper.nil?
+    end
+
+    def active?
+      @active
+    end
+
+    def tabulation
+      @real_tabs + @tabulation
+    end
+
+    def tabulation=(val)
+      val = val - @real_tabs
+      @tabulation = val > -1 ? val : 0
+    end
+
+    def initialize(upper = nil, options = {})
+      @active     = true
+      @upper      = upper
+      @options    = Options.buffer_defaults
+      @options    = @options.merge(options) unless options.empty?
+      @buffer     = new_encoded_string
+      @tabulation = 0
+
+      # The number of tabs that Engine thinks we should have
+      # @real_tabs + @tabulation is the number of tabs actually output
+      @real_tabs = 0
+    end
+
+    def push_text(text, tab_change, dont_tab_up)
+      if @tabulation > 0
+        # Have to push every line in by the extra user set tabulation.
+        # Don't push lines with just whitespace, though,
+        # because that screws up precompiled indentation.
+        text.gsub!(/^(?!\s+$)/m, tabs)
+        text.sub!(tabs, '') if dont_tab_up
+      end
+
+      @real_tabs += tab_change
+      @buffer << text
+    end
+
+    def adjust_tabs(tab_change)
+      @real_tabs += tab_change
+    end
+
+    def attributes(class_id, obj_ref, *attributes_hashes)
+      attributes = class_id
+      attributes_hashes.each do |old|
+        result = {}
+        old.each { |k, v| result[k.to_s] = v }
+        AttributeBuilder.merge_attributes!(attributes, result)
+      end
+      AttributeBuilder.merge_attributes!(attributes, parse_object_ref(obj_ref)) if obj_ref
+      AttributeBuilder.build_attributes(
+        html?, @options[:attr_wrapper], @options[:escape_attrs], @options[:hyphenate_data_attrs], attributes)
+    end
+
+    def rstrip!
+      if capture_position.nil?
+        buffer.rstrip!
+        return
+      end
+
+      buffer << buffer.slice!(capture_position..-1).rstrip
+    end
+
+    def fix_textareas!(input)
+      return input unless input.include?('<textarea'.freeze)
+
+      pattern = /<(textarea)([^>]*)>(\n|&#x000A;)(.*?)<\/textarea>/im
+      input.gsub!(pattern) do |s|
+        match = pattern.match(s)
+        content = match[4]
+        if match[3] == '&#x000A;'
+          content.sub!(/\A /, '&#x0020;')
+        else
+          content.sub!(/\A[ ]*/, '')
+        end
+        "<#{match[1]}#{match[2]}>\n#{content}</#{match[1]}>"
+      end
+      input
+    end
+
+    private
+
+    def new_encoded_string
+      "".encode(options[:encoding])
+    end
+
+    @@tab_cache = {}
+    # Gets `count` tabs. Mostly for internal use.
+    def tabs(count = 0)
+      tabs = [count + @tabulation, 0].max
+      @@tab_cache[tabs] ||= '  ' * tabs
+    end
+
+    def parse_object_ref(ref)
+      prefix = ref[1]
+      ref = ref[0]
+      # Let's make sure the value isn't nil. If it is, return the default Hash.
+      return {} if ref.nil?
+      class_name =
+        if ref.respond_to?(:ezml_object_ref)
+          ref.ezml_object_ref
+        else
+          underscore(ref.class)
+        end
+      ref_id =
+        if ref.respond_to?(:to_key)
+          key = ref.to_key
+          key.join('_') unless key.nil?
+        else
+          ref.id
+        end
+      id = "#{class_name}_#{ref_id || 'new'}"
+      if prefix
+        class_name = "#{ prefix }_#{ class_name}"
+        id = "#{ prefix }_#{ id }"
+      end
+
+      { 'id'.freeze => id, 'class'.freeze => class_name }
+    end
+
+    def underscore(camel_cased_word)
+      word = camel_cased_word.to_s.dup
+      word.gsub!(/::/, '_')
+      word.gsub!(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      word.gsub!(/([a-z\d])([A-Z])/, '\1_\2')
+      word.tr!('-', '_')
+      word.downcase!
+      word
+    end
+
+  end
+
+end