stash 1.0.0 → 2.0.0

data/ext/stash/types.c

@@ -0,0 +1,181 @@
+#include <ruby.h>
+#include "mustache.h"
+#include "stash.h"
+
+const size_t INITIAL_BUFFER_SIZE = 1024;
+
+mustache_ruby_context_t* create_mustache_ruby_context()
+{
+    mustache_ruby_context_t* r_ctx = mustache_malloc(sizeof(mustache_ruby_context_t));
+    r_ctx->buffer = rb_str_buf_new(INITIAL_BUFFER_SIZE);
+    r_ctx->buffer_length = 0;
+    return r_ctx;
+}
+
+void destroy_mustache_context(mustache_context_t* m_ctx)
+{
+    mustache_free(m_ctx);
+}
+
+mustache_context_t* create_mustache_context(mustache_context_t* parent)
+{
+    mustache_context_t* m_ctx = mustache_malloc(sizeof(mustache_context_t));
+    m_ctx->get_data = convert_type;
+    m_ctx->get_partial = get_partial;
+    m_ctx->parent = parent;
+    m_ctx->data = NULL;
+    m_ctx->partials = parent ? parent->partials : NULL;
+    m_ctx->prefix = parent ? parent->prefix : NULL;
+    m_ctx->custom = parent ? parent->custom : create_mustache_ruby_context();
+    m_ctx->debug_mode = parent ? parent->debug_mode : false;
+    m_ctx->destroy = destroy_mustache_context;
+    return m_ctx;
+}
+
+static void destroy_mustache_object(mustache_value_t* value)
+{
+    mustache_value_t* m_value = (mustache_value_t*) value;
+    m_value->data.object->destroy(m_value->data.object);
+    mustache_free(m_value);
+}
+
+static mustache_value_t* create_mustache_object(
+    mustache_context_t* m_ctx,
+    VALUE object)
+{
+    mustache_value_t* val = mustache_malloc(sizeof(mustache_value_t));
+    val->type = VALUE_OBJECT;
+    val->length = 0;
+    val->data.object = create_mustache_context(m_ctx);
+    val->data.object->data = (void*) object;
+    val->destroy = destroy_mustache_object;
+    return val;
+}
+
+static void destroy_mustache_list(mustache_value_t* value)
+{
+    mustache_context_t** m_list_ctxs = value->data.list;
+    for (size_t i = 0; i < value->length; i++) {
+        m_list_ctxs[i]->destroy(m_list_ctxs[i]);
+    }
+    mustache_free(value);
+}
+
+static mustache_value_t* create_mustache_list(
+    mustache_context_t* m_ctx,
+    VALUE rb_array)
+{
+    size_t length = RARRAY_LEN(rb_array);
+    mustache_context_t** m_list_ctxs = mustache_malloc(sizeof(mustache_context_t*) * length);
+
+    for (long i = 0; i < length; i++) {
+        m_list_ctxs[i] = create_mustache_context(m_ctx);
+        m_list_ctxs[i]->data = (void*) rb_ary_entry(rb_array, i);
+    }
+
+    mustache_value_t* val = mustache_malloc(sizeof(mustache_value_t));
+    val->type = VALUE_LIST;
+    val->length = length;
+    val->data.list = m_list_ctxs;
+    val->destroy = destroy_mustache_list;
+    return val;
+}
+
+static void destroy_mustache_value(mustache_value_t* value)
+{
+    mustache_free(value);
+}
+
+static mustache_value_t* create_mustache_value(
+    mustache_context_t* m_ctx,
+    VALUE rb_string)
+{
+    mustache_value_t* val = mustache_malloc(sizeof(mustache_value_t));
+    val->type = VALUE_VALUE;
+    val->data.value = rb_string == Qnil ? NULL : RSTRING_PTR(rb_string);
+    val->length = rb_string == Qnil ? 0 : RSTRING_LEN(rb_string);
+    val->destroy = destroy_mustache_value;
+    return val;
+}
+
+static mustache_value_t* convert_value(
+    VALUE rb_value,
+    mustache_context_t* m_ctx)
+{
+    switch (TYPE(rb_value)) {
+        case T_OBJECT: return create_mustache_object(m_ctx, rb_value);
+        case T_STRUCT: return create_mustache_object(m_ctx, rb_value);
+        case T_HASH:   return create_mustache_object(m_ctx, rb_value);
+        case T_TRUE:   return create_mustache_value(m_ctx, rb_str_new2("true"));
+        case T_FALSE:  return create_mustache_value(m_ctx, Qnil);
+        case T_NONE:   return create_mustache_value(m_ctx, Qnil);
+        case T_NIL:    return create_mustache_value(m_ctx, Qnil);
+        case T_FLOAT:  return create_mustache_value(m_ctx, rb_funcall(rb_value, rb_intern("to_s"), 0, 0));
+        case T_STRING: return create_mustache_value(m_ctx, rb_value);
+        case T_FIXNUM: return create_mustache_value(m_ctx, rb_fix2str(rb_value, 10));
+        case T_BIGNUM: return create_mustache_value(m_ctx, rb_big2str(rb_value, 10));
+        case T_ARRAY:  return create_mustache_list(m_ctx, rb_value);
+        default:
+            if (rb_class_of(rb_value) == rb_cProc) {
+                return convert_value(rb_funcall(rb_value, rb_intern("call"), 0, 0), m_ctx);
+            }
+            return create_mustache_value(m_ctx, rb_any_to_s(rb_value));
+    }
+}
+
+static mustache_value_t* convert_hash(
+  VALUE hash,
+  char* key,
+  mustache_context_t* m_lookup_context,
+  mustache_context_t* m_exection_context)
+{
+    VALUE rb_value;
+    if (NIL_P(rb_value = rb_hash_aref(hash, ID2SYM(rb_intern(key))))) {
+        return NULL;
+    }
+    return convert_value(rb_value, m_lookup_context);
+}
+
+static mustache_value_t* convert_object(
+  VALUE rb_object,
+  char* key,
+  mustache_context_t* m_lookup_context,
+  mustache_context_t* m_exection_context)
+{
+    ID id = rb_intern(key);
+    if (rb_respond_to(rb_object, id)) {
+        rb_ivar_set(rb_object, rb_intern("@context"), (VALUE) m_exection_context->data);
+
+        double start = 0;
+        if (m_lookup_context->debug_mode) {
+            start = get_time();
+        }
+
+        VALUE result = rb_funcall(rb_object, id, 0, 0);
+
+        if (m_lookup_context->debug_mode) {
+            log_ruby_callback_execution_time(m_lookup_context, id, get_time() - start);
+        }
+
+        return convert_value(result, m_lookup_context);
+    }
+    return NULL;
+}
+
+mustache_value_t* convert_type(
+  char* key,
+  void* context,
+  mustache_context_t* m_lookup_context,
+  mustache_context_t* m_exection_context)
+{
+    if (strcmp(key, ".") == 0) {
+        return convert_value((VALUE)context, m_lookup_context);
+    }
+
+    VALUE rb_context = (VALUE) context;
+    switch (TYPE(rb_context)) {
+        case T_OBJECT: return convert_object(rb_context, key, m_lookup_context, m_exection_context);
+        case T_HASH:   return convert_hash(rb_context, key, m_lookup_context, m_exection_context);
+        default:       return NULL;
+    }
+}

