faml 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 12548082a8aaf67316ba96345010c92ded15aa41
-  data.tar.gz: bf0e80233a7227814421df27fe15b8fe05271aad
+  metadata.gz: fbb7777d09caaf6c398326ad22eb8f86a6fb4f2b
+  data.tar.gz: f5ce8d0e1e6f7a0d43e1e153bdf47f2905e147a1
 SHA512:
-  metadata.gz: 13d98c0fd7b3fa67895b874a99bc02606e3eb334be9d169038d975f86f09c7715f602a94d577ea63ef9ae7222795fbe7987555a6cfd8bd104216722ad6ef2765
-  data.tar.gz: 2ac8f294c6bfe8eab1ace2a755f6f5eceff9fd0b59770653a0d8c321c300a876d09f105e7d4f09d7dd1a130015588ea10fb05bd689bd6b3adfb90ae844fa8d3c
+  metadata.gz: 963b5897db86f1fdb168725f38194b5a29ffc5d40b5d4ebae219b19bd4bc7c7b82fd06b1ca23c7636917c71a8a9407c415fcf695505e0b0bb4e3b5ebf1dc9a1b
+  data.tar.gz: 41b0e8980767ae9fad3dcec64dbda59dfbb8a2d40bad2cf3c7545072ac2168bad850511f89c7ce904c6fcfb98765f4a452147d0c4346b88c7354dd2b744dd0d1

data/.clang-format

@@ -0,0 +1,3 @@
+Language: Cpp
+BasedOnStyle: Google
+Standard: C++03

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+## 0.7.0 (2015-11-30)
+- Rewrite AttributeBuilder in C++
+    - It improves performance,  memory usage, and readability
+
 ## 0.6.5 (2015-11-28)
 - Delete falsey values after merging all attributes
     - `%span(foo=true){foo: false}` now renders `<span></span>`, because old attributes have priority even if the value is falsey.

data/ext/attribute_builder/attribute_builder.cc

