ultra-lite-tool 0.0.1

data/haml-7.2.0/Rakefile

@@ -0,0 +1,48 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new do |t|
+  t.libs << 'lib' << 'test'
+  files = Dir['test/haml/**/*_test.rb']
+  t.ruby_opts = %w[-rtest_helper]
+  t.test_files = files
+  t.verbose = true
+end
+task :test
+
+desc 'bench task for CI'
+task :bench do
+  if ENV['SLIM_BENCH'] == '1'
+    cmd = %w[bundle exec ruby benchmark/slim/run-benchmarks.rb]
+  else
+    cmd = ['bin/bench', 'bench', ('-c' if ENV['COMPILE'] == '1'), *ENV['TEMPLATE'].split(',')].compact
+  end
+  exit system(*cmd)
+end
+
+namespace :doc do
+  task :sass do
+    require 'sass'
+    Dir["yard/default/**/*.sass"].each do |sass|
+      File.open(sass.gsub(/sass$/, 'css'), 'w') do |f|
+        f.write(Sass::Engine.new(File.read(sass)).render)
+      end
+    end
+  end
+
+  desc "List all undocumented methods and classes."
+  task :undocumented do
+    command = 'yard --list --query '
+    command << '"object.docstring.blank? && '
+    command << '!(object.type == :method && object.is_alias?)"'
+    sh command
+  end
+end
+
+desc "Generate documentation"
+task(:doc => 'doc:sass') {sh "yard"}
+
+desc "Generate documentation incrementally"
+task(:redoc) {sh "yard -c"}
+
+task default: :test

data/haml-7.2.0/bin/bench

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'haml'
+require 'thor'
+require 'benchmark/ips'
+require_relative '../benchmark/utils/benchmark_ips_extension'
+
+class Bench < Thor
+  class_option :show_template, type: :boolean, aliases: ['-t']
+
+  desc 'bench HAML', 'Benchmark haml template'
+  option :compile, type: :boolean, aliases: ['-c']
+  option :show_code, type: :boolean, aliases: ['-s']
+  def bench(*files)
+    files.each { |file| render(file) }
+    files.each { |file| compile(file) if options[:compile] }
+    files.each { |file| code(file) if options[:show_code] }
+  end
+
+  desc 'compile HAML', 'Benchmark compilation'
+  def compile(file)
+    puts "#{?= * 49}\n Compilation: #{file}\n#{?= * 49}"
+    haml = File.read(file)
+
+    Benchmark.ips do |x|
+      x.report("haml v#{Haml::VERSION}") { Haml::Engine.new.call(haml) }
+      x.compare!
+    end
+  end
+
+  desc 'render HAML', 'Benchmark rendering'
+  def render(file)
+    puts "#{?= * 49}\n Rendering: #{file}\n#{?= * 49}"
+    haml = File.read(file)
+    puts haml + "\n" if options[:show_template]
+    object = Object.new
+    ruby_file = file.gsub(/\.haml\z/, '.rb')
+    if File.exist?(ruby_file)
+      object.instance_eval(File.read(ruby_file))
+    end
+
+    object.instance_eval "def haml; #{Haml::Engine.new.call(haml)}; end"
+
+    Benchmark.ips do |x|
+      x.report("haml v#{Haml::VERSION}") { object.haml }
+      x.compare!
+    end
+  end
+
+  desc 'code HAML', 'Show compiled code'
+  def code(file)
+    haml = File.read(file)
+    puts "\n#{?= * 49}\n Haml Source: #{file}\n#{?= * 49}"
+    puts Haml::Engine.new.call(haml)
+  end
+
+  private
+
+  def method_missing(*args)
+    return super if args.length > 1
+    render(args.first.to_s)
+  end
+end
+
+Bench.start

data/haml-7.2.0/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'haml'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+require 'irb'
+IRB.start

data/haml-7.2.0/bin/ruby

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+bundle exec ruby -Ilib:test -rtest_helper $@

