tomparse 0.1.0

data/.ruby

@@ -0,0 +1,47 @@
+---
+source:
+- meta
+authors:
+- name: Trans
+  email: transfire@gmail.com
+copyrights:
+- holder: Rubyworks
+  year: '2012'
+  license: BSD-2-Clause
+requirements:
+- name: microtest
+  groups:
+  - test
+  development: true
+- name: detroit
+  groups:
+  - build
+  development: true
+dependencies: []
+alternatives: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/tomparse.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/tomparse
+  docs: http://rubydoc.info/gems/tomparse
+  code: http://github.com/rubyworks/tomparse
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-03-04'
+summary: TomDoc parser for Ruby
+title: TomParse
+version: 0.1.0
+name: tomparse
+description: ! 'TomParse is a Ruby TomDoc parser. It contains no other functionality
+
+  than the ability to take a comment and parse it in accordance to the
+
+  TomDoc standard.'
+organization: rubyworks
+date: '2012-03-04'

data/HISTORY.md

@@ -0,0 +1,13 @@
+# Release History
+
+## 0.1.0 / 2012-03-04
+
+TomParse is stand-alone TomDoc parser, spun-off and rewritten from the original
+tomdoc.rb code from the defunkt/tomdoc project. Having a stand-alone project
+just for the parser, makes it more convenient for other libraries to make use,
+including, eventually, the original tomdoc project itself.
+
+Changes:
+
+* Happy Birthday.
+

data/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright 2002 Rubyworks. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+   1. Redistributions of source code must retain the above copyright notice,
+      this list of conditions and the following disclaimer.
+
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR  SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
+OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
+EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+(BSD-2-Clauase License)

data/README.md

