mustache 0.1.4 → 0.2.0

data/.kick

@@ -0,0 +1,26 @@
+# take control of the growl notifications
+module GrowlHacks
+  def growl(type, subject, body, *args, &block)
+    case type
+    when Kicker::GROWL_NOTIFICATIONS[:succeeded]
+      puts subject = "Success"
+      body = body.split("\n").last
+    when Kicker::GROWL_NOTIFICATIONS[:failed]
+      subject = "Failure"
+      puts body
+      body = body.split("\n").last
+    else
+      return nil
+    end
+    super(type, subject, body, *args, &block)
+  end
+end
+
+Kicker.send :extend, GrowlHacks
+
+# no logging
+Kicker::Utils.module_eval do
+  def log(message)
+    nil
+  end
+end

data/README.md

@@ -1,10 +1,8 @@
 Mustache
 =========
 
-Inspired by [ctemplate](http://code.google.com/p/google-ctemplate/)
-and
-[et](http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html),
-Mustache is a framework-agnostic way to render logic-free views.
+Inspired by [ctemplate][1] and [et][2], Mustache is a
+framework-agnostic way to render logic-free views.
 
 As ctemplates says, "It emphasizes separating logic from presentation:
 it is impossible to embed application logic in this template language."
@@ -82,7 +80,7 @@ Now let's write the template:
 This template references our view methods. To bring it all together,
 here's the code to render actual HTML;
 
-    Simple.new.to_html
+    Simple.render
 
 Which returns the following:
 
@@ -184,7 +182,7 @@ We can fill in the values at will:
     dict = Dict.new
     dict[:name] = 'George'
     dict[:value] = 100
-    dict.to_html
+    dict.render
 
 Which returns:
 
@@ -194,7 +192,7 @@ Which returns:
 We can re-use the same object, too:
 
     dict[:name] = 'Tony'
-    dict.to_html
+    dict.render
     Hello Tony
     You have just won $100!
 
@@ -299,7 +297,7 @@ normal class.
 
 Now:
 
-    Simple.new(request.ssl?).to_html
+    Simple.new(request.ssl?).render
 
 Convoluted but you get the idea.
 
@@ -312,6 +310,9 @@ Mustache ships with Sinatra integration. Please see
 <http://defunkt.github.com/mustache/classes/Mustache/Sinatra.html> for
 complete documentation.
 
+An example Sinatra application is also provided:
+<http://github.com/defunkt/mustache-sinatra-example>
+
 
 Installation
 ------------
@@ -343,3 +344,6 @@ Meta
 * Test: <http://runcoderun.com/defunkt/mustache>
 * Gems: <http://gemcutter.org/gems/mustache>
 * Boss: Chris Wanstrath :: <http://github.com/defunkt>
+
+[1]: http://code.google.com/p/google-ctemplate/
+[2]: http://www.ivan.fomichev.name/2008/05/erlang-template-engine-prototype.html

data/Rakefile

@@ -9,6 +9,12 @@ Rake::TestTask.new do |t|
   t.verbose = false
 end
 
+desc "Launch Kicker (like autotest)"
+task :kicker do
+  puts "Kicking... (ctrl+c to cancel)"
+  exec "kicker -e rake test lib"
+end
+
 begin
   require 'jeweler'
   $LOAD_PATH.unshift 'lib'
@@ -23,7 +29,8 @@ begin
     gemspec.version = Mustache::Version
   end
 rescue LoadError
-  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+  puts "Jeweler not available."
+  puts "Install it with: gem install jeweler"
 end
 
 begin
@@ -34,6 +41,9 @@ end
 
 desc "Push a new version to Gemcutter"
 task :publish => [ :gemspec, :build ] do
-  system "gem push pkg/mustache-#{Mustache::Version}.gem" 
-  exec "git clean -fd"
+  system "git tag v#{Mustache::Version}"
+  system "git push origin v#{Mustache::Version}"
+  system "gem push pkg/mustache-#{Mustache::Version}.gem"
+  system "git clean -fd"
+  exec "rake pages"
 end

data/benchmarks/speed.rb

@@ -41,9 +41,11 @@ end
 
 content = File.read(ComplexView.template_file)
 
-bench '{ w/o caching' do
-  tpl = ComplexView.new
-  tpl.template = content
-  tpl[:item] = items
-  tpl.to_html
+unless ENV['CACHED']
+  bench '{ w/o caching' do
+    tpl = ComplexView.new
+    tpl.template = content
+    tpl[:item] = items
+    tpl.to_html
+  end
 end

data/examples/inner_partial.txt

@@ -0,0 +1 @@
+## Again, {{title}}! ##

data/examples/template_partial.rb

@@ -7,6 +7,10 @@ class TemplatePartial < Mustache
   def title
     "Welcome"
   end
+
+  def title_bars
+    '-' * title.size
+  end
 end
 
 if $0 == __FILE__

data/examples/template_partial.txt

@@ -0,0 +1,4 @@
+{{title}}
+{{title_bars}}
+
+{{<inner_partial}}

data/lib/mustache.rb

@@ -1,172 +1,126 @@
-require 'cgi'
-
+require 'mustache/template'
+require 'mustache/context'
+
+# Mustache is the base class from which your Mustache subclasses
+# should inherit (though it can be used on its own).
+#
+# The typical Mustache workflow is as follows:
+#
+# * Create a Mustache subclass: class Stats < Mustache
+# * Create a template: stats.html
+# * Instantiate an instance: view = Stats.new
+# * Render that instance: view.render
+#
+# You can skip the instantiation by calling `Stats.render` directly.
+#
+# While Mustache will do its best to load and render a template for
+# you, this process is completely customizable using a few options.
+#
+# All settings can be overriden at either the class or instance
+# level. For example, going with the above example, we can do either
+# `Stats.template_path = "/usr/local/templates"` or
+# `view.template_path = "/usr/local/templates"`
+#
+# Here are the available options:
+#
+# * template_path
+#
+# The `template_path` setting determines the path Mustache uses when
+# looking for a template. By default it is "."
+# Setting it to /usr/local/templates, for example, means (given all
+# other settings are default) a Mustache subclass `Stats` will try to
+# load /usr/local/templates/stats.html
+#
+# * template_extension
+#
+# The `template_extension` is the extension Mustache uses when looking
+# for template files. By default it is "html"
+#
+# * template_file
+#
+# You can tell Mustache exactly which template to us with this
+# setting. It can be a relative or absolute path.
+#
+# * template
+#
+# Sometimes you want Mustache to render a string, not a file. In those
+# cases you may set the `template` setting. For example:
+#
+#   >> Mustache.render("Hello {{planet}}", :planet => "World!")
+#   => "Hello World!"
+#
 class Mustache
-  # A Template is a compiled version of a Mustache template.
-  class Template
-    def initialize(source, template_path)
-      @source = source
-      @template_path = template_path
-      @tmpid = 0
-    end
-
-    def render(context)
-      class << self; self; end.class_eval <<-EOF, __FILE__, __LINE__ - 1
-        def render(ctx)
-          #{compile}
-        end
-      EOF
-      render(context)
-    end
-
-    def compile(src = @source)
-      "\"#{compile_sections(src)}\""
-    end
-
-  ## private
-
-    # {{#sections}}okay{{/sections}}
-    #
-    # Sections can return true, false, or an enumerable.
-    # If true, the section is displayed.
-    # If false, the section is not displayed.
-    # If enumerable, the return value is iterated over (a for loop).
-    def compile_sections(src)
-      res = ""
-      while src =~ /^\s*\{\{\#(.+)\}\}\n*(.+)^\s*\{\{\/\1\}\}\n*/m
-        res << compile_tags($`)
-        name = $1.strip.to_sym.inspect
-        code = compile($2)
-        ctxtmp = "ctx#{tmpid}"
-        res << ev("(v = ctx[#{name}]) ? v.respond_to?(:each) ? "\
-          "(#{ctxtmp}=ctx.dup; r=v.map{|h|ctx.merge!(h);#{code}}.join; "\
-          "ctx.replace(#{ctxtmp});r) : #{code} : ''")
-        src = $'
-      end
-      res << compile_tags(src)
-    end
-
-    # Find and replace all non-section tags.
-    # In particular we look for four types of tags:
-    # 1. Escaped variable tags - {{var}}
-    # 2. Unescaped variable tags - {{{var}}}
-    # 3. Comment variable tags - {{! comment}
-    # 4. Partial tags - {{< partial_name }}
-    def compile_tags(src)
-      res = ""
-      while src =~ /\{\{(!|<|\{)?([^\/#]+?)\1?\}\}+/
-        res << str($`)
-        case $1
-        when '!'
-          # ignore comments
-        when '<'
-          res << compile_partial($2.strip)
-        when '{'
-          res << utag($2.strip)
-        else
-          res << etag($2.strip)
-        end
-        src = $'
-      end
-      res << str(src)
-    end
-
-    # Partials are basically a way to render views from inside other views.
-    def compile_partial(name)
-      klass = Mustache.classify(name)
-      if Object.const_defined?(klass)
-        ev("#{klass}.render")
-      else
-        src = File.read(@template_path + '/' + name + '.html')
-        compile(src)[1..-2]
-      end
-    end
-
-    # Generate a temporary id.
-    def tmpid
-      @tmpid += 1
-    end
-
-    def str(s)
-      s.inspect[1..-2]
-    end
-
-    def etag(s)
-      ev("Mustache.escape(ctx[#{s.strip.to_sym.inspect}])")
-    end
-
-    def utag(s)
-      ev("ctx[#{s.strip.to_sym.inspect}]")
-    end
+  # Helper method for quickly instantiating and rendering a view.
+  def self.render(*args)
+    new.render(*args)
+  end
 
-    def ev(s)
-      "#\{#{s}}"
-    end
+  # Alias for `render`
+  def self.to_html(*args)
+    render(*args)
   end
 
-  class Context < Hash
-    def initialize(mustache)
-      @mustache = mustache
-      super()
-    end
+  # Alias for `render`
+  def self.to_text(*args)
+    render(*args)
+  end
 
-    def [](name)
-      if has_key?(name)
-        super
-      elsif @mustache.respond_to?(name)
-        @mustache.send(name)
-      else
-        raise "Can't find #{name} in #{inspect}"
-      end
-    end
+  # The template path informs your Mustache subclass where to look for its
+  # corresponding template. By default it's the current directory (".")
+  def self.template_path
+    @template_path || '.'
   end
 
-  # Helper method for quickly instantiating and rendering a view.
-  def self.render(*args)
-    new.render(*args)
+  def self.template_path=(path)
+    @template_path = File.expand_path(path)
   end
 
-  class << self
-    alias_method :to_html, :render
-    alias_method :to_text, :render
+  # Alias for `template_path`
+  def self.path
+    template_path
   end
 
-  # The path informs your Mustache subclass where to look for its
-  # corresponding template.
+  # Alias for `template_path`
   def self.path=(path)
-    @path = File.expand_path(path)
+    self.template_path = path
   end
 
-  def self.path
-    @path || '.'
+  # A Mustache template's default extension is 'html'
+  def self.template_extension
+    @template_extension || 'html'
   end
 
-  # Templates are self.class.name.underscore + extension -- a class of
-  # Dashboard would have a template (relative to the path) of
-  # dashboard.html
+  def self.template_extension=(template_extension)
+    @template_extension = template_extension
+  end
+
+  # The template file is the absolute path of the file Mustache will
+  # use as its template. By default it's ./class_name.html
   def self.template_file
-    @template_file ||= path + '/' + underscore(to_s) + '.' + template_extension
+    @template_file || "#{template_path}/#{underscore(to_s)}.#{template_extension}"
   end
 
   def self.template_file=(template_file)
     @template_file = template_file
   end
 
+  # The template is the actual string Mustache uses as its template.
+  # There is a bit of magic here: what we get back is actually a
+  # Mustache::Template object here, but you can still safely use
+  # `template=` with a string.
   def self.template
-    @template ||= templateify(File.read(template_file))
+    @template || templateify(File.read(template_file))
   end
 
-  # Default extension is 'html'
-  def self.template_extension
-    @template_extension ||= 'html'
-  end
-
-  def self.template_extension=(template_extension)
-    @template_extension = template_extension
+  def self.template=(template)
+    @template = templateify(template)
   end
 
   # template_partial => TemplatePartial
   def self.classify(underscored)
-    underscored.split(/[-_]/).map { |part| part[0] = part[0].chr.upcase; part }.join
+    underscored.split(/[-_]/).map do |part|
+      part[0] = part[0].chr.upcase; part
+    end.join
   end
 
   # TemplatePartial => template_partial
@@ -176,31 +130,60 @@ class Mustache
     string.gsub(/[A-Z]/) { |s| "_#{s.downcase}"}
   end
 
-  # Escape HTML.
-  def self.escape(string)
-    CGI.escapeHTML(string.to_s)
+  # Turns a string into a Mustache::Template. If passed a Template,
+  # returns it.
+  def self.templateify(obj)
+    if obj.is_a?(Template)
+      obj
+    else
+      Template.new(obj.to_s, template_path, template_extension)
+    end
   end
 
-  def self.templateify(obj)
-    obj.is_a?(Template) ? obj : Template.new(obj.to_s, path)
+  # Instance version.Turns a string into a Mustache::Template. If passed a Template,
+  def templateify(obj)
+    if obj.is_a?(Template)
+      obj
+    else
+      Template.new(obj.to_s, template_path, template_extension)
+    end
   end
 
-  # The template itself. You can override this if you'd like.
-  def template
-    @template ||= self.class.template
+  #
+  # Instance level settings
+  #
+
+  def template_path
+    @template_path || self.class.template_path
   end
 
-  def template=(template)
-    @template = self.class.templateify(template)
+  def template_path=(template_path)
+    @template_path = template_path
   end
 
-  # Pass a block to `debug` with your debug putses. Set the `DEBUG`
-  # env variable when you want to run those blocks.
-  #
-  # e.g.
-  #  debug { puts @context.inspect }
-  def debug
-    yield if ENV['DEBUG']
+  def template_extension
+    @template_extension || self.class.template_extension
+  end
+
+  def template_extension=(template_extension)
+    @template_extension = template_extension
+  end
+
+  def template_file
+    return @template_file if @template_file
+    "#{template_path}/#{Mustache.underscore(self.class.name)}.#{template_extension}"
+  end
+
+  def template_file=(template_file)
+    @template_file = template_file
+  end
+
+  def template
+    @template || templateify(File.read(template_file))
+  end
+
+  def template=(template)
+    @template = templateify(template)
   end
 
   # A helper method which gives access to the context at a given time.
@@ -210,7 +193,12 @@ class Mustache
     @context ||= Context.new(self)
   end
 
-  # Context accessors
+  # Context accessors.
+  #
+  # view = Mustache.new
+  # view[:name] = "Jon"
+  # view.template = "Hi, {{name}}!"
+  # view.render # => "Hi, Jon!"
   def [](key)
     context[key.to_sym]
   end
@@ -222,7 +210,7 @@ class Mustache
   # Parses our fancy pants template file and returns normal file with
   # all special {{tags}} and {{#sections}}replaced{{/sections}}.
   def render(data = template, ctx = {})
-    self.class.templateify(data).render(context.update(ctx))
+    templateify(data).render(context.update(ctx))
   end
   alias_method :to_html, :render
   alias_method :to_text, :render

data/lib/mustache/context.rb

@@ -0,0 +1,20 @@
+class Mustache
+  # A Context represents the context which a Mustache template is
+  # executed within. All Mustache tags reference keys in the Context.
+  class Context < Hash
+    def initialize(mustache)
+      @mustache = mustache
+      super()
+    end
+
+    def [](name)
+      if has_key?(name)
+        super
+      elsif @mustache.respond_to?(name)
+        @mustache.send(name)
+      else
+        raise "Can't find #{name} in #{@mustache.inspect}"
+      end
+    end
+  end
+end

data/lib/mustache/template.rb

@@ -0,0 +1,127 @@
+require 'cgi'
+
+class Mustache
+  # A Template is a compiled version of a Mustache template.
+  #
+  # The idea is this: when handed a Mustache template, convert it into
+  # a Ruby string by transforming Mustache tags into interpolated
+  # Ruby.
+  #
+  # You shouldn't use this class directly.
+  class Template
+    # Expects a Mustache template as a string along with a template
+    # path, which it uses to find partials.
+    def initialize(source, template_path = '.', template_extension = 'html')
+      @source = source
+      @template_path = template_path
+      @template_extension = template_extension
+      @tmpid = 0
+    end
+
+    # Renders the `@source` Mustache template using the given
+    # `context`, which should be a simple hash keyed with symbols.
+    def render(context)
+      # Compile our Mustache template into a Ruby string
+      compiled = "def render(ctx) #{compile} end"
+
+      # Here we rewrite ourself with the interpolated Ruby version of
+      # our Mustache template so subsequent calls are very fast and
+      # can skip the compilation stage.
+      instance_eval(compiled, __FILE__, __LINE__ - 1)
+
+      # Call the newly rewritten version of #render
+      render(context)
+    end
+
+    # Does the dirty work of transforming a Mustache template into an
+    # interpolation-friendly Ruby string.
+    def compile(src = @source)
+      "\"#{compile_sections(src)}\""
+    end
+
+    # {{#sections}}okay{{/sections}}
+    #
+    # Sections can return true, false, or an enumerable.
+    # If true, the section is displayed.
+    # If false, the section is not displayed.
+    # If enumerable, the return value is iterated over (a `for` loop).
+    def compile_sections(src)
+      res = ""
+      while src =~ /^\s*\{\{\#(.+)\}\}\n*(.+)^\s*\{\{\/\1\}\}\n*/m
+        # $` = The string to the left of the last successful match
+        res << compile_tags($`)
+        name = $1.strip.to_sym.inspect
+        code = compile($2)
+        ctxtmp = "ctx#{tmpid}"
+        res << ev("(v = ctx[#{name}]) ? v.respond_to?(:each) ? "\
+          "(#{ctxtmp}=ctx.dup; r=v.map{|h|ctx.update(h);#{code}}.join; "\
+          "ctx.replace(#{ctxtmp});r) : #{code} : ''")
+        # $' = The string to the right of the last successful match
+        src = $'
+      end
+      res << compile_tags(src)
+    end
+
+    # Find and replace all non-section tags.
+    # In particular we look for four types of tags:
+    # 1. Escaped variable tags - {{var}}
+    # 2. Unescaped variable tags - {{{var}}}
+    # 3. Comment variable tags - {{! comment}
+    # 4. Partial tags - {{< partial_name }}
+    def compile_tags(src)
+      res = ""
+      while src =~ /\{\{(!|<|\{)?([^\/#]+?)\1?\}\}+/
+        res << str($`)
+        case $1
+        when '!'
+          # ignore comments
+        when '<'
+          res << compile_partial($2.strip)
+        when '{'
+          res << utag($2.strip)
+        else
+          res << etag($2.strip)
+        end
+        src = $'
+      end
+      res << str(src)
+    end
+
+    # Partials are basically a way to render views from inside other views.
+    def compile_partial(name)
+      klass = Mustache.classify(name)
+      if Object.const_defined?(klass)
+        ev("#{klass}.render")
+      else
+        src = File.read("#{@template_path}/#{name}.#{@template_extension}")
+        compile(src)[1..-2]
+      end
+    end
+
+    # Generate a temporary id, used when compiling code.
+    def tmpid
+      @tmpid += 1
+    end
+
+    # Get a (hopefully) literal version of an object, sans quotes
+    def str(s)
+      s.inspect[1..-2]
+    end
+
+    # {{}} - an escaped tag
+    def etag(s)
+      ev("CGI.escapeHTML(ctx[#{s.strip.to_sym.inspect}].to_s)")
+    end
+
+    # {{{}}} - an unescaped tag
+    def utag(s)
+      ev("ctx[#{s.strip.to_sym.inspect}]")
+    end
+
+    # An interpolation-friendly version of a string, for use within a
+    # Ruby string.
+    def ev(s)
+      "#\{#{s}}"
+    end
+  end
+end

data/lib/mustache/version.rb

@@ -1,3 +1,3 @@
 class Mustache
-  Version = '0.1.4'
+  Version = '0.2.0'
 end

data/test/mustache_test.rb

@@ -23,7 +23,7 @@ end_passenger
   end
 
   def test_complex_view
-    assert_equal <<-end_complex, ComplexView.to_html
+    assert_equal <<-end_complex, ComplexView.render
 <h1>Colors</h1>
   <ul>
       <li><strong>red</strong></li>
@@ -34,7 +34,7 @@ end_complex
   end
 
   def test_simple
-    assert_equal <<-end_simple, Simple.to_html
+    assert_equal <<-end_simple, Simple.render
 Hello Chris
 You have just won $10000!
 Well, $6000.0, after taxes.
@@ -47,7 +47,7 @@ end_simple
     view[:value] = '4000'
     view[:in_ca] = false
 
-    assert_equal <<-end_simple, view.to_html
+    assert_equal <<-end_simple, view.render
 Hello Bob
 You have just won $4000!
 end_simple
@@ -62,7 +62,7 @@ end_simple
       { :taxed_value => 3 },
     ]
 
-    assert_equal <<-end_simple, view.to_html
+    assert_equal <<-end_simple, view.render
 Hello Crazy
 You have just won $10000!
 Well, $1, after taxes.
@@ -76,11 +76,11 @@ end_simple
     view.template = 'Hi {{person}}!'
     view[:person]  = 'mom'
 
-    assert_equal 'Hi mom!', view.to_html
+    assert_equal 'Hi mom!', view.render
   end
 
   def test_view_partial
-    assert_equal <<-end_partial.strip, ViewPartial.to_html
+    assert_equal <<-end_partial.strip, ViewPartial.render
 <h1>Welcome</h1>
 Hello Chris
 You have just won $10000!
@@ -91,22 +91,34 @@ end_partial
   end
 
   def test_template_partial
-    assert_equal <<-end_partial.strip, TemplatePartial.to_html
+    assert_equal <<-end_partial.strip, TemplatePartial.render
 <h1>Welcome</h1>
 Again, Welcome!
 end_partial
   end
 
+  def test_template_partial_with_custom_extension
+    partial = TemplatePartial.new
+    partial.template_extension = 'txt'
+
+    assert_equal <<-end_partial.strip, partial.render.strip
+Welcome
+-------
+
+## Again, Welcome! ##
+end_partial
+  end
+
   def test_comments
-    assert_equal "<h1>A Comedy of Errors</h1>\n", Comments.to_html
+    assert_equal "<h1>A Comedy of Errors</h1>\n", Comments.render
   end
 
   def test_escaped
-    assert_equal '<h1>Bear &gt; Shark</h1>', Escaped.to_html
+    assert_equal '<h1>Bear &gt; Shark</h1>', Escaped.render
   end
 
   def test_unescaped
-    assert_equal '<h1>Bear > Shark</h1>', Unescaped.to_html
+    assert_equal '<h1>Bear > Shark</h1>', Unescaped.render
   end
 
   def test_classify
@@ -138,9 +150,9 @@ end_partial
 </VirtualHost>
 data
     template = File.read("examples/passenger.conf")
-    assert_equal expected, Mustache.render(template, :stage => 'production', 
-                                                     :server => 'example.com', 
+    assert_equal expected, Mustache.render(template, :stage => 'production',
+                                                     :server => 'example.com',
                                                      :deploy_to => '/var/www/example.com' )
   end
 
-end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mustache
 version: !ruby/object:Gem::Version 
-  version: 0.1.4
+  version: 0.2.0
 platform: ruby
 authors: 
 - Chris Wanstrath
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-10-08 00:00:00 -07:00
+date: 2009-10-10 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,6 +24,7 @@ extra_rdoc_files:
 - README.md
 files: 
 - .gitignore
+- .kick
 - CONTRIBUTORS
 - LICENSE
 - README.md
@@ -39,18 +40,22 @@ files:
 - examples/escaped.html
 - examples/escaped.rb
 - examples/inner_partial.html
+- examples/inner_partial.txt
 - examples/passenger.conf
 - examples/passenger.rb
 - examples/simple.html
 - examples/simple.rb
 - examples/template_partial.html
 - examples/template_partial.rb
+- examples/template_partial.txt
 - examples/unescaped.html
 - examples/unescaped.rb
 - examples/view_partial.html
 - examples/view_partial.rb
 - lib/mustache.rb
+- lib/mustache/context.rb
 - lib/mustache/sinatra.rb
+- lib/mustache/template.rb
 - lib/mustache/version.rb
 - test/mustache_test.rb
 has_rdoc: true