braai 1.0.1 → 1.1.0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    braai (0.0.1)
+    braai (1.0.1)
       activesupport
 
 GEM

data/README.md

@@ -23,12 +23,12 @@ Or install it yourself as:
 
 Braai comes shipped with two simple matchers for you, but you can easily add your own.
 
-The first matcher is a simple <code>to_s</code> handler. It will match a single variable and then call <code>to_s</code> on it:
+The first matcher is a simple <code>to_s</code> matcher. It will match a single variable and then call <code>to_s</code> on it:
 
 <pre><code>
 template = "Hi {{ name }}!"
 response = Braai::Template.new(template).render(name: "Mark")
-response # => "Hi Mark!"
+response.should eql "Hi Mark!"
 </code></pre>
 
 The second matcher will call a method on the variable.
@@ -36,7 +36,7 @@ The second matcher will call a method on the variable.
 <pre><code>
 template = "Hi {{ name.upcase }}!"
 response = Braai::Template.new(template).render(name: "Mark")
-response # => "Hi MARK!"
+response.should eql "Hi MARK!"
 </code></pre>
 
 ### Custom Matchers
@@ -45,15 +45,16 @@ Braai let's you easily define your own matchers to do whatever you would like to
 
 <pre><code>
 template = "I'm {{ name }} and {{ mmm... bbq }}!"
-Braai::Template.map(/mmm\.\.\. bbq/i) do |template, key, matches|
+Braai::Template.map(/({{\s*mmm\.\.\. bbq\s*}})/i) do |template, key, matches|
   "Damn, I love BBQ!"
 end
 
-Braai::Template.map(/name/i) do |template, key, matches|
-  template.attributes[matches.first].upcase
+Braai::Template.map(/({{\s*name\s*}})/i) do |template, key, matches|
+  template.attributes[:name].upcase
 end
 
-Braai::Template.new(template).render # => "I'm MARK and Damn, I love BBQ!!"
+response = Braai::Template.new(template).render(name: "mark")
+response.should eql "I'm MARK and Damn, I love BBQ!!"
 </code></pre>
 
 ### For Loops
@@ -61,7 +62,7 @@ Braai::Template.new(template).render # => "I'm MARK and Damn, I love BBQ!!"
 Braai supports looping right out of the box.
 
 <pre><code>
-template = <<-EOF
+template = &lt;&lt;-EOF
 &lt;h1>{{ greet }}&lt;/h1>
 &lt;ul>
   {{ for product in products }}
@@ -76,19 +77,14 @@ template = <<-EOF
 &lt;h2>{{greet.upcase}}&lt;/h2>
 EOF
 
-Braai::Template.new(template).render(greet: "mark", products: %w{car boat truck}, foods: %w{apple orange})
-# =>
-"&lt;h1>mark&lt;/h1>
-&lt;ul>
-    &lt;li>car&lt;/li>
-    &lt;li>boat&lt;/li>
-    &lt;li>truck&lt;/li>
-&lt;/ul>
-&lt;div>
-    &lt;p>apple&lt;/p>
-    &lt;p>orange&lt;/p>
-&lt;/div>
-&lt;h2>MARK&lt;/h2>"
+res = Braai::Template.new(template).render(greet: "mark", products: %w{car boat truck}, foods: %w{apple orange})
+res.should match("&lt;h1>mark&lt;/h1>")
+res.should match("&lt;li>car&lt;/li>")
+res.should match("&lt;li>boat&lt;/li>")
+res.should match("&lt;li>truck&lt;/li>")
+res.should match("&lt;p>apple&lt;/p>")
+res.should match("&lt;p>orange&lt;/p>")
+res.should match("&lt;h2>MARK&lt;/h2>")
 </code></pre>
 
 ## Contributing

data/lib/braai/configuration.rb

@@ -1,16 +1,10 @@
 class Braai::Configuration
 
   attr_accessor :logger
-  attr_accessor :raise_on_missing_handler
-  attr_accessor :swallow_handler_errors
-  attr_accessor :for_loop_regex
-  attr_accessor :handler_regex
+  attr_accessor :swallow_matcher_errors
 
   def initialize
