hamlit 1.7.2 → 2.0.1

data/lib/hamlit/compilers/attributes.rb

@@ -1,108 +0,0 @@
-require 'hamlit/compilers/new_attribute'
-require 'hamlit/compilers/old_attribute'
-require 'hamlit/compilers/runtime_attribute'
-require 'hamlit/concerns/escapable'
-require 'hamlit/concerns/included'
-
-module Hamlit
-  module Compilers
-    module Attributes
-      extend Concerns::Included
-      include Compilers::NewAttribute
-      include Compilers::OldAttribute
-      include Compilers::RuntimeAttribute
-
-      included do
-        include Concerns::Escapable
-
-        define_options :format, :attr_quote
-      end
-
-      def on_haml_attrs(*attrs)
-        attrs = compile_attributes(attrs)
-        attrs = join_ids(attrs)
-        attrs = combine_classes(attrs)
-        attrs = sort_attributes(attrs)
-
-        if has_runtime_attribute?(attrs) && has_attr?(attrs, 'class', 'id')
-          attrs = merge_runtime_attributes(attrs)
-          return [:html, :attrs, *escape_attribute_values(attrs)]
-        end
-        attrs = attrs.map { |a| compile(a) }
-
-        [:html, :attrs, *escape_attribute_values(attrs)]
-      end
-
-      private
-
-      def escape_attribute_values(attrs)
-        attrs.map do |attr|
-          _, _, name, value = attr
-          type, arg = value
-          next attr unless name && type && type && arg
-
-          [:html, :attr, name, escape_html(value, true)]
-        end
-      end
-
-      def compile_attributes(exps)
-        attrs = []
-        exps.each do |exp|
-          case exp
-          when /\A\(.+\)\Z/m
-            attrs += compile_new_attribute(exp)
-          when /\A{.+}\Z/
-            attrs += compile_old_attribute(exp)
-          else
-            attrs << compile(exp)
-          end
-        end
-        attrs
-      end
-
-      def combine_classes(attrs)
-        class_attrs = filter_attrs(attrs, 'class')
-        return attrs if class_attrs.length <= 1
-
-        values = class_attrs.map(&:last).sort_by(&:last)
-        [[:html, :attr, 'class', [:multi, *insert_static(values, ' ')]]] + (attrs - class_attrs)
-      end
-
-      def join_ids(attrs)
-        id_attrs = filter_attrs(attrs, 'id')
-        return attrs if id_attrs.length <= 1
-
-        values = attrs.map(&:last)
-        [[:html, :attr, 'id', [:multi, *insert_static(values, '_')]]] + (attrs - id_attrs)
-      end
-
-      def has_attr?(attrs, *targets)
-        filter_attrs(attrs, *targets).any?
-      end
-
-      def filter_attrs(attrs, *targets)
-        attrs.select do |html, attr, name, content|
-          targets.include?(name)
-        end
-      end
-
-      def insert_static(array, str)
-        result = []
-        array.each_with_index do |value, index|
-          result << [:static, str] if index > 0
-          result << value
-        end
-        result
-      end
-
-      # Sort attributes by attribute name.
-      # Move runtime attributes to last.
-      def sort_attributes(attrs)
-        attrs.sort_by do |(sexp, _, attr_name, _)|
-          next '' if sexp == :runtime
-          attr_name
-        end
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/comment.rb

@@ -1,13 +0,0 @@
-module Hamlit
-  module Compilers
-    module Comment
-      def on_haml_comment(condition, exps)
-        content = [:multi]
-        content << [:static, "#{condition}>\n"]
-        content += exps.map { |exp| compile(exp) }
-        content << [:static, "<![endif]"]
-        [:html, :comment, content]
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/doctype.rb

