brice 0.2.8 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 17a8fb5226397ca8922e81decc7ac9257a2f55b2
-  data.tar.gz: b982e783401e4135050b3c9a050cb4a6886b4d36
+SHA256:
+  metadata.gz: 36999aee54c54f1de81d06593f1038074c2b9726c8201752cb692ba28c33a411
+  data.tar.gz: 6dd8b2419fc5e1f0a3192ba5fb3273c1ab9c66f1136d12e27865f4ba0e8104db
 SHA512:
-  metadata.gz: 3ea3bf6fdbd2e9e78a4d007d648e0bd708fdaed2738ffd335dd1c17a91552a84743b5c0cde32effe076c517844bf9ebbc9d23f87c002514398ffe1907c4f10e7
-  data.tar.gz: 6e36c1b51e274c1b804cfbc0806530cb2aa0d80277248c723bfecaa54dd66a399ba1c0cd59fe95b999aeabf5f1b163f308ae8f9033e18df58ab238364845c225
+  metadata.gz: 9d00c57bd13955221544ae079b8fe8f62553419544c716f1492fab2a3850fe4d8a5f92716b9ab5adfecc9c37b78c3716d02ad40c5d438d709e3c71a3408c3670
+  data.tar.gz: 10ab3f892e919a92a29b32e5c4d2064bb3045ea375adfe74648642dbd35af9c0ac9101a754ec31285ca4aa26a1fc3caa766a0c74b5af3a1b1fa46206b1b21afe

data/ChangeLog

@@ -1,5 +1,23 @@
+# markup: rd
+
 = Revision history for brice
 
+== 0.4.2 [2020-09-17]
+
+* Ruby 2.7 compatibility.
+
+== 0.4.1 [2016-03-29]
+
+* To mark default packages as optional, use underscore in addition to question
+  mark, since the latter is not supported on Windows file systems (issue #10
+  by Hovis Biddle).
+
+== 0.4.0 [2014-10-31]
+
+* Require at least Ruby 1.9.3.
+* Only set prompt if left at default.
+* Default package +added_methods+ now optional.
+
 == 0.0.1 [2008-11-14]
 
 * Birthday :-)

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to brice version 0.2.8
+This documentation refers to brice version 0.4.2
 
 
 == DESCRIPTION
@@ -15,12 +15,10 @@ in that regard.
 
 Add this to your <tt>~/.irbrc</tt> and receive the default goodness:
 
-  require 'rubygems'
   require 'brice/init'  # equivalent to: require 'brice'; Brice.init
 
 Or get some more control over the configuration:
 
