bri 0.1.1

data/README

@@ -0,0 +1,40 @@
+= What is this ?
+During the days of Ruby 1.8, the ri command was slow. I mean really slow. Glacially. Starting a web browser and looking up a class or method description on ruby-doc.org often felt faster.
+
+Then Mauricio Fernandez produced fastri and qri that produced results a whole lot faster than the native ri tool. Unfortunately, Mauricio seems to have lost interest and didn't port fastri to ruby 1.9. There are patches porting fastri to 1.9.1, but they are iffy and don't work well with 1.9.2 and the new rdoc cache format.
+
+Now with ruby 1.9 and the rdoc 2.x gem ri is very responsive. However the output format looks like darkfish without the HTML and uses up a lot of space. And subjectively, it's ugly.
+
+This is where bri comes in: it tries to emulate fastri/qris output format and lookup patterns while using the new rdoc 2.x infrastructure.
+
+To compare, do 'ri Array' and 'bri Array' and see which appeals more to you.
+
+= Too... much... text...
+Bri is a Beautiful RI formatter.
+
+= Usage
+
+ bri Array # looks up the class description of Array in the ri documentation
+
+ bri Array.class_method # looks up the class method of the given class
+
+ bri Array#instance_method # looks up the instance method of the given class
+
+ bri .class_method # looks up the class method in any class
+
+ bri #instance_method # looks up the instance method in any class
+
+ bri method # looks up an instance method in any class, first looking for
+            # an exact match, then methods names where the beginning matches
+            # the given search term, and finally looking for the term
+            # anywhere in the method name
+
+= Requirements
+ * Ruby 1.9.2
+ * rdoc 2.5.x
+ * term-ansicolor
+
+
+= The Cheesy Stuff
+There are many bries, but there is only one RI bri. 
+(Apologies to Pierre).

data/TODO

@@ -0,0 +1,6 @@
+- Prepend/markup list items properly
+- Extend unqualified search to include class methods and case insensitive searches
+- Misc. error handlings
+- Do more specs
+- Add command line option parsing and help
+- Set output width dynamically leveraging all synergy effects

data/bin/bri

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'bri'
+
+if ARGV.size != 1 
+  STDERR.puts "Usage: #{$0} <reference>"
+  exit 0
+end
+
+puts Bri.ri( ARGV[0] )

data/lib/bri.rb

@@ -0,0 +1,51 @@
+$: << File.dirname( __FILE__ )
+require 'erb'
+require 'term/ansicolor'
+
+
+require 'bri/mall'
+require 'bri/matcher'
+require 'bri/templates'
+require 'bri/search'
+require 'bri/match'
+
+module Bri
+  WIDTH = 72
+
+  def self.format_elements( array )
+    rows = []
+    row = []
+    row_length = 0
+
+    array.each do |element|
+      element_length_with_separator = element.length + 2
+
+      if row_length + element_length_with_separator >= WIDTH
+        rows << row
+        row = []
+        row_length = 0
+      end
+
+      row << element
+      row_length += element_length_with_separator
+    end
+
+    rows << row
+    rows
+  end
+
+  def self.ri( query )
+    results = Bri::Matcher.new( query ).find
+
+    if results.size == 0
+      "No matching results found"
+    elsif results.size == 1
+      results.first.to_s
+    else
+      qualified_methods = results.collect{ |result| result.full_name }.sort
+      ERB.new( Bri::Templates::MULTIPLE_CHOICES, nil, '<>' ).result( binding )
+    end
+  end
+
+end
+

data/lib/bri/mall.rb

@@ -0,0 +1,26 @@
+require 'rdoc/ri/paths'
+require 'rdoc/ri/store'
+require 'singleton'
+
+module Bri
+  class Mall
+    include Singleton
+
+    attr_reader :stores
+
+    def classes
+      @stores.collect { |store| store.modules }.flatten.uniq.sort
+    end
+
+    private
+    def initialize
+      @stores = []
+
+      # We want: system, site, home and gem documentation
+      RDoc::RI::Paths.each( true, true, true, true ) do |path, type|
+        @stores << RDoc::RI::Store.new( path, type ).tap { |store| store.load_cache }
+      end
+    end
+
+  end
+end

data/lib/bri/match.rb

@@ -0,0 +1,3 @@
+require 'bri/match/base'
+require 'bri/match/class'
+require 'bri/match/method'

