fast_haml 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d18511a93b15141a266bc26d9fda1c988c6ed09a
+  data.tar.gz: adb2246bc9102aa0983ef003b1351e5effa3a80c
+SHA512:
+  metadata.gz: e9ba91139b2222b4d8c4e172c8e694f6d8dc107c474402cb8e115f0d8869886a89659eb35a1b4aa84010943675ebfe235539dfd872b610a27b63caa068096d6f
+  data.tar.gz: 1b111f4bf03b525f4ca15201907103654a8213fd1d20d47ac8b36412af2c70acfc3b6aaae462b7a9eb37ab5c587bff9420c92693c3a3e493523532526252a3ff

data/.gitignore

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

data/.gitmodules

@@ -0,0 +1,3 @@
+[submodule "haml-spec"]
+	path = haml-spec
+	url = https://github.com/haml/haml-spec

data/.rspec

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

data/.travis.yml

@@ -0,0 +1,25 @@
+language: ruby
+sudo: false
+rvm:
+  - 2.0.0
+  - 2.1
+  - 2.2
+  - ruby-head
+gemfile:
+  - gemfiles/rails_4.0.gemfile
+  - gemfiles/rails_4.1.gemfile
+  - gemfiles/rails_4.2.gemfile
+  - gemfiles/rails_edge.gemfile
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - gemfile: gemfiles/rails_edge.gemfile
+    # https://github.com/rspec/rspec-rails/pull/1264
+    - rvm: 2.2
+      gemfile: gemfiles/rails_4.0.gemfile
+  exclude:
+    # Rails 5 requires to run on Ruby 2.2.0 or newer.
+    - rvm: 2.0.0
+      gemfile: gemfiles/rails_edge.gemfile
+    - rvm: 2.1
+      gemfile: gemfiles/rails_edge.gemfile

data/Appraisals