@@ -0,0 +1,345 @@
+#include <ruby.h>
+#include <ruby/version.h>
+#include "houdini.h"
+#include <algorithm>
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+/* faml requires Ruby >= 2.0.0 */
+/* RARRAY_AREF() is available since Ruby 2.1 */
+#if RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR < 1
+#define RARRAY_AREF(a, i) RARRAY_PTR(a)[i]
+#endif
+/* rb_utf8_str_new() is available since Ruby 2.2 */
+#if RUBY_API_VERSION_MAJOR == 2 && RUBY_API_VERSION_MINOR < 2
+#include <ruby/encoding.h>
+#define rb_utf8_str_new(ptr, len) rb_enc_str_new(ptr, len, rb_utf8_encoding())
+#endif
+
+#define FOREACH_FUNC(func) reinterpret_cast<int (*)(ANYARGS)>(func)
+
+VALUE rb_mAttributeBuilder;
+static ID id_flatten;
+
+static inline std::string string_from_value(VALUE v) {
+  return std::string(RSTRING_PTR(v), RSTRING_LEN(v));
+}
+
+enum attribute_value_type {
+  ATTRIBUTE_TYPE_TRUE,
+  ATTRIBUTE_TYPE_FALSE,
+  ATTRIBUTE_TYPE_VALUE,
+};
+
+struct attribute_value {
+  attribute_value_type type_;
+  std::string str_;
+
+  attribute_value(attribute_value_type type) : type_(type) {}
+  attribute_value(const char* cstr, long len)
+      : type_(ATTRIBUTE_TYPE_VALUE), str_(cstr, len) {}
+  attribute_value(const std::string& str)
+      : type_(ATTRIBUTE_TYPE_VALUE), str_(str) {}
+
+  static attribute_value from_value(VALUE value) {
+    if (RB_TYPE_P(value, T_TRUE)) {
+      return attribute_value(ATTRIBUTE_TYPE_TRUE);
+    } else if (!RTEST(value)) {
+      return attribute_value(ATTRIBUTE_TYPE_FALSE);
+    } else {
+      value = rb_convert_type(value, T_STRING, "String", "to_s");
+      return attribute_value(string_from_value(value));
+    }
+  }
+};
+
+typedef std::map<std::string, attribute_value> attributes_type;
+
+void upsert_attribute(attributes_type& m, const std::string& key,
+                      const attribute_value& value) {
+  const std::pair<attributes_type::iterator, bool> r =
+      m.insert(std::make_pair(key, value));
+  if (!r.second) {
+    r.first->second = value;
+  }
+}
+
+struct attribute_holder {
+  std::vector<attribute_value> ids_, classes_;
+  attributes_type m_;
+
+  inline void upsert(const std::string& key, const attribute_value& value) {
+    return upsert_attribute(m_, key, value);
+  }
+};
+
+static VALUE to_value(const attributes_type& m) {
+  VALUE h = rb_hash_new();
+  for (attributes_type::const_iterator it = m.begin(); it != m.end(); ++it) {
+    VALUE k = rb_utf8_str_new(it->first.data(), it->first.size());
+    VALUE v = Qnil;
+    switch (it->second.type_) {
+      case ATTRIBUTE_TYPE_TRUE:
+        v = Qtrue;
+        break;
+      case ATTRIBUTE_TYPE_FALSE:
+        v = Qnil;
+        break;
+      case ATTRIBUTE_TYPE_VALUE:
+        v = rb_utf8_str_new(it->second.str_.data(), it->second.str_.size());
+        break;
+    }
+    rb_hash_aset(h, k, v);
+  }
+  return h;
+}
+
+static void concat_array_attribute(std::vector<attribute_value>& ary,
+                                   VALUE value) {
+  if (RB_TYPE_P(value, T_ARRAY)) {
+    value = rb_funcall(value, id_flatten, 0);
+  } else {
+    value = rb_Array(value);
+  }
+  const long len = RARRAY_LEN(value);
+  for (long i = 0; i < len; i++) {
+    ary.push_back(attribute_value::from_value(RARRAY_AREF(value, i)));
+  }
+}
+
+static attributes_type normalize_data(VALUE data);
+
+static int normalize_data_i(VALUE key, VALUE value, VALUE arg) {
+  attributes_type* normalized = reinterpret_cast<attributes_type*>(arg);
+  key = rb_convert_type(key, T_STRING, "String", "to_s");
+  std::string key_ = string_from_value(key);
+  std::replace(key_.begin(), key_.end(), '_', '-');
+
+  if (RB_TYPE_P(value, T_HASH)) {
+    const attributes_type sub = normalize_data(value);
+    for (attributes_type::const_iterator it = sub.begin(); it != sub.end();
+         ++it) {
+      upsert_attribute(*normalized, key_ + "-" + it->first, it->second);
+    }
+  } else {
+    upsert_attribute(*normalized, key_, attribute_value::from_value(value));
+  }
+  return ST_CONTINUE;
+}
+
+static attributes_type normalize_data(VALUE data) {
+  Check_Type(data, T_HASH);
+  attributes_type m;
+  rb_hash_foreach(data, FOREACH_FUNC(normalize_data_i),
+                  reinterpret_cast<VALUE>(&m));
+  return m;
+}
+
+static int merge_one_i(VALUE key, VALUE value, VALUE arg) {
+  attribute_holder* attributes = reinterpret_cast<attribute_holder*>(arg);
+
+  key = rb_convert_type(key, T_STRING, "String", "to_s");
+  const std::string key_ = string_from_value(key);
+  if (key_ == "class") {
+    concat_array_attribute(attributes->classes_, value);
+  } else if (key_ == "id") {
+    concat_array_attribute(attributes->ids_, value);
+  } else if (key_ == "data" && RB_TYPE_P(value, T_HASH)) {
+    const attributes_type data = normalize_data(value);
+    for (attributes_type::const_iterator it = data.begin(); it != data.end();
+         ++it) {
+      attributes->upsert("data-" + it->first, it->second);
+    }
+  } else {
+    attributes->upsert(key_, attribute_value::from_value(value));
+  }
+  return ST_CONTINUE;
+}
+
+static void merge_one(attribute_holder& attributes, VALUE h) {
+  Check_Type(h, T_HASH);
+  rb_hash_foreach(h, FOREACH_FUNC(merge_one_i),
+                  reinterpret_cast<VALUE>(&attributes));
+}
+
+static void join_class_attribute(attribute_holder& attributes) {
+  const std::vector<attribute_value>& classes = attributes.classes_;
+  std::vector<std::string> ary;
+
+  for (std::vector<attribute_value>::const_iterator it = classes.begin();
+       it != classes.end(); ++it) {
+    switch (it->type_) {
+      case ATTRIBUTE_TYPE_FALSE:
+        break;
+      case ATTRIBUTE_TYPE_TRUE:
+        ary.push_back("true");
+        break;
+      case ATTRIBUTE_TYPE_VALUE:
+        size_t prev = 0, pos;
+        while ((pos = it->str_.find_first_of(' ', prev)) != std::string::npos) {
+          if (pos != prev) {
+            ary.push_back(std::string(it->str_, prev, pos - prev));
+          }
+          prev = pos + 1;
+        }
+        ary.push_back(std::string(it->str_, prev, it->str_.size() - prev));
+        break;
+    }
+  }
+  if (ary.empty()) {
+    return;
+  }
+
+  std::sort(ary.begin(), ary.end());
+  ary.erase(std::unique(ary.begin(), ary.end()), ary.end());
+  std::ostringstream oss;
+  for (std::vector<std::string>::const_iterator it = ary.begin();
+       it != ary.end(); ++it) {
+    if (it != ary.begin()) {
+      oss << ' ';
+    }
+    oss << *it;
+  }
+  attributes.upsert("class", attribute_value(oss.str()));
+}
+
+static void join_id_attribute(attribute_holder& attributes) {
+  const std::vector<attribute_value>& ids = attributes.ids_;
+  std::ostringstream oss;
+  bool first = true;
+
+  for (std::vector<attribute_value>::const_iterator it = ids.begin();
+       it != ids.end(); ++it) {
+    switch (it->type_) {
+      case ATTRIBUTE_TYPE_FALSE:
+        break;
+      case ATTRIBUTE_TYPE_TRUE:
+        if (!first) {
+          oss << '_';
+        }
+        oss << "true";
+        first = false;
+        break;
+      case ATTRIBUTE_TYPE_VALUE:
+        if (!first) {
+          oss << '_';
+        }
+        oss << it->str_;
+        first = false;
+        break;
+    }
+  }
+  if (first) {
+    return;
+  }
+
+  attributes.upsert("id", attribute_value(oss.str()));
+}
+
+static void delete_falsey_values(attributes_type& m) {
+  for (attributes_type::iterator it = m.begin(); it != m.end();) {
+    if (it->second.type_ == ATTRIBUTE_TYPE_FALSE) {
+      attributes_type::iterator jt = it;
+      ++it;
+      m.erase(jt);
+    } else {
+      ++it;
+    }
+  }
+}
+
+static attributes_type merge(VALUE object_ref, int argc, VALUE* argv) {
+  int i;
+  attribute_holder attributes;
+
+  for (i = 0; i < argc; i++) {
+    merge_one(attributes, argv[i]);
+  }
+  if (!NIL_P(object_ref)) {
+    merge_one(attributes, object_ref);
+  }
+
+  join_class_attribute(attributes);
+  join_id_attribute(attributes);
+  delete_falsey_values(attributes.m_);
+
+  return attributes.m_;
+}
+
+static void put_attribute(std::ostringstream& oss,
+                          const std::string& attr_quote, const std::string& key,
+                          const std::string& value) {
+  oss << " " << key << "=" << attr_quote;
+
+  gh_buf ob = GH_BUF_INIT;
+  if (houdini_escape_html0(&ob, (const uint8_t*)value.data(), value.size(),
+                           0)) {
+    oss << std::string(ob.ptr, ob.size);
+    gh_buf_free(&ob);
+  } else {
+    oss << value;
+  }
+  oss << attr_quote;
+}
+
+static void build_attribute(std::ostringstream& oss,
+                            const std::string& attr_quote, int is_html,
+                            const std::string& key,
+                            const attribute_value& value) {
+  if (value.type_ == ATTRIBUTE_TYPE_TRUE) {
+    if (is_html) {
+      oss << ' ' << key;
+    } else {
+      put_attribute(oss, attr_quote, key, key);
+    }
+  } else {
+    put_attribute(oss, attr_quote, key, value.str_);
+  }
+}
+
+static VALUE m_build(int argc, VALUE* argv, RB_UNUSED_VAR(VALUE self)) {
+  VALUE object_ref;
+  int is_html;
+
+  rb_check_arity(argc, 3, UNLIMITED_ARGUMENTS);
+  Check_Type(argv[0], T_STRING);
+  const std::string attr_quote = string_from_value(argv[0]);
+  is_html = RTEST(argv[1]);
+  object_ref = argv[2];
+  const attributes_type attributes = merge(object_ref, argc - 3, argv + 3);
+
+  std::ostringstream oss;
+  for (attributes_type::const_iterator it = attributes.begin();
+       it != attributes.end(); ++it) {
+    build_attribute(oss, attr_quote, is_html, it->first, it->second);
+  }
+
+  const std::string str = oss.str();
+  return rb_utf8_str_new(str.data(), str.size());
+}
+
+static VALUE m_normalize_data(RB_UNUSED_VAR(VALUE self), VALUE data) {
+  return to_value(normalize_data(data));
+}
+
+static VALUE m_merge(int argc, VALUE* argv, RB_UNUSED_VAR(VALUE self)) {
+  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
+  return to_value(merge(argv[0], argc - 1, argv + 1));
+}
+
+extern "C" {
+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);
+  rb_define_singleton_method(rb_mAttributeBuilder, "merge",
+                             RUBY_METHOD_FUNC(m_merge), -1);
+
+  id_flatten = rb_intern("flatten");
+}
+};