-    self.raise_on_missing_handler = false
-    self.swallow_handler_errors = true
-    self.handler_regex = /{{\s*[^}]+\s*}}/i
-    self.for_loop_regex = /({{\s*for (\w+) in (\w+)\s*}}(.+?){{\s*\/for\s*}})/im
+    self.swallow_matcher_errors = true
   end
 
   def logger

data/lib/braai/context.rb

@@ -2,65 +2,30 @@ class Braai::Context
 
   attr_accessor :attributes
   attr_accessor :template
-  attr_accessor :handlers
+  attr_accessor :matchers
 
-  def initialize(template, handlers, attributes = {})
+  def initialize(template, matchers, attributes = {})
     self.attributes = HashWithIndifferentAccess.new(attributes)
     self.template = template.dup
-    self.handlers = handlers
+    self.matchers = matchers
   end
 
   def render
     begin
-      self.render!
-    rescue Exception => e
-      Braai.logger.error(e)
-      raise e
-    end
-  end
-
-  def render!
-    self.process_loops
-    self.process_keys
-    return self.template
-  end
-
-  protected
-  def process_loops
-    loops = self.template.scan(Braai.config.for_loop_regex)
-    loops.each do |loop|
-      res = []
-      self.attributes[loop[2]].each do |val|
-        res << Braai::Context.new(loop[3], self.handlers, self.attributes.merge(loop[1] => val)).render!
-      end
-      self.template.gsub!(loop[0], res.join("\n"))
-    end
-  end
-
-  def process_keys
-    keys = self.template.scan(Braai.config.handler_regex).flatten.uniq
-    keys.each do |key|
-      self.handle_key(key)
-    end
-  end
-
-  def handle_key(key)
-    stripped_key = key.gsub(/({|})/, "").strip
-    matched = false
-    self.handlers.each do |regex, handler|
-      regex = Regexp.new(regex)
-      if regex.match(stripped_key)
-        begin
-          val = handler.call(self, stripped_key, stripped_key.scan(regex).flatten)
-          self.template.gsub!(key, val.to_s) if val
-        rescue Exception => e
-          raise e unless Braai.config.swallow_handler_errors
+      self.matchers.each do |regex, matcher|
+        regex = Regexp.new(regex)
+        matches = self.template.scan(regex)
+        matches.each do |set|
+          val = matcher.call(self, set[0], set)
+          self.template.gsub!(set[0], val.to_s) if val
         end
-        matched = true
-        break
       end
+      return self.template
+    rescue Exception => e
+      puts e.inspect
+      Braai.logger.error(e)
+      raise e unless Braai.config.swallow_matcher_errors
     end
-    raise Braai::MissingHandlerError.new(stripped_key) if !matched && Braai.config.raise_on_missing_handler    
   end
 
 end

data/lib/braai/matchers.rb

@@ -0,0 +1,40 @@
+module Braai::Matchers
+
+  def matchers
+    @matchers ||= reset!
+  end
+
+  def map(regex, &block)
+    @matchers = {regex.to_s => block}.merge(self.matchers)
+  end
+
+  def unmap(regex)
+    self.matchers.delete(regex.to_s)
+  end
+
+  def clear!
+    self.matchers.clear
+  end
+
+  def reset!
+    @matchers = {
+      /({{\s*for (\w+) in (\w+)\s*}}(.+?){{\s*\/for\s*}})/im => ->(template, key, matches) {
+        res = []
+        template.attributes[matches[2]].each do |val|
+          res << Braai::Context.new(matches[3], template.matchers, template.attributes.merge(matches[1] => val)).render
+        end
+        res.join("\n")
+      },
+      /({{\s*([\w]+)\.([\w]+)\s*}})/i => ->(template, key, matches) {
+        attr = template.attributes[matches[1]]
+        attr ? attr.send(matches[2]) : nil
+      },
+      /({{\s*([\w]+)\s*}})/i => ->(template, key, matches) {
+        attr = template.attributes[matches.last]
+        attr ? attr.to_s : nil
+      }
+    }
+    return @matchers
+  end
+
+end

data/lib/braai/template.rb

@@ -1,27 +1,18 @@
 class Braai::Template
-  extend Braai::Handlers
-  include Braai::Handlers
+  extend Braai::Matchers
+  include Braai::Matchers
 
   attr_accessor :attributes
   attr_accessor :template
 