data/haml-7.2.0/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/haml-7.2.0/bin/stackprof

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'haml'
+require 'stackprof'
+
+def open_flamegraph(report)
+  temp = `mktemp /tmp/stackflame-XXXXXXXX`.strip
+  data_path = "#{temp}.js"
+  system("mv #{temp} #{data_path}")
+
+  File.open(data_path, 'w') do |f|
+    report.print_flamegraph(f)
+  end
+
+  viewer_path = File.join(`bundle show stackprof`.strip, 'lib/stackprof/flamegraph/viewer.html')
+  url = "file://#{viewer_path}?data=#{data_path}"
+  system(%Q[osascript -e 'open location "#{url}"'])
+end
+
+haml = File.read(ARGV.first)
+StackProf.start(mode: :wall, interval: 1, raw: false)
+Haml::Engine.new.call(haml)
+StackProf.stop
+
+report = StackProf::Report.new(StackProf.results)
+report.print_text(false)

data/haml-7.2.0/bin/test

@@ -0,0 +1,24 @@
+#!/bin/bash
+
+VERSIONS=(
+  2.1.10
+  2.2.5
+  2.3.1
+)
+
+set -e
+trap 'echo "${VERSIONS[2]}" > .ruby-version' 0
+
+function test_with() {
+  version=$1
+  rbenv local $version
+  if ! bundle check > /dev/null; then
+    bundle install
+  fi
+  ruby -v
+  bundle exec rake test
+}
+
+for version in ${VERSIONS[@]}; do
+  test_with $version
+done

data/haml-7.2.0/exe/haml

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+$:.unshift File.expand_path('../lib', __dir__)
+require 'haml/cli'
+
+Haml::CLI.start(ARGV)

data/haml-7.2.0/haml.gemspec

@@ -0,0 +1,45 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'haml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'haml'
+  spec.version       = Haml::VERSION
+  spec.authors       = ['Natalie Weizenbaum', 'Hampton Catlin', 'Norman Clarke', 'Akira Matsuda', 'Takashi Kokubun']
+  spec.email         = ['haml@googlegroups.com', 'ronnie@dio.jp']
+
+  spec.summary       = %q{An elegant, structured (X)HTML/XML templating engine.}
+  spec.description   = %q{An elegant, structured (X)HTML/XML templating engine.}
+  spec.homepage      = 'https://haml.info'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|sample|benchmark)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.metadata      = { 'rubygems_mfa_required' => 'true' }
+
+  spec.metadata["changelog_uri"] = "https://github.com/haml/haml/releases"
+  spec.metadata["source_code_uri"] = "https://github.com/haml/haml"
+
+  spec.required_ruby_version = '>= 3.2.0'
+
+  spec.add_dependency 'temple', '>= 0.8.2'
+  spec.add_dependency 'thor'
+  spec.add_dependency 'tilt'
+
+  spec.add_development_dependency 'benchmark_driver'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'coffee-script'
+  spec.add_development_dependency 'erubi'
+  spec.add_development_dependency 'less'
+  spec.add_development_dependency 'minitest-reporters', '~> 1.1'
+  spec.add_development_dependency 'rails', '>= 4.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'sass'
+  spec.add_development_dependency 'slim'
+  spec.add_development_dependency 'string_template'
+  spec.add_development_dependency 'unindent'
+end

data/haml-7.2.0/lib/haml/ambles.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+module Haml
+  class Ambles < Temple::Filter
+    define_options :preamble, :postamble
+
+    def initialize(*)
+      super
+      @preamble = options[:preamble]
+      @postamble = options[:postamble]
+    end
+
+    def call(ast)
+      ret = [:multi]
+      ret << [:static, @preamble] if @preamble
+      ret << ast
+      ret << [:static, @postamble] if @postamble
+      ret
+    end
+  end
+end

