musterb 0.0.3 → 0.0.4

data/lib/musterb/chain.rb

@@ -0,0 +1,7 @@
+class Musterb::Chain
+  include ExtractValues
+
+  def initialize(value)
+    @context = new_context(value, Musterb::NullExtractor.new(nil))
+  end
+end

data/lib/musterb/evaluator.rb

@@ -1,18 +1,11 @@
 class Musterb::Evaluator
+  include ExtractValues
+
   def initialize(context)
     @context = context
-  end
+  end  
 
-  def [](symbol)
-    return @context.value if symbol == "."    
-    final_context = symbol.split(".").inject(@context) do |con, symbol|      
-      new_context con[symbol], con
-    end
-    final_context.value
-  end
-
-  def block(symbol)
-    value = self[symbol]
+  def block_if(value)
     return if is_falsy? value
 
     case value
@@ -25,8 +18,8 @@ class Musterb::Evaluator
     end
   end
 
-  def block_unless(symbol)
-    yield if is_falsy? self[symbol]
+  def block_unless(value)
+    yield if is_falsy? value
   end
 
   private
@@ -40,26 +33,11 @@ class Musterb::Evaluator
     else
       !value
     end
-  end
-
-  def new_context(value, old_context = @context)
-    case value
-    when Hash
-      Musterb::HashExtractor.new(value, old_context)
-    when nil
-      Musterb::NullExtractor.new(old_context)
-    else
-      Musterb::ObjectExtractor.new(value, old_context)
-    end
-  end
-
-  def old_context
-    @context.parent
-  end
+  end  
 
   def switch_context(value)
     @context = new_context(value)
     yield value
-    @context = old_context
+    @context = @context.parent
   end
 end

data/lib/musterb/extract_values.rb

@@ -0,0 +1,25 @@
+module ExtractValues
+  def value
+    @context.value
+  end
+
+  def [](symbol)
+    @context[symbol]
+  end
+
+  def chain(symbol)
+    Musterb::Chain.new self[symbol]
+  end
+
+  private
+  def new_context(value, old_context = @context)
+    case value
+    when Hash
+      Musterb::HashExtractor.new(value, old_context)
+    when nil
+      Musterb::NullExtractor.new(old_context)
+    else
+      Musterb::ObjectExtractor.new(value, old_context)
+    end
+  end
+end

data/lib/musterb/musterbifier.rb

@@ -3,24 +3,35 @@ class Musterb::Musterbifier
     @template = template
   end
 
+  def fetch(tokens)
+    tokens = tokens.strip.split(".")
+    last_token = tokens.pop
+    fetch_command = tokens.inject("musterb") do |str, token|
+      "#{str}.chain('#{token}')"
+    end
+    "#{fetch_command}['#{last_token}']"
+  end
+
   def to_erb
     @template.gsub(/\{\{(\{?[^\}]*\}?)\}\}/) do |match|
       match = $1
       case match[0]
       when '#'
-        "<% musterb.block '#{match[1..-1].strip}' do %>"
+        "<% musterb.block_if #{fetch match[1..-1]} do %>"
       when '^'
-        "<% musterb.block_unless '#{match[1..-1].strip}' do %>"
+        "<% musterb.block_unless #{fetch match[1..-1]} do %>"
       when "/"
         "<% end %>"
       when '{'
-        "<%= musterb['#{match[1..-2].strip}'] %>"
+        "<%= #{fetch match[1..-2]} %>"
       when '&'
-        "<%= musterb['#{match[1..-1].strip}'] %>"
+        "<%= #{fetch match[1..-1]} %>"
       when '!'
         ""
+      when '.'
+        "<%== musterb.current %>"
       else
-        "<%== musterb['#{match.strip}'] %>"
+        "<%== #{fetch match} %>"
       end
     end
   end

data/lib/musterb/version.rb

@@ -1,3 +1,3 @@
 module Musterb
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/musterb.rb

@@ -1,10 +1,12 @@
 require "musterb/version"
+require "musterb/extract_values"
 require "musterb/musterbifier"
 require "musterb/binding_extractor"
 require "musterb/hash_extractor"
 require "musterb/object_extractor"
 require "musterb/null_extractor"
 require "musterb/evaluator"
+require "musterb/chain"
 
 module Musterb
   def self.to_erb(template)

data/musterb.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |gem|
   gem.add_dependency "erubis"
   gem.add_dependency "hashie"
   gem.add_development_dependency "rspec"
+  gem.add_development_dependency "mustache" # for performance
 end

data/spec/musterb/evaluator_spec.rb

@@ -7,74 +7,65 @@ describe Musterb::Evaluator do
 
   it "pulls out values from ." do
     evaluator = Musterb::Evaluator.new Musterb::ObjectExtractor.new(2, nil)
-    evaluator["."].should eq 2
+    evaluator.value.should eq 2
   end
 
   it "can do nested values" do
     evaluator = Musterb::Evaluator.new Musterb::ObjectExtractor.new(2, nil)
