garterbelt 0.0.2

data/lib/renderers/xml.rb

@@ -0,0 +1,9 @@
+module Garterbelt
+  class Xml < ClosedTag
+    max_pool_size 1000
+    
+    def template
+      "#{indent}<?xml #{rendered_attributes} ?>\n"
+    end
+  end
+end

data/lib/stocking.rb

@@ -0,0 +1,11 @@
+module Garterbelt
+  def self.cache_hash
+    @cache_hash ||= {:default => Moneta::Memory.new}
+  end
+  
+  def self.cache(store = :default)
+    c = cache_hash[store]
+    raise "Cache #{store.inspect} has not yet been configured" unless c
+    c
+  end
+end

data/lib/support/string.rb

@@ -0,0 +1,165 @@
+require 'active_support/inflector/methods'
+require 'active_support/inflector/inflections'
+
+# including the string extension directly require i18l gem, which is lame when not needed
+# String inflections define new methods on the String class to transform names for different purposes.
+# For instance, you can figure out the name of a database from the name of a class.
+#
+#   "ScaleScore".tableize # => "scale_scores"
+#
+
+class String
+  # Returns the plural form of the word in the string.
+  #
+  #   "post".pluralize             # => "posts"
+  #   "octopus".pluralize          # => "octopi"
+  #   "sheep".pluralize            # => "sheep"
+  #   "words".pluralize            # => "words"
+  #   "the blue mailman".pluralize # => "the blue mailmen"
+  #   "CamelOctopus".pluralize     # => "CamelOctopi"
+  def pluralize
+    ActiveSupport::Inflector.pluralize(self)
+  end
+
+  # The reverse of +pluralize+, returns the singular form of a word in a string.
+  #
+  #   "posts".singularize            # => "post"
+  #   "octopi".singularize           # => "octopus"
+  #   "sheep".singularize            # => "sheep"
+  #   "word".singularize             # => "word"
+  #   "the blue mailmen".singularize # => "the blue mailman"
+  #   "CamelOctopi".singularize      # => "CamelOctopus"
+  def singularize
+    ActiveSupport::Inflector.singularize(self)
+  end
+
+  # +constantize+ tries to find a declared constant with the name specified
+  # in the string. It raises a NameError when the name is not in CamelCase
+  # or is not initialized.
+  #
+  # Examples
+  #   "Module".constantize # => Module
+  #   "Class".constantize  # => Class
+  def constantize
+    ActiveSupport::Inflector.constantize(self)
+  end
+
+  # By default, +camelize+ converts strings to UpperCamelCase. If the argument to camelize
+  # is set to <tt>:lower</tt> then camelize produces lowerCamelCase.
+  #
+  # +camelize+ will also convert '/' to '::' which is useful for converting paths to namespaces.
+  #
+  #   "active_record".camelize                # => "ActiveRecord"
+  #   "active_record".camelize(:lower)        # => "activeRecord"
+  #   "active_record/errors".camelize         # => "ActiveRecord::Errors"
+  #   "active_record/errors".camelize(:lower) # => "activeRecord::Errors"
+  def camelize(first_letter = :upper)
+    case first_letter
+      when :upper then ActiveSupport::Inflector.camelize(self, true)
+      when :lower then ActiveSupport::Inflector.camelize(self, false)
+    end
+  end
+  alias_method :camelcase, :camelize
+
+  # Capitalizes all the words and replaces some characters in the string to create
+  # a nicer looking title. +titleize+ is meant for creating pretty output. It is not
+  # used in the Rails internals.
+  #
+  # +titleize+ is also aliased as +titlecase+.
+  #
+  #   "man from the boondocks".titleize # => "Man From The Boondocks"
+  #   "x-men: the last stand".titleize  # => "X Men: The Last Stand"
+  def titleize
+    ActiveSupport::Inflector.titleize(self)
+  end
+  alias_method :titlecase, :titleize
+
+  # The reverse of +camelize+. Makes an underscored, lowercase form from the expression in the string.
+  #
+  # +underscore+ will also change '::' to '/' to convert namespaces to paths.
+  #
+  #   "ActiveRecord".underscore         # => "active_record"
+  #   "ActiveRecord::Errors".underscore # => active_record/errors
+  def underscore
+    ActiveSupport::Inflector.underscore(self)
+  end
+
+  # Replaces underscores with dashes in the string.
+  #
+  #   "puni_puni" # => "puni-puni"
+  def dasherize
+    ActiveSupport::Inflector.dasherize(self)
+  end
+
+  # Removes the module part from the constant expression in the string.
+  #
+  #   "ActiveRecord::CoreExtensions::String::Inflections".demodulize # => "Inflections"
+  #   "Inflections".demodulize                                       # => "Inflections"
+  def demodulize
+    ActiveSupport::Inflector.demodulize(self)
+  end
+
+  # Replaces special characters in a string so that it may be used as part of a 'pretty' URL.
+  #
+  # ==== Examples
+  #
+  #   class Person
+  #     def to_param
+  #       "#{id}-#{name.parameterize}"
+  #     end
+  #   end
+  #
+  #   @person = Person.find(1)
+  #   # => #<Person id: 1, name: "Donald E. Knuth">
+  #
+  #   <%= link_to(@person.name, person_path %>
+  #   # => <a href="/person/1-donald-e-knuth">Donald E. Knuth</a>
+  def parameterize(sep = '-')
+    ActiveSupport::Inflector.parameterize(self, sep)
+  end
+
+  # Creates the name of a table like Rails does for models to table names. This method
+  # uses the +pluralize+ method on the last word in the string.
+  #
+  #   "RawScaledScorer".tableize # => "raw_scaled_scorers"
+  #   "egg_and_ham".tableize     # => "egg_and_hams"
+  #   "fancyCategory".tableize   # => "fancy_categories"
+  def tableize
+    ActiveSupport::Inflector.tableize(self)
+  end
+
+  # Create a class name from a plural table name like Rails does for table names to models.
+  # Note that this returns a string and not a class. (To convert to an actual class
+  # follow +classify+ with +constantize+.)
+  #
+  #   "egg_and_hams".classify # => "EggAndHam"
+  #   "posts".classify        # => "Post"
+  #
+  # Singular names are not handled correctly.
+  #
+  #   "business".classify # => "Busines"
+  def classify
+    ActiveSupport::Inflector.classify(self)
+  end
+
+  # Capitalizes the first word, turns underscores into spaces, and strips '_id'.
+  # Like +titleize+, this is meant for creating pretty output.
+  #
+  #   "employee_salary" # => "Employee salary"
+  #   "author_id"       # => "Author"
+  def humanize
+    ActiveSupport::Inflector.humanize(self)
+  end
+
+  # Creates a foreign key name from a class name.
+  # +separate_class_name_and_id_with_underscore+ sets whether
+  # the method should put '_' between the name and 'id'.
+  #
+  # Examples
+  #   "Message".foreign_key        # => "message_id"
+  #   "Message".foreign_key(false) # => "messageid"
+  #   "Admin::Post".foreign_key    # => "post_id"
+  def foreign_key(separate_class_name_and_id_with_underscore = true)
+    ActiveSupport::Inflector.foreign_key(self, separate_class_name_and_id_with_underscore)
+  end
+end

