faml 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3b0f1b792e063159d89d05f763e294c63d45348
+  data.tar.gz: 7aa644aea3462479bd94e0def8c174c7e560e8bc
+SHA512:
+  metadata.gz: 71db1678c99dd7e46e7d64ea14e8336879a69da2beb115524715f265e730402c617c63fc2bde58061b07190cadffd20730bacc9ad17ecefca2352a94f881e8c8
+  data.tar.gz: 63150b32c393d4b75a10681f944f98c0fa86a08f2eedc1a90151e6feb74bd09e454d02616d268e0a00918872be127a1acfc9c460dc2bf1a7858ad785ff71f2e4

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,27 @@
+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
+after_script:
+  - bundle exec rake benchmark:rendering
+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,47 @@
+## 0.2.0 (2015-03-19)
+- Rename from fast_haml to faml
+- Allow .faml extension
+
+## 0.1.10 (2015-03-19)
+- Fix ruby filter to not generate newlines
+- Support markdown filter
+
+## 0.1.9 (2015-03-18)
+- Refactor script parser (internal)
+- Fix newline generation with filters
+- Support sass, scss and coffee filter
+
+## 0.1.8 (2015-03-17)
+- Fix whitespace removal (`<` and `>`) behavior
+    - Internally, new instructions `mknl` and `rmnl` are added.
+
+## 0.1.7 (2015-03-16)
+- Fix attribute rendering with falsey values
+    - https://github.com/eagletmt/faml/pull/11
+
+## 0.1.6 (2015-03-11)
+- Fix render error with comment-only script
+    - https://github.com/eagletmt/faml/issues/6
+- Fix parsing error at multiline attributes
+    - https://github.com/eagletmt/faml/issues/7
+
+## 0.1.5 (2015-03-01)
+- Fix minor newline generation bug with Haml comment
+
+## 0.1.4 (2015-02-28)
+- Fix newline generation around empty lines
+    - Internal: introduce Ast::Empty and remove LineCounter
+
+## 0.1.3 (2015-02-27)
+- Fix internal compiler error when `>` is used
+- Fix newline generation at Ast::Element case
+
+## 0.1.2 (2015-02-24)
+- Keep newlines for better backtrace (#4)
+
+## 0.1.1 (2015-02-23)
+- Fix attribute parsing with `%span {foo}` or `%span (foo)` cases.
+- Fix comparison with statically-compilable class attributes like `%span.foo{class: bar}` .
+
+## 0.1.0 (2015-02-23)
+- Initial release

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in faml.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,115 @@
+# Faml
+[![Gem Version](https://badge.fury.io/rb/faml.svg)](http://badge.fury.io/rb/faml)
+[![Build Status](https://travis-ci.org/eagletmt/faml.svg)](https://travis-ci.org/eagletmt/faml)
+[![Coverage Status](https://coveralls.io/repos/eagletmt/faml/badge.svg)](https://coveralls.io/r/eagletmt/faml)
+[![Code Climate](https://codeclimate.com/github/eagletmt/faml/badges/gpa.svg)](https://codeclimate.com/github/eagletmt/faml)
+
+Faster implementation of Haml template language.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'faml'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install faml
+
+## Usage
+
+Just replace your `gem 'haml'` with `gem 'faml'` .
+
+## 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 faml, 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 faml 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. Faml::Parser converts source language (Haml template) to own AST (Faml::Ast) .
+    - You can see the Faml::Ast by running `faml parse template.haml` .
+2. Faml::Compiler compiles Faml::Ast into Temple AST.
+    - You can see the Temple AST by running `faml temple template.haml` .
+3. Temple compiles its AST into Ruby code.
+    - You can see the Ruby code by running `faml 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 faml.
+
+Internally, attributes are categolized into three types.
+
+1. Static attributes
+    - Both the key and the value are literal.
+    - Compiled into string literals.
+    - Fastest.
+    - e.g. `%input{checked: false}`
+2. Dynamic attributes
+    - The key is literal but the value isn't.
+    - The key is compiled into string literal. The value is interpolated at run-time.
+    - Relatively fast.
+    - e.g. `%input{checked: helper_method(@record)}`
+3. Ruby attributes
+    - Both the key and the value are non-literal expression.
+    - The attributes are stringified at run-time.
+    - Slow.
+    - e.g. `%input{helper_method(@record)}`
+
+## Contributing
+
+1. Fork it ( https://github.com/eagletmt/faml/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,28 @@
+require 'bundler/gem_tasks'
+
+task :default => [:compile, :spec]
+
+require 'rake/extensiontask'
+Rake::ExtensionTask.new('attribute_builder') do |ext|
+  ext.lib_dir = 'lib/faml'
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+namespace :benchmark do
+  task :rendering => ['benchmark:rendering:haml', 'benchmark:rendering:attributes']
+  namespace :rendering do
+    desc "Run benchmark with Haml's standard template"
+    task :haml do
+      haml_gem = Gem::Specification.find_by_name('haml')
+      standard_haml_path = File.join(haml_gem.gem_dir, 'test', 'templates', 'standard.haml')
+      sh 'ruby', 'benchmark/rendering.rb', standard_haml_path
+    end
+
+    desc "Run benchmark for attribute builder"
+    task :attributes do
+      sh 'ruby', 'benchmark/rendering.rb', File.join('benchmark/attribute_builder.haml')
+    end
+  end
+end

data/benchmark/attribute_builder.haml

@@ -0,0 +1,5 @@
+- h = { 'user' => { id: 1234, name: 'eagletmt' }, book_id: 5432 }
+- c = %w[content active]
+
+%span.book{data: h, class: c}
+  Book

data/benchmark/rendering.rb

@@ -0,0 +1,35 @@
+#!/usr/bin/env ruby
+require 'benchmark/ips'
+require 'haml'
+require 'faml'
+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_array = Faml::Engine.new.call(File.read(template))
+  obj.instance_eval("def faml_array; #{code_array}; end")
+  code_string = Faml::Engine.new(generator: Temple::Generators::RailsOutputBuffer).call(File.read(template))
+  obj.instance_eval("def faml_string; #{code_string}; end")
+
+  x.report('Haml') do
+    obj.haml
+  end
+
+  x.report('Faml (Array)') do
+    obj.faml_array
+  end
+
+  x.report('Faml (String)') do
+    obj.faml_string
+  end
+
+  x.compare!
+end

data/bin/faml

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

data/ext/attribute_builder/attribute_builder.c

@@ -0,0 +1,261 @@
+#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_TYPE_P(value, T_FALSE) || NIL_P(value))) {
+      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 if (RB_TYPE_P(value, T_FALSE) || NIL_P(value)) {
+    return Qnil;
+  } 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 mFaml = rb_define_module("Faml");
+  rb_mAttributeBuilder = rb_define_module_under(mFaml, "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");
+}