-    evaluator["next.to_s"].should eq "3"
+    evaluator.chain("next")["to_s"].should eq "3"
+  end
+
+  it "can deeply nest things" do
+    evaluator = Musterb::Evaluator.new Musterb::ObjectExtractor.new(2, nil)
+    evaluator.chain("next").chain("next")["to_s"].should eq "4"
   end
 
   it "does not barf when pulling out a value on nil" do
     evaluator = Musterb::Evaluator.new Musterb::HashExtractor.new({:foo => nil}, nil)
-    evaluator["foo.bar"].should eq nil
+    evaluator.chain("foo")["bar"].should eq nil
   end
 
   context "block" do
-    it "yields to the block if a value is set" do    
-      foo = "bar"
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block("foo", &b) }.to yield_control
+    let(:evaluator) { Musterb::Evaluator.new Musterb::NullExtractor.new(nil) }
+
+    it "yields to the block if a value is set" do          
+      expect { |b| evaluator.block_if("bar", &b) }.to yield_control
     end
 
     it "does not yield to the block if the value is unset" do
-      foo = nil
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block("foo", &b) }.not_to yield_control
+      expect { |b| evaluator.block_if(nil, &b) }.not_to yield_control
     end
 
     it "yields to the block for every element in the array" do
-      foo = [1, 2, 3]
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block("foo", &b) }.to yield_successive_args(1,2,3)
+      expect { |b| evaluator.block_if([1,2,3], &b) }.to yield_successive_args(1,2,3)
     end
 
     it "does not yield to an empty array" do
-      foo = []
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block("foo", &b) }.not_to yield_control
+      expect { |b| evaluator.block_if([], &b) }.not_to yield_control
     end
 
     it "yields to an empty hash" do
-      foo = {}
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block("foo", &b) }.to yield_control
+      expect { |b| evaluator.block_if({}, &b) }.to yield_control
     end
   end
 
   context "block_unless" do
-    it "does not yield to the block if a value is set" do    
-      foo = "bar"
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block_unless("foo", &b) }.not_to yield_control
+    let(:evaluator) { Musterb::Evaluator.new Musterb::NullExtractor.new(nil) }
+
+    it "does not yield to the block if a value is set" do          
+      expect { |b| evaluator.block_unless("bar", &b) }.not_to yield_control
     end
 
     it "does not yield to the block if the value is unset" do
-      foo = nil
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block_unless("foo", &b) }.to yield_control
+      expect { |b| evaluator.block_unless(nil, &b) }.to yield_control
     end
 
     it "yields to the block for every element in the array" do
-      foo = [1, 2, 3]
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block_unless("foo", &b) }.not_to yield_control
+      expect { |b| evaluator.block_unless([1, 2, 3], &b) }.not_to yield_control
     end
 
-    it "does not yield to an empty array" do
-      foo = []
-      evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      expect { |b| evaluator.block_unless("foo", &b) }.to yield_control
+    it "does not yield to an empty array" do    
+      expect { |b| evaluator.block_unless([], &b) }.to yield_control
     end
   end
 
@@ -82,7 +73,7 @@ describe Musterb::Evaluator do
     it "switches inside a hash" do
       hash = { "foo" => "bar"}    
       evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      evaluator.block "hash" do
+      evaluator.block_if hash do
         evaluator['foo'].should eq 'bar'
       end
     end
@@ -90,7 +81,7 @@ describe Musterb::Evaluator do
     it "resets the context later" do
       hash = { "foo" => "bar"}
       evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      evaluator.block("hash") {}
+      evaluator.block_if(hash) {}
       evaluator["hash"].should eq hash
     end
 
@@ -98,7 +89,7 @@ describe Musterb::Evaluator do
       foo = "bar"
       hash = { }
       evaluator = Musterb::Evaluator.new Musterb::BindingExtractor.new(binding)
-      evaluator.block "hash" do
+      evaluator.block_if hash do
         evaluator['foo'].should eq 'bar'
       end
     end

data/spec/musterb/musterbifier_spec.rb

@@ -16,14 +16,22 @@ describe Musterb::Musterbifier do
   end
 
   it "replaces blocks correctly" do
-    Musterb::Musterbifier.new("{{#cond}}foo{{/cond}}").to_erb.should eq "<% musterb.block 'cond' do %>foo<% end %>"
+    Musterb::Musterbifier.new("{{#cond}}foo{{/cond}}").to_erb.should eq "<% musterb.block_if musterb['cond'] do %>foo<% end %>"
   end
 
   it "replaces carrot correctly" do
