bri 0.5.0 → 1.0.0.pre.beta1

data/lib/bri/renderer.rb

@@ -1,195 +1,35 @@
 require 'strscan'
+require 'rdoc'
+require 'rdoc/markup'
+
+require_relative 'renderer/default'
+require_relative 'renderer/blank_line'
+require_relative 'renderer/document'
+require_relative 'renderer/heading'
+require_relative 'renderer/list_item'
+require_relative 'renderer/list'
+require_relative 'renderer/paragraph'
+require_relative 'renderer/rule'
+require_relative 'renderer/verbatim'
+require_relative 'renderer/result'
 
 module Bri
   module Renderer
-    Color = ::Term::ANSIColor
-
-    INDENT = ' ' * 2
-    INDENT_WIDTH = 2
-    LOWER_ALPHABET = ('a'..'z').to_a.map { |char| "#{char}." }.freeze
-    UPPER_ALPHABET = ('A'..'Z').to_a.map { |char| "#{char}." }.freeze
-
-    def self.render( element, width = Bri.width, alignment_width = 0 )
-      case element
-        when RDoc::Markup::Verbatim 
-          text = extract_text( element, width )
-          styled_text = replace_markup( text )
-          "#{indent( styled_text )}\n"
-
-        when RDoc::Markup::List
-          item_width = width - INDENT_WIDTH
-          case element.type
-            when :BULLET 
-              rendered_items = element.items.map { |item| render( item, item_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-              rendered_items.map! { |item| item.prepend( ' *' ) }
-
-            when :NUMBER
-              rendered_items = element.items.map { |item| render( item, item_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-              rendered_items.map!.with_index( 1 ) { |item, i| item.prepend( "#{i}." ) }
-
-            when :LALPHA
-              rendered_items = element.items.map { |item| render( item, item_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-              rendered_items.map!.with_index { |item, i| item.prepend( LOWER_ALPHABET[i] ) }
-
-            when :UALPHA
-              rendered_items = element.items.map { |item| render( item, item_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-              rendered_items.map!.with_index { |item, index| item.prepend( UPPER_ALPHABET[i] ) }
-              
-            when :LABEL
-              # do nothing
-              rendered_items = element.items.map { |item| render( item, item_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-
-            when :NOTE
-              alignment_width = element.items.flat_map(&:label).map(&:size).max + 1
-              rendered_items = element.items.map { |item| render( item, item_width, alignment_width ) }
-              rendered_items.map! { |item| item.gsub( /\n/, "\n#{INDENT}" ) }
-          end
-
-          "#{rendered_items.join( "\n" )}\n"
-
-        else
-          text = extract_text( element, width, alignment_width )
-
-          if text == "\n"
-            nil
-          else
-            styled_text = replace_markup( text )
-            wrapped_text = wrap_to_width( styled_text, width )
-            indent( wrapped_text )
-          end
-      end
-    end
-
-    def self.extract_text( element, width, label_alignment_width = 0, conserve_newlines = false )
-      case element
-        when RDoc::Markup::Paragraph
-          join_char = conserve_newlines ? "\n" : " "
-          element.parts.map(&:strip).join( join_char ) + "\n"
-
-        when RDoc::Markup::BlankLine
-          "\n"
-
-        when RDoc::Markup::Rule
-          "-" * width + "\n"
-
-        when RDoc::Markup::Verbatim
-          element.parts.map { |part| part.prepend( "  " ) }.join + "\n"
-
-        when RDoc::Markup::Heading
-          "<h>#{element.text}</h>\n" 
-
-        when RDoc::Markup::ListItem
-          parts = element.parts.map { |part| extract_text( part, width, 0, true ) }.join
-
-          if element.label
-            labels = element.label.map { |l| "#{l}:" }.join("\n")
-            sprintf( "%*s %s", -label_alignment_width, labels, parts )
-          else
-            parts
-          end
-
-        when RDoc::Markup::List
-          render( element, width - INDENT_WIDTH ) + "\n"
-
-         when RDoc::Markup::Document
-           element.parts.
-                   map { |part| extract_text( part, width, label_alignment_width, conserve_newlines ) }.
-                   join + "\n"
-        else  
-          raise "Don't know how to handle type #{element.class}: #{element.inspect}"
-      end
-    end
-
-    def self.replace_markup( text )
-      text.gsub!( /(?<!\\)<(?:tt|code)>/, Color.cyan )
-      text.gsub!( /(?<!\\)<\/(?:tt|code)>/, Color.reset )
-
-      text.gsub!( /(?<!\\)<b>/, Color.bold )
-      text.gsub!( /(?<!\\)<\/b>/, Color.reset )
-
-      text.gsub!( /(?<!\\)<(?:em|i)>/, Color.yellow )
-      text.gsub!( /(?<!\\)<\/(?:em|i)>/, Color.reset )
-
-      text.gsub!( "<h>", Color.green )
-      text.gsub!( "</h>", Color.reset )
-
-      text.gsub!( "\\<", "<" )
-
-      text.gsub!( /(#\s*=>)(.*)/,
-                  "#{Color.dark}\\1#{Color.reset}#{Color.bold}\\2#{Color.reset}" )
-
-      text.gsub!( /(^|\s)\*(.*?[a-zA-Z0-9]+.*?)\*/, 
-                  "\\1#{Color.bold}\\2#{Color.reset}" )
-      text.gsub!( /(^|\s)\+(.*?[a-zA-Z0-9]+.*?)\+/, 
-                  "\\1#{Color.cyan}\\2#{Color.reset}" )
-      text.gsub!( /(^|\s)_(.*?[a-zA-Z0-9]+.*?)_/, 
-                  "\\1#{Color.yellow}\\2#{Color.reset}" )
-
-      text.gsub!( %r{\b((?:https?|ftp)://[-\w.?%&=/]+)\b}, 
-                  "#{Color.underline}\\1#{Color.reset}" )
-
-      text.gsub!( %r{\b(mailto:[-\w.%]+@[-\w.]+)\b}, 
-                  "#{Color.underline}\\1#{Color.reset}" )
-
-      text.gsub!( %r{\b((?<!:\/\/)www.[-\w.?%&=]+)\b}, 
-                  "#{Color.underline}\\1#{Color.reset}" )
-
-      text.gsub!( %r{\blink:(.*?)(\s|$)}, 
-                  "#{Color.underline}\\1#{Color.reset}\\2" )
-
-      text.gsub!( %r{\{(.*?)\}\[(.*?)\]}, "\\1 (\\2)" )
-      text.gsub!( %r{\[(#{Regexp.escape( Color.underline )}.*?#{Regexp.escape( Color.reset )})\]}, 
-                  " (\\1)" )
-      text
-    end
-
-    def self.printable_length( text )
-      Term::ANSIColor.uncolored( text ).length
-    end
-
-    def self.wrap_list( array, width = Bri.width )
-      indent( wrap_to_width( array.join("  "), width ) )
-    end
-
-    def self.wrap_to_width( styled_text, width )
-      styled_text.split( "\n" ).map { |row| wrap_row( row, width ) }.join
-    end
-
-    def self.wrap_row( physical_row, width )
-      output_text = ''
-      logical_row = ''
-      printable_row_length = 0
-
-      scanner = StringScanner.new( physical_row )
-
-      while( !scanner.eos? ) 
-        token = scanner.scan( /\S+/ ).to_s
-        printable_token_length = printable_length( token )
-
-        if printable_token_length + printable_row_length > width
-          output_text << logical_row << "\n"
-          logical_row = ''
-          printable_row_length = 0
-        end
-
-        logical_row << token
-        printable_row_length += printable_token_length
-
-        token = scanner.scan( /\s*/ ).to_s
-        logical_row << token
-        printable_row_length += token.length
-      end
-
-      output_text << logical_row << "\n"
-    end
-
-    def self.indent( text )
-      text.split( "\n" ).map { |row| "#{INDENT}#{row}" }.join("\n" )
+    RDOC_TO_BRI_RENDERER_CLASS_MAP = {
+      ::RDoc::Markup::Document  => ::Bri::Renderer::Document,
+      ::RDoc::Markup::Paragraph => ::Bri::Renderer::Paragraph,
+      ::RDoc::Markup::BlankLine => ::Bri::Renderer::BlankLine,
+      ::RDoc::Markup::Rule      => ::Bri::Renderer::Rule,
+      ::RDoc::Markup::Verbatim  => ::Bri::Renderer::Verbatim,
+      ::RDoc::Markup::Heading   => ::Bri::Renderer::Heading,
+      ::RDoc::Markup::ListItem  => ::Bri::Renderer::ListItem,
+      ::RDoc::Markup::List      => ::Bri::Renderer::List,
+    }
+    RDOC_TO_BRI_RENDERER_CLASS_MAP.default = ::Bri::Renderer::Default
+
+    def self.new( element )
+      renderer_class = RDOC_TO_BRI_RENDERER_CLASS_MAP[element.class]
+      renderer_class.new( element )
     end
   end
 end

data/lib/bri/search/class.rb

@@ -3,7 +3,9 @@ module Bri
     class Class < Base
       def search( type = :fully_qualified )
         # NOTE: classes are only searched as fully qualified for the time being
-        Bri::Mall.instance.stores.select { |s| s.module_names.include?( @term ) }.each do |store|
+        Bri::Mall.stores.
+                  select { |s| s.module_names.include?( @term ) }.
+                  each do |store|
           @matches << Bri::Match::Class.new( store.load_class( @term ), store )
         end
       end

data/lib/bri/search/method.rb

@@ -31,7 +31,7 @@ module Bri
       end
 
       def store_for_method
-        Bri::Mall.instance.stores.detect do |store|
+        Bri::Mall.stores.detect do |store|
           store_methods( store ).has_key?( @class_term ) &&
           store_methods( store )[@class_term].include?( @method_term )
         end
@@ -54,7 +54,7 @@ module Bri
 
 
       def partially_qualified_search  
-        Bri::Mall.instance.stores.each do |store|
+        Bri::Mall.stores.each do |store|
           classes_with_method( store, @method_term ).each do |klass|
             match_data = method_rdoc( store, klass, @method_term ) 
             next unless match_data
@@ -74,7 +74,7 @@ module Bri
       end
 
       def unqualified_search_worker( method_re )
-        Bri::Mall.instance.stores.each do |store|
+        Bri::Mall.stores.each do |store|
           candidates_from_method_re( store, method_re ).each do |klass, methods|
             methods.each do |method|
               match_data = method_rdoc( store, klass, method )

data/lib/bri/templates.rb

@@ -1,9 +1,7 @@
 module Bri
   module Templates
-    RULE_CHARACTER = '-'.freeze
-
     MULTIPLE_CHOICES =<<-EOT
-<%= Bri::Templates::Helpers.hrule( "Multiple choices:" ) %>
+<%= hrule( "Multiple choices:" ) %>
 
 <%= qualified_methods.sort.join("\n") %>
 
@@ -24,38 +22,32 @@ module Bri
 
 <% if !includes.empty? %>
 <%= section_header( "Includes:" ) %>
-<%= Bri::Renderer.wrap_list( includes.sort ) %>
-
+<%= wrap_list( includes.sort ) %>
 
 <% end %>
 <% if !extends.empty? %>
 <%= section_header( "Extends:" ) %>
-<%= Bri::Renderer.wrap_list( extends.sort ) %>
-
+<%= wrap_list( extends.sort ) %>
 
 <% end %>
 <% if !constants.empty? %>
 <%= section_header( "Constants:" ) %>
-<%= Bri::Renderer.wrap_list( constants.sort ) %>
-
+<%= wrap_list( constants.sort ) %>
 
 <% end %>
 <% if !class_methods.empty? %>
 <%= section_header( "Class methods:" ) %>
-<%= Bri::Renderer.wrap_list( class_methods.sort ) %>
-
+<%= wrap_list( class_methods.sort ) %>
 
 <% end %>
 <% if !instance_methods.empty? %>
 <%= section_header( "Instance methods:" ) %>
-<%= Bri::Renderer.wrap_list( instance_methods.sort ) %>
-
+<%= wrap_list( instance_methods.sort ) %>
 
 <% end %>
 <% if !attributes.empty? %>
 <%= section_header( "Attributes:" ) %>
-<%= Bri::Renderer.wrap_list( attributes.sort ) %>
-
+<%= wrap_list( attributes.sort ) %>
 
 <% end %>
     EOT
@@ -73,28 +65,5 @@ module Bri
 <% end %>
 
     EOT
-
-    module Helpers
-      def hrule( text = '', width = Bri.width )
-        text.prepend( " " ) unless text.empty?
-
-        rule_length = width - text.length
-        rule_length = 1 if rule_length < 1
-
-        rule = RULE_CHARACTER * rule_length
-        "#{rule}#{Term::ANSIColor::bold( text )}\n"
-      end
-      module_function :hrule
-
-      def print_origin( origin_text, width = Bri.width )
-        return unless origin_text
-        "(#{origin_text})".rjust( width )
-      end
-
-      def section_header( text )
-        "#{Term::ANSIColor.green}#{Term::ANSIColor.underline}#{text}#{Term::ANSIColor.reset}\n"
-      end
-      module_function :section_header
-    end
   end
 end

data/lib/bri/text_formatting_utils.rb

@@ -0,0 +1,92 @@
+module Bri
+  module TextFormattingUtils
+    RULE_CHARACTER = '-'.freeze
+
+    def wrap_to_width( styled_text, width )
+      styled_text.split( "\n" ).map { |row| wrap_row( row, width ) }.join
+    end
+    module_function :wrap_to_width
+
+    def wrap_row( physical_row, width )
+      output_text = ''
+      logical_row = ''
+      printable_row_length = 0
+      tokens_in_row = 0
+
+      scanner = StringScanner.new( physical_row )
+
+      while( !scanner.eos? ) 
+        token = scanner.scan( /\S+/ ).to_s
+        printable_token_length = printable_length( token )
+
+        if printable_token_length + printable_row_length > width && tokens_in_row > 0
+          output_text << logical_row.rstrip << "\n"
+          logical_row.clear
+          printable_row_length = 0
+          tokens_in_row = 0
+        end
+
+        logical_row << token
+        printable_row_length += printable_token_length
+        tokens_in_row += 1
+
+        # TODO: Instead of using rstrip when appending the logical row,
+        #       identify here if the whitespace token will be the last 
+        #       on the row, and if so, don't add it in the first place.
+        #       (sr 2019-06-23)
+        token = scanner.scan( /\s+/ ).to_s
+        logical_row << token
+        printable_row_length += token.length
+      end
+
+      output_text << logical_row.rstrip << "\n"
+    end
+    module_function :wrap_row
+
+    def indent( text, indent_depth: 2, each_row: true )
+      indent = " " * indent_depth
+
+      if each_row
+        text.lines.map { |row| row.prepend( indent ) }.join
+      else
+        text.prepend( indent )
+      end
+    end
+    module_function :indent
+
+    def printable_length( text )
+      Term::ANSIColor.uncolored( text ).length
+    end
+    module_function :printable_length
+
+    def wrap_list( array, width = Bri.width )
+      return '' if array.empty?
+
+      indent( wrap_to_width( array.join( "  " ), width - 2 ) )
+    end
+    module_function :wrap_list
+
+    def hrule( text = '', width = Bri.width )
+      return "#{RULE_CHARACTER * width}\n" if text.empty?
+
+      rule_length = width - text.length - 1
+      rule_length = 1 if rule_length < 1
+
+      rule = RULE_CHARACTER * rule_length
+      "#{rule} #{Term::ANSIColor::bold( text )}\n"
+    end
+    module_function :hrule
+
+    def print_origin( origin_text, width = Bri.width )
+      return '' if !origin_text || origin_text.empty?
+
+      "(#{origin_text})".rjust( width )
+    end
+    module_function :print_origin
+
+    def section_header( text )
+      "#{Term::ANSIColor.green}#{Term::ANSIColor.underline}#{text}#{Term::ANSIColor.reset}\n"
+    end
+    module_function :section_header
+  end
+end

data/lib/bri.rb

@@ -1,6 +1,7 @@
 require 'erb'
 require 'term/ansicolor'
 
+require_relative 'bri/text_formatting_utils'
 require_relative 'bri/renderer'
 require_relative 'bri/mall'
 require_relative 'bri/matcher'
@@ -11,22 +12,24 @@ require_relative 'bri/match'
 module Bri
   DEFAULT_WIDTH = 72
 
-  def self.ri( query, show_all: false )
+  def self.ri( query, options )
+    if options[:show_all]
+      Bri::Mall.ri_paths( system: true, site: true, home: true, gems: true )
+    else
+      Bri::Mall.ri_paths( system: true, site: true, home: true, gems: false )
+    end
+
     results = Bri::Matcher.new( query ).find
 
     if results.size == 0
       "No matching results found"
+
     elsif results.size == 1
       results.first.to_s
+
     elsif results.all? { |r| r.is_a?(Bri::Match::Class) }
-      if show_all
-        results.map(&:to_s)
-      else
-        gem_docs, core_docs = results.partition { |r| r.origin =~ %r{gem\b} }
-
-        docs_to_output = core_docs.empty? ? gem_docs : core_docs
-        docs_to_output.map(&:to_s)
-      end
+      results.map(&:to_s)
+
     else
       qualified_methods = results.map(&:full_name).sort
       ERB.new( Bri::Templates::MULTIPLE_CHOICES, nil, '<>' ).result( binding )
@@ -47,18 +50,18 @@ module Bri
   end
 
   def self.list_classes
-    Bri::Mall.instance.classes.join("\n" )
+    Bri::Mall.classes.join("\n" )
   end
 
   def self.list_methods
-    ( Bri::Mall.instance.instance_methods + 
-      Bri::Mall.instance.class_methods ).sort.join( "\n" )
+    ( Bri::Mall.instance_methods + 
+      Bri::Mall.class_methods ).sort.join( "\n" )
   end
 
   def self.list_names
-    ( Bri::Mall.instance.classes +
-      Bri::Mall.instance.instance_methods +
-      Bri::Mall.instance.class_methods ).sort.join( "\n" )
+    ( Bri::Mall.classes +
+      Bri::Mall.instance_methods +
+      Bri::Mall.class_methods ).sort.join( "\n" )
   end
 
 end

metadata

@@ -1,10 +1,11 @@
 --- !ruby/object:Gem::Specification
 name: bri
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 1.0.0.pre.beta1
 platform: ruby
 authors:
 - Sven Riedel
+autorequire: 
 bindir: bin
 cert_chain: []
 date: 2011-05-20 00:00:00.000000000 Z
@@ -29,28 +30,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.13.0
+        version: 6.1.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 6.13.0
+        version: 6.1.1
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.13.0
+        version: 3.8.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.13.0
+        version: 3.8.0
 - !ruby/object:Gem::Dependency
   name: rspec-its
   requirement: !ruby/object:Gem::Requirement
@@ -99,6 +100,23 @@ files:
 - lib/bri/match/method.rb
 - lib/bri/matcher.rb
 - lib/bri/renderer.rb
+- lib/bri/renderer/blank_line.rb
+- lib/bri/renderer/default.rb
+- lib/bri/renderer/document.rb
+- lib/bri/renderer/heading.rb
+- lib/bri/renderer/list.rb
+- lib/bri/renderer/list/base.rb
+- lib/bri/renderer/list/bullet.rb
+- lib/bri/renderer/list/labeled.rb
+- lib/bri/renderer/list/lower_lettered.rb
+- lib/bri/renderer/list/note.rb
+- lib/bri/renderer/list/numbered.rb
+- lib/bri/renderer/list/upper_lettered.rb
+- lib/bri/renderer/list_item.rb
+- lib/bri/renderer/paragraph.rb
+- lib/bri/renderer/result.rb
+- lib/bri/renderer/rule.rb
+- lib/bri/renderer/verbatim.rb
 - lib/bri/search.rb
 - lib/bri/search/base.rb
 - lib/bri/search/class.rb
@@ -106,20 +124,11 @@ files:
 - lib/bri/search/instance_method.rb
 - lib/bri/search/method.rb
 - lib/bri/templates.rb
-- spec/bri_dummy_spec_class.rb
-- spec/lib/bri/mall_spec.rb
-- spec/lib/bri/match/class_spec.rb
-- spec/lib/bri/match/method_spec.rb
-- spec/lib/bri/matcher_spec.rb
-- spec/lib/bri/renderer_spec.rb
-- spec/lib/bri/search/class_method_spec.rb
-- spec/lib/bri/search/class_spec.rb
-- spec/lib/bri/search/instance_method_spec.rb
-- spec/lib/bri/search/method_spec.rb
-- spec/spec_helper.rb
+- lib/bri/text_formatting_utils.rb
 homepage: http://github.com/sriedel/bri
 licenses: []
 metadata: {}
+post_install_message: 
 rdoc_options:
 - "--charset=UTF-8"
 require_paths:
@@ -135,7 +144,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.6.5
+rubygems_version: 3.0.4
+signing_key: 
 specification_version: 4
 summary: Beautified RI in the spirit of fastri/qri. Unlike fastri, bri builds on top
   of the rdoc 2.x/3.x backend, only output and formatting is handled by bri