data/ext/attribute_builder/extconf.rb

@@ -2,10 +2,11 @@
 require 'mkmf'
 
 $CFLAGS << ' -Wall -W'
+$CXXFLAGS << ' -Wall -W -std=c++03'
 houdini_dir = File.expand_path('../../vendor/houdini', __dir__)
 $INCFLAGS << " -I#{houdini_dir}"
 
-$srcs = %w[attribute_builder.c]
+$srcs = %w[attribute_builder.cc]
 %w[
   buffer.c
   houdini_html_e.c

data/incompatibilities/README.md

@@ -1,7 +1,7 @@
 # Incompatibilities
 ## Versions
 - Haml 4.1.0.beta.1
-- Faml 0.6.5
+- Faml 0.7.0
 - Hamlit 1.7.2
 
 ## Table of contents

data/lib/faml/version.rb

@@ -1,4 +1,4 @@
 # frozen-string-literal: true
 module Faml
-  VERSION = '0.6.5'
+  VERSION = '0.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: faml
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Kohei Suzuki
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-11-28 00:00:00.000000000 Z
+date: 2015-11-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: escape_utils
@@ -299,6 +299,7 @@ extensions:
 - ext/attribute_builder/extconf.rb
 extra_rdoc_files: []
 files:
+- ".clang-format"
 - ".gitignore"
 - ".gitmodules"
 - ".rspec"
@@ -320,7 +321,7 @@ files:
 - benchmark/view.haml
 - benchmark/view.slim
 - bin/faml
-- ext/attribute_builder/attribute_builder.c
+- ext/attribute_builder/attribute_builder.cc
 - ext/attribute_builder/extconf.rb
 - faml.gemspec
 - gemfiles/rails_4.0.gemfile

data/ext/attribute_builder/attribute_builder.c

@@ -1,366 +0,0 @@
-#include <ruby.h>
-#include <ruby/encoding.h>
-#include <ruby/version.h>
-#include "houdini.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
-
-#define FOREACH_FUNC(func) ((int (*)(ANYARGS))(func))
-
-VALUE rb_mAttributeBuilder;
-static ID id_keys, id_sort_bang, id_uniq_bang, id_merge_bang, id_flatten;
-static ID id_id, id_class, id_underscore, id_hyphen, id_space, id_equal;
-
-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;
-
-    if (RB_TYPE_P(v, T_ARRAY)) {
-      v = rb_funcall(v, id_flatten, 0);
-    } else {
-      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_convert_type(key, T_STRING, "String", "to_s");
-  rb_hash_aset(arg, key, value);
-  return ST_CONTINUE;
-}
-
-static VALUE
-stringify_keys(VALUE hash)
-{
-  VALUE h = rb_hash_new();
-  rb_hash_foreach(hash, FOREACH_FUNC(stringify_keys_i), h);
-  return h;
-}
-
-struct normalize_data_i2_arg {
-  VALUE key, normalized;
-};
-
-static VALUE
-substitute_underscores(VALUE str)
-{
-  int frozen;
-  long i, len;
-
-  /* gsub('_', '-') */
-  Check_Type(str, T_STRING);
-  len = RSTRING_LEN(str);
-  frozen = OBJ_FROZEN(str);
-  for (i = 0; i < len; i++) {
-    if (RSTRING_PTR(str)[i] == '_') {
-      if (frozen) {
-        str = rb_str_dup(str);
-        frozen = 0;
-      }
-      rb_str_update(str, i, 1, rb_const_get(rb_mAttributeBuilder, id_hyphen));
-    }
-  }
-
-  return str;
-}
-
-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_str_dup(arg->key);
-
-  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)
-{
-  key = rb_convert_type(key, T_STRING, "String", "to_s");
-  key = substitute_underscores(key);
-
-  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), FOREACH_FUNC(normalize_data_i2), (VALUE)(&arg));
-  } else if (RB_TYPE_P(value, T_TRUE) || !RTEST(value)) {
-    /* Keep Qtrue and falsey value */
-    rb_hash_aset(normalized, key, value);
-  } else {
-    rb_hash_aset(normalized, key, rb_convert_type(value, T_STRING, "String", "to_s"));
-  }
-  return ST_CONTINUE;
-}
-
-static VALUE
-normalize_data(VALUE data)
-{
-  VALUE normalized;
-
-  Check_Type(data, T_HASH);
-  normalized = rb_hash_new();
-  rb_hash_foreach(data, FOREACH_FUNC(normalize_data_i), normalized);
-  return normalized;
-}
-
-static int
-put_data_attribute(VALUE key, VALUE val, VALUE hash)
-{
-  VALUE k = rb_str_buf_new(5 + RSTRING_LEN(key));
-  rb_str_buf_cat(k, "data-", 5);
-  rb_str_buf_append(k, key);
-  rb_hash_aset(hash, k, val);
-  return ST_CONTINUE;
-}
-
-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);
-    VALUE value = rb_hash_lookup(hash, key);
-
-    /* key must be String because it is already stringified by stringify_keys */
-    Check_Type(key, T_STRING);
-    if (RB_TYPE_P(value, T_HASH) && RSTRING_LEN(key) == 4 && memcmp(RSTRING_PTR(key), "data", 4) == 0) {
-      VALUE data;
-
-      rb_hash_delete(hash, key);
-      data = normalize_data(value);
-      rb_hash_foreach(data, FOREACH_FUNC(put_data_attribute), hash);
-    } else if (RB_TYPE_P(value, T_TRUE) || !RTEST(value)) {
-      /* Keep Qtrue and falsey value */
-    } else {
-      rb_hash_aset(hash, key, rb_convert_type(value, T_STRING, "String", "to_s"));
-    }
-  }
-}
-
-static void
-merge_one(VALUE attributes, VALUE arg)
-{
-  VALUE h;
-
-  Check_Type(arg, T_HASH);
-  h = stringify_keys(arg);
-  concat_array_attribute(attributes, h, rb_const_get(rb_mAttributeBuilder, id_class));
-  concat_array_attribute(attributes, h, rb_const_get(rb_mAttributeBuilder, id_id));
-  normalize(h);
-  rb_funcall(attributes, id_merge_bang, 1, h);
-}
-
-static void
-join_class_attribute(VALUE attributes, VALUE key)
-{
-  long len;
-  VALUE val;
-
-  val = rb_hash_delete(attributes, key);
-  Check_Type(val, T_ARRAY);
-  len = RARRAY_LEN(val);
-  if (len != 0) {
-    long i;
-    VALUE ary = rb_ary_new_capa(len);
-    for (i = 0; i < len; i++) {
-      VALUE v = RARRAY_AREF(val, i);
-      if (RTEST(v)) {
-        rb_ary_concat(ary, rb_str_split(rb_convert_type(v, T_STRING, "String", "to_s"), " "));
-      }
-    }
-    rb_funcall(ary, id_sort_bang, 0);
-    rb_funcall(ary, id_uniq_bang, 0);
-    rb_hash_aset(attributes, key, rb_ary_join(ary, rb_const_get(rb_mAttributeBuilder, id_space)));
-  }
-}
-
-static void
-join_id_attribute(VALUE attributes, VALUE key)
-{
-  long len;
-  VALUE val;
-
-  val = rb_hash_delete(attributes, key);
-  Check_Type(val, T_ARRAY);
-  len = RARRAY_LEN(val);
-  if (len != 0) {
-    long i;
-    VALUE ary = rb_ary_new_capa(len);
-    for (i = 0; i < len; i++) {
-      VALUE v = RARRAY_AREF(val, i);
-      if (RTEST(v)) {
-        rb_ary_push(ary, rb_convert_type(v, T_STRING, "String", "to_s"));
-      }
-    }
-    rb_hash_aset(attributes, key, rb_ary_join(ary, rb_const_get(rb_mAttributeBuilder, id_underscore)));
-  }
-}
-
-static int
-delete_falsey_values_i(RB_UNUSED_VAR(VALUE key), VALUE value, RB_UNUSED_VAR(VALUE arg))
-{
-  if (RTEST(value)) {
-    return ST_CONTINUE;
-  } else {
-    return ST_DELETE;
-  }
-}
-
-static void
-delete_falsey_values(VALUE attributes)
-{
-  rb_hash_foreach(attributes, FOREACH_FUNC(delete_falsey_values_i), Qnil);
-}
-
-static VALUE
-merge(VALUE object_ref, int argc, VALUE *argv)
-{
-  VALUE attributes, id_str, class_str;
-  int i;
-
-  attributes = rb_hash_new();
-  id_str = rb_const_get(rb_mAttributeBuilder, id_id);
-  class_str = rb_const_get(rb_mAttributeBuilder, id_class);
-  rb_hash_aset(attributes, id_str, rb_ary_new());
-  rb_hash_aset(attributes, class_str, rb_ary_new());
-
-  for (i = 0; i < argc; i++) {
-    merge_one(attributes, argv[i]);
-  }
-  if (!NIL_P(object_ref)) {
-    merge_one(attributes, object_ref);
-  }
-
-  join_class_attribute(attributes, class_str);
-  join_id_attribute(attributes, id_str);
-  delete_falsey_values(attributes);
-
-  return attributes;
-}
-
-static void
-put_attribute(VALUE buf, VALUE attr_quote, VALUE key, VALUE value)
-{
-  gh_buf ob = GH_BUF_INIT;
-
-  Check_Type(value, T_STRING);
-  if (houdini_escape_html0(&ob, (const uint8_t *)RSTRING_PTR(value), RSTRING_LEN(value), 0)) {
-    value = rb_enc_str_new(ob.ptr, ob.size, rb_utf8_encoding());
-    gh_buf_free(&ob);
-  }
-
-  rb_ary_push(buf, rb_const_get(rb_mAttributeBuilder, id_space));
-  rb_ary_push(buf, key);
-  rb_ary_push(buf, rb_const_get(rb_mAttributeBuilder, id_equal));
-  rb_ary_push(buf, attr_quote);
-  rb_ary_push(buf, value);
-  rb_ary_push(buf, attr_quote);
-}
-
-static void
-build_attribute(VALUE buf, VALUE attr_quote, int is_html, VALUE key, VALUE value)
-{
-  Check_Type(key, T_STRING);
-  if (RB_TYPE_P(value, T_TRUE)) {
-    if (is_html) {
-      rb_ary_push(buf, rb_const_get(rb_mAttributeBuilder, id_space));
-      rb_ary_push(buf, key);
-    } else {
-      put_attribute(buf, attr_quote, key, key);
-    }
-  } else {
-    put_attribute(buf, attr_quote, key, value);
-  }
-}
-
-static VALUE
-m_build(int argc, VALUE *argv, RB_UNUSED_VAR(VALUE self))
-{
-  VALUE attr_quote, object_ref, attributes, keys, buf;
-  int is_html;
-  long len, i;
-
-  rb_check_arity(argc, 3, UNLIMITED_ARGUMENTS);
-  attr_quote = argv[0];
-  is_html = RTEST(argv[1]);
-  object_ref = argv[2];
-  attributes = merge(object_ref, argc-3, argv+3);
-
-  keys = rb_funcall(attributes, id_keys, 0);
-  rb_funcall(keys, id_sort_bang, 0);
-  len = RARRAY_LEN(keys);
-  buf = rb_ary_new();
-  for (i = 0; i < len; i++) {
-    VALUE k = RARRAY_AREF(keys, i);
-    build_attribute(buf, attr_quote, is_html, k, rb_hash_lookup(attributes, k));
-  }
-
-  return rb_ary_join(buf, Qnil);
-}
-
-static VALUE
-m_normalize_data(RB_UNUSED_VAR(VALUE self), VALUE data)
-{
-  return normalize_data(data);
-}
-
-static VALUE
-m_merge(int argc, VALUE *argv, RB_UNUSED_VAR(VALUE self))
-{
-  rb_check_arity(argc, 1, UNLIMITED_ARGUMENTS);
-  return merge(argv[0], argc-1, argv+1);
-}
-
-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);
-  rb_define_singleton_method(rb_mAttributeBuilder, "merge", RUBY_METHOD_FUNC(m_merge), -1);
-
-  id_keys = rb_intern("keys");
-  id_sort_bang = rb_intern("sort!");
-  id_uniq_bang = rb_intern("uniq!");
-  id_merge_bang = rb_intern("merge!");
-  id_flatten = rb_intern("flatten");
-
-  id_id = rb_intern("ID");
-  id_class = rb_intern("CLASS");
-  id_underscore = rb_intern("UNDERSCORE");
-  id_hyphen = rb_intern("HYPHEN");
-  id_space = rb_intern("SPACE");
-  id_equal = rb_intern("EQUAL");
-
-  rb_const_set(rb_mAttributeBuilder, id_id, rb_obj_freeze(rb_str_new_cstr("id")));
-  rb_const_set(rb_mAttributeBuilder, id_class, rb_obj_freeze(rb_str_new_cstr("class")));
-  rb_const_set(rb_mAttributeBuilder, id_underscore, rb_obj_freeze(rb_str_new_cstr("_")));
-  rb_const_set(rb_mAttributeBuilder, id_hyphen, rb_obj_freeze(rb_str_new_cstr("-")));
-  rb_const_set(rb_mAttributeBuilder, id_space, rb_obj_freeze(rb_str_new_cstr(" ")));
-  rb_const_set(rb_mAttributeBuilder, id_equal, rb_obj_freeze(rb_str_new_cstr("=")));
-}