hamlit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8594e7acaa30584a12d923e97b4b7a21b407f054
+  data.tar.gz: 03eb5ce30ba76ac8c46df2f7b62dff6674569d22
+SHA512:
+  metadata.gz: f32944cc0f55a3f4aad6c4bf0bc52e36e7a1a24dd57963af0bbf575c1fa50d542d6e63d690c9067d65134fa2ae2f9877b770ae96357ae64d5b91977c05b6590a
+  data.tar.gz: fb37bdf58c61dfcd68807df744ca705b865225074fd147bbd339560cf4242ec1713977d02b2084d924343e8b4ec08383534934379dc47fd2cc99ade73f486a72

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+*.cache
+mkmf.log
+.sass-cache/

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,34 @@
+language: ruby
+rvm:
+  - 2.0.0
+  - 2.1
+  - 2.2
+sudo: false
+cache: bundler
+script:
+  - "bundle exec rake $TASK"
+gemfile:
+  - Gemfile
+  - spec/rails/Gemfile
+env:
+  - TASK=spec
+  - TASK=rails:spec
+  - TASK=bench TIME=10
+matrix:
+  allow_failures:
+    - env: TASK=bench TIME=10
+  exclude:
+    - env: TASK=spec
+      gemfile: spec/rails/Gemfile
+    - env: TASK=rails:spec
+      gemfile: Gemfile
+    - env: TASK=bench TIME=10
+      gemfile: spec/rails/Gemfile
+    - rvm: 2.1
+      env: TASK=rails:spec
+    - rvm: 2.1
+      env: TASK=bench TIME=10
+    - rvm: 2.0.0
+      env: TASK=rails:spec
+    - rvm: 2.0.0
+      env: TASK=bench TIME=10

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in hamlit.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,23 @@
+Copyright (c) 2015 Takashi Kokubun
+Copyright (c) 2006-2009 Hampton Catlin and Natalie Weizenbaum
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,45 @@
+# Hamlit [![Build Status](https://travis-ci.org/k0kubun/hamlit.svg?branch=master)](https://travis-ci.org/k0kubun/hamlit)
+
+Hamlit is a high performance [haml](https://github.com/haml/haml) implementation.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'hamlit'
+```
+
+or just replace `gem "haml"` with `gem "hamlit"`.
+
+## Features
+### Fast rendering
+
+Hamlit's rendering is **8.47x times faster** than original haml.
+
+```
+    hamlit:   133922.9 i/s
+    erubis:   123464.1 i/s - 1.08x slower
+      slim:   110404.3 i/s - 1.21x slower
+      faml:    92009.3 i/s - 1.46x slower
+      haml:    15810.4 i/s - 8.47x slower
+```
+
+[This benchmark](https://github.com/k0kubun/hamlit/blob/74ede1101f228828e343ceb1af481c45eaf0a1dd/benchmarks/benchmark.rb)
+is the same as [slim-template/slim](https://github.com/slim-template/slim)'s one for fairness.
+([The result on travis CI](https://travis-ci.org/k0kubun/hamlit/jobs/56403724))
+
+### Better parser
+
+Haml's attribute parser is not so good. For example, raises syntax error for `%a{ b: '}' }`.
+Hamlit's attribute parser is implemented with Ripper, which is an official lexer for Ruby,
+so it can able to parse such an attribute.
+
+### Passing haml-spec
+
+[haml/haml-spec](https://github.com/haml/haml-spec) is a basic suite of tests for Haml interpreters.
+For all test cases in haml-spec, Hamlit behaves the same as Haml (ugly mode only, which is used on production).
+
+## License
+
+MIT License

data/Rakefile

@@ -0,0 +1,34 @@
+require 'bundler/gem_tasks'
+
+desc 'Run benchmarks'
+task :bench do
+  exit system('bundle exec ruby benchmarks/benchmark.rb')
+end
+
+desc 'Run RSpec code examples'
+task :spec do
+  exit system('bundle exec rspec --pattern spec/hamlit/**{,/\*/\*\*\}/\*_spec.rb')
+end
+
+namespace :spec do
+  namespace :update do
+    desc 'Generate converted ugly haml-spec'
+    task :ugly do
+      system('cd spec && rake ugly')
+    end
+
+    desc 'Generate converted pretty haml-spec'
+    task :pretty do
+      system('cd spec && rake pretty')
+    end
+  end
+end
+
+namespace :rails do
+  desc 'Run Rails specs'
+  task :spec do
+    exit system('cd spec/rails && rake spec')
+  end
+end
+
+task default: [:spec, 'rails:spec']

data/benchmarks/benchmark.rb

@@ -0,0 +1,94 @@
+#!/usr/bin/env ruby
+
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'), File.dirname(__FILE__))
+
+require_relative './context'
+require 'benchmark/ips'
+
+require 'erb'
+require 'erubis'
+require 'faml'
+require 'haml'
+require 'slim'
+require 'tenjin'
+require 'tilt'
+require 'hamlit'
+
+class Benchmarks
+  def initialize(time)
+    @time     = time
+    @benches  = []
+    @versions = {}
+
+    @erb_code    = File.read(File.dirname(__FILE__) + '/view.erb')
+    @haml_code   = File.read(File.dirname(__FILE__) + '/view.haml')
+    @slim_code   = File.read(File.dirname(__FILE__) + '/view.slim')
+    @rbhtml_path = File.dirname(__FILE__) + '/view.rbhtml'
+
+    init_compiled_benches
+  end
+
+  def init_compiled_benches
+    erb         = ERB.new(@erb_code)
+    erubis      = Erubis::Eruby.new(@erb_code)
+    fast_erubis = Erubis::FastEruby.new(@erb_code)
+    haml_ugly   = Haml::Engine.new(@haml_code, format: :html5, ugly: true)
+    tenjin      = Tenjin::Engine.new.get_template(@rbhtml_path)
+
+    context = Context.new
+
+    haml_ugly.def_method(context, :run_haml_ugly)
+    context.instance_eval %{
+      def run_erb; #{erb.src}; end
+      def run_erubis; #{erubis.src}; end
+      def run_temple_erb; #{Temple::ERB::Engine.new.call @erb_code}; end
+      def run_fast_erubis; #{fast_erubis.src}; end
+      def run_slim_ugly; #{Slim::Engine.new.call @slim_code}; end
+      def run_faml; #{Faml::Engine.new.call @haml_code}; end
+      def run_tenjin; _buf = ''; #{tenjin.script}; end
+      def run_hamlit; #{Hamlit::Engine.new.call @haml_code}; end
+    }
+
+    bench('hamlit', Hamlit::VERSION) { context.run_hamlit }
+    bench('erubis', Erubis::VERSION) { context.run_erubis }
+    bench('slim', Slim::VERSION)     { context.run_slim_ugly }
+    bench('faml', Faml::VERSION)     { context.run_faml }
+    bench('haml', Haml::VERSION)     { context.run_haml_ugly }
+
+    if ENV['ALL']
+      erb_version = ERB.version.match(/\[([^ ]+)/)[1]
+      bench('tenjin', Tenjin::RELEASE)      { context.run_tenjin }
+      bench('fast erubis', Erubis::VERSION) { context.run_fast_erubis }
+      bench('temple erb', Temple::VERSION)  { context.run_temple_erb }
+      bench('erb', erb_version)             { context.run_erb }
+    end
+  end
+
+  def run
+    show_versions
+    result = Benchmark.ips do |x|
+      x.config(time: @time, warmup: 2)
+      @benches.each do |name, block|
+        x.report(name, &block)
+      end
+      x.compare!
+    end
+  end
+
+  private
+
+  def bench(name, version, &block)
+    @benches.push([name, block])
+    @versions[name] = version
+  end
+
+  def show_versions
+    puts 'Versions ' + '-' * 40
+    @versions.each do |name, version|
+      printf "%20s %10s\n", name, "v#{version}"
+    end
+  end
+end
+
+time = (ENV['TIME'] || 5).to_i
+Benchmarks.new(time).run

data/benchmarks/context.rb

@@ -0,0 +1,13 @@
+class Context
+  def header
+    'Colors'
+  end
+
+  def item
+    [
+      { name: 'red',   current: true,  url: '#red'   },
+      { name: 'green', current: false, url: '#green' },
+      { name: 'blue',  current: false, url: '#blue'  },
+    ]
+  end
+end

data/benchmarks/view.erb

@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+
+<html>
+  <head>
+    <title>Simple Benchmark</title>
+  </head>
+  <body>
+    <h1><%= header %></h1>
+    <% unless item.empty? %>
+      <ul>
+      <% for i in item %>
+        <% if i[:current] %>
+          <li><strong><%= i[:name] %></strong></li>
+        <% else %>
+          <li><a href="<%= i[:url] %>"><%= i[:name] %></a></li>
+        <% end %>
+      <% end %>
+      </ul>
+    <% else %>
+      <p>The list is empty.</p>
+    <% end %>
+  </body>
+</html>

data/benchmarks/view.haml

@@ -0,0 +1,18 @@
+!!! html
+
+%html
+  %head
+    %title Simple Benchmark
+  %body
+    %h1= header
+    - unless item.empty?
+      %ul
+        - for i in item
+          - if i[:current]
+            %li
+              %strong= i[:name]
+          - else
+            %li
+              %a{:href => i[:url]}= i[:name]
+    - else
+      %p The list is empty.

data/benchmarks/view.rbhtml

@@ -0,0 +1,23 @@
+<!DOCTYPE HTML>
+
+<html>
+  <head>
+    <title>Simple Benchmark</title>
+  </head>
+  <body>
+    <h1>#{ header }</h1>
+    <?rb unless item.empty? ?>
+      <ul>
+      <?rb for i in item ?>
+        <?rb if i[:current] ?>
+          <li><strong>#{ i[:name] }</strong></li>
+        <?rb else ?>
+          <li><a href="#{ i[:url] }">#{ i[:name] }</a></li>
+        <?rb end ?>
+      <?rb end ?>
+      </ul>
+    <?rb else ?>
+      <p>The list is empty.</p>
+    <?rb end ?>
+  </body>
+</html>

data/benchmarks/view.slim

@@ -0,0 +1,17 @@
+doctype html
+html
+  head
+    title Simple Benchmark
+  body
+    h1 == header
+    - unless item.empty?
+      ul
+        - for i in item
+          - if i[:current]
+            li
+              strong == i[:name]
+          - else
+            li
+              a href==i[:url] == i[:name]
+    - else
+      p The list is empty.

data/bin/hamlit

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

data/hamlit.gemspec

@@ -0,0 +1,40 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'hamlit/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "hamlit"
+  spec.version       = Hamlit::VERSION
+  spec.authors       = ["Takashi Kokubun"]
+  spec.email         = ["takashikkbn@gmail.com"]
+  spec.summary       = %q{Yet another haml implementation}
+  spec.description   = %q{Yet another haml implementation}
+  spec.homepage      = "https://github.com/k0kubun/hamlit"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "temple"
+  spec.add_dependency "thor"
+  spec.add_dependency "tilt"
+  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "coffee-script"
+  spec.add_development_dependency "erubis"
+  spec.add_development_dependency "faml"
+  spec.add_development_dependency "haml"
+  spec.add_development_dependency "less"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "redcarpet"
+  spec.add_development_dependency "rspec", ">= 3"
+  spec.add_development_dependency "sass"
+  spec.add_development_dependency "slim"
+  spec.add_development_dependency "tenjin"
+  spec.add_development_dependency "therubyracer"
+  spec.add_development_dependency "unindent"
+end

data/lib/hamlit/attribute.rb

@@ -0,0 +1,31 @@
+require 'hamlit/concerns/attribute_builder'
+require 'temple/utils'
+
+# Hamlit::Attribute is a module to compile old-style attributes which
+# can be compiled only on runtime. If you write old-style attributes
+# which is not valid as Ruby hash, the attributes are compiled on runtime.
+#
+# Note that you should avoid writing such a template for performance.
+module Hamlit
+  class Attribute
+    include Concerns::AttributeBuilder
+
+    def self.build(quote, attributes)
+      builder = self.new(quote)
+      builder.build(attributes)
+    end
+
+    def initialize(quote)
+      @quote = quote
+    end
+
+    def build(attributes)
+      result = ''
+      flatten_attributes(attributes).each do |key, value|
+        escaped = Temple::Utils.escape_html(value)
+        result += " #{key}=#{@quote}#{escaped}#{@quote}"
+      end
+      result
+    end
+  end
+end

data/lib/hamlit/cli.rb

@@ -0,0 +1,89 @@
+require 'hamlit'
+require 'thor'
+
+module Hamlit
+  class CLI < Thor
+    IGNORED_COMPILERS = ['HTML'].freeze
+
+    desc 'render HAML', 'Render haml template'
+    option :ugly, type: :boolean, aliases: ['-u']
+    def render(file)
+      code = generate_code(file)
+      puts eval(code)
+    end
+
+    desc 'compile HAML', 'Show generated rendering code'
+    option :ugly, type: :boolean, aliases: ['-u']
+    def compile(file)
+      code = generate_code(file)
+      puts code
+    end
+
+    desc 'temple HAML', 'Show a compile result of hamlit AST'
+    option :ugly, type: :boolean, aliases: ['-u']
+    def temple(file)
+      pp generate_temple_ast(file)
+    end
+
+    desc 'parse HAML', 'Show parse result'
+    def parse(file)
+      pp generate_hamlit_ast(file)
+    end
+
+    private
+
+    # Flexible default_task, compatible with haml's CLI
+    def method_missing(*args)
+      return super(*args) if args.length > 1
+
+      render(args.first.to_s)
+    end
+
+    def generate_code(file)
+      template = File.read(file)
+      Hamlit::Engine.new(options).call(template)
+    end
+
+    def generate_temple_ast(file)
+      chain = Hamlit::Engine.chain.map(&:first).map(&:to_s)
+      compilers = chain.select do |compiler|
+        compiler =~ /\AHamlit::/ && !ignored_compilers.include?(compiler)
+      end
+
+      template = File.read(file)
+      compilers.inject(template) do |exp, compiler|
+        Module.const_get(compiler).new(options).call(exp)
+      end
+    end
+
+    def generate_hamlit_ast(file)
+      template = File.read(file)
+      Hamlit::Parser.new.call(template)
+    end
+
+    # Enable colored pretty printing only for development environment.
+    # I don't think it is a good idea to add pry as runtime dependency
+    # just for debug color printing.
+    def pp(arg)
+      begin
+        require 'pry'
+        Pry::ColorPrinter.pp(arg)
+      rescue LoadError
+        require 'pp'
+        super(arg)
+      end
+    end
+
+    def ignored_compilers
+      IGNORED_COMPILERS.map { |name| "Hamlit::#{name}" }
+    end
+
+    def options
+      symbolize_keys(super)
+    end
+
+    def symbolize_keys(hash)
+      {}.tap { |h| hash.each { |k, v| h[k.to_sym] = v } }
+    end
+  end
+end

data/lib/hamlit/compiler.rb

@@ -0,0 +1,24 @@
+require 'hamlit/compilers/attributes'
+require 'hamlit/compilers/comment'
+require 'hamlit/compilers/doctype'
+require 'hamlit/compilers/dynamic'
+require 'hamlit/compilers/filter'
+require 'hamlit/compilers/preserve'
+require 'hamlit/compilers/script'
+require 'hamlit/compilers/strip'
+require 'hamlit/compilers/text'
+require 'temple/html/filter'
+
+module Hamlit
+  class Compiler < Temple::HTML::Filter
+    include Compilers::Attributes
+    include Compilers::Comment
+    include Compilers::Doctype
+    include Compilers::Dynamic
+    include Compilers::Filter
+    include Compilers::Preserve
+    include Compilers::Script
+    include Compilers::Strip
+    include Compilers::Text
+  end
+end

data/lib/hamlit/compilers/attributes.rb

@@ -0,0 +1,78 @@
+require 'hamlit/compilers/new_attribute'
+require 'hamlit/compilers/old_attribute'
+require 'hamlit/concerns/included'
+
+module Hamlit
+  module Compilers
+    module Attributes
+      extend Concerns::Included
+      include Compilers::NewAttribute
+      include Compilers::OldAttribute
+
+      included do
+        define_options :format, :attr_quote
+      end
+
+      def on_haml_attrs(*attrs)
+        attrs = compile_attributes(attrs)
+        attrs = join_ids(attrs)
+        attrs = combine_classes(attrs)
+        attrs = pull_class_first(attrs)
+        [:html, :attrs, *attrs]
+      end
+
+      private
+
+      def compile_attributes(exps)
+        attrs = []
+        exps.each do |exp|
+          case exp
+          when /\A\(.+\)\Z/
+            attrs += compile_new_attribute(exp)
+          when /\A{.+}\Z/
+            attrs += compile_old_attribute(exp)
+          else
+            attrs << compile(exp)
+          end
+        end
+        attrs
+      end
+
+      def pull_class_first(attrs)
+        class_attrs = filter_attrs(attrs, 'class')
+        combine_classes(class_attrs) + (attrs - class_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 filter_attrs(attrs, target)
+        class_attrs = attrs.select do |html, attr, name, content|
+          name == target
+        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
+    end
+  end
+end

data/lib/hamlit/compilers/comment.rb

@@ -0,0 +1,13 @@
+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