-  require 'rubygems'
   require 'brice'
 
   Brice.init { |config|
@@ -64,10 +62,10 @@ guaranteed to have any effect after <tt>Brice.init</tt> has been called.
 
 == LINKS
 
-<b></b>
-Documentation:: http://blackwinter.github.com/brice
-Source code::   http://github.com/blackwinter/brice
-RubyGem::       http://rubygems.org/gems/brice
+Documentation:: https://blackwinter.github.com/brice
+Source code::   https://github.com/blackwinter/brice
+RubyGem::       https://rubygems.org/gems/brice
+Travis CI::     https://travis-ci.org/blackwinter/brice
 
 
 == AUTHORS
@@ -77,7 +75,7 @@ RubyGem::       http://rubygems.org/gems/brice
 
 == LICENSE AND COPYRIGHT
 
-Copyright (C) 2008-2013 Jens Wille
+Copyright (C) 2008-2020 Jens Wille
 
 brice is free software: you can redistribute it and/or modify it under the
 terms of the GNU Affero General Public License as published by the Free

data/Rakefile

@@ -1,17 +1,20 @@
-require File.expand_path(%q{../lib/brice/version}, __FILE__)
+require_relative 'lib/brice/version'
 
 begin
   require 'hen'
 
   Hen.lay! {{
-    :gem => {
-      :name         => %q{brice},
-      :version      => Brice::VERSION,
-      :summary      => %q{Extra cool IRb goodness for the masses},
-      :author       => %q{Jens Wille},
-      :email        => %q{jens.wille@gmail.com},
-      :homepage     => :blackwinter,
-      :dependencies => [['ruby-nuggets', '>= 0.5.2']]
+    gem: {
+      name:         %q{brice},
+      version:      Brice::VERSION,
+      summary:      %q{Extra cool IRb goodness for the masses},
+      author:       %q{Jens Wille},
+      email:        %q{jens.wille@gmail.com},
+      license:      %q{AGPL-3.0},
+      homepage:     :blackwinter,
+      dependencies: { nuggets: '~> 1.6' },
+
+      required_ruby_version: '>= 1.9.3'
     }
   }}
 rescue LoadError => err

data/lib/brice.rb

@@ -3,7 +3,7 @@
 #                                                                             #
 # brice -- Extra cool IRb goodness for the masses                             #
 #                                                                             #
-# Copyright (C) 2008-2013 Jens Wille                                          #
+# Copyright (C) 2008-2016 Jens Wille                                          #
 #                                                                             #
 # Authors:                                                                    #
 #     Jens Wille <jens.wille@gmail.com>                                       #
@@ -27,16 +27,11 @@
 require 'irb'
 require 'nuggets/env/user_home'
 
-require 'brice/version'
+require_relative 'brice/dsl'
+require_relative 'brice/version'
 
 module Brice
 
-  autoload :Config,    'brice/config'
-  autoload :Colours,   'brice/colours'
-  autoload :DSL,       'brice/dsl'
-  autoload :History,   'brice/history'
-  autoload :Shortcuts, 'brice/shortcuts'
-
   RC_DIR = __FILE__.sub(/\.rb\z/, '/rc')
 
   BRICE_HOME = File.join(ENV.user_home, '.brice')
@@ -53,24 +48,25 @@ module Brice
 
   # call-seq:
   #   Brice.init { |config| ... }
-  #   Brice.init(:verbose => true) { |config| ... }
+  #   Brice.init(verbose: true) { |config| ... }
   #
   # Initialize Brice and optionally configure any packages.
   def init(options = {})
     @irb_rc = []
 
-    @config = Config.new(rc_files(true).map { |rc|
-      File.basename(rc, '.rb').sub(/\A\d+_/, '')
-    })
-
     options.each { |key, value|
-      if respond_to?(method = "#{key}=")
-        send(method, value)
-      else
-        raise ArgumentError, "illegal option: #{key}"
-      end
+      respond_to?(set = "#{key}=") ? send(set, value) :
+        raise(ArgumentError, "illegal option: #{key}")
     }
 
+    packages = rc_files(true).map { |rc|
+      File.basename(rc, '.rb').sub(/\A\d+_/, '')
+    }.reject { |rc| rc.end_with?('?') || rc.end_with?('_') }
+
+    warn "Default packages: #{packages.join(', ')}" if verbose
+
+    @config = Config.new(packages)
+
     yield config if block_given?
 
     load_rc_files(true)
@@ -85,11 +81,8 @@ module Brice
   # Set config to +config+. Raises a TypeError if +config+ is not a
   # Brice::Config.
   def config=(config)
-    if config.is_a?(Config)
-      @config = config
-    else
-      raise TypeError, "expected Brice::Config, got #{config.class}"
-    end
+    config.is_a?(Config) ? @config = config :
+      raise(TypeError, "Brice::Config expected, got #{config.class}")
   end
 
   # call-seq:
@@ -127,7 +120,11 @@ module Brice
   # Returns the value of +opt+ at +key+ if present, or +default+
   # otherwise.
   def opt(opt, key, default = true)
-    opt.is_a?(Hash) && opt.has_key?(key) ? opt[key] : default
+    opt.is_a?(Hash) && opt.key?(key) ? opt[key] : default
+  end
+
+  def error(obj, met, err)
+    warn "Error in #{obj}##{met}: #{err.backtrace.first}: #{err} (#{err.class})"
   end
 
   private
@@ -145,7 +142,7 @@ module Brice
       brice_load rc
     }
 
-    include_custom_extensions ? res += load_custom_extensions : res
+    include_custom_extensions ? res + load_custom_extensions : res
   end
 
   # call-seq:
@@ -164,7 +161,7 @@ module Brice
   #
   # Find the actual extension files in +dir+.
   def find_rc_files(dir = RC_DIR)
-    File.directory?(dir) ? Dir["#{dir}/*.rb"].sort : []
+    File.directory?(dir) ? Dir["#{dir}/**/*.rb"].sort : []
   end
 
   # call-seq:
@@ -178,3 +175,8 @@ module Brice
   end
 
 end
+
+require_relative 'brice/config'
+require_relative 'brice/colours'
+require_relative 'brice/history'
+require_relative 'brice/shortcuts'

data/lib/brice/colours.rb

@@ -3,7 +3,7 @@
 #                                                                             #
 # A component of brice, the extra cool IRb goodness donator                   #
 #                                                                             #
-# Copyright (C) 2008-2012 Jens Wille                                          #
+# Copyright (C) 2008-2014 Jens Wille                                          #
 #                                                                             #
 # Authors:                                                                    #
 #     Jens Wille <jens.wille@gmail.com>                                       #
@@ -24,15 +24,13 @@
 ###############################################################################
 #++
 
-require 'brice'
-
 module Brice
 
   # Add colour support to IRb.
   #
-  # Set your own colours with <tt>config.colours.opt = { :colours => { ... } }</tt>
+  # Set your own colours with <tt>config.colours.opt = { colours: { ... } }</tt>
   # or modify the default scheme (DEFAULT_COLOURS) with <tt>config.colours.opt =
-  # { :colours => Brice::Colours::DEFAULT_COLOURS.merge(...) }</tt>.
+  # { colours: Brice::Colours::DEFAULT_COLOURS.merge(...) }</tt>.
 
   module Colours
 
@@ -41,61 +39,63 @@ module Brice
     # Default IRb colour scheme.
     DEFAULT_COLOURS = {
       # delimiter colours
-      :comma              => :blue,
-      :refers             => :blue,
+      comma:              :blue,
+      refers:             :blue,
 
       # container colours (hash and array)
-      :open_hash          => :green,
-      :close_hash         => :green,
-      :open_array         => :green,
-      :close_array        => :green,
+      open_hash:          :green,
+      close_hash:         :green,
+      open_array:         :green,
+      close_array:        :green,
 
       # object colours
-      :open_object        => :light_red,
-      :object_class       => :white,
-      :object_addr_prefix => :blue,
-      :object_line_prefix => :blue,
-      :close_object       => :light_red,
+      open_object:        :light_red,
+      object_class:       :white,
+      object_addr_prefix: :blue,
+      object_line_prefix: :blue,
+      close_object:       :light_red,
 
       # symbol colours
-      :symbol             => :yellow,
-      :symbol_prefix      => :yellow,
+      symbol:             :yellow,
+      symbol_prefix:      :yellow,
 
       # string colours
-      :open_string        => :red,
-      :string             => :cyan,
-      :close_string       => :red,
+      open_string:        :red,
+      string:             :cyan,
+      close_string:       :red,
 
       # misc colours
-      :number             => :cyan,
-      :keyword            => :green,
-      :class              => :light_green,
-      :range              => :red,
-      :unknown            => :green
+      number:             :cyan,
+      keyword:            :green,
+      class:              :light_green,
+      range:              :red,
+      unknown:            :green
     }
 
     # Fruity testing colours.
     TESTING_COLOURS = {
-      :comma            => :red,
-      :refers           => :red,
-      :open_hash        => :blue,
-      :close_hash       => :blue,
-      :open_array       => :green,
-      :close_array      => :green,
-      :open_object      => :light_red,
-      :object_class     => :light_green,
-      :object_addr      => :purple,
-      :object_line      => :light_purple,
-      :close_object     => :light_red,
-      :symbol           => :yellow,
-      :symbol_prefix    => :yellow,
-      :number           => :cyan,
-      :string           => :cyan,
-      :keyword          => :white,
-      :range            => :light_blue
+      comma:              :red,
+      refers:             :red,
+      open_hash:          :blue,
+      close_hash:         :blue,
+      open_array:         :green,
+      close_array:        :green,
+      open_object:        :light_red,
+      object_class:       :light_green,
+      object_addr:        :purple,
+      object_line:        :light_purple,
+      close_object:       :light_red,
+      symbol:             :yellow,
+      symbol_prefix:      :yellow,
+      number:             :cyan,
+      string:             :cyan,
+      keyword:            :white,
+      range:              :light_blue
     }
 
     def init(opt = {})
+      require 'ripper'
+
       enable_irb if Brice.opt(opt, :irb, STDOUT.tty?)
       enable_pp  if Brice.opt(opt, :pp,  STDOUT.tty?)
 
@@ -109,51 +109,26 @@ module Brice
 
     # Enable colourized IRb results.
     def enable_irb
-      if IRB.const_defined?(:Inspector)
-        IRB::Inspector.class_eval {
-          unless method_defined?(:inspect_value_with_colour)
-            alias_method :inspect_value_without_colour, :inspect_value
-
-            def inspect_value_with_colour(value)
-              Colours.colourize(inspect_value_without_colour(value))
-            end
-          end
+      IRB::Inspector.class_eval {
+        unless method_defined?(:inspect_value_with_colour)
+          alias_method :inspect_value_without_colour, :inspect_value
 
-          alias_method :inspect_value, :inspect_value_with_colour
-        }
-      else
-        IRB::Irb.class_eval {
-          unless method_defined?(:output_value_with_colour)
-            alias_method :output_value_without_colour, :output_value
-
-            def output_value_with_colour
-              value = @context.last_value
-              value = Colours.colourize(value.inspect) if @context.inspect?
-
-              printf(@context.return_format, value)
-            end
+          def inspect_value_with_colour(value)
+            Colours.colourize(inspect_value_without_colour(value))
           end
+        end
 
-          alias_method :output_value, :output_value_with_colour
-        }
-      end
+        alias_method :inspect_value, :inspect_value_with_colour
+      }
     end
 
     # Disable colourized IRb results.
     def disable_irb
-      if IRB.const_defined?(:Inspector)
-        IRB::Inspector.class_eval {
-          if method_defined?(:inspect_value_without_colour)
-            alias_method :inspect_value, :inspect_value_without_colour
-          end
-        }
-      else
-        IRB::Irb.class_eval {
-          if method_defined?(:output_value_without_colour)
-            alias_method :output_value, :output_value_without_colour
-          end
-        }
-      end
+      IRB::Inspector.class_eval {
+        if method_defined?(:inspect_value_without_colour)
+          alias_method :inspect_value, :inspect_value_without_colour
+        end
+      }
     end
 
     def enable_pp
@@ -215,14 +190,11 @@ module Brice
 
     # Colourize the results of inspect
     def colourize(str)
-      res = ''
-
-      Tokenizer.tokenize(str) { |token, value|
+     ''.tap { |res| Tokenizer.tokenize(str.to_s) { |token, value|
         res << colourize_string(value, colours[token])
-      }
-
-      res
-    rescue
+      } }
+    rescue => err
+      Brice.error(self, __method__, err)
       str
     end
 
@@ -233,28 +205,28 @@ module Brice
       extend self
 
       COLOURS = {
-        :reset        => '0;0',
-        :black        => '0;30',
-        :red          => '0;31',
-        :green        => '0;32',
-        :brown        => '0;33',
-        :blue         => '0;34',
-        :cyan         => '0;36',
-        :purple       => '0;35',
-        :light_gray   => '0;37',
-        :dark_gray    => '1;30',
-        :light_red    => '1;31',
-        :light_green  => '1;32',
-        :yellow       => '1;33',
-        :light_blue   => '1;34',
-        :light_cyan   => '1;36',
-        :light_purple => '1;35',
-        :white        => '1;37'
+        reset:         '0;0',
+        black:         '0;30',
+        red:           '0;31',
+        green:         '0;32',
+        brown:         '0;33',
+        blue:          '0;34',
+        cyan:          '0;36',
+        purple:        '0;35',
+        light_gray:    '0;37',
+        dark_gray:     '1;30',
+        light_red:     '1;31',
+        light_green:   '1;32',
+        yellow:        '1;33',
+        light_blue:    '1;34',
+        light_cyan:    '1;36',
+        light_purple:  '1;35',
+        white:         '1;37'
       }
 
       # Return the escape code for a given colour.
       def escape(key)
-        "\033[#{COLOURS[key]}m" if COLOURS.has_key?(key)
+        "\033[#{COLOURS[key]}m" if COLOURS.key?(key)
       end
 
       alias_method :[], :escape
@@ -263,144 +235,174 @@ module Brice
 
     # Tokenize an inspection string.
 
-    module Tokenizer
+    class Tokenizer
+
+      EVENT_MAP = {
+      # on_CHAR:            :unknown,
+      # on___end__:         :unknown,
+      # on_backref:         :unknown,
+      # on_backtick:        :unknown,
+        on_comma:           :comma,
+        on_comment:         :unknown,
+        on_const:           :class,
+      # on_cvar:            :unknown,
+      # on_embdoc:          :unknown,
+      # on_embdoc_beg:      :unknown,
+      # on_embdoc_end:      :unknown,
+      # on_embexpr_beg:     :unknown,
+      # on_embexpr_end:     :unknown,
+      # on_embvar:          :unknown,
+        on_float:           :number,
+      # on_gvar:            :unknown,
+      # on_heredoc_beg:     :unknown,
+      # on_heredoc_end:     :unknown,
+        on_ident:           :symbol,
+      # on_ignored_nl:      :unknown,
+        on_imaginary:       :number,
+        on_int:             :number,
+      # on_ivar:            :unknown,
+        on_kw:              :keyword,
+        on_label:           :unknown,
+        on_lbrace:          :open_hash,
+        on_lbracket:        :open_array,
+        on_lparen:          :unknown,
+      # on_nl:              :unknown,
+        on_op:              :refers,
+        on_period:          :comma,
+      # on_qsymbols_beg:    :unknown,
+      # on_qwords_beg:      :unknown,
+        on_rational:        :number,
+        on_rbrace:          :close_hash,
+        on_rbracket:        :close_array,
+        on_regexp_beg:      :unknown,
+        on_regexp_end:      :unknown,
+        on_rparen:          :unknown,
+        on_semicolon:       :comma,
+        on_sp:              :whitespace,
+        on_symbeg:          :symbol_prefix,
+      # on_symbols_beg:     :unknown,
+      # on_tlambda:         :unknown,
+      # on_tlambeg:         :unknown,
+        on_tstring_beg:     :open_string,
+        on_tstring_content: :string,
+        on_tstring_end:     :close_string,
+      # on_words_beg:       :unknown,
+      # on_words_sep:       :unknown
+      }
 
-      extend self
+      OBJECT_RE = %r{
+        \A
+        ( \#< )
+        ( .+ )
+        ( > )
+        \z
+      }x
+
+      OBJECT_CLASS_RE = %r{
+        \A
+        (?: \w | :: )+
+      }x
+
+      OBJECT_ADDR_RE = %r{
+        \A
+        ( : )
+        ( 0x [\hx]+ )
+        (?= \s | \z )
+      }x
+
+      IVAR_RE = %r{
+        \A
+        ( @ )
+        ( .+ )
+        \z
+      }x
+
+      RANGE_RE = %r{
+        \A
+        \.+
+        \z
+      }x
+
+      def self.tokenize(str, &block)
+        new(&block).tokenize(str)
+      end
+
+      def initialize(&block)
+        @block = block or raise ArgumentError, 'no block given'
+      end
+
+      attr_reader :block
 
       def tokenize(str)
-        raise ArgumentError, 'no block given' unless block_given?
+        return if str.empty?
+        return if enc_event(str)
 
-        chars = str.split(//)
-        char  = last_char = repeat = nil
-        states, value, index = [], '', 0
+        lex, prev = Ripper.lex(str), nil
 
-        reset = lambda { |*args|
-          states.pop
+        len = lex[-1][0][-1] + lex[-1][-1].bytesize
+        str, rest = str.byteslice(0, len), str.byteslice(len .. -1)
 
-          value  = ''
-          repeat = args.first unless args.empty?
-        }
+        return block[:unknown, rest] if str.empty?
+
+        lex.each { |_, event, tok|
+          sym_event(event, tok, prev) ||
+          obj_event(event, tok)       ||
+          rng_event(event, tok)       ||
+          var_event(event, tok)       ||
+          map_event(event, tok)
 
-        yield_last = lambda { |*args|
-          yield states.last, value
-          reset[*args]
+          prev = event
         }
 
-        until index > chars.size
-          char, repeat = chars[index], false
-
-          case states.last
-            when nil
-              case char
-                when ':' then states << :symbol
-                when '"' then states << :string
-                when '#' then states << :object
-                when /[a-z]/i
-                  states << :keyword
-                  repeat = true
-                when /[0-9-]/
-                  states << :number
-                  repeat = true
-                when '{'  then yield :open_hash,   '{'
-                when '['  then yield :open_array,  '['
-                when ']'  then yield :close_array, ']'
-                when '}'  then yield :close_hash,  '}'
-                when /\s/ then yield :whitespace,  char
-                when ','  then yield :comma,       ','
-                when '>'  then yield :refers,      '=>' if last_char == '='
-                when '.'  then yield :range,       '..' if last_char == '.'
-                when '='  then nil
-                else           yield :unknown,     char
-              end
-            when :symbol
-              if char =~ /[a-z0-9_!?]/  # should have =, but that messes up foo=>bar
-                value << char
-              else
-                yield :symbol_prefix, ':'
-                yield_last[true]
-              end
-            when :string
-              if char == '"'
-                if last_char == '\\'
-                  value[-1] = char
-                else
-                  yield :open_string,  char
-                  yield_last[]
-                  yield :close_string, char
-                end
-              else
-                value << char
-              end
-            when :keyword
-              if char =~ /[a-z0-9_]/i
-                value << char
-              else
-                states[-1] = :class if value =~ /\A[A-Z]/
-                yield_last[true]
-
-                value << char if char == '.'
-              end
-            when :number
-              case char
-                when /[0-9e-]/
-                  value << char
-                when '.'
-                  if last_char == char
-                    value.chop!
-
-                    yield_last[]
-                    yield :range, '..'
-                  else
-                    value << char
-                  end
-                else
-                  yield_last[true]
-              end
-            when :object
-              case char
-                when '<'
-                  yield :open_object, '#<'
-                  states << :object_class
-                when ':'
-                  states << :object_addr
-                when '@'
-                  states << :object_line
-                when '>'
-                  yield :close_object, '>'
-                  reset[]
-              end
-            when :object_class
-              if char == ':'
-                yield_last[true]
-              else
-                value << char
-              end
-            when :object_addr
-              case char
-                when '>'
-                  # ignore
-                when '@'
-                  yield :object_addr_prefix, ':'
-                  yield_last[true]
-                else
-                  value << char
-              end
-            when :object_line
-              if char == '>'
-                yield :object_line_prefix, '@'
-                yield_last[true]
-              else
-                value << char
-              end
-            else
-              raise "unknown state: #{states}"
-          end
+        tokenize(rest)
+      end
+
+      private
+
+      def enc_event(str)  # XXX /\A\s*#.*?coding\s*:\s*./
+        object($1, $2, $3) if str =~ OBJECT_RE && str.include?('coding')
+      end
+
+      def obj_event(event, tok)
+        object($1, $2, $3) if event == :on_comment && tok =~ OBJECT_RE
+      end
+
+      def sym_event(event, tok, prev)
+        block[:symbol, tok] if event == :on_kw && prev == :on_symbeg
+      end
 
-          unless repeat
-            index += 1
-            last_char = char
+      def rng_event(event, tok)
+        block[:range, tok] if event == :on_op && tok =~ RANGE_RE
+      end
+
+      def var_event(event, tok)
+        if event == :on_ivar && tok =~ IVAR_RE
+          block[:object_line_prefix, $1]
+          block[:keyword, $2]
+        end
+      end
+
+      def map_event(event, tok)
+        block[EVENT_MAP[event], tok]
+      end
+
+      def object(open, str, close)
+        block[:open_object, open]
+
+        if str.sub!(OBJECT_CLASS_RE, '')
+          block[:object_class, $&]
+
+          if str.sub!(OBJECT_ADDR_RE, '')
+            block[:object_addr_prefix, $1]
+            block[:object_addr, $2]
+
+            str = tokenize(str)
           end
         end
+
+        block[:unknown, str] if str
+
+        block[:close_object, close]
       end
 
     end