@@ -0,0 +1,75 @@
+# TomParse
+
+[Website](http://github.com/rubyworks/tomparse) /
+[Report Issue](http://github.com/rubyworks/tomparse/issues) /
+[Source Code](http://github.com/rubyworks/tomparse) /
+[Gem Page](http://rubygems.org/gems/tomparse)
+
+[![Build Status](https://secure.travis-ci.org/rubyworks/tomparse.png)](http://travis-ci.org/rubyworks/tomparse)
+
+
+## Description
+
+TomParse is TomDoc parser for Ruby. It provides no other functionality
+than to take a code comment and parse it in to a convenient object-oriented
+structure in accordance with TomDoc standard.
+
+See [TomDoc](https://github.com/mojombo/tomdoc) for more information about
+the TomDoc format.
+
+
+## Limitations
+
+Current implmentation doesn't yet support named parameters. Hopefully
+that will be fixed soon in an upcoming release --any volunteers?
+
+
+## Installation
+
+    $ gem install tomparse
+
+
+## Instruction
+
+The primay interface is the `TomParse.parse` method. It will parse the
+comment and return a `TomParse::TomDoc` instance.
+
+    TomParse.parse(comment)  #=> TomParse::TomDoc
+
+The comment string can have comment markers ('#') or not. The
+parse will remove them if present. The resulting TomDoc object
+then has a selection of methods that provide information from
+the comment, such as `#arguments`, `#examples`, etc.
+
+See the [API documention](http://rubydoc.info/gems/tomparse/frames)
+for more details on this.
+
+
+## Example
+
+If you are unfamiliar with TomDoc, an example TomDoc comment for a method
+looks something like this:
+
+    # Duplicate some text an abitrary number of times.
+    #
+    # text  - The String to be duplicated.
+    # count - The Integer number of times to duplicate the text.
+    #
+    # Examples
+    #   multiplex('Tom', 4)
+    #   # => 'TomTomTomTom'
+    #
+    # Returns the duplicated String.
+    def multiplex(text, count)
+      text * count
+    end
+
+
+## License
+
+Copyright (c) 2012 Rubyworks
+
+TomParse is distributable under the terms of the *BSD-2-Clause* license.
+
+See LICENSE.txt for details.
+

data/lib/tomparse.rb

@@ -0,0 +1,469 @@
+module TomParse
+
+  # Main interface to parser.
+  #
+  # comment - code comment [String]
+  #
+  def self.parse(comment, parse_options={})
+    TomDoc.new(comment, parse_options)
+  end
+
+  # Raised when comment can't be parsed, which means it's most
+  # likely not valid TomDoc.
+  #
+  class ParseError < RuntimeError
+    # Create new ParseError object.
+    #
+    # doc - document string
+    #
+    def initialize(doc)
+      @doc = doc
+    end
+
+    # Provide access to document string.
+    #
+    # Returns String.
+    def message
+      @doc
+    end
+
+    # Provide access to document string.
+    #
+    # Returns String.
+    def to_s
+      @doc
+    end
+  end
+
+  # Encapsulate parsed tomdoc documentation.
+  #
+  # TODO: Currently uses lazy evaluation, eventually this should
+  # be removed and simply parsed at initialization time.
+  #
+  class TomDoc
+    attr_accessor :raw
+
+    # Public: Initialize a TomDoc object.
+    #
+    # text - The raw text of a method or class/module comment.
+    #
+    # Returns new TomDoc instance.
+    def initialize(text, parse_options={})
+      @raw = text.to_s.strip
+
+      @arguments        = []
+      @options          = []  # TODO
+      @examples         = []
+      @returns          = []
+      @raises           = []
+      @signatures       = []
+      @signature_fields = []
+
+      parse unless @raw.empty?
+    end
+
+    def to_s
+      @raw
+    end
+
+    # Validate given comment text.
+    #
+    # Returns true if comment is valid, otherwise false.
+    def self.valid?(text)
+      new(text).valid?
+    end
+
+    # Validate raw comment.
+    #
+    # Returns true if comment is valid, otherwise false.
+    def valid?
+      return false if !raw.include?('Returns')
+      return false if sections.size < 2
+      true
+    end
+
+    # Validate raw comment.
+    #
+    # Returns true if comment is valid.
+    # Raises ParseError if comment is not valid.
+    def validate
+      if !raw.include?('Returns')
+        raise ParseError.new("No `Returns' statement.")
+      end
+
+      if sections.size < 2
+        raise ParseError.new("No description section found.")
+      end
+
+      true
+    end
+
+    # The raw comment text cleaned-up and ready for section parsing.
+    #
+    # Returns cleaned-up comment String.
+    def tomdoc
+      lines = raw.split("\n")
+
+      # remove remark symbol
+      if lines.all?{ |line| /^\s*#/ =~ line }   
+        lines = lines.map do |line|
+          line =~ /^(\s*#)/ ? line.sub($1, '') : nil
+        end
+      end
+
+      # for some reason the first line is coming in without indention
+      # regardless, so we temporary remove it
+      first = lines.shift
+
+      # remove indention
+      spaces = lines.map do |line|
+        next if line.strip.empty?
+        md = /^(\s*)/.match(line)
+        md ? md[1].size : nil
+      end.compact
+
+      space = spaces.min || 0
+      lines = lines.map do |line|
+        if line.empty?
+          line.strip
+        else
+          line[space..-1]
+        end
+      end
+
+      # put first line back
+      lines.unshift(first.sub(/^\s*/,''))
+
+      lines.compact.join("\n")
+    end
+
+    # List of comment sections. These are divided simply on "\n\n".
+    #
+    # Returns Array of comment sections.
+    def sections
+      parsed {
+        @sections
+      }
+    end
+
+    # Description of method or class/module.
+    #
+    # Returns description String.
+    def description
+      parsed {
+        @description
+      }
+    end
+
+    # Description of method or class/module.
+    #
+    # Returns description String.
+    def arguments
+      parsed {
+        @arguments
+      }
+    end
+    alias args arguments
+
+    # List of use examples of a method or class/module.
+    #
+    # Returns String of examples.
+    def examples
+      parsed {
+        @examples
+      }
+    end
+
+    # Description of a methods yield procedure.
+    #
+    # Returns String decription of yield procedure.
+    def yields
+      parsed {
+        @yields
+      }
+    end
+
+    # The list of retrun values a method can return.
+    #
+    # Returns Array of method return descriptions.
+    def returns
+      parsed {
+        @returns
+      }
+    end
+
+    # A list of errors a method might raise.
+    #
+    # Returns Array of method raises descriptions.
+    def raises
+      parsed {
+        @raises
+      }
+    end
+
+    # A list of alternate method signatures.
+    #
+    # Returns Array of signatures.
+    def signatures
+      parsed {
+        @signatures 
+      }
+    end
+
+    # A list of signature fields.
+    #
+    # Returns Array of field definitions.
+    def signature_fields
+      parsed {
+        @signature_fields
+      }
+    end
+
+    # Check if method is public.
+    #
+    # Returns true if method is public.
+    def public?
+      parsed {
+        @status == 'Public'
+      }
+    end
+
+    # Check if method is internal.
+    #
+    # Returns true if method is internal.
+    def internal?
+      parsed {
+        @status == 'Internal'
+      }
+    end
+
+    # Check if method is deprecated.
+    #
+    # Returns true if method is deprecated.
+    def deprecated?
+      parsed {
+        @status == 'Deprecated'
+      }
+    end
+
+  private
+
+    # Has the comment been parsed yet?
+    def parsed(&block)
+      parse unless @parsed
+      block.call
+    end
+
+    # Internal: Parse the Tomdoc formatted comment.
+    #
+    # Returns true if there was a comment to parse.
+    def parse
+      @parsed = true
+
+      @sections = tomdoc.split("\n\n")
+      sections  = @sections.dup
+
+      return false if sections.empty?
+
+      parse_description(sections.shift)
+
+      if sections.first && sections.first =~ /^\w+\s+\-/m
+        parse_arguments(sections.shift)
+      end
+
+      current = sections.shift
+      while current
+        case current
+        when /^Examples/
+          parse_examples(current, sections)
+        when /^Yields/
+          parse_yields(current)
+        when /^(Returns|Raises)/
+          parse_returns(current)
+        when /^Signature/
+          parse_signature(current, sections)
+        end
+        current = sections.shift
+      end
+
+      return @parsed
+    end
+
+    # Parse description.
+    #
+    # section - String containig description.
+    #
+    # Returns nothing.
+    def parse_description(section)
+      if md = /^([A-Z]\w+\:)/.match(section)
+        @status      = md[1].chomp(':')
+        @description = md.post_match.strip
+      else
+        @description = section.strip
+      end   
+    end
+
+    # Parse arguments section. Arguments occur subsequent to
+    # the description.
+    #
+    # section - String containing agument definitions.
+    #
+    # Returns nothing.
+    def parse_arguments(section)
+      args = []
+      last_indent = nil
+
+      section.split("\n").each do |line|
+        next if line.strip.empty?
+        indent = line.scan(/^\s*/)[0].to_s.size
+
+        if last_indent && indent > last_indent
+          args.last.description += line.squeeze(" ")
+        else
+          param, desc = line.split(" - ")
+          args << Argument.new(param.strip, desc.strip) if param && desc
+        end
+
+        last_indent = indent
+      end
+
+      @arguments = args
+    end
+
+    # Parse examples.
+    #
+    # section  - String starting with `Examples`.
+    # sections - All sections subsequent to section.
+    #
+    # Returns nothing.
+    def parse_examples(section, sections)
+      examples = []
+
+      section = section.sub('Examples', '').strip
+
+      examples << section unless section.empty?
+      while sections.first && sections.first !~ /^\S/
+        examples << sections.shift.strip
+      end
+
+      @examples = examples
+    end
+
+    # Parse yields section.
+    #
+    # section - String contaning Yields line.
+    #
+    # Returns nothing.
+    def parse_yields(section)
+      @yields = section.strip
+    end
+
+    # Parse returns section.
+    #
+    # section - String contaning Returns and/or Raises lines.
+    #
+    # Returns nothing.
+    def parse_returns(section)
+      returns, raises, current = [], [], []
+
+      lines = section.split("\n")  
+      lines.each do |line|
+        case line
+        when /^Returns/
+          returns << line
+          current = returns
+        when /^Raises/
+          raises << line
+          current = raises
+        when /^\s+/
+          current.last << line.squeeze(' ')
+        else
+          current << line  # TODO: What to do with non-compliant line?
+        end
+      end
+
+      @returns, @raises = returns, raises
+    end
+
+    # Parse signature section.
+    #
+    # section  - String starting with `Signature`.
+    # sections - All sections subsequent to section.
+    #
+    # Returns nothing.
+    def parse_signature(section, sections=[])
+      signatures = []
+
+      section = section.sub('Signature', '').strip
+
+      signatures << section unless section.empty?
+
+      while sections.first && sections.first !~ /^\S/
+        sigs = sections.shift
+        sigs.split("\n").each do |s|
+          signatures << s.strip
+        end
+      end
+
+      @signatures = signatures
+
+      if sections.first && sections.first =~ /^\w+\s*\-/m
+        parse_signature_fields(sections.shift)
+      end
+    end
+
+    # Subsequent to Signature section there can be field
+    # definitions.
+    #
+    # section  - String subsequent to signatures.
+    #
+    # Returns nothing.
+    def parse_signature_fields(section)
+      args = []
+      last_indent = nil
+
+      section.split("\n").each do |line|
+        next if line.strip.empty?
+        indent = line.scan(/^\s*/)[0].to_s.size
+
+        if last_indent && indent > last_indent
+          args.last.description += line.squeeze(" ")
+        else
+          param, desc = line.split(" - ")
+          args << Argument.new(param.strip, desc.strip) if param && desc
+        end
+
+        last_indent = indent
+      end
+
+      @signature_fields = args
+    end
+
+  end
+
+  # Encapsulate a method argument.
+  #
+  class Argument
+
+    attr_accessor :name, :description
+
+    # Create new Argument object.
+    #
+    # name        - name of argument
+    # description - argument description
+    #
+    def initialize(name, description = '')
+      @name = name.to_s.intern
+      @description = description
+    end
+
+    # Is this an optional argument?
+    #
+    # Returns Boolean.
+    def optional?
+      @description.downcase.include? 'optional'
+    end
+
+  end
+
+end

data/lib/tomparse.yml

@@ -0,0 +1,47 @@
+---
+source:
+- meta
+authors:
+- name: Trans
+  email: transfire@gmail.com
+copyrights:
+- holder: Rubyworks
+  year: '2012'
+  license: BSD-2-Clause
+requirements:
+- name: microtest
+  groups:
+  - test
+  development: true
+- name: detroit
+  groups:
+  - build
+  development: true
+dependencies: []
+alternatives: []
+conflicts: []
+repositories:
+- uri: git@github.com:rubyworks/tomparse.git
+  scm: git
+  name: upstream
+resources:
+  home: http://rubyworks.github.com/tomparse
+  docs: http://rubydoc.info/gems/tomparse
+  code: http://github.com/rubyworks/tomparse
+  mail: http://groups.google.com/groups/rubyworks-mailinglist
+extra: {}
+load_path:
+- lib
+revision: 0
+created: '2012-03-04'
+summary: TomDoc parser for Ruby
+title: TomParse
+version: 0.1.0
+name: tomparse
+description: ! 'TomParse is a Ruby TomDoc parser. It contains no other functionality
+
+  than the ability to take a comment and parse it in accordance to the
+
+  TomDoc standard.'
+organization: rubyworks
+date: '2012-03-04'

data/test/helper.rb

@@ -0,0 +1,20 @@
+#require 'microtest/testunit'
+#require 'test/unit'
+#require 'test/fixtures/multiplex'
+require 'tomparse'
+
+module TomParse
+  class Test < ::Test::Unit::TestCase
+    def self.test(name, &block)
+      define_method("test_#{name.gsub(/\W/,'_')}", &block) if block
+    end
+
+    def default_test
+    end
+
+    def fixture(name)
+      @fixtures ||= {}
+      @fixtures[name] ||= File.read("test/fixtures/#{name}.rb")
+    end
+  end
+end

data/test/test_tomdoc.rb

@@ -0,0 +1,175 @@
+require 'helper'
+
+class TomDocTestCase < TomParse::Test
+
+  def setup
+    @comment = TomParse::TomDoc.new(<<comment)
+    # Duplicate some text an abitrary number of times.
+    #
+    # text    - The String to be duplicated.
+    # count   - The Integer number of times to
+    #           duplicate the text.
+    # reverse - An optional Boolean indicating
+    #           whether to reverse the result text or not.
+    #
+    # Examples
+    #   multiplex('Tom', 4)
+    #   # => 'TomTomTomTom'
+    #
+    #   multiplex('Bo', 2)
+    #   # => 'BoBo'
+    #
+    #   multiplex('Chris', -1)
+    #   # => nil
+    #
+    # Returns the duplicated String when the count is > 1.
+    # Returns the atomic mass of the element as a Float. The value is in
+    #   unified atomic mass units.
+    # Returns nil when the count is < 1.
+    # Raises ExpectedString if the first argument is not a String.
+    # Raises ExpectedInteger if the second argument is not an Integer.
+comment
+
+    @comment2 = TomParse::TomDoc.new(<<comment2)
+    # Duplicate some text an abitrary number of times.
+    #
+    # Returns the duplicated String.
+comment2
+
+    @comment3 = TomParse::TomDoc.new(<<comment3)
+    # Duplicate some text an abitrary number of times.
+    #
+    # Examples
+    #
+    #   multiplex('Tom', 4)
+    #   # => 'TomTomTomTom'
+    #
+    #   multiplex('Bo', 2)
+    #   # => 'BoBo'
+comment3
+
+    @comment4 = TomParse::TomDoc.new(<<comment4)
+    # Duplicate some text an abitrary number of times.
+    #
+    # Yields the Integer index of the iteration.
+    #
+    # Signature
+    #
+    #   find_by_<field>[_and_<field>...](args)
+    #
+    # field - A field name.
+comment4
+
+    @comment5 = TomParse::TomDoc.new(<<comment5)
+    Duplicate some text an abitrary number of times.
+    
+    Yields the Integer index of the iteration.
+    
+    Signature
+    
+      find_by_<field>[_and_<field>...](args)
+    
+    field - A field name.
+comment5
+
+  end
+
+  test "knows when TomDoc is invalid" do
+    assert_raises TomParse::ParseError do
+      @comment3.validate
+    end
+  end
+
+  test "parses a description" do
+    assert_equal "Duplicate some text an abitrary number of times.",
+      @comment.description
+  end
+
+  test "parses args" do
+    assert_equal 3, @comment.args.size
+  end
+
+  test "knows an arg's name" do
+    assert_equal :text, @comment.args.first.name
+    assert_equal :count, @comment.args[1].name
+    assert_equal :reverse, @comment.args[2].name
+  end
+
+  test "knows an arg's description" do
+    assert_equal 'The Integer number of times to duplicate the text.',
+      @comment.args[1].description
+
+    reverse = 'An optional Boolean indicating whether to reverse the'
+    reverse << ' result text or not.'
+    assert_equal reverse, @comment.args[2].description
+  end
+
+  test "knows an arg's optionality" do
+    assert_equal false, @comment.args.first.optional?
+    assert_equal true, @comment.args.last.optional?
+  end
+
+  test "knows what to do when there are no args" do
+    assert_equal 0, @comment2.args.size
+  end
+
+  test "knows how many examples there are" do
+    assert_equal 3, @comment.examples.size
+  end
+
+  test "knows each example" do
+    assert_equal "multiplex('Bo', 2)\n  # => 'BoBo'",
+      @comment.examples[1].to_s
+  end
+
+  test "knows what to do when there are no examples" do
+    assert_equal 0, @comment2.examples.size
+  end
+
+  test "knows how many return examples there are" do
+    assert_equal 3, @comment.returns.size
+  end
+
+  test "knows if the method raises anything" do
+    assert_equal 2, @comment.raises.size
+  end
+
+  test "knows each return example" do
+    assert_equal "Returns the duplicated String when the count is > 1.",
+      @comment.returns.first.to_s
+
+    string = ''
+    string << "Returns the atomic mass of the element as a Float. "
+    string << "The value is in unified atomic mass units."
+    assert_equal string, @comment.returns[1].to_s
+
+    assert_equal "Returns nil when the count is < 1.",
+      @comment.returns[2].to_s
+  end
+
+  test "knows what to do when there are no return examples" do
+    assert_equal 0, @comment2.examples.size
+  end
+
+  test "knows what the method yields" do
+    assert_equal "Yields the Integer index of the iteration.", @comment4.yields
+  end
+
+  test "knows if the method has alternate signatures" do
+    assert_equal 1, @comment4.signatures.size
+    assert_equal "find_by_<field>[_and_<field>...](args)", @comment4.signatures.first
+  end
+
+  test "knows the fields associated with signatures" do
+    assert_equal 1, @comment4.signature_fields.size
+
+    arg = @comment4.signature_fields.first
+    assert_equal :field, arg.name
+    assert_equal "A field name.", arg.description
+  end
+
+  test "can hande comments without comment marker" do
+    assert_equal "Duplicate some text an abitrary number of times.",
+      @comment5.description
+  end
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: tomparse
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Trans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: microtest
+  requirement: &23546980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23546980
+- !ruby/object:Gem::Dependency
+  name: detroit
+  requirement: &23545320 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *23545320
+description: ! 'TomParse is a Ruby TomDoc parser. It contains no other functionality
+
+  than the ability to take a comment and parse it in accordance to the
+
+  TomDoc standard.'
+email:
+- transfire@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- HISTORY.md
+- README.md
+files:
+- .ruby
+- lib/tomparse.rb
+- lib/tomparse.yml
+- test/helper.rb
+- test/test_tomdoc.rb
+- LICENSE.txt
+- HISTORY.md
+- README.md
+homepage: http://rubyworks.github.com/tomparse
+licenses:
+- BSD-2-Clause
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: TomDoc parser for Ruby
+test_files: []