data/lib/bri/match/base.rb

@@ -0,0 +1,53 @@
+module Bri
+  module Match
+    class Base
+      def to_s
+        ERB.new( self.class.const_get( :TEMPLATE ), nil, '<>' ).
+            result( binding )
+      end
+
+      private 
+      def build_description( source )
+        result = []
+        source.each do |element|
+          case element
+            when RDoc::Markup::Paragraph 
+              result << reflow( element.text )
+            when RDoc::Markup::BlankLine
+              result << ""
+            when RDoc::Markup::Rule
+              result << "-" * Bri::WIDTH
+            when RDoc::Markup::Verbatim
+              result << element.text
+            when RDoc::Markup::Heading
+              result << '  ' * element.level + element.text
+            when RDoc::Markup::ListItem
+              result << "#{element.label} #{build_description( element.parts ).join}"
+            when RDoc::Markup::List
+              case element.type
+                when :NOTE, :LABEL
+                  result << "Note:"
+                  result << build_description( element.items ).join( "\n" )
+                when :NUMBER
+                  result << "Numbered List:"
+                  result << build_description( element.items ).join( "\n" )
+                when :BULLET
+                  #FIXME: Add bullet symbol to each item
+                  result << "Bulletet List:"
+                  result << build_description( element.items ).join( "\n" )
+                else 
+                  raise "Don't know how to handle list type #{element.type}: #{element.inspect}"
+              end
+            else  
+              raise "Don't know how to handle type #{element.class}: #{element.inspect}"
+          end
+        end
+        result
+      end
+
+      def reflow( text, width = Bri::WIDTH )
+        array_to_width( text.split( /\s+/ ), width, " ", 1 )
+      end
+    end
+  end
+end

data/lib/bri/match/class.rb

@@ -0,0 +1,32 @@
+require 'rdoc/markup'
+require 'rdoc/markup/paragraph'
+
+module Bri
+  module Match
+    class Class < Base
+      include Bri::Templates::Helpers
+      TEMPLATE = Bri::Templates::CLASS_DESCRIPTION
+
+      attr_reader :type, :name, :description_paragraphs
+      attr_reader :includes, :constants, :class_methods, :instance_methods
+      attr_reader :attributes
+
+      def initialize( rdoc_result )
+        @type = rdoc_result.type
+        @name = rdoc_result.name
+        @description_paragraphs = rdoc_result.comment.parts.collect { |p| p.parts.join( " " ) }
+        @includes = rdoc_result.includes.collect { |i| i.full_name }
+        @constants = rdoc_result.constants.collect { |c| { :name => c.name,
+                                                           :value => c.value } }
+        @attributes = rdoc_result.attributes.collect { |a| "#{a.name} (#{a.rw})" }
+
+        class_methods, instance_methods = rdoc_result.method_list.
+                                                      select {|m| m.visibility == :public }.
+                                                      partition { |m| m.singleton }
+        @class_methods = class_methods.collect { |m| m.name }
+        @instance_methods = instance_methods.collect { |m| m.name }
+      end
+
+    end
+  end
+end

data/lib/bri/match/method.rb

@@ -0,0 +1,18 @@
+module Bri
+  module Match
+    class Method < Base
+      include Bri::Templates::Helpers
+      TEMPLATE = Bri::Templates::METHOD_DESCRIPTION
+
+      attr_accessor :full_name, :call_syntaxes, :description_paragraphs
+
+      def initialize( rdoc_method )
+        @full_name = rdoc_method.full_name
+        @call_syntaxes = rdoc_method.call_seq.split( "\n" ).
+                                              map { |e| "  " + e }.
+                                              join( "\n" ) + "\n" rescue ''
+        @description_paragraphs = build_description( rdoc_method.comment.parts )
+      end
+    end
+  end
+end

data/lib/bri/matcher.rb