data/haml-7.2.0/lib/haml/attribute_builder.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+require 'haml/object_ref'
+
+module Haml::AttributeBuilder
+  class << self
+    def build(escape_attrs, quote, format, object_ref, *hashes)
+      hashes << Haml::ObjectRef.parse(object_ref) if object_ref
+      buf  = []
+      hash = merge_all_attrs(hashes)
+
+      keys = hash.keys.sort!
+      keys.each do |key|
+        case key
+        when 'id'
+          buf << " id=#{quote}#{build_id(escape_attrs, *hash[key])}#{quote}"
+        when 'class'
+          buf << " class=#{quote}#{build_class(escape_attrs, *hash[key])}#{quote}"
+        when 'data'
+          buf << build_data(escape_attrs, quote, format, *hash[key])
+        when 'aria'
+          buf << build_aria(escape_attrs, quote, format, *hash[key])
+        when *Haml::BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          build_boolean!(escape_attrs, quote, format, buf, key, hash[key])
+        else
+          buf << " #{key}=#{quote}#{escape_html(escape_attrs, hash[key].to_s)}#{quote}"
+        end
+      end
+      buf.join
+    end
+
+    def build_id(escape_attrs, *values)
+      escape_html(escape_attrs, values.flatten.select { |v| v }.join('_'))
+    end
+
+    def build_class(escape_attrs, *values)
+      if values.size == 1
+        value = values.first
+        case
+        when value.is_a?(String)
+          # noop
+        when value.is_a?(Array)
+          value = value.flatten.select { |v| v }.map(&:to_s).uniq.join(' ')
+        when value
+          value = value.to_s
+        else
+          return ''
+        end
+        return escape_html(escape_attrs, value)
+      end
+
+      classes = []
+      values.each do |value|
+        case
+        when value.is_a?(String)
+          classes += value.split(' ')
+        when value.is_a?(Array)
+          classes += value.flatten.select { |v| v }
+        when value
+          classes << value.to_s
+        end
+      end
+      escape_html(escape_attrs, classes.map(&:to_s).uniq.join(' '))
+    end
+
+    def build_data(escape_attrs, quote, format, *hashes)
+      build_data_attribute(:data, escape_attrs, quote, format, *hashes)
+    end
+
+    def build_aria(escape_attrs, quote, format, *hashes)
+      build_data_attribute(:aria, escape_attrs, quote, format, *hashes)
+    end
+
+    private
+
+    def build_data_attribute(key, escape_attrs, quote, format, *hashes)
+      attrs = []
+      if hashes.size > 1 && hashes.all? { |h| h.is_a?(Hash) }
+        data_value = merge_all_attrs(hashes)
+      else
+        data_value = hashes.last
+      end
+      hash = flatten_attributes(key => data_value)
+
+      hash.sort_by(&:first).each do |key, value|
+        case value
+        when true
+          build_boolean!(escape_attrs, quote, format, attrs, key, value)
+        when nil, false
+          # noop
+        else
+          attrs << " #{key}=#{quote}#{escape_html(escape_attrs, value.to_s)}#{quote}"
+        end
+      end
+      attrs.join
+    end
+
+    def flatten_attributes(attributes)
+      flattened = {}
+
+      attributes.each do |key, value|
+        case value
+        when attributes
+        when Hash
+          flatten_attributes(value).each do |k, v|
+            if k.nil?
+              flattened[key] = v
+            else
+              flattened["#{key}-#{k.to_s.tr('_', '-')}"] = v
+            end
+          end
+        else
+          flattened[key] = value if value
+        end
+      end
+      flattened
+    end
+
+    def merge_all_attrs(hashes)
+      merged = {}
+      hashes.each do |hash|
+        unless hash.is_a?(Hash)
+          raise ArgumentError, "Non-hash object is given to attributes!"
+        end
+        hash.each do |key, value|
+          key = key.to_s
+          case key
+          when 'id', 'class', 'data', 'aria'
+            merged[key] ||= []
+            merged[key] << value
+          else
+            merged[key] = value
+          end
+        end
+      end
+      merged
+    end
+
+    def build_boolean!(escape_attrs, quote, format, buf, key, value)
+      case value
+      when true
+        case format
+        when :xhtml
+          buf << " #{key}=#{quote}#{key}#{quote}"
+        else
+          buf << " #{key}"
+        end
+      when false, nil
+        # omitted
+      else
+        buf << " #{key}=#{quote}#{escape_html(escape_attrs, value)}#{quote}"
+      end
+    end
+
+    def escape_html(escape_attrs, str)
+      if escape_attrs
+        Haml::Util.escape_html(str)
+      else
+        str
+      end
+    end
+  end
+end