data/lib/stash.rb

@@ -1,34 +1,2 @@
-# Stash is an abstract interface to data structures servers
-class Stash
-  attr_reader :adapter
-  
-  # Timeout when performing a blocking action, such as blocking pop
-  class TimeoutError < StandardError; end
-  
-  def initialize(config)
-    raise ArgumentError, "no adapter specified" unless config[:adapter]
-    @adapter = Stash.adapter_class(config[:adapter]).new config
-  end 
-  
-  # Store an object in the Stash
-  def []=(key, value)
-    @adapter[key.to_s] = value
-  end
-  
-  # Retrieve an object from the Stash
-  def [](key)
-    @adapter[key.to_s]
-  end
-  
-  # Remove a key from the Stash
-  def delete(key)
-    @adapter.delete(key.to_s)
-    true
-  end
-end
-
-require 'stash/class_methods'
-require 'stash/redis_adapter'
-require 'stash/string'
-require 'stash/list'
-require 'stash/hash'
+require 'stash/stash'
+require 'stash/debug'

data/lib/stash/debug.rb

@@ -0,0 +1,46 @@
+class Template::Callback
+  attr_accessor :name
+  attr_accessor :time
+
+  def initialize(name, time)
+    @name = name
+    @time = time
+  end
+
+  def to_s
+    "['#{@name}', #{@time}],"
+  end
+end
+
+class Template::Debug
+  attr_accessor :total_time
+  attr_accessor :callbacks
+
+  def initialize
+    @callbacks = []
+  end
+
+  def log_callback(name, time)
+    @callbacks.push Template::Callback.new(name, time)
+  end
+
+  def slowest_callbacks(n)
+    @callbacks.sort { |a, b| b.time <=> a.time}.first(n)
+  end
+
+  def group_slowest_callbacks(n)
+    @callbacks.group_by(&:name) \
+              .map { |k, v| [ k, v.inject(0) { |sum, x| sum + x.time }, v.length ] } \
+              .sort { |a, b| b[1] <=> a[1] } \
+              .first(n)
+  end
+
+  def mustache_time
+    total_time - ruby_time
+  end
+
+  def ruby_time
+    @callbacks.inject(0) { |sum, x| sum + x.time }
+  end
+
+end