data/lib/view.rb

@@ -0,0 +1,341 @@
+module Garterbelt
+  class View
+    include RuPol::Swimsuit
+    
+    attr_accessor :output, :buffer, :level, :escape
+    attr_reader :curator
+    
+    def initialize(opts={})
+      self.buffer = []
+      self.level =  (opts.delete(:level) || 0)
+      self.output = ""
+      self.escape = true
+      
+      self.curator = opts.delete(:curator) || self
+      
+      params = self.class.default_variables.merge(opts)
+      keys = params.keys
+      
+      unless ((self.class.required || []) - keys).empty?
+        raise ArgumentError, "#{(self.class.required - keys).inspect} required as an initialization option"
+      end
+      
+      if self.class.selective_require && keys != self.class.required
+        raise ArgumentError, "Allowed initalization options are only #{self.class.required.inspect}"
+      end
+      
+      params.each do |key, value|
+        self.class.add_accssor(key) unless respond_to?(key)
+        send("#{key}=", value)
+      end
+    end
+    
+    def curator=(parent_view)
+      @curator = parent_view
+      if parent_view != self
+        self.buffer = parent_view.buffer
+        self.level = parent_view.level
+        self.output = parent_view.output
+        self.escape = parent_view.escape
+      end
+    end
+    
+    def curated?
+      curator === self
+    end
+    
+    # VARIABLE ACCESS -----------------------------
+    class << self
+      attr_accessor :required, :selective_require
+    end
+    
+    def self.add_accssor key
+      key = key.to_s
+      return if accessories.include?(key)
+      if instance_methods.include?(key)
+        raise ArgumentError, ":#{key} cannot be a required variable because it maps to an existing method"
+      end
+      
+      accessories << key.to_s
+      attr_accessor key
+    end
+    
+    def self.accessories
+      @accessories ||= superclass? ? superclass.accessories.dup : []
+    end
+    
+    def self.superclass?
+      @superclassed ||= superclass.respond_to?( :required )
+    end
+    
+    def self.super_required
+      superclass? ? superclass.required || [] : []
+    end 
+    
+    def self.default_variables
+      @default_variables ||= superclass? ? superclass.default_variables.dup : Hash.new
+    end  
+    
+    def self.requires *args
+      if args.last.is_a?(Hash) 
+        self.default_variables.merge!(args.pop) 
+        args += default_variables.keys.map{ |x| x.to_sym }
+      end 
+      
+      args = super_required + args  
+      self.required = args.uniq
+      build_accessors
+      required
+    end
+        
+    def self.requires_only(*args)
+      self.selective_require = true
+      requires(*args)
+    end
+    
+    class << self
+      alias :needs :requires
+      alias :needs_only :requires_only
+    end
+    
+    def self.build_accessors
+      required.each do |m|
+        add_accssor m
+      end
+    end
+    
+    # TAG HELPERS -----------------------
+    
+    def add_to_buffer(renderer)
+      buffer << renderer
+      renderer
+    end
+    
+    def tag(type, *args, &block)
+      add_to_buffer ContentTag.new(parse_tag_arguments(type, args), &block)
+    end
+    
+    def closed_tag(type, *args)
+      add_to_buffer ClosedTag.new(parse_tag_arguments(type, args))
+    end
+    
+    def non_escape_tag(*args, &block)
+      if escape
+        curator.escape = false
+        t = tag(*args, &block)
+        curator.escape = true
+        t
+      else
+        tag(*args, &block)
+      end
+    end
+    
+    def text(content)
+      add_to_buffer Text.new(:view => curator, :content => content)
+    end
+    
+    alias :h :text
+    
+    def raw_text(content)
+      if escape
+        curator.escape = false
+        t = text(content)
+        curator.escape = true
+        t
+      else
+        text(content)
+      end
+    end
+    alias :raw :raw_text
+    alias :rawtext :raw_text
+    
+    def comment(content)
+      add_to_buffer Comment.new(:view => curator, :content => content)
+    end
+    
+    def doctype(type=:transitional)
+      add_to_buffer Doctype.new(:view => curator, :type => type)
+    end
+    
+    def xml(opts={})
+      opts = {:version => 1.0, :encoding => 'utf-8'}.merge(opts)
+      add_to_buffer Xml.new(parse_tag_arguments(:xml, [opts]))
+    end
+    
+    def parse_tag_arguments(type, args)
+      opts = {:type => type, :view => curator}
+      if args.size == 2
+        opts[:content] = args.shift
+        opts[:attributes] = args.first
+      else
+        if args.first.is_a?(Hash)
+          opts[:attributes] = args.first
+        else
+          opts[:content] = args.first
+        end
+      end
+      opts
+    end
+    
+    CONTENT_TAGS = [
+      'a', 'abbr', 'acronym', 'address', 
+      'b', 'bdo', 'big', 'blockquote', 'body', 'button', 
+      'caption', 'center', 'cite', 'colgroup',
+      'dd', 'del', 'dfn', 'div', 'dl', 'dt', 'em',
+      'embed',
+      'fieldset', 'form', 'frameset',
+      'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'html', 'i',
+      'iframe', 'ins', 'kbd', 'label', 'legend', 'li', 'map',
+      'noframes', 'noscript', 
+      'object', 'ol', 'optgroup', 'option', 'p', 'param', 
+      'q', 's',
+      'samp', 'script', 'select', 'small', 'span',
+      'strong', 'style', 'sub', 'sup',
+      'table', 'tbody', 'td', 'textarea', 'tfoot', 
+      'th', 'thead', 'tr', 'tt', 'u', 'ul', 'var'
+    ]
+    CONTENT_TAGS.each do |type|
+      class_eval <<-RUBY
+        def #{type}(*args, &block)
+          tag(:#{type}, *args, &block)
+        end
+      RUBY
+    end
+    
+    NON_ESCAPE_TAGS = ['code', 'pre']
+    NON_ESCAPE_TAGS.each do |type|
+      class_eval <<-RUBY
+        def #{type}(*args, &block)
+          non_escape_tag(:#{type}, *args, &block)
+        end
+      RUBY
+    end
+    
+    CLOSED_TAGS = ['area', 'br', 'col', 'frame', 'hr', 'img', 'input']
+    CLOSED_TAGS.each do |type|
+      class_eval <<-RUBY
+        def #{type}(*args)
+          closed_tag(:#{type}, *args)
+        end
+      RUBY
+    end  
+    
+    HEAD_TAGS = ['base', 'meta', 'link']
+    HEAD_TAGS.each do |type|
+      class_eval <<-RUBY
+        def _#{type}(*args)
+          closed_tag(:#{type}, *args)
+        end
+      RUBY
+    end
+    
+    def page_title(*args, &block)
+      tag(:title, *args, &block)
+    end
+    
+    def stylesheet_link(path)
+      _link(:rel => "stylesheet", 'type' => "text/css", :href => "#{path}.css")
+    end
+    
+    def javascript_link(path)
+      script(:src => "#{path}.js", 'type' => "text/javascript")
+    end
+    
+    # RENDERING -------------------------
+    
+    def content
+      raise NotImplementedError, "Implement #content in #{self.class}!"
+    end
+    
+    def render(content_method = :content)
+      self.output = "" if curated?
+      if content_method == :content
+        content
+      else
+        send(content_method)
+      end
+      render_buffer
+      output
+    end
+    
+    alias :to_s :render
+    alias :to_html :render
+    
+    def render_buffer
+      array = buffer.dup
+      buffer.clear
+      array.each do |item|
+        if item.respond_to?(:render)
+          item.render
+          item.recycle
+        else
+          output << item.to_s
+        end
+      end
+    end
+    
+    def self.render(opts={})
+      content_method = opts[:method]
+      view = new
+      output = content_method ? view.render(content_method) : view.render
+      view.recycle
+      output
+    end
+    
+    def partial(*args, &block)
+      if (klass = args.first).is_a?(Class)
+        args.shift
+        view = klass.new(*args)
+      else
+        view = args.first
+      end
+      view.curator = curator
+      self.buffer << view
+      view
+    end
+    
+    alias :widget :partial
+    
+    # CACHING ---------------------------
+    
+    class << self
+      attr_writer :cache_store_key, :cache_key_base
+    end
+    
+    attr_writer :cache_store_key, :cache_key_base
+    
+    
+    def self.cache_store_key
+      @cache_store_key ||= :default
+    end
+    
+    def cache_store_key
+      @cache_store_key ||= self.class.cache_store_key
+    end
+    
+    def cache_store
+      @cache ||= Garterbelt.cache(cache_store_key)
+    end
+    
+    def self.cache_key_base
+      @cache_key_base ||= self.to_s.underscore
+    end
+    
+    def cache_key_base
+      @cache_key_base ||= self.class.cache_key_base
+    end
+    
+    CACHE_DETAIL_DEFAULT = 'default'
+    
+    def cache_key(detail = CACHE_DETAIL_DEFAULT)
+      detail ||= CACHE_DETAIL_DEFAULT
+      "#{cache_key_base}_#{detail}"
+    end
+    
+    def cache(key, &block)
+      renderer = Cache.new(:view => self, :key => cache_key(key), &block)
+      buffer << renderer
+      renderer
+    end
+  end
+end

data/spec/benchmark/templates/erector.rb

@@ -0,0 +1,37 @@
+class ErectorTemplate < Erector::Widget
+  needs :user, :flash => nil
+  
+  def content
+    html do
+      head do
+        title "Benchmarking Templates"
+        link :rel => 'stylesheet', :href => '/stylesheet/application.css'
+        link :rel => 'stylesheet', :href => '/stylesheet/ie.css'
+      end
+      
+      body :class => self.class.to_s.underscore do
+        div :id => :wrapper, :class => 'line' do
+          if flash
+            div :id => 'flash', :class => 'inner' do
+              text flash
+            end
+          end
+          
+          dl :class => ['inner', 'user_info'] do
+            dt 'username'
+            dd user.username
+            
+            dt 'email'
+            dd user.email
+            
+            dt 'name'
+            dd user.name
+            
+            dt 'number of assigned tasks'
+            dd rand(20)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/benchmark/templates/garterbelt.rb

@@ -0,0 +1,37 @@
+class GarterbeltTemplate < Garterbelt::View
+  needs :user, :flash => nil
+  
+  def content
+    html do
+      head do
+        title "Benchmarking Templates"
+        link :rel => 'stylesheet', :href => '/stylesheet/application.css'
+        link :rel => 'stylesheet', :href => '/stylesheet/ie.css'
+      end
+      
+      body :class => self.class.to_s.underscore do
+        div :id => :wrapper, :class => 'line' do
+          if flash
+            div :id => 'flash', :class => 'inner' do
+              text flash
+            end
+          end
+          
+          dl :class => ['inner', 'user_info'] do
+            dt 'username'
+            dd user.username
+            
+            dt 'email'
+            dd user.email
+            
+            dt 'name'
+            dd user.name
+            
+            dt 'number of assigned tasks'
+            dd rand(20)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/benchmark/vs_erector.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require "rbench"
+require 'hashie'
+
+require 'erector'
+require File.dirname(__FILE__) + "/../../lib/garterbelt"
+
+require File.dirname(__FILE__) + '/templates/stocking'
+require File.dirname(__FILE__) + '/templates/erector'
+
+TIMES = 500_000
+
+RBench.run(TIMES) do
+  LoungeTemplate.max_pool_size TIMES/10
+  column :garterbelt
+  column :erector
+  
+  report "Simple Page Rendering" do
+    user = Hashie::Mash.new(:username => 'baccigalupi', :email => 'baccigalupi@example.com', :name => 'Kane Baccigalupi')
+    erector { ErectorTemplate.new(:user => user) }
+    garterbelt { GarterbeltTemplate.new(:user => user) }
+  end
+end
+
+# 4/11/2011, version 0.0.1, standard pooling
+# GARTERBELT = pooling at standard 1000 instances
+# GARTERBELT_2 = pooling at 10% of sample time
+
+# 10_000 times
+#                                   GARTERBELT | ERECTOR |
+# ---------------------------------------------------------------------
+# Simple Page Rendering                 0.164 |   0.205 |    20% faster
+
+# 100_000 times
+#                                   GARTERBELT | GARTERBELT_2 | ERECTOR |
+# ---------------------------------------------------------------------
+# Simple Page Rendering                 1.857 | 1.828 | 1.932 |    3.8-5.3%/ faster
+
+# 200_000 times
+#                                   GARTERBELT | GARTERBELT_2 | ERECTOR |
+# ---------------------------------------------------------------------
+# Simple Page Rendering                 3.743 | 3.660 | 3.846 |    2.7-4.8% faster
+
+# 500_000 times
+#                                   GARTERBELT | GARTERBELT_2 | ERECTOR |
+# ---------------------------------------------------------------------
+# Simple Page Rendering                 9.420 | 9.422 | 9.637 |    2.3-2.2% faster
+
+
+
+

data/spec/garterbelt_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Garterbelt do
+  describe 'cache module level methods' do
+    describe '#cache_hash' do
+      it 'creates a default hash when accessed the first time' do
+        cache_hash = Garterbelt.cache_hash.dup
+        cache_hash.class.should == Hash
+        cache_hash[:default].is_a?(Moneta::Memory).should == true
+        cache_hash.keys.size.should == 1
+      end
+      
+      it 'gives direct access to the hash' do
+        Garterbelt.cache_hash[:foo] = 'foo'
+        Garterbelt.cache_hash[:foo].should == 'foo'
+      end
+    end
+    
+    describe '#cache=' do
+      it 'creates a Moneta cache' do
+        
+      end
+      
+      describe 'options' do
+        it 'creates a memory Moneta cache correctly'
+        it 'creates a file system Moneta cache'
+        it 'creates alternative types as requested'
+      end
+      it 'sets the default key when not provided a argument'
+      it 'sets other keys when not '
+    end
+    
+    describe '#cache' do
+      it 'returns the :default if no arugment is received' do
+        Garterbelt.cache.should == Garterbelt.cache_hash[:default]
+      end
+      
+      it 'returns an alternative cache by key' do
+        Garterbelt.cache_hash[:foo] = 'foo'
+        Garterbelt.cache(:foo).should == 'foo'
+      end
+      
+      it 'raises an error when accessing via a key that has no been configured' do
+        Garterbelt.cache_hash[:bar].should be_nil
+        lambda { Garterbelt.cache(:bar) }.should raise_error( "Cache :bar has not yet been configured" )
+      end
+    end
+  end
+end