data/haml-7.2.0/lib/haml/attribute_compiler.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require 'haml/attribute_builder'
+require 'haml/attribute_parser'
+require 'haml/ruby_expression'
+
+module Haml
+  # The list of boolean attributes. You may add custom attributes to this constant.
+  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 download]
+
+  class AttributeCompiler
+    def initialize(identity, options)
+      @identity = identity
+      @quote  = options[:attr_quote]
+      @format = options[:format]
+      @escape_attrs = options[:escape_attrs]
+    end
+
+    def compile(node)
+      hashes = []
+      if node.value[:object_ref] != :nil || !AttributeParser.available?
+        return runtime_compile(node)
+      end
+      [node.value[:dynamic_attributes].new, node.value[:dynamic_attributes].old].compact.each do |attribute_str|
+        hash = AttributeParser.parse(attribute_str)
+        return runtime_compile(node) if hash.nil? || hash.any? { |_key, value| value.empty? }
+        hashes << hash
+      end
+      static_compile(node.value[:attributes], hashes)
+    end
+
+    private
+
+    def runtime_compile(node)
+      attrs = []
+      attrs.unshift(node.value[:attributes].inspect) if node.value[:attributes] != {}
+
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect, node.value[:object_ref]] + attrs
+      [:html, :attrs, [:dynamic, "::Haml::AttributeBuilder.build(#{args.join(', ')}, #{node.value[:dynamic_attributes].to_literal})"]]
+    end
+
+    def static_compile(static_hash, dynamic_hashes)
+      temple = [:html, :attrs]
+      keys = [*static_hash.keys, *dynamic_hashes.map(&:keys).flatten].uniq.sort
+      keys.each do |key|
+        values = [[:static, static_hash[key]], *dynamic_hashes.map { |h| [:dynamic, h[key]] }]
+        values.select! { |_, exp| exp != nil }
+
+        case key
+        when 'id'
+          compile_id!(temple, key, values)
+        when 'class'
+          compile_class!(temple, key, values)
+        when 'data', 'aria'
+          compile_data!(temple, key, values)
+        when *BOOLEAN_ATTRIBUTES, /\Adata-/, /\Aaria-/
+          compile_boolean!(temple, key, values)
+        else
+          compile_common!(temple, key, values)
+        end
+      end
+      temple
+    end
+
+    def compile_id!(temple, key, values)
+      build_code = attribute_builder(:id, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_class!(temple, key, values)
+      build_code = attribute_builder(:class, values)
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:html, :attr, key, [:static, eval(build_code).to_s]]
+      else
+        temple << [:html, :attr, key, [:dynamic, build_code]]
+      end
+    end
+
+    def compile_data!(temple, key, values)
+      args = [@escape_attrs.inspect, "#{@quote.inspect}.freeze", @format.inspect, values.map { |v| literal_for(v) }]
+      build_code = "::Haml::AttributeBuilder.build_#{key}(#{args.join(', ')})"
+
+      if values.all? { |type, exp| type == :static || Temple::StaticAnalyzer.static?(exp) }
+        temple << [:static, eval(build_code).to_s]
+      else
+        temple << [:dynamic, build_code]
+      end
+    end
+
+    def compile_boolean!(temple, key, values)
+      exp = literal_for(values.last)
+
+      if values.last.first == :static || Temple::StaticAnalyzer.static?(exp)
+        value = eval(exp)
+        case value
+        when true then temple << [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]
+        when false, nil
+        else temple << [:html, :attr, key, [:fescape, @escape_attrs, [:static, value.to_s]]]
+        end
+      else
+        var = @identity.generate
+        temple << [
+          :case, "(#{var} = (#{exp}))",
+          ['true', [:html, :attr, key, @format == :xhtml ? [:static, key] : [:multi]]],
+          ['false, nil', [:multi]],
+          [:else, [:multi, [:static, " #{key}=#{@quote}"], [:fescape, @escape_attrs, [:dynamic, var]], [:static, @quote]]],
+        ]
+      end
+    end
+
+    def compile_common!(temple, key, values)
+      temple << [:html, :attr, key, [:fescape, @escape_attrs, values.last]]
+    end
+
+    def attribute_builder(type, values)
+      args = [@escape_attrs.inspect, *values.map { |v| literal_for(v) }]
+      "::Haml::AttributeBuilder.build_#{type}(#{args.join(', ')})"
+    end
+
+    def literal_for(value)
+      type, exp = value
+      type == :static ? "#{exp.inspect}.freeze" : exp
+    end
+  end
+end

