brice 0.1.1 → 0.2.0

data/README

@@ -2,7 +2,7 @@
 
 == VERSION
 
-This documentation refers to brice version 0.1.1
+This documentation refers to brice version 0.2.0
 
 
 == DESCRIPTION

data/lib/brice/colours.rb

@@ -0,0 +1,406 @@
+#--
+###############################################################################
+#                                                                             #
+# A component of brice, the extra cool IRb goodness donator                   #
+#                                                                             #
+# Copyright (C) 2008-2011 Jens Wille                                          #
+#                                                                             #
+# Authors:                                                                    #
+#     Jens Wille <jens.wille@uni-koeln.de>                                    #
+#                                                                             #
+# 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     #
+# Software Foundation, either version 3 of the License, or (at your option)   #
+# any later version.                                                          #
+#                                                                             #
+# brice is distributed in the hope that it will be useful, but WITHOUT ANY    #
+# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS   #
+# FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for     #
+# more details.                                                               #
+#                                                                             #
+# You should have received a copy of the GNU Affero General Public License    #
+# along with brice. If not, see <http://www.gnu.org/licenses/>.               #
+#                                                                             #
+###############################################################################
+#++
+
+require 'brice'
+
+module Brice
+
+  # Add colour support to IRb.
+
+  module Colours
+
+    extend self
+
+    # Default IRb colour scheme.
+    DEFAULT_COLOURS = {
+      # delimiter colours
+      :comma              => :blue,
+      :refers             => :blue,
+
+      # container colours (hash and array)
+      :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,
+
+      # symbol colours
+      :symbol             => :yellow,
+      :symbol_prefix      => :yellow,
+
+      # string colours
+      :open_string        => :red,
+      :string             => :cyan,
+      :close_string       => :red,
+
+      # misc colours
+      :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
+    }
+
+    def init(opt = {})
+      enable_irb if Brice.opt(opt, :irb, STDOUT.tty?)
+      enable_pp  if Brice.opt(opt, :pp,  STDOUT.tty?)
+
+      self.colours = Brice.opt(opt, :colours, colours)
+    end
+
+    def disable
+      disable_irb
+      disable_pp
+    end
+
+    # 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
+
+          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
+          end
+
+          alias_method :output_value, :output_value_with_colour
+        }
+      end
+    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
+    end
+
+    def enable_pp
+      require 'pp'
+
+      class << PP
+        unless method_defined?(:pp_with_colour)
+          alias_method :pp_without_colour, :pp
+
+          def pp_with_colour(obj, out = $>, width = 79)
+            res = pp_without_colour(obj, str = '', width)
+            out << Colours.colourize(str)
+            res
+          end
+
+          alias_method :pp, :pp_with_colour
+        end
+
+        unless method_defined?(:singleline_pp_with_colour)
+          alias_method :singleline_pp_without_colour, :singleline_pp
+
+          def singleline_pp_with_colour(obj, out = $>)
+            res = singleline_pp_without_colour(obj, str = '')
+            out << Colours.colourize(str)
+            res
+          end
+
+          alias_method :singleline_pp, :singleline_pp_with_colour
+        end
+      end
+    end
+
+    def disable_pp
+      PP.class_eval {
+        if method_defined?(:pp_without_colour)
+          alias_method :pp, :pp_without_colour
+        end
+
+        if method_defined?(:singleline_pp_without_colour)
+          alias_method :singleline_pp, :singleline_pp_without_colour
+        end
+      }
+    end
+
+    # Set colour map to hash
+    def colours=(hash)
+      @colours = hash
+    end
+
+    # Get current colour map
+    def colours
+      @colours ||= DEFAULT_COLOURS.dup
+    end
+
+    # Return a string with the given colour.
+    def colourize_string(str, colour)
+      (col = Colour[colour]) ? "#{col}#{str}#{Colour[:reset]}" : str
+    end
+
+    # Colourize the results of inspect
+    def colourize(str)
+      res = ''
+
+      Tokenizer.tokenize(str) { |token, value|
+        res << colourize_string(value, colours[token])
+      }
+
+      res
+    rescue
+      str
+    end
+
+    # Terminal escape codes for colours.
+
+    module Colour
+
+      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'
+      }
+
+      # Return the escape code for a given colour.
+      def escape(key)
+        "\033[#{COLOURS[key]}m" if COLOURS.has_key?(key)
+      end
+
+      alias_method :[], :escape
+
+    end
+
+    # Tokenize an inspection string.
+
+    module Tokenizer
+
+      extend self
+
+      def tokenize(str)
+        raise ArgumentError, 'no block given' unless block_given?
+
+        chars = str.split(//)
+        char  = last_char = repeat = nil
+        states, value, index = [], '', 0
+
+        reset = lambda { |*args|
+          states.pop
+
+          value  = ''
+          repeat = args.first unless args.empty?
+        }
+
+        yield_last = lambda { |*args|
+          yield states.last, value
+          reset[*args]
+        }
+
+        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
+
+          unless repeat
+            index += 1
+            last_char = char
+          end
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/brice/config.rb

@@ -25,8 +25,9 @@
 #++
 
 require 'ostruct'
+require 'brice'
 
-class Brice
+module Brice
 
   # Exclude unwanted packages:
   #
@@ -45,9 +46,9 @@ class Brice
   #
   #   # set multiple properties
   #   config.foo = %w[bar baz]
-  #   # equivalent to:
-  #   #config.foo.bar = true
-  #   #config.foo.baz = true
+  #   # which is equivalent to:
+  #   config.foo.bar = true
+  #   config.foo.baz = true
   #
   #   # reset package configuration
   #   config.foo!
@@ -69,7 +70,7 @@ class Brice
     #
     # Accessor for package +package+.
     def [](package)
-      @packages[package.to_s]
+      packages[package.to_s]
     end
 
     # call-seq:
@@ -90,7 +91,7 @@ class Brice
     #
     # Disable/exclude packages +packages+.
     def exclude(*packages)
-      packages.each { |package| @packages.delete(package.to_s) }
+      packages.each { |package| self.packages.delete(package.to_s) }
       self
     end
 
@@ -101,7 +102,7 @@ class Brice
     #
     # Clear all packages.
     def clear
-      @packages.clear
+      packages.clear
     end
 
     # call-seq:
@@ -110,7 +111,7 @@ class Brice
     #
     # See whether package +package+ is enabled/included.
     def include?(package)
-      @packages.include?(package.to_s)
+      packages.include?(package.to_s)
     end
 
     alias_method :have?, :include?
@@ -126,17 +127,21 @@ class Brice
     def method_missing(method, *args)
       package, punctuation = method.to_s.sub(/([=!?])?\z/, ''), $1
 
-      raise ArgumentError, "wrong number of arguments (#{args.size} for 0)" \
-        unless punctuation == '=' || args.empty?
+      assignment = punctuation == '='
+
+      unless assignment || args.empty?
+        raise ArgumentError, "wrong number of arguments (#{args.size} for 0)"
+      end
 
       case punctuation
-        when '='
-          @packages[package] = PackageConfig.new
-          [*args.first].each { |arg| @packages[package].send("#{arg}=", true) }
-        when '!'
-          @packages[package] = PackageConfig.new
+        when '=', '!'
+          config = packages[package] = PackageConfig.new
+
+          assignment ? Array(args.first).each { |arg|
+            config.send("#{arg}=", true)
+          } : config
         when '?'
-          self.include?(package)
+          include?(package)
         else
           self[package]
       end
@@ -144,12 +149,23 @@ class Brice
 
     class PackageConfig < OpenStruct
 
+      include Enumerable
+
+      # call-seq:
+      #   pkgconfig.each { |entry| ... } -> pkgconfig
+      #
+      # Iterates over all entries in +pkgconfig+. Returns +pkgconfig+.
+      def each
+        @table.keys.each { |key| yield key.to_s }
+        self
+      end
+
       # call-seq:
-      #   pkgconfig.entries => anArray
+      #   pkgconfig.empty? -> true | false
       #
-      # Returns all entries/keys.
-      def entries
-        instance_variable_get(:@table).keys.map { |key| key.to_s }.sort
+      # Checks whether +pkgconfig+ is empty?
+      def empty?
+        @table.empty?
       end
 
     end

data/lib/brice/dsl.rb

@@ -27,7 +27,9 @@
 require 'nuggets/object/silence_mixin'
 require 'nuggets/env/set'
 
-class Brice
+require 'brice'
+
+module Brice
 
   # Certain global helper methods for use inside IRb extensions. Also
   # available inside the IRb session.
@@ -40,8 +42,8 @@ class Brice
     #   irb_rc { ... }
     #
     # Add IRB_RC proc (to be executed whenever a (sub-)session is started).
-    def irb_rc
-      Brice.irb_rc << Proc.new
+    def irb_rc(&block)
+      Brice.irb_rc << block
     end
 
     # call-seq:
@@ -49,14 +51,10 @@ class Brice
     #   irb_def(symbol, method)
     #
     # Define a method for use inside the IRb session.
-    def irb_def(symbol, method = nil)
+    def irb_def(symbol, method = nil, &block)
       irb_rc {
         Object.instance_eval {
-          if method
-            define_method(symbol, method)
-          else
-            define_method(symbol, &Proc.new)
-          end
+          define_method(symbol, method || block)
         }
       }
     end
@@ -93,14 +91,8 @@ class Brice
     # block in case of success.
     #
     # Returns either the result of the executed method or of the block.
-    def brice_require(string)
-      args = [:require, [string], LoadError]
-
-      if block_given?
-        brice_rescue(*args) { |*a| yield(*a) }
-      else
-        brice_rescue(*args)
-      end
+    def brice_require(string, &block)
+      brice_rescue(:require, [string], LoadError, &block)
     end
 
     # call-seq:
@@ -110,14 +102,8 @@ class Brice
     # block in case of success.
     #
     # Returns either the result of the executed method or of the block.
-    def brice_load(filename, wrap = false)
-      args = [:load, [filename, wrap]]
-
-      if block_given?
-        brice_rescue(*args) { |*a| yield(*a) }
-      else
-        brice_rescue(*args)
-      end
+    def brice_load(filename, wrap = false, &block)
+      brice_rescue(:load, [filename, wrap], &block)
     end
 
     # call-seq:
@@ -125,7 +111,7 @@ class Brice
     #
     # Runs +cmd+ with ENV modified according to +env+.
     def brice_run_cmd(cmd, env = {})
-      ENV.with(env) { `#{cmd}` }
+      ENV.with(env) { %x{#{cmd}} }
     end
 
     # call-seq:
@@ -141,12 +127,14 @@ class Brice
     def brice(package)
       package, libs = case package
         when Hash
-          raise ArgumentError, "Too many package names: #{package.keys.join(' ')}" \
-            if package.size > 1
-          raise ArgumentError, 'No package name given' \
-            if package.size < 1
+          names = package.keys
+
+          err = names.size > 1 ? "Too many package names: #{names.join(' ')}" :
+                names.size < 1 ? 'No package name given' : nil
+
+          raise ArgumentError, err if err
 
-          [package.keys.first, [*package.values.first]]
+          [names.first, Array(package.values.first)]
         else
           [package, [package]]
       end