-  def initialize(template, handlers = {})
+  def initialize(template, matchers = {})
     self.template = template
-    @handlers = self.class.handlers.merge(handlers)
+    @matchers = self.class.matchers.merge(matchers)
   end
 
   def render(attributes = {})
-    begin
-      return self.render!(attributes)
-    rescue Exception => e
-      Braai.logger.error(e)
-      raise e
-    end
-  end
-
-  def render!(attributes)
-    context = Braai::Context.new(self.template, self.handlers, attributes)
-    context.render!
+    context = Braai::Context.new(self.template, self.matchers, attributes)
+    context.render
   end
 
 end

data/lib/braai/version.rb

@@ -1,3 +1,3 @@
 module Braai
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/braai.rb

@@ -2,8 +2,7 @@ require 'logger'
 require 'active_support/hash_with_indifferent_access'
 require "braai/version"
 require "braai/configuration"
-require "braai/errors"
-require "braai/handlers"
+require "braai/matchers"
 require "braai/template"
 require "braai/context"
 

data/spec/braai/matchers_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe Braai::Matchers do
+  include Braai::Matchers
+  
+  describe 'map' do
+
+    it "maps a new matcher" do
+      map("foo") {}
+      matchers.should include("foo")
+    end
+
+    it "makes the latest matcher the first matcher in the list" do
+      map("foo") {}
+      map("bar") {}
+      matchers.keys.first.should eql("bar")
+    end
+    
+  end
+
+  describe 'unmap' do
+    
+    it "unmaps a matcher" do
+      map("foo") {}
+      matchers.should include("foo")
+      unmap("foo")
+      matchers.should_not include("foo")
+    end
+
+  end
+
+  describe 'clear!' do
+    
+    it "removes all of the matchers" do
+      map("foo") {}
+      matchers.should_not be_empty
+      clear!
+      matchers.should be_empty
+    end
+
+  end
+
+  describe 'reset!' do
+    
+    it "resets the matchers to their original state" do
+      matchers.should have(3).matchers
+      map("foo") {}
+      matchers.should have(4).matchers
+      reset!
+      matchers.should have(3).matchers
+    end
+
+  end
+
+end

data/spec/braai/readme_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe 'README' do
+
+  it "simple example" do
+    template = "Hi {{ name }}!"
+    response = Braai::Template.new(template).render(name: "Mark")
+    response.should eql "Hi Mark!"
+  end  
+
+  it "simple method call example" do
+    template = "Hi {{ name.upcase }}!"
+    response = Braai::Template.new(template).render(name: "Mark")
+    response.should eql "Hi MARK!"
+  end
+
+  it "custom matcher example" do
+    template = "I'm {{ name }} and {{ mmm... bbq }}!"
+    Braai::Template.map(/({{\s*mmm\.\.\. bbq\s*}})/i) do |template, key, matches|
+      "Damn, I love BBQ!"
+    end
+
+    Braai::Template.map(/({{\s*name\s*}})/i) do |template, key, matches|
+      template.attributes[:name].upcase
+    end
+
+    response = Braai::Template.new(template).render(name: "mark")
+    response.should eql "I'm MARK and Damn, I love BBQ!!"
+  end
+
+  it "for loop example" do
+    template = <<-EOF
+<h1>{{ greet }}</h1>
+<ul>
+  {{ for product in products }}
+    <li>{{ product }}</li>
+  {{ /for }}
+</ul>
+<div>
+  {{ for food in foods }}
+    <p>{{ food }}</p>
+  {{ /for }}
+</div>
+<h2>{{greet.upcase}}</h2>
+EOF
+
+  res = Braai::Template.new(template).render(greet: "mark", products: %w{car boat truck}, foods: %w{apple orange})
+  res.should match("<h1>mark</h1>")
+  res.should match("<li>car</li>")
+  res.should match("<li>boat</li>")
+  res.should match("<li>truck</li>")
+  res.should match("<p>apple</p>")
+  res.should match("<p>orange</p>")
+  res.should match("<h2>MARK</h2>")
+  end
+
+        # it "description" do
+      #   template = "I'm {{ name }} and {{ mmm... bbq }}!"
+      #   Braai::Template.map(/mmm\.\.\. bbq/i) do |template, key, matches|
+      #     puts "key: #{key.inspect}"
+      #     puts "matches: #{matches.inspect}"
+      #     "Damn, I love BBQ!"
+      #   end
+
+      #   Braai::Template.map(/name/i) do |template, key, matches|
+      #     template.attributes[matches.first].upcase
+      #   end
+
+      #   puts Braai::Template.new(template).render(name: "Mark")
+      # end
+
+end