data/haml-7.2.0/lib/haml/attribute_parser.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+require 'haml/ruby_expression'
+
+module Haml
+  class AttributeParser
+    class ParseSkip < StandardError
+    end
+
+    # @return [TrueClass, FalseClass] - return true if AttributeParser.parse can be used.
+    def self.available?
+      # TruffleRuby doesn't have Ripper.lex
+      defined?(Ripper) && Ripper.respond_to?(:lex) && Temple::StaticAnalyzer.available?
+    end
+
+    def self.parse(text)
+      self.new.parse(text)
+    end
+
+    def parse(text)
+      exp = wrap_bracket(text)
+      return if Temple::StaticAnalyzer.syntax_error?(exp)
+
+      hash = {}
+      tokens = Ripper.lex(exp)[1..-2] || []
+      each_attr(tokens) do |attr_tokens|
+        key = parse_key!(attr_tokens)
+        hash[key] = attr_tokens.map { |t| t[2] }.join.strip
+      end
+      hash
+    rescue ParseSkip
+      nil
+    end
+
+    private
+
+    def wrap_bracket(text)
+      text = text.strip
+      return text if text[0] == '{'
+      "{#{text}}"
+    end
+
+    def parse_key!(tokens)
+      _, type, str = tokens.shift
+      case type
+      when :on_sp
+        parse_key!(tokens)
+      when :on_label
+        str.tr(':', '')
+      when :on_symbeg
+        _, _, key = tokens.shift
+        assert_type!(tokens.shift, :on_tstring_end) if str != ':'
+        skip_until_hash_rocket!(tokens)
+        key
+      when :on_tstring_beg
+        _, _, key = tokens.shift
+        next_token = tokens.shift
+        unless next_token[1] == :on_label_end
+          assert_type!(next_token, :on_tstring_end)
+          skip_until_hash_rocket!(tokens)
+        end
+        key
+      else
+        raise ParseSkip
+      end
+    end
+
+    def assert_type!(token, type)
+      raise ParseSkip if token[1] != type
+    end
+
+    def skip_until_hash_rocket!(tokens)
+      until tokens.empty?
+        _, type, str = tokens.shift
+        break if type == :on_op && str == '=>'
+      end
+    end
+
+    def each_attr(tokens)
+      attr_tokens = []
+      open_tokens = Hash.new { |h, k| h[k] = 0 }
+
+      tokens.each do |token|
+        _, type, _ = token
+        case type
+        when :on_comma
+          if open_tokens.values.all?(&:zero?)
+            yield(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 :on_sp
+          next if attr_tokens.empty?
+        end
+
+        attr_tokens << token
+      end
+      yield(attr_tokens) unless attr_tokens.empty?
+    end
+  end
+end