@@ -1,39 +0,0 @@
-module Hamlit
-  module Compilers
-    module Doctype
-      def on_haml_doctype(format, type)
-        if type == 'XML'
-          return xml_doctype_tag(format)
-        elsif type
-          return doctype_tag(type)
-        end
-
-        case format
-        when :html4
-          doctype_tag(:transitional)
-        when :html5
-          doctype_tag(:html)
-        when :xhtml
-          doctype_tag(:transitional)
-        else
-          doctype_tag(format)
-        end
-      end
-
-      private
-
-      def xml_doctype_tag(format)
-        case format
-        when :html4, :html5
-          [:multi]
-        else
-          [:multi, [:static, "<?xml version='1.0' encoding='utf-8' ?>"], [:static, "\n"]]
-        end
-      end
-
-      def doctype_tag(type)
-        [:multi, [:html, :doctype, type.to_s], [:static, "\n"]]
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/filter.rb

@@ -1,53 +0,0 @@
-require 'hamlit/concerns/included'
-require 'hamlit/concerns/registerable'
-require 'hamlit/filters/coffee'
-require 'hamlit/filters/css'
-require 'hamlit/filters/erb'
-require 'hamlit/filters/escaped'
-require 'hamlit/filters/javascript'
-require 'hamlit/filters/less'
-require 'hamlit/filters/plain'
-require 'hamlit/filters/preserve'
-require 'hamlit/filters/ruby'
-require 'hamlit/filters/sass'
-require 'hamlit/filters/markdown'
-require 'hamlit/filters/scss'
-
-module Hamlit
-  module Compilers
-    module Filter
-      extend Concerns::Included
-
-      included do
-        extend Concerns::Registerable
-
-        define_options :format
-
-        register :coffee,       Filters::Coffee
-        register :coffeescript, Filters::Coffee
-        register :css,          Filters::Css
-        register :erb,          Filters::Erb
-        register :escaped,      Filters::Escaped
-        register :javascript,   Filters::Javascript
-        register :less,         Filters::Less
-        register :markdown,     Filters::Markdown
-        register :plain,        Filters::Plain
-        register :preserve,     Filters::Preserve
-        register :ruby,         Filters::Ruby
-        register :sass,         Filters::Sass
-        register :scss,         Filters::Scss
-      end
-
-      def on_haml_filter(name, lines)
-        ast = compile_filter(name, lines)
-        compile(ast)
-      end
-
-      private
-
-      def compile_filter(name, exp)
-        self.class.find(name).new(options).compile(exp)
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/new_attribute.rb

@@ -1,115 +0,0 @@
-require 'hamlit/concerns/lexable'
-
-# This module compiles new-style attributes, which is
-# surrounded by parentheses.
-module Hamlit
-  module Compilers
-    module NewAttribute
-      include Concerns::Lexable
-
-      def compile_new_attribute(str)
-        str   = str.gsub(/\A\(|\)\Z/, '')
-        attrs = parse_new_attributes(str)
-        attrs.map do |key, value|
-          next true_attribute(key) if value == 'true'
-          [:html, :attr, key, [:dynamic, value]]
-        end
-      end
-
-      private
-
-      def parse_new_attributes(str)
-        attributes = {}
-
-        while str.length > 0
-          tokens = Ripper.lex(str)
-          key = read_key!(tokens)
-          val = read_value!(tokens)
-          if key && val
-            attributes[key] = val
-          elsif key
-            attributes[key] = 'true'
-          end
-
-          token = tokens.first
-          break unless token
-
-          pos = convert_position(str, *token.first)
-          str = str[pos..-1]
-        end
-
-        attributes
-      end
-
-      def read_key!(tokens)
-        skip_tokens!(tokens, :on_sp, :on_nl, :on_ignored_nl)
-        (row, col), type, key = tokens.shift
-
-        while tokens.any? && tokens.first[2] == '-'
-          tokens.shift
-
-          (row, col), type, part = tokens.shift
-
-          key = "#{key}-#{part}"
-        end
-
-        key
-      end
-
-      def read_value!(tokens)
-        skip_tokens!(tokens, :on_sp)
-        _, _, str = tokens.shift
-        return nil if str != '='
-
-        skip_tokens!(tokens, :on_sp)
-        return if tokens.empty?
-
-        case tokens.first[TYPE_POSITION]
-        when :on_tstring_beg
-          val = fetch_balanced_quotes(tokens)
-        else
-          val = fetch_until(tokens, :on_sp)
-        end
-        val.length.times { tokens.shift }
-        val.map(&:last).join
-      end
-
-      def fetch_balanced_quotes(all_tokens)
-        tokens     = []
-        open_count = 0
-
-        all_tokens.each do |token|
-          case type_of(token)
-          when :on_tstring_beg then open_count += 1
-          when :on_tstring_end then open_count -= 1
-          end
-
-          tokens << token
-          break if open_count == 0
-        end
-
-        tokens
-      end
-
-      def fetch_until(all_tokens, type)
-        tokens = []
-
-        all_tokens.each do |token|
-          break if token[TYPE_POSITION] == type
-          tokens << token
-        end
-
-        tokens
-      end
-
-      def true_attribute(key)
-        case options[:format]
-        when :xhtml
-          [:html, :attr, key, [:static, key]]
-        else
-          [:html, :attr, key, [:multi]]
-        end
-      end
-    end
-  end
-end