data/spec/braai/template_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Braai::Template do
   
   let(:greet_regex) { /^greet$/i }
-  let(:greet_handler) do
+  let(:greet_matcher) do
     ->(view, key, matches) {
       view.attributes[:greet]
     }
@@ -11,10 +11,10 @@ describe Braai::Template do
 
   describe '.map' do
 
-    it "let's you register a handler" do
-      Braai::Template.handlers.should_not have_key(greet_regex.to_s)
-      Braai::Template.map(greet_regex, &greet_handler)
-      Braai::Template.handlers.should have_key(greet_regex.to_s)
+    it "let's you register a matcher" do
+      Braai::Template.matchers.should_not have_key(greet_regex.to_s)
+      Braai::Template.map(greet_regex, &greet_matcher)
+      Braai::Template.matchers.should have_key(greet_regex.to_s)
     end
     
   end
@@ -22,7 +22,7 @@ describe Braai::Template do
   describe '#render' do
 
     before(:each) do
-      Braai::Template.map(greet_regex, &greet_handler)
+      Braai::Template.map(greet_regex, &greet_matcher)
     end
     
     it "renders a simple template" do
@@ -57,7 +57,6 @@ EOF
 
       it "renders the loop" do
         res = Braai::Template.new(template).render(greet: "mark", products: %w{car boat truck}, foods: %w{apple orange})
-        puts res
         res.should match("<h1>mark</h1>")
         res.should match("<li>car</li>")
         res.should match("<li>boat</li>")
@@ -67,28 +66,13 @@ EOF
         res.should match("<h2>MARK</h2>")
       end
 
-      # it "description" do
-      #   template = "I'm {{ name }} and {{ mmm... bbq }}!"
-      #   Braai::Template.map(/mmm\.\.\. bbq/i) do |template, key, matches|
-      #     puts "key: #{key.inspect}"
-      #     puts "matches: #{matches.inspect}"
-      #     "Damn, I love BBQ!"
-      #   end
-
-      #   Braai::Template.map(/name/i) do |template, key, matches|
-      #     template.attributes[matches.first].upcase
-      #   end
-
-      #   puts Braai::Template.new(template).render(name: "Mark")
-      # end
-
     end
 
-    context "default handler" do
+    context "default matcher" do
       
       let(:template) { "{{ greet }} {{ name.upcase }}" }
 
-      it "uses the default handler to render" do
+      it "uses the default matcher to render" do
         res = Braai::Template.new(template).render(greet: "Hi", name: "mark")
         res.should eql("Hi MARK")
       end
@@ -100,73 +84,35 @@ EOF
 
     end
 
-    context "missing handlers" do
-
-      before(:each) do
-        Braai::Template.reset!
-      end
-
-      after(:each) do
-        Braai.config.raise_on_missing_handler = false
-      end
-      
-      context "raise_on_missing_handler is true" do
-        
-        before(:each) do
-          Braai.config.raise_on_missing_handler = true
-        end
-
-        it "raises an error" do
-          expect {
-            Braai::Template.new("{{ please.greet.me }}").render(greet: "Hi Mark")
-          }.to raise_error(Braai::MissingHandlerError)
-        end
-
-      end
-
-      context "raise_on_missing_handler is false" do
-
-        it "does not raise an error" do
-          expect {
-            res = Braai::Template.new("{{ greet }}").render(greet: "Hi Mark")
-            res.should eql("{{ greet }}")
-          }.to_not raise_error(Braai::MissingHandlerError)
-        end
-        
-      end
-
-    end
-
-    context "handler errors" do
+    context "matcher errors" do
       
       before(:each) do
-        Braai::Template.map(/^foo$/) do |view, key, matches|
+        Braai::Template.map(/foo/) do |view, key, matches|
           raise ArgumentError 
         end
       end
 