@@ -0,0 +1,26 @@
+appraise 'rails-4.0' do
+  gem 'rails', '~> 4.0.0'
+  gem 'rspec-rails'
+  gem 'sqlite3'
+end
+
+appraise 'rails-4.1' do
+  gem 'rails', '~> 4.1.0'
+  gem 'rspec-rails'
+  gem 'sqlite3'
+end
+
+appraise 'rails-4.2' do
+  gem 'rails', '~> 4.2.0'
+  gem 'rspec-rails'
+  gem 'sqlite3'
+end
+
+appraise 'rails-edge' do
+  gem 'rails', git: 'https://github.com/rails/rails'
+  gem 'arel', git: 'https://github.com/rails/arel'
+  gem 'rspec-rails'
+  gem 'sqlite3'
+end
+
+# vim: set ft=ruby:

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## 0.1.0 (2015-02-23)
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fast_haml.gemspec
+gemspec
+
+gem 'rails'
+gem 'rspec-rails'
+gem 'sqlite3'

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Kohei Suzuki
+
+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,96 @@
+# FastHaml
+[![Build Status](https://travis-ci.org/eagletmt/fast_haml.svg)](https://travis-ci.org/eagletmt/fast_haml)
+[![Coverage Status](https://coveralls.io/repos/eagletmt/fast_haml/badge.svg)](https://coveralls.io/r/eagletmt/fast_haml)
+[![Code Climate](https://codeclimate.com/github/eagletmt/fast_haml/badges/gpa.svg)](https://codeclimate.com/github/eagletmt/fast_haml)
+
+Faster implementation of Haml template language.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fast_haml'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install fast_haml
+
+## Usage
+
+Just replace your `gem 'haml'` with `gem 'fast_haml'` .
+
+## Incompatibilities
+There are several incompatibilities.
+
+### Hash attributes
+Hash attributes are only supported to "data" attributes.
+
+With original haml, `%span{foo: {bar: 'baz'}}` is rendered as `<span foo-bar='baz'></span>` .
+With fast_haml, it's rendered as `<span foo='{:bar=&gt;&quot;baz&quot;}'></span>` .
+
+Only "data" attributes are converted to hyphenated attributes.
+
+### HTML-escape by default
+Even with non-Rails project, all string are HTML-escaped.
+
+### "ugly" mode only
+Only "ugly" mode in original haml is supported.
+
+```haml
+%div
+  %div hello
+```
+
+is always rendered as
+
+```html
+<div>
+<div>hello</div>
+</div>
+```
+
+It's equivalent to haml's "ugly" mode.
+
+### Others
+If you find other incompatibility, please report it to me :-p.
+
+## Why fast_haml is faster?
+### Temple backend
+I use [temple](https://github.com/judofyr/temple) to achieve faster template rendering.
+It's used by [slim](https://github.com/slim-template/slim) template language & engine which is known as fast.
+
+1. FastHaml::Parser converts source language (Haml template) to own AST (FastHaml::Ast) .
+    - You can see the FastHaml::Ast by running `fast_haml parse template.haml` .
+2. FastHaml::Compiler compiles FastHaml::Ast into Temple AST.
+    - You can see the Temple AST by running `fast_haml temple template.haml` .
+3. Temple compiles its AST into Ruby code.
+    - You can see the Ruby code by running `fast_haml compile template.haml` .
+    - During this process, several optimizations are performed such as Temple::Filters::MultiFlattener and Temple::Filters::StaticMerger.
+
+### Attribute optimization
+Although Haml allows arbitrary Ruby hash in the attribute syntax, most attributes are written in hash literal form.
+All keys are string or symbol literals (i.e., not dynamic values) in typical case.
+
+```haml
+%div{class: some_helper_method(current_user)}
+  %a{href: foo_path(@item)}= @item.name
+```
+
+There is an optimization chance if we could know the value is String.
+I introduced incompatibility to expand the chance: all attribute values are converted to String by `#to_s` except for `id`, `class` and `data` .
+This will enable us to avoid runtime expensive hash merging and rendering.
+The runtime hash merging is implemented by C extension in fast_haml.
+
+## Contributing
+
+1. Fork it ( https://github.com/eagletmt/fast_haml/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,11 @@
+require 'bundler/gem_tasks'
+
+task :default => [:compile, :spec]
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('attribute_builder') do |ext|
+  ext.lib_dir = 'lib/fast_haml'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)

data/benchmark/rendering.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env ruby
+require 'benchmark/ips'
+require 'haml'
+require 'fast_haml'
+require 'escape_utils/html/haml'
+
+template = ARGV[0]
+unless template
+  $stderr.puts "Usage: #{$0} template.haml"
+  exit 1
+end
+
+Benchmark.ips do |x|
+  obj = Object.new
+
+  Haml::Engine.new(File.read(template), ugly: true, escape_html: true).def_method(obj, :haml)
+  code = FastHaml::Engine.new.call(File.read(template))
+  obj.instance_eval("def fast_haml; #{code}; end")
+
+  x.report('Haml rendering') do
+    obj.haml
+  end
+
+  x.report('FastHaml rendering') do
+    obj.fast_haml
+  end
+
+  x.compare!
+end

data/bin/fast_haml

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require 'fast_haml/cli'
+
+FastHaml::CLI.start(ARGV)

data/ext/attribute_builder/attribute_builder.c

@@ -0,0 +1,259 @@
+#include <ruby.h>
+#include <ruby/version.h>
+
+#if (RUBY_API_VERSION_MAJOR > 2) || (RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR >= 1)
+/* define nothing */
+#else
+# define RARRAY_AREF(a, i) RARRAY_PTR(a)[i]
+# define rb_ary_new_capa rb_ary_new2
+#endif
+
+VALUE rb_mAttributeBuilder;
+static ID id_keys, id_sort_bang, id_merge_bang, id_temple, id_utils, id_escape_html, id_gsub, id_to_s;
+
+static void
+concat_array_attribute(VALUE attributes, VALUE hash, VALUE key)
+{
+  VALUE v;
+
+  Check_Type(hash, T_HASH);
+  v = rb_hash_delete(hash, key);
+  if (!NIL_P(v)) {
+    VALUE ary;
+
+    v = rb_Array(v);
+    ary = rb_hash_lookup(attributes, key);
+    Check_Type(ary, T_ARRAY);
+    rb_ary_concat(ary, v);
+  }
+}
+
+static int
+stringify_keys_i(VALUE key, VALUE value, VALUE arg)
+{
+  key = rb_funcall(key, id_to_s, 0);
+  rb_hash_aset(arg, key, value);
+  return ST_CONTINUE;
+}
+
+static VALUE
+stringify_keys(VALUE hash)
+{
+  VALUE h = rb_hash_new();
+  rb_hash_foreach(hash, stringify_keys_i, h);
+  return h;
+}
+
+struct normalize_data_i2_arg {
+  VALUE key, normalized;
+};
+
+static int
+normalize_data_i2(VALUE key, VALUE value, VALUE ptr)
+{
+  struct normalize_data_i2_arg *arg = (struct normalize_data_i2_arg *)ptr;
+  VALUE k = rb_funcall(arg->key, id_to_s, 0);
+
+  k = rb_funcall(k, id_gsub, 2, rb_str_new_cstr("_"), rb_str_new_cstr("-"));
+  rb_str_cat(k, "-", 1);
+  rb_str_append(k, key);
+  rb_hash_aset(arg->normalized, k, value);
+  return ST_CONTINUE;
+}
+
+static VALUE normalize_data(VALUE data);
+
+static int
+normalize_data_i(VALUE key, VALUE value, VALUE normalized)
+{
+  if (RB_TYPE_P(value, T_HASH)) {
+    struct normalize_data_i2_arg arg;
+    arg.key = key;
+    arg.normalized = normalized;
+    rb_hash_foreach(normalize_data(value), normalize_data_i2, (VALUE)(&arg));
+  } else {
+    key = rb_funcall(key, id_to_s, 0);
+    key = rb_funcall(key, id_gsub, 2, rb_str_new_cstr("_"), rb_str_new_cstr("-"));
+    rb_hash_aset(normalized, key, value);
+  }
+  return ST_CONTINUE;
+}
+
+static VALUE
+normalize_data(VALUE data)
+{
+  VALUE normalized;
+
+  Check_Type(data, T_HASH);
+  normalized = rb_hash_new();
+  rb_hash_foreach(data, normalize_data_i, normalized);
+  return normalized;
+}
+
+static void
+normalize(VALUE hash)
+{
+  VALUE keys = rb_funcall(hash, id_keys, 0);
+  const long len = RARRAY_LEN(keys);
+  long i;
+  for (i = 0; i < len; i++) {
+    VALUE key = RARRAY_AREF(keys, i);
+    const char *key_cstr = StringValueCStr(key);
+    VALUE value = rb_hash_lookup(hash, key);
+    if (RB_TYPE_P(value, T_HASH) && strcmp(key_cstr, "data") == 0) {
+      VALUE data, data_keys;
+      long data_len, j;
+
+      rb_hash_delete(hash, key);
+      data = normalize_data(value);
+      data_keys = rb_funcall(data, id_keys, 0);
+      rb_funcall(data_keys, id_sort_bang, 0);
+      data_len = RARRAY_LEN(data_keys);
+      for (j = 0; j < data_len; j++) {
+        VALUE data_key = RARRAY_AREF(data_keys, j);
+        VALUE k = rb_str_buf_new(5 + RSTRING_LEN(data_key));
+        rb_str_buf_cat(k, "data-", 5);
+        rb_str_buf_append(k, data_key);
+        rb_hash_aset(hash, k, rb_hash_lookup(data, data_key));
+      }
+    } else if (!RB_TYPE_P(value, T_TRUE)) {
+      rb_hash_aset(hash, key, rb_funcall(value, id_to_s, 0));
+    }
+  }
+}
+
+static void
+merge(VALUE attributes, int argc, VALUE *argv)
+{
+  int i;
+
+  for (i = 0; i < argc; i++) {
+    VALUE h;
+
+    Check_Type(argv[i], T_HASH);
+    h = stringify_keys(argv[i]);
+    concat_array_attribute(attributes, h, rb_str_new_cstr("class"));
+    concat_array_attribute(attributes, h, rb_str_new_cstr("id"));
+    normalize(h);
+    rb_funcall(attributes, id_merge_bang, 1, h);
+  }
+}
+
+static VALUE
+put_attribute(VALUE attr_quote, VALUE key, VALUE value)
+{
+  VALUE utils_class, str;
+  long len;
+
+  value = rb_funcall(value, id_to_s, 0);
+  utils_class = rb_const_get(rb_const_get(rb_cObject, id_temple), id_utils);
+  value = rb_funcall(utils_class, id_escape_html, 1, value);
+
+  len = 2 + 2*RSTRING_LEN(attr_quote) + RSTRING_LEN(key) + RSTRING_LEN(value);
+  str = rb_str_buf_new(len);
+  rb_str_buf_cat(str, " ", 1);
+  rb_str_buf_append(str, key);
+  rb_str_buf_cat(str, "=", 1);
+  rb_str_buf_append(str, attr_quote);
+  rb_str_buf_append(str, value);
+  rb_str_buf_append(str, attr_quote);
+  return str;
+}
+
+static VALUE
+build_attribute(VALUE attr_quote, VALUE key, VALUE value)
+{
+  const char *key_cstr = StringValueCStr(key);
+  if (strcmp(key_cstr, "class") == 0) {
+    long len;
+
+    Check_Type(value, T_ARRAY);
+    len = RARRAY_LEN(value);
+    if (len == 0) {
+      return rb_str_new_cstr("");
+    } else {
+      long i;
+      VALUE ary = rb_ary_new_capa(len);
+      for (i = 0; i < len; i++) {
+        VALUE v = RARRAY_AREF(value, i);
+        rb_ary_push(ary, rb_funcall(v, id_to_s, 0));
+      }
+      rb_funcall(ary, id_sort_bang, 0);
+      return put_attribute(attr_quote, key, rb_ary_join(ary, rb_str_new_cstr(" ")));
+    }
+  } else if (strcmp(key_cstr, "id") == 0) {
+    long len = RARRAY_LEN(value);
+
+    Check_Type(value, T_ARRAY);
+    len = RARRAY_LEN(value);
+    if (len == 0) {
+      return rb_str_new_cstr("");
+    } else {
+      long i;
+      VALUE ary = rb_ary_new_capa(len);
+      for (i = 0; i < len; i++) {
+        VALUE v = RARRAY_AREF(value, i);
+        rb_ary_push(ary, rb_funcall(v, id_to_s, 0));
+      }
+      return put_attribute(attr_quote, key, rb_ary_join(ary, rb_str_new_cstr("_")));
+    }
+  } else if (RB_TYPE_P(value, T_TRUE)) {
+    VALUE attr = rb_str_buf_new(1 + RSTRING_LEN(key));
+    rb_str_buf_cat(attr, " ", 1);
+    rb_str_buf_append(attr, key);
+    return attr;
+  } else {
+    return put_attribute(attr_quote, key, value);
+  }
+  return value;
+}
+
+static VALUE
+m_build(int argc, VALUE *argv, VALUE self)
+{
+  VALUE attr_quote, attributes, keys, buf;
+  long len, i;
+
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  attr_quote = argv[0];
+  attributes = rb_hash_new();
+  rb_hash_aset(attributes, rb_str_new_cstr("id"), rb_ary_new());
+  rb_hash_aset(attributes, rb_str_new_cstr("class"), rb_ary_new());
+  merge(attributes, argc-1, argv+1);
+
+  keys = rb_funcall(attributes, id_keys, 0);
+  rb_funcall(keys, id_sort_bang, 0);
+  len = RARRAY_LEN(keys);
+  buf = rb_ary_new_capa(len);
+  for (i = 0; i < len; i++) {
+    VALUE k = RARRAY_AREF(keys, i);
+    rb_ary_push(buf, build_attribute(attr_quote, k, rb_hash_lookup(attributes, k)));
+  }
+
+  return rb_ary_join(buf, Qnil);
+}
+
+static VALUE
+m_normalize_data(VALUE self, VALUE data)
+{
+  return normalize_data(data);
+}
+
+void
+Init_attribute_builder(void)
+{
+  VALUE mFastHaml = rb_define_module("FastHaml");
+  rb_mAttributeBuilder = rb_define_module_under(mFastHaml, "AttributeBuilder");
+  rb_define_singleton_method(rb_mAttributeBuilder, "build", RUBY_METHOD_FUNC(m_build), -1);
+  rb_define_singleton_method(rb_mAttributeBuilder, "normalize_data", RUBY_METHOD_FUNC(m_normalize_data), 1);
+
+  id_keys = rb_intern("keys");
+  id_sort_bang = rb_intern("sort!");
+  id_merge_bang = rb_intern("merge!");
+  id_temple = rb_intern("Temple");
+  id_utils = rb_intern("Utils");
+  id_escape_html = rb_intern("escape_html");
+  id_gsub = rb_intern("gsub");
+  id_to_s = rb_intern("to_s");
+  rb_require("temple");
+}

data/ext/attribute_builder/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+
+create_makefile('fast_haml/attribute_builder')

data/fast_haml.gemspec

@@ -0,0 +1,35 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'fast_haml/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "fast_haml"
+  spec.version       = FastHaml::VERSION
+  spec.authors       = ["Kohei Suzuki"]
+  spec.email         = ["eagletmt@gmail.com"]
+  spec.summary       = %q{Faster implementation of Haml template language.}
+  spec.description   = %q{Faster implementation of Haml template language.}
+  spec.homepage      = "https://github.com/eagletmt/fast_haml"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.extensions    = ['ext/attribute_builder/extconf.rb']
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "escape_utils"
+  spec.add_dependency "parser"
+  spec.add_dependency "temple"
+  spec.add_dependency "tilt"
+  spec.add_development_dependency "appraisal"
+  spec.add_development_dependency "benchmark-ips"
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "coveralls"
+  spec.add_development_dependency "haml"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "rspec", ">= 3"
+  spec.add_development_dependency "simplecov"
+end

data/gemfiles/rails_4.0.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.0.0"
+gem "rspec-rails"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails_4.1.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.1.0"
+gem "rspec-rails"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails_4.2.gemfile

@@ -0,0 +1,9 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", "~> 4.2.0"
+gem "rspec-rails"
+gem "sqlite3"
+
+gemspec :path => "../"

data/gemfiles/rails_edge.gemfile

@@ -0,0 +1,10 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "rails", :git => "https://github.com/rails/rails"
+gem "rspec-rails"
+gem "sqlite3"
+gem "arel", :git => "https://github.com/rails/arel"
+
+gemspec :path => "../"

data/haml_spec_test.rb

@@ -0,0 +1,22 @@
+require 'minitest/autorun'
+require 'json'
+require 'fast_haml'
+
+class HamlTest < Minitest::Test
+  contexts = JSON.parse(File.read(File.join(__dir__, 'haml-spec', 'tests.json')))
+  contexts.each do |context|
+    context[1].each do |name, test|
+      define_method("test_spec: #{name} (#{context[0]})") do
+        html             = test["html"]
+        haml             = test["haml"]
+        locals           = Hash[(test["locals"] || {}).map {|x, y| [x.to_sym, y]}]
+        options          = Hash[(test["config"] || {}).map {|x, y| [x.to_sym, y]}]
+        options[:format] = options[:format].to_sym if options.key?(:format)
+        tilt = Tilt.new("#{name}.haml", nil, options) { haml }
+        result = tilt.render(Object.new, locals)
+
+        assert_equal html, result.strip
+      end
+    end
+  end
+end