@@ -0,0 +1,42 @@
+module Bri
+  class Matcher
+    def initialize( term )
+      @term = term
+    end
+
+    def find
+      search_instance = create_search_instance( subject, @term )
+      search_instance.search( type )
+      search_instance.matches
+    end
+
+    def type
+      case @term
+        when /^[A-Z]/  then :fully_qualified
+        when /^[_a-z]/ then :unqualified
+        when /^[.#]/   then :partially_qualified
+        else :error
+      end
+    end
+
+    def subject
+      case @term
+        when /^[A-Z].*\./, /^\./   then :class_method
+        when /^[A-Z].*#/,  /^#/    then :instance_method
+        when /^[A-Z][^.#]*/        then :module
+        else :method
+      end
+    end
+
+    private
+    def create_search_instance( type, term )
+      case type
+        when :module          then Bri::Search::Class.new( term )
+        when :class_method    then Bri::Search::ClassMethod.new( term )
+        when :instance_method then Bri::Search::InstanceMethod.new( term )
+        when :method          then Bri::Search::InstanceMethod.new( term )
+        else nil # FIXME: Error handling
+      end
+    end
+  end
+end

data/lib/bri/search.rb

@@ -0,0 +1,5 @@
+require 'bri/search/base'
+require 'bri/search/class'
+require 'bri/search/method'
+require 'bri/search/class_method'
+require 'bri/search/instance_method'

data/lib/bri/search/base.rb

@@ -0,0 +1,12 @@
+module Bri
+  module Search
+    class Base
+      attr_reader :term, :matches
+
+      def initialize( term )
+        @term = term
+        @matches = []
+      end
+    end
+  end
+end

data/lib/bri/search/class.rb

@@ -0,0 +1,14 @@
+module Bri
+  module Search
+    class Class < Base
+
+      def search( type = :fully_qualified )
+        # NOTE: classes are only searched as fully qualified for the time being
+        # FIXME: What do we do if more than one store defines the same class?
+        store = Bri::Mall.instance.stores.detect { |s| s.modules.include? @term }
+        @matches << Bri::Match::Class.new( store.load_class( @term ) ) if store
+      end
+
+    end
+  end
+end

data/lib/bri/search/class_method.rb

@@ -0,0 +1,14 @@
+module Bri
+  module Search
+    class ClassMethod < Method
+      private
+      def store_methods( store )
+        store.class_methods
+      end
+
+      def method_rdoc( store, klass = @class_term, method = @method_term )
+        store.load_method( klass, method )
+      end
+    end
+  end
+end

data/lib/bri/search/instance_method.rb

@@ -0,0 +1,14 @@
+module Bri
+  module Search
+    class InstanceMethod < Method
+      private
+      def store_methods( store )
+        store.instance_methods
+      end
+
+      def method_rdoc( store, klass = @class_term, method = @method_term )
+        store.load_method( klass, "#" + method )
+      end
+    end
+  end
+end

data/lib/bri/search/method.rb

@@ -0,0 +1,84 @@
+module Bri
+  module Search
+    class Method < Base
+      attr_reader :class_term, :method_term
+
+      def initialize( term )
+        super
+        @class_term, @method_term = term.split( /[\.#]/, 2 )
+
+        if @class_term !~ /^[A-Z]/ && @method_term.nil?
+          @method_term, @class_term = @class_term, @method_term
+        end
+
+        @class_term = nil if @class_term == ""
+      end
+
+      def search( type = :fully_qualified )
+        case type
+          when :fully_qualified     then fully_qualified_search
+          when :partially_qualified then partially_qualified_search
+          when :unqualified         then unqualified_search
+          else :error # TODO: Error handling
+        end
+      end
+
+      private
+      def fully_qualified_search
+        store = store_for_method
+        
+        @matches << Bri::Match::Method.new( method_rdoc( store ) ) if store
+      end
+
+      def store_for_method
+        Bri::Mall.instance.stores.detect do |store|
+          store_methods( store ).has_key?( @class_term ) &&
+          store_methods( store )[@class_term].include?( @method_term )
+        end
+      end
+
+      def classes_with_method( store, method )
+        store_methods( store ).select { |klass, methods| methods.include? method }.keys
+      end
+
+      def candidates_from_method_re( store, method_re )
+        candidates = {}
+        store_methods( store ).each do |klass, methods|
+          matching_methods = methods.grep( method_re )
+          next if matching_methods.empty?
+          candidates[klass] = matching_methods
+        end
+        candidates
+      end
+
+
+      def partially_qualified_search  
+        Bri::Mall.instance.stores.each do |store|
+          classes_with_method( store, @method_term ).each do |klass|
+            @matches << Bri::Match::Method.new( method_rdoc( store, klass, @method_term ) )
+          end
+        end
+      end
+
+      def unqualified_search
+        [ /^#{Regexp.escape @method_term}$/,
+          /^#{Regexp.escape @method_term}/,
+          /#{Regexp.escape @method_term}/ ].each do |method_re|
+          unqualified_search_worker( method_re )
+          break unless @matches.empty?
+        end
+      end
+
+      def unqualified_search_worker( method_re )
+        Bri::Mall.instance.stores.each do |store|
+          candidates_from_method_re( store, method_re ).each do |klass, methods|
+            methods.each do |method|
+              @matches << Bri::Match::Method.new( method_rdoc( store, klass, method ) )
+            end
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/bri/templates.rb

@@ -0,0 +1,109 @@
+module Bri
+  module Templates
+    MULTIPLE_CHOICES =<<-EOT
+<%= Bri::Templates::Helpers.hrule( "Multiple choices:" ) %>
+
+<%= Bri::Templates::Helpers.array_to_width( qualified_methods.sort ) %>
+
+
+    EOT
+
+    CLASS_DESCRIPTION =<<-EOT
+<%= hrule( type + ": " + name ) %>
+<% if description_paragraphs.empty? %>
+  (no description...)
+<% else %>
+<% description_paragraphs.each do |paragraph| %>
+<%= array_to_width( paragraph.split( /\s+/ ), 72, " ") %>
+<% end %>
+<% end %>
+
+<%= hrule %>
+
+<% if !includes.empty? %>
+<%= section_header( "Includes:" ) %>
+<%= array_to_width( includes.sort ) %>
+
+
+<% end %>
+<% if !constants.empty? %>
+<%= section_header( "Constants:" ) %>
+<%= array_to_width( constants.sort ) %>
+
+
+<% end %>
+<% if !class_methods.empty? %>
+<%= section_header( "Class methods:" ) %>
+<%= array_to_width( class_methods.sort ) %>
+
+
+<% end %>
+<% if !instance_methods.empty? %>
+<%= section_header( "Instance methods:" ) %>
+<%= array_to_width( instance_methods.sort ) %>
+
+
+<% end %>
+<% if !attributes.empty? %>
+<%= section_header( "Attributes:" ) %>
+<%= array_to_width( attributes.sort ) %>
+
+
+<% end %>
+    EOT
+
+    METHOD_DESCRIPTION =<<-EOT
+<%= hrule( full_name ) %>
+<%= call_syntaxes %>
+<%= hrule %>
+<% if description_paragraphs.empty? %>
+  (no description...)
+<% else %>
+<%= description_paragraphs.join( "\n" ) %>
+<% end %>
+
+    EOT
+
+    module Helpers
+      def hrule( text = '', width = Bri::WIDTH )
+        '-' * ( width - text.length - 1 ) + " " + 
+          Term::ANSIColor::bold + text + Term::ANSIColor::reset + 
+          "\n"
+      end
+      module_function :hrule
+
+      def section_header( text )
+        Term::ANSIColor::green + Term::ANSIColor::underline + text + Term::ANSIColor::reset + "\n"
+      end
+      module_function :section_header
+
+      def array_to_width( array, width = Bri::WIDTH, separator = ", ", indent_steps = 1 )
+        indentation = '  '
+        rows = '' + indentation * indent_steps
+        row = ''
+        row_length = 0
+
+        array = add_separators( array, separator )
+
+        array.each do |element|
+          if row.length + element.length >= width
+            rows << row + "\n" + indentation * indent_steps
+            row = ''
+          end
+
+          row << element
+        end
+
+        rows << row
+        rows
+      end
+      module_function :array_to_width
+
+      def add_separators( array, separator )
+        last_element = array.pop
+        array.map { |e| e + separator } + [ last_element ]
+      end
+      module_function :add_separators
+    end
+  end
+end

data/spec/lib/bri/mall_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Bri::Mall do
+  # NOTE the specs here are commented out until I figure out how to properly
+  #      test singletons. Otherwise specs will fail in a bulk run while
+  #      running fine on their own
+  subject { Bri::Mall.instance }
+
+  before( :each ) do
+    RDoc::RI::Paths.stub!( :each ).
+                    and_yield( "store1_path", "store1_type" ).
+                    and_yield( "store2_path", "store2_type" )
+    RDoc::RI::Store.stub!( :new ).
+                    and_return { mock( RDoc::RI::Store, :load_cache=> true ) }
+  end
+
+  # describe "the instance" do
+
+  #   its( :stores ) { should have(2).objects }
+  # end
+
+  # describe "#classes" do
+  #   it "should query all stores for their modules" do
+  #     subject.stores.each do |store|
+  #       store.should_receive( :modules ).and_return( true )
+  #     end
+
+  #     subject.classes
+  #   end
+
+  #   it "should return a sorted array of unique class names" do
+  #     subject.stores.first.stub!( :modules => [ "C", "B", "A" ] )
+  #     subject.stores.last.stub!( :modules => [ "Z", "B", "C" ] )
+  #     subject.classes.should == [ "A", "B", "C", "Z" ]
+  #   end
+  # end
+
+end

data/spec/lib/bri/match/class_match_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Bri::Match::Class do
+  let( :fake_paragraph ) do
+    mock( RDoc::Markup::Paragraph, :parts => [ "This is row one", 
+                                               "And this is row 2" ] )
+  end
+
+  let( :fake_description ) do 
+    mock( RDoc::Markup::Document, :parts => [ fake_paragraph ] ) 
+  end
+
+  let( :fake_include ) do
+    mock( RDoc::Include, :full_name => "Included::Module" )
+  end
+
+  let( :fake_constant ) do
+    mock( RDoc::Constant, :name => "MockConstant", :value => "This is my value" )
+  end
+
+  let( :fake_attribute ) do
+    mock( RDoc::Constant, :name => "attribute", :rw => 'R' )
+  end
+
+  let( :fake_public_instance_method ) do
+    mock( RDoc::AnyMethod, :name => "public_instance",  
+                           :singleton => false,
+                           :visibility => :public )
+  end
+
+  let( :fake_protected_instance_method ) do
+    mock( RDoc::AnyMethod, :name => "protected_instance",  
+                           :singleton => false,
+                           :visibility => :protected )
+  end
+
+  let( :fake_private_instance_method ) do
+    mock( RDoc::AnyMethod, :name => "private_instance",  
+                           :singleton => false,
+                           :visibility => :private )
+  end
+
+  let( :fake_public_class_method ) do
+    mock( RDoc::AnyMethod, :name => "public_class",  
+                           :singleton => true,
+                           :visibility => :public )
+  end
+
+  let( :fake_protected_class_method ) do
+    mock( RDoc::AnyMethod, :name => "protected_class",  
+                           :singleton => true,
+                           :visibility => :protected )
+  end
+
+  let( :fake_private_class_method ) do
+    mock( RDoc::AnyMethod, :name => "private_class",  
+                           :singleton => true,
+                           :visibility => :private )
+  end
+
+  let( :rdoc_class ) { mock( RDoc::NormalClass, :type => "module",
+                                                :name => "MyModule",
+                                                :comment => fake_description,
+                                                :includes => [ fake_include ],
+                                                :constants => [ fake_constant ],
+                                                :attributes => [ fake_attribute ],
+                                                :method_list => [ fake_public_instance_method,
+                                                                  fake_protected_instance_method,
+                                                                  fake_private_instance_method,
+                                                                  fake_public_class_method,
+                                                                  fake_protected_class_method,
+                                                                  fake_private_class_method ]
+                                                )
+                                                }
+
+  describe "#initialize" do
+    context "a class with everything" do
+      subject { Bri::Match::Class.new( rdoc_class ) }
+
+      its( :type ) { should == rdoc_class.type }
+      its( :name ) { should == rdoc_class.name }
+      its( :description_paragraphs ) { should == fake_description.parts.collect { |p| p.parts.join( " " ) } }
+      its( :includes ) { should == rdoc_class.includes.collect{ |i| i.full_name } }
+      its( :constants ) { should == rdoc_class.constants.collect { |c| { :name => c.name, :value => c.value } } }
+      its( :attributes ) { should == rdoc_class.attributes.collect { |a| "#{a.name} (#{a.rw})" } }
+      its( :instance_methods ) { should == rdoc_class.method_list.select { |m| m.visibility == :public && m.singleton == false }.collect { |m| m.name } }
+      its( :class_methods ) { should == rdoc_class.method_list.select { |m| m.visibility == :public && m.singleton == true }.collect { |m| m.name } }
+    end
+  end
+end

data/spec/lib/bri/match/method_match_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Bri::Match::Method do
+  let( :fake_paragraph ) do
+    RDoc::Markup::Paragraph.new "This is line one", "This is line two" 
+  end
+
+  let( :fake_description ) do
+    mock( RDoc::Markup::Document, :parts => [ fake_paragraph ] )
+  end
+
+  let( :rdoc_method ) do
+    mock( RDoc::AnyMethod, :full_name => "This::IS::My.full_name",
+                           :call_seq => "First\nSecond\nThird",
+                           :comment => fake_description )
+  end
+
+  describe "#initialize" do
+    subject { Bri::Match::Method.new( rdoc_method ) }
+
+    its( :full_name ) { should == rdoc_method.full_name }
+    its( :call_syntaxes ) { should == "  First\n  Second\n  Third\n" }
+    its( :description_paragraphs ) { should == [ "  This is line one This is line two" ] }
+  end
+end

data/spec/lib/bri/matcher_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+describe Bri::Matcher do
+  describe "#type" do
+
+    context "the query term begins with a capital" do
+      subject { Bri::Matcher.new( "Foo" ) }
+      its( :type ) { should == :fully_qualified }
+    end
+
+    context "the query term begins with a lower case letter" do
+      subject { Bri::Matcher.new( "foo" ) }
+      its( :type ) { should == :unqualified }
+    end
+
+    context "the query term begins with a _" do
+      subject { Bri::Matcher.new( "_foo" ) }
+      its( :type ) { should == :unqualified }
+    end
+
+    context "the query begins with a ." do
+      subject { Bri::Matcher.new( ".foo" ) }
+      its( :type ) { should == :partially_qualified }
+    end
+
+    context "the query begins with a #" do
+      subject { Bri::Matcher.new( "#foo" ) }
+      its( :type ) { should == :partially_qualified }
+    end
+
+    context "it begins with a character other than _, ., #, or a letter" do
+      subject { Bri::Matcher.new( "2134" ) }
+      its( :type ) { should == :error }
+    end
+  end
+
+  describe "#subject" do
+    context "the term begins with a capital letter" do
+      context "and the term contains a ." do
+        subject { Bri::Matcher.new( "Foo.bar" ) }
+        its( :subject ) { should == :class_method }
+      end
+
+      context "and the term contains a #" do
+        subject { Bri::Matcher.new( "Foo#bar" ) }
+        its( :subject ) { should == :instance_method }
+      end
+
+      context "and the term contains neither . nor #" do
+        subject { Bri::Matcher.new( "FooBar" ) }
+        its( :subject ) { should == :module }
+      end
+    end
+  end
+
+  context "the term begins with a ." do
+    subject { Bri::Matcher.new( ".foo" ) }
+    its( :subject ) { should == :class_method }
+  end
+
+  context "the term begins with a #" do
+    subject { Bri::Matcher.new( "#foo" ) }
+    its( :subject ) { should == :instance_method }
+  end
+
+  context "the term begins with neither a capital letter nor . or #" do
+    subject { Bri::Matcher.new( "foo" ) }
+    its( :subject ) { should == :method }
+  end
+end

data/spec/lib/bri/search/class_method_search_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Bri::Search::ClassMethod do
+  context "the searches" do
+    let( :paragraph ) { RDoc::Markup::Paragraph.new( "Foo Description" ) }
+    let( :document ) { mock( RDoc::Markup::Document, :parts => [ paragraph ] ) }
+    let( :rdoc_method ) { mock( RDoc::AnyMethod, :full_name => "Foo",
+                                                 :call_seq => "",
+                                                 :comment => document ) }
+    before( :each ) do
+      store_one = mock( RDoc::RI::Store, :load_cache => true, 
+                                         :load_class => true,
+                                         :load_method => rdoc_method,
+                                         :modules    => %w{ ClassThree },
+                                         :class_methods => { "ClassThree" => [ "method" ] } )
+      store_two = mock( RDoc::RI::Store, :load_cache => true, 
+                                         :load_class => true,
+                                         :load_method => rdoc_method,
+                                         :modules    => %w{ ClassOne ClassTwo },
+                                         :class_methods => { "ClassOne" => [ "method" ],
+                                                             "ClassTwo" => [ "method", "my_other_method" ] } )
+      Bri::Mall.instance.stub!( :stores => [ store_one, store_two ] )
+      Bri::Match::Class.stub!( :new ).and_return( mock( Bri::Match::Class ) )
+    end
+
+    describe "a fully qualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::ClassMethod.new( "I::Dont::Exist.go_away" ) }
+        it "should have no matches" do
+          subject.search( :fully_qualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        subject { Bri::Search::ClassMethod.new( "ClassOne.method" ) }
+        it "should have a match for each method" do
+          subject.search( :fully_qualified )
+          subject.matches.size.should == 1
+        end
+      end
+    end
+
+    describe "a partially qualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::ClassMethod.new( ".go_away" ) }
+        it "should have no matches" do
+          subject.search( :partially_qualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        subject { Bri::Search::ClassMethod.new( ".method" ) }
+        it "should have a match for each method" do
+          subject.search( :partially_qualified )
+          subject.matches.size.should == 3
+        end
+      end
+    end
+
+    describe "an unqualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::ClassMethod.new( "go_away" ) }
+        it "should have no matches" do
+          subject.search( :unqualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        context "if there are matching methods, where the match starts at the beginning of the method name" do
+          subject { Bri::Search::ClassMethod.new( "method" ) }
+          it "should have a match for each method" do
+            subject.search( :unqualified )
+            subject.matches.size.should == 3
+          end
+        end
+
+        context "if there are matching methods, but none where the match starts at the beginning of the method name" do
+          subject { Bri::Search::ClassMethod.new( "other" ) }
+          it "should have a match for each method" do
+            subject.search( :unqualified )
+            subject.matches.size.should == 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/bri/search/class_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe Bri::Search::Class do
+  before( :each ) do
+    store_one = mock( RDoc::RI::Store, :load_cache => true, 
+                                       :load_class => true,
+                                       :modules => %w{ ClassThree } )
+    store_two = mock( RDoc::RI::Store, :load_cache => true, 
+                                       :load_class => true,
+                                       :modules => %w{ ClassOne ClassTwo } )
+    Bri::Mall.instance.stub!( :stores => [ store_one, store_two ] )
+    Bri::Match::Class.stub!( :new ).and_return( mock( Bri::Match::Class ) )
+  end
+
+  describe "#search" do
+    context "if there are no matching modules in any store" do
+      subject { Bri::Search::Class.new( "I::Dont::Exist" ) }
+      it "should have no matches" do
+        subject.search
+        subject.matches.should == []
+      end
+    end
+
+    context "if there is a matching module in the stores" do
+      subject { Bri::Search::Class.new( "ClassOne" ) }
+      it "should have a match for each name" do
+        subject.search
+        subject.matches.size.should == 1
+      end
+    end
+  end
+end

data/spec/lib/bri/search/instance_method_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+
+describe Bri::Search::InstanceMethod do
+  context "the searches" do
+    let( :paragraph ) { RDoc::Markup::Paragraph.new( "Foo Description" ) }
+    let( :document ) { mock( RDoc::Markup::Document, :parts => [ paragraph ] ) }
+    let( :rdoc_method ) { mock( RDoc::AnyMethod, :full_name => "Foo",
+                                                 :call_seq => "",
+                                                 :comment => document ) }
+    before( :each ) do
+      store_one = mock( RDoc::RI::Store, :load_cache => true, 
+                                         :load_class => true,
+                                         :load_method => rdoc_method,
+                                         :modules    => %w{ ClassThree },
+                                         :instance_methods => { "ClassThree" => [ "method" ] } )
+      store_two = mock( RDoc::RI::Store, :load_cache => true, 
+                                         :load_class => true,
+                                         :load_method => rdoc_method,
+                                         :modules    => %w{ ClassOne ClassTwo },
+                                         :instance_methods => { "ClassOne" => [ "method" ],
+                                                             "ClassTwo" => [ "method", "my_other_method" ] } )
+      Bri::Mall.instance.stub!( :stores => [ store_one, store_two ] )
+      Bri::Match::Class.stub!( :new ).and_return( mock( Bri::Match::Class ) )
+    end
+
+    describe "a fully qualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::InstanceMethod.new( "I::Dont::Exist#go_away" ) }
+        it "should have no matches" do
+          subject.search( :fully_qualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        subject { Bri::Search::InstanceMethod.new( "ClassOne#method" ) }
+        it "should have a match for each method" do
+          subject.search( :fully_qualified )
+          subject.matches.size.should == 1
+        end
+      end
+    end
+
+    describe "a partially qualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::InstanceMethod.new( "#go_away" ) }
+        it "should have no matches" do
+          subject.search( :partially_qualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        subject { Bri::Search::InstanceMethod.new( "#method" ) }
+        it "should have a match for each method" do
+          subject.search( :partially_qualified )
+          subject.matches.size.should == 3
+        end
+      end
+    end
+
+    describe "an unqualified search" do 
+      context "if there are no matching methods in any store" do
+        subject { Bri::Search::InstanceMethod.new( "go_away" ) }
+        it "should have no matches" do
+          subject.search( :unqualified )
+          subject.matches.should == []
+        end
+      end
+
+      context "if there are matching methods in the stores" do
+        context "if there are matching methods, where the match starts at the beginning of the method name" do
+          subject { Bri::Search::InstanceMethod.new( "method" ) }
+          it "should have a match for each method" do
+            subject.search( :unqualified )
+            subject.matches.size.should == 3
+          end
+        end
+
+        context "if there are matching methods, but none where the match starts at the beginning of the method name" do
+          subject { Bri::Search::InstanceMethod.new( "other" ) }
+          it "should have a match for each method" do
+            subject.search( :unqualified )
+            subject.matches.size.should == 1
+          end
+        end
+      end
+    end
+  end
+end

data/spec/lib/bri/search/method_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Bri::Search::Method do
+  describe "#initialize" do
+    context "the searchterm is a class" do
+      subject { Bri::Search::Method.new( "Class" ) }
+      its( :class_term ) { should == "Class" }
+      its( :method_term ) { should be_nil }
+    end
+
+    context "the search term is a fully qualified class method" do
+      subject { Bri::Search::Method.new( "Class.method" ) }
+      its( :class_term ) { should == "Class" }
+      its( :method_term ) { should == "method" }
+    end
+
+    context "the search term is a fully qualified instance method" do
+      subject { Bri::Search::Method.new( "Class#method" ) }
+      its( :class_term ) { should == "Class" }
+      its( :method_term ) { should == "method" }
+    end
+
+    context "the search term begins with a ." do
+      subject { Bri::Search::Method.new( ".method" ) }
+      its( :class_term ) { should be_nil }
+      its( :method_term ) { should == "method" }
+    end
+
+    context "the search term begins with a #" do
+      subject { Bri::Search::Method.new( "#method" ) }
+      its( :class_term ) { should be_nil }
+      its( :method_term ) { should == "method" }
+    end
+
+    context "the search term is not a class and does not contain a . or #" do
+      subject { Bri::Search::Method.new( "method" ) }
+      its( :class_term ) { should be_nil }
+      its( :method_term ) { should == "method" }
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1 @@
+require File.join( File.dirname( __FILE__ ), '..', 'lib', 'bri.rb' )

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification 
+name: bri
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Sven Riedel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-19 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 1
+        - 0
+        - 5
+        version: 1.0.5
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 5
+        - 0
+        version: 2.5.0
+  type: :runtime
+  version_requirements: *id002
+description: An alternative to the ri command
+email: sr@gimp.org
+executables: 
+- bri
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- TODO
+- bin/bri
+- lib/bri.rb
+- lib/bri/mall.rb
+- lib/bri/matcher.rb
+- lib/bri/match.rb
+- lib/bri/match/base.rb
+- lib/bri/match/class.rb
+- lib/bri/match/method.rb
+- lib/bri/search.rb
+- lib/bri/search/base.rb
+- lib/bri/search/class.rb
+- lib/bri/search/method.rb
+- lib/bri/search/class_method.rb
+- lib/bri/search/instance_method.rb
+- lib/bri/templates.rb
+- spec/spec_helper.rb
+- spec/lib/bri/mall_spec.rb
+- spec/lib/bri/matcher_spec.rb
+- spec/lib/bri/match/class_match_spec.rb
+- spec/lib/bri/match/method_match_spec.rb
+- spec/lib/bri/search/class_spec.rb
+- spec/lib/bri/search/class_method_search_spec.rb
+- spec/lib/bri/search/instance_method_spec.rb
+- spec/lib/bri/search/method_spec.rb
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 9
+      - 2
+      version: 1.9.2
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Beautified RI in the spirit of fastri/qri. Unlike fastri, bri builds on top of the rdoc 2.x backend, only output and formatting is handled by bri
+test_files: []
+