-      let(:template) { "{{ foo }}" }
+      let(:template) { "foo" }
 
-      context "swallow_handler_errors is true" do
+      context "swallow_matcher_errors is true" do
         
-        it "swallows errors in the handler" do
+        it "swallows errors in the matcher" do
           expect {
             res = Braai::Template.new(template).render()
-            res.should eql template
           }.to_not raise_error
         end
 
       end
 
-      context "swallow_handler_errors is false" do
+      context "swallow_matcher_errors is false" do
 
         before(:each) do
-          Braai.config.swallow_handler_errors = false
+          Braai.config.swallow_matcher_errors = false
         end
         
-        it "raises the errors from the handler" do
+        it "raises the errors from the matcher" do
           expect {
-            Braai::Template.new(template).render()
+            res = Braai::Template.new(template).render
           }.to raise_error(ArgumentError)
         end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: braai
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-28 00:00:00.000000000 Z
+date: 2012-08-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -44,11 +44,11 @@ files:
 - lib/braai.rb
 - lib/braai/configuration.rb
 - lib/braai/context.rb
-- lib/braai/errors.rb
-- lib/braai/handlers.rb
+- lib/braai/matchers.rb
 - lib/braai/template.rb
 - lib/braai/version.rb
-- spec/braai/handlers_spec.rb
+- spec/braai/matchers_spec.rb
+- spec/braai/readme_spec.rb
 - spec/braai/template_spec.rb
 - spec/spec_helper.rb
 homepage: ''
@@ -76,6 +76,7 @@ signing_key:
 specification_version: 3
 summary: Fully extensible templating system.
 test_files:
-- spec/braai/handlers_spec.rb
+- spec/braai/matchers_spec.rb
+- spec/braai/readme_spec.rb
 - spec/braai/template_spec.rb
 - spec/spec_helper.rb

data/lib/braai/errors.rb

@@ -1,7 +0,0 @@
-module Braai
-  class MissingHandlerError < StandardError
-    def initialize(key)
-      super "#{key} was missing a handler! Please implement one."
-    end
-  end
-end

data/lib/braai/handlers.rb

@@ -1,33 +0,0 @@
-module Braai::Handlers
-
-  def handlers
-    @handlers ||= reset!
-  end
-
-  def map(regex, &block)
-    @handlers = {regex.to_s => block}.merge(self.handlers)
-  end
-
-  def unmap(regex)
-    self.handlers.delete(regex.to_s)
-  end
-
-  def clear!
-    self.handlers.clear
-  end
-
-  def reset!
-    @handlers = {
-      /^([\w]+)\.([\w]+)$/i => ->(template, key, matches) {
-        attr = template.attributes[matches.first]
-        attr ? attr.send(matches.last) : nil
-      },
-      /^(\w+)$/i => ->(template, key, matches) {
-        attr = template.attributes[matches.first]
-        attr ? attr.to_s : nil
-      }
-    }
-    return @handlers
-  end
-
-end

data/spec/braai/handlers_spec.rb

@@ -1,55 +0,0 @@
-require 'spec_helper'
-
-describe Braai::Handlers do
-  include Braai::Handlers
-  
-  describe 'map' do
-
-    it "maps a new handler" do
-      map("foo") {}
-      handlers.should include("foo")
-    end
-
-    it "makes the latest handler the first handler in the list" do
-      map("foo") {}
-      map("bar") {}
-      handlers.keys.first.should eql("bar")
-    end
-    
-  end
-
-  describe 'unmap' do
-    
-    it "unmaps a handler" do
-      map("foo") {}
-      handlers.should include("foo")
-      unmap("foo")
-      handlers.should_not include("foo")
-    end
-
-  end
-
-  describe 'clear!' do
-    
-    it "removes all of the handlers" do
-      map("foo") {}
-      handlers.should_not be_empty
-      clear!
-      handlers.should be_empty
-    end
-
-  end
-
-  describe 'reset!' do
-    
-    it "resets the handlers to their original state" do
-      handlers.should have(2).handlers
-      map("foo") {}
-      handlers.should have(3).handlers
-      reset!
-      handlers.should have(2).handlers
-    end
-
-  end
-
-end