metadata

@@ -1,100 +1,49 @@
 --- !ruby/object:Gem::Specification 
 name: stash
 version: !ruby/object:Gem::Version 
-  hash: 23
   prerelease: false
   segments: 
-  - 1
+  - 2
   - 0
   - 0
-  version: 1.0.0
+  version: 2.0.0
 platform: ruby
 authors: 
-- Tony Arcieri
+- J.P. Cummins
 autorequire: 
 bindir: bin
 cert_chain: []
 
-date: 2010-12-07 00:00:00 -07:00
+date: 2012-06-24 00:00:00 -07:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: redis
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 2
-        - 1
-        - 0
-        version: 2.1.0
-  type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: redis-namespace
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 55
-        segments: 
-        - 0
-        - 10
-        - 0
-        version: 0.10.0
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: rspec
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 2
-        - 2
-        - 0
-        version: 2.2.0
-  type: :development
-  version_requirements: *id003
-description: Stash maps the facilities provided by data structures servers onto classes which mimic Ruby's built-in types
-email: tony@medioh.com
+dependencies: []
+
+description: stash, a lower-level mustache
+email: jpcummins@gmail.com
 executables: []
 
-extensions: []
+extensions: 
+- ext/stash/extconf.rb
+extra_rdoc_files: []
 
-extra_rdoc_files: 
-- LICENSE
-- README.markdown
 files: 
-- .document
-- LICENSE
-- README.markdown
-- Rakefile
-- VERSION
+- lib/stash/debug.rb
 - lib/stash.rb
-- lib/stash/class_methods.rb
-- lib/stash/hash.rb
-- lib/stash/list.rb
-- lib/stash/redis_adapter.rb
-- lib/stash/string.rb
-- spec/hash_spec.rb
-- spec/list_spec.rb
-- spec/spec.opts
-- spec/spec_helper.rb
-- spec/string_spec.rb
-- stash.gemspec
+- ext/stash/build.c
+- ext/stash/execute.c
+- ext/stash/lex.yy.c
+- ext/stash/mustache.c
+- ext/stash/optimize.c
+- ext/stash/stash.c
+- ext/stash/tokens.c
+- ext/stash/types.c
+- ext/stash/intern.h
+- ext/stash/lex.yy.h
+- ext/stash/mustache.h
+- ext/stash/stash.h
+- ext/stash/extconf.rb
 has_rdoc: true
-homepage: http://github.com/tarcieri/stash
+homepage: https://github.com/jpcummins/stash
 licenses: []
 
 post_install_message: 
@@ -103,32 +52,25 @@ rdoc_options: []
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3
       segments: 
       - 0
       version: "0"
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
-summary: Abstract interface to data structures servers
-test_files: 
-- spec/hash_spec.rb
-- spec/list_spec.rb
-- spec/spec_helper.rb
-- spec/string_spec.rb
+summary: High perfomance mustache rendering engine written in C with extensions for Ruby
+test_files: []
+

data/.document

@@ -1,5 +0,0 @@
-README.rdoc
-lib/**/*.rb
-bin/*
-features/**/*.feature
-LICENSE

data/LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2009 Tony Arcieri
-
-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.