-    Musterb::Musterbifier.new("{{^cond}}foo{{/cond}}").to_erb.should eq "<% musterb.block_unless 'cond' do %>foo<% end %>"
+    Musterb::Musterbifier.new("{{^cond}}foo{{/cond}}").to_erb.should eq "<% musterb.block_unless musterb['cond'] do %>foo<% end %>"
   end
 
   it "replaces comments with nothing" do
     Musterb::Musterbifier.new("{{! foo\n bar}}").to_erb.should eq ""
   end
+
+  it "replaces . with current value" do
+    Musterb::Musterbifier.new("{{.}}").to_erb.should eq "<%== musterb.current %>"
+  end
+
+  it "replaces foo.bar with a chain" do
+    Musterb::Musterbifier.new("{{foo.bar}}").to_erb.should eq "<%== musterb.chain('foo')['bar'] %>"
+  end
 end

data/spec/performance.rb

@@ -0,0 +1,74 @@
+require 'bundler/setup'
+require 'benchmark'
+
+require 'musterb'
+require 'mustache'
+require 'erubis'
+
+template = <<-EOF
+{{#products}}
+<div class="product-item" data-variant-id='{{id}}' data-favorite-id='{{favorite_id}}' data-quick-view-url="{{quick_view_url}}">
+    <h3>Product: {{name}}</h3>
+
+    <a href="{{url}}" class="quickView">
+        <img src="{{thumbnail}}"/>
+    </a>
+    <ul>
+        <li>SKU: {{sku}}</li>
+        <li>Fabrics: {{fabrics}}</li>
+        <li>Themes: {{themes}}</li>
+        <li>Price: {{price}}</li>
+        <li>Designer: {{designer}}
+        <li class="favorite">
+          <div class="not-favorited {{favorited}}">
+            <button class="add-to-favorites">Add to Favorite</button>
+          </div>
+          <div class="favorited  {{favorited}}">
+            <button class="remove-from-favorites">Remove from Favorite</button>
+          </div>
+        </li>
+    </ul>
+</div>
+{{/products}}
+EOF
+
+def random_product
+  {
+    "id" => rand(10000),
+    "favorite_id" => rand(10000),
+    "quick_view_url" => "http://foo.bar",
+    "name" => "Product name",
+    "url" => "http://foo.url",
+    "thumbnail" => "http://foo.image",
+    "sku" => "sku",
+    "fabrics" => "fabrics",
+    "themes" => "themes",
+    "designer" => "designer",
+    "favorited" => "favorited"
+  }
+end
+
+products = 16.times.map { random_product }
+
+mustache = lambda { Mustache.render(template, :products => products) }
+
+erb = Musterb.to_erb(template)
+compiled_erb = Erubis::Eruby.new(erb)
+musterb = lambda { compiled_erb.result(:products => products) }
+
+if mustache.call == musterb.call
+  puts "mustache and musterb are identical"
+else
+  puts "mustache and musterb differ (this will usually be whitespace)"
+  puts "mustache:"
+  puts mustache.call
+  puts "--------------------------------------------------------------------------------"
+  puts "musterb:"
+  puts musterb.call
+  puts "--------------------------------------------------------------------------------"
+end
+
+Benchmark.bmbm do |x|
+  x.report("mustache") { 1000.times { mustache.call } }
+  x.report("musterb") { 1000.times { musterb.call } }
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: musterb
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -59,6 +59,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mustache
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: The ability to compile mustache templates to erubis erb templates so
   that we can make use of the performance of compiling templates
 email:
@@ -83,8 +99,12 @@ files:
   bGliL211c3RlcmIucmI=
 - !binary |-
   bGliL211c3RlcmIvYmluZGluZ19leHRyYWN0b3IucmI=
+- !binary |-
+  bGliL211c3RlcmIvY2hhaW4ucmI=
 - !binary |-
   bGliL211c3RlcmIvZXZhbHVhdG9yLnJi
+- !binary |-
+  bGliL211c3RlcmIvZXh0cmFjdF92YWx1ZXMucmI=
 - !binary |-
   bGliL211c3RlcmIvaGFzaF9leHRyYWN0b3IucmI=
 - !binary |-
@@ -111,6 +131,8 @@ files:
   c3BlYy9tdXN0ZXJiL29iamVjdF9leHRyYWN0b3Jfc3BlYy5yYg==
 - !binary |-
   c3BlYy9tdXN0ZXJiX3NwZWMucmI=
+- !binary |-
+  c3BlYy9wZXJmb3JtYW5jZS5yYg==
 - !binary |-
   c3BlYy9zcGVjX2hlbHBlci5yYg==
 homepage: ''
@@ -150,5 +172,7 @@ test_files:
   c3BlYy9tdXN0ZXJiL29iamVjdF9leHRyYWN0b3Jfc3BlYy5yYg==
 - !binary |-
   c3BlYy9tdXN0ZXJiX3NwZWMucmI=
+- !binary |-
+  c3BlYy9wZXJmb3JtYW5jZS5yYg==
 - !binary |-
   c3BlYy9zcGVjX2hlbHBlci5yYg==