data/lib/hamlit/compilers/old_attribute.rb

@@ -1,241 +0,0 @@
-require 'hamlit/concerns/attribute_builder'
-require 'hamlit/concerns/balanceable'
-require 'hamlit/concerns/lexable'
-
-# This module compiles only old-style attribute, which is
-# surrounded by brackets.
-module Hamlit
-  # This error is raised when hamlit copmiler decide to
-  # copmile the attributes on runtime.
-  class RuntimeBuild < StandardError; end
-
-  module Compilers
-    module OldAttribute
-      include Concerns::AttributeBuilder
-      include Concerns::Balanceable
-      include Concerns::Lexable
-
-      # Only data can be nested for performance.
-      NESTABLE_ATTRIBUTES = %w[data].freeze
-      IGNORED_EXPRESSIONS = %w[false nil].freeze
-
-      # Class and id are joined if the value is an array.
-      JOIN_ATTRIBUTES = %w[class id].freeze
-      JOINABLE_TOKENS = %i[on_ident on_qwords_beg on_lbracket].freeze
-
-      # Only boolean attributes can be deleted for performance.
-      BOOLEAN_ATTRIBUTES = %w[disabled readonly multiple checked autobuffer
-                           autoplay controls loop selected hidden scoped async
-                           defer reversed ismap seamless muted required
-                           autofocus novalidate formnovalidate open pubdate
-                           itemscope allowfullscreen default inert sortable
-                           truespeed typemustmatch data].freeze
-
-      DEFAULT_COUNTS = {
-        brace:  -1,
-        emb:     0,
-        paren:   0,
-        bracket: 0,
-      }.freeze
-
-      OPEN_TOKEN_TYPES = {
-        on_lbrace:      :brace,
-        on_embexpr_beg: :emb,
-        on_lparen:      :paren,
-        on_lbracket:    :bracket,
-      }.freeze
-
-      CLOSE_TOKEN_TYPES = {
-        on_rbrace:      :brace,
-        on_embexpr_end: :emb,
-        on_rparen:      :paren,
-        on_rbracket:    :bracket,
-      }.freeze
-
-      def compile_old_attribute(str)
-        raise RuntimeBuild unless valid_hash?(str)
-
-        attrs = parse_old_attributes(str)
-        assert_no_boolean_attributes!(attrs)
-
-        format_attributes(attrs).map do |key, value|
-          next true_attribute(key) if value == 'true'
-          assert_static_value!(value)   if NESTABLE_ATTRIBUTES.include?(key)
-          detect_joinable_value!(value) if JOIN_ATTRIBUTES.include?(key)
-
-          [:html, :attr, key, [:dynamic, value]]
-        end
-      rescue RuntimeBuild
-        # Give up static compilation when given string is invalid as ruby hash
-        [[:runtime, str]]
-      end
-
-      private
-
-      def valid_hash?(str)
-        sexp = Ripper.sexp(str)
-        return false unless sexp
-
-        sexp.flatten[1] == :hash
-      end
-
-      def format_attributes(attributes)
-        attributes = flatten_attributes(attributes)
-        ignore_falsy_values(attributes)
-      end
-
-      def ignore_falsy_values(attributes)
-        attributes = attributes.dup
-        attributes.each do |key, value|
-          attributes.delete(key) if IGNORED_EXPRESSIONS.include?(value)
-        end
-      end
-
-      # Give up static compilation when variables are detected.
-      def assert_static_value!(value)
-        tokens = Ripper.lex(value)
-        tokens.each do |token|
-          raise RuntimeBuild if type_of(token) == :on_ident
-        end
-      end
-
-      # Give up static compilation when the value is a variable or an array.
-      def detect_joinable_value!(value)
-        tokens = Ripper.lex(value)
-        tokens.each do |token|
-          raise RuntimeBuild if JOINABLE_TOKENS.include?(type_of(token))
-        end
-      end
-
-      # Give up static compilation when attributes have deletable
-      # attributes, such as 'checked'.
-      def assert_no_boolean_attributes!(attrs)
-        if BOOLEAN_ATTRIBUTES.any? { |key| attrs.keys.include?(key) }
-          raise RuntimeBuild
-        end
-      end
-
-      # Parse brace-balanced string and return the result as hash
-      def parse_old_attributes(str)
-        attributes = {}
-
-        split_hash(str).each do |attr|
-          tokens = Ripper.lex("{#{attr}").drop(1)
-          key = read_hash_key!(tokens)
-          val = read_hash_value!(tokens)
-
-          attributes[key] = val if key
-        end
-
-        attributes
-      end
-
-      def read_hash_value!(tokens)
-        skip_tokens!(tokens, :on_sp)
-        val = tokens.map(&:last).join.strip
-
-        if type_of(tokens.first) == :on_lbrace
-          val = parse_old_attributes(val)
-        end
-        val
-      end
-
-      def read_hash_key!(tokens)
-        skip_tokens!(tokens, :on_sp)
-
-        (row, col), type, str = tokens.shift
-        case type
-        when :on_label
-          str.gsub!(/:\Z/, '')
-        when :on_symbeg
-          if %w[:" :'].include?(str)
-            str = read_string!(tokens)
-          else
-            (row, col), type, str = tokens.shift
-          end
-          assert_rocket!(tokens)
-        when :on_tstring_beg
-          str = read_string!(tokens, assert_rocket: true)
-        end
-        str
-      end
-
-      def read_string!(tokens, assert_rocket: false)
-        _, type, str = tokens.shift
-        return '' if type == :on_tstring_end
-
-        next_token = tokens.shift
-        return str if RUBY_VERSION >= "2.2.0" && type_of(next_token) == :on_label_end
-
-        raise SyntaxError if type_of(next_token) != :on_tstring_end
-        assert_rocket!(tokens) if assert_rocket
-
-        str
-      end
-
-      def assert_rocket!(tokens, *types)
-        skip_tokens!(tokens, :on_sp)
-        _, type, str = tokens.shift
-
-        raise SyntaxError unless type == :on_op && str == '=>'
-      end
-
-      def split_hash(str)
-        columns = HashParser.assoc_columns(str)
-        columns = reject_nested_columns(str, columns)
-
-        splitted  = []
-        start_pos = 1
-        columns.each do |end_pos|
-          splitted << str.byteslice(start_pos...end_pos)
-          start_pos = end_pos + 1
-        end
-
-        splitted
-      end
-
-      def reject_nested_columns(str, columns)
-        result = []
-        counts = DEFAULT_COUNTS.dup
-
-        Ripper.lex(str).each do |(_, col), type, _|
-          if columns.include?(col) && counts.values.all?(&:zero?)
-            result << col
-          end
-          update_open_counts(counts, type)
-        end
-        result
-      end
-
-      def update_open_counts(counts, type)
-        case
-        when OPEN_TOKEN_TYPES[type]
-          counts[OPEN_TOKEN_TYPES[type]] += 1
-        when CLOSE_TOKEN_TYPES[type]
-          counts[CLOSE_TOKEN_TYPES[type]] -= 1
-        end
-      end
-
-      class HashParser < Ripper
-        attr_reader :columns
-
-        def self.assoc_columns(src)
-          parser = new(src)
-          parser.parse
-          parser.columns
-        end
-
-        def initialize(src)
-          super(src)
-          @columns = []
-        end
-
-        private
-
-        def on_assoc_new(*args)
-          @columns << column - 1
-        end
-      end
-    end
-  end
-end