facets 1.1.0 → 1.2.0

data/lib/facets/more/ansicode.rb

@@ -0,0 +1,311 @@
+#--
+# ANSICode
+#
+# Copyright (c) Thomsa Sawyer
+#
+# Ruby License
+#
+# This module is free software. You may use, modify, and/or redistribute this
+# software under the same terms as Ruby.
+#
+# This program 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.
+#
+# ==========================================================================
+#  Revision History
+# --------------------------------------------------------------------------
+#  2005-04-28  Trans  * Modifications to documentation.
+#
+#  2004-11-30  Trans  * Ported to Facets/More collection
+#
+#  2004-09-28  FF     * First release on Rubyforge
+#                     * Supports Rubygems now
+#
+#  2003-10-09  FF     * Added uncolored method as suggested by
+#                       Thomas Husterer <Thomas.Husterer@heidelberg.com>
+#                     * Added attribute methods with string arguments
+#                     * Deleted now unused files
+#
+#  2002-07-27  FF     * Minor Code Cleanup
+#                     * Added cdiff.rb
+#
+#  2002-06-12  FF     * Initial Release
+# ==========================================================================
+#
+# THANKS Florian Frank. ANSICode is a partial adaptation of
+#        ANSIColor, Copyright (c) 2002-2005 Florian Frank, LGPL.
+#
+# TODO Need to add rest of ANSI codes. Include modes?
+#
+# TODO Re-evaluate how color/yielding methods are defined.
+#
+# TODO Maybe up, down, right, left should have yielding
+#      versions too?
+#
+#++
+
+# :title: ANSICode
+#
+# Module which makes it very easy to use ANSI codes.
+# These are esspecially nice for beautifying shell output.
+#
+# == Synopsis
+#
+#   include ANSICode
+#
+#   p red, "Hello", blue, "World"   
+#   => "\e[31mHello\e[34mWorld"
+#
+#   p red { "Hello" } + blue { "World" }
+#   => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+#
+# == Supported ANSI Commands
+#
+#     save
+#     restore
+#     clear_screen
+#     cls             # synonym for :clear_screen
+#     clear_line
+#     clr             # synonym for :clear_line
+#     move
+#     up
+#     down
+#     left
+#     right
+#     display
+#
+#     clear
+#     reset           # synonym for :clear
+#     bold
+#     dark
+#     italic          # not widely implemented
+#     underline
+#     underscore      # synonym for :underline
+#     blink
+#     rapid_blink     # not widely implemented
+#     negative        # no reverse because of String#reverse
+#     concealed
+#     strikethrough   # not widely implemented
+#
+#     black
+#     red
+#     green
+#     yellow
+#     blue
+#     magenta
+#     cyan
+#     white
+#
+#     on_black
+#     on_red
+#     on_green
+#     on_yellow
+#     on_blue
+#     on_magenta
+#     on_cyan
+#     on_white
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+# * Florian Frank
+#
+#
+
+module Console
+
+  module ANSICode
+
+    # Save current cursor positon.
+
+    def save
+      "\e[s"
+    end
+
+    # Restore saved cursor positon.
+
+    def restore
+      "\e[u"
+    end
+
+    # Clear the screen and move cursor to home.
+
+    def clear_screen
+      "\e[2J"
+    end
+    alias_method :cls, :clear_screen
+
+    # Clear to the end of the current line.
+
+    def clear_line
+      "\e[K"
+    end
+    alias_method :clr, :clear_line
+
+    #--
+    #def position
+    #  "\e[#;#R"
+    #end
+    #++
+
+    # Move curose to line and column.
+
+    def move( line, column=0 )
+      "\e[#{line.to_i};#{column.to_i}H"
+    end
+
+    # Move cursor up a specificed number of spaces.
+
+    def up( spaces=1 )
+      "\e[#{spaces.to_i}A"
+    end
+
+    # Move cursor down a specificed number of spaces.
+
+    def down( spaces=1 )
+      "\e[#{spaces.to_i}B"
+    end
+
+    # Move cursor left a specificed number of spaces.
+
+    def left( spaces=1 )
+      "\e[#{spaces.to_i}D"
+    end
+
+    # Move cursor right a specificed number of spaces.
+
+    def right( spaces=1 )
+      "\e[#{spaces.to_i}C"
+    end
+
+    # Like +move+ but returns to original positon
+    # after yielding block or adding string argument.
+
+    def display( line, column=0, string=nil ) #:yield:
+      result = "\e[s"
+      result << "\e[#{line.to_i};#{column.to_i}H"
+      if block_given?
+        result << yield
+        result << "\e[u"
+      elsif string
+        result << string
+        result << "\e[u"
+      elsif respond_to?(:to_str)
+        result << self
+        result << "\e[u"
+      end
+      return result
+    end
+
+    # Define color codes.
+
+    def self.define_ansicolor_method(name,code)
+      class_eval <<-HERE
+        def #{name.to_s}(string = nil)
+            result = "\e[#{code}m"
+            if block_given?
+                result << yield
+                result << "\e[0m"
+            elsif string
+                result << string
+                result << "\e[0m"
+            elsif respond_to?(:to_str)
+                result << self
+                result << "\e[0m"
+            end
+            return result
+        end
+      HERE
+    end
+
+    @@colors = [
+      [ :clear        ,   0 ], 
+      [ :reset        ,   0 ],     # synonym for :clear
+      [ :bold         ,   1 ], 
+      [ :dark         ,   2 ], 
+      [ :italic       ,   3 ],     # not widely implemented
+      [ :underline    ,   4 ], 
+      [ :underscore   ,   4 ],     # synonym for :underline
+      [ :blink        ,   5 ], 
+      [ :rapid_blink  ,   6 ],     # not widely implemented
+      [ :negative     ,   7 ],     # no reverse because of String#reverse
+      [ :concealed    ,   8 ], 
+      [ :strikethrough,   9 ],     # not widely implemented
+      [ :black        ,  30 ], 
+      [ :red          ,  31 ], 
+      [ :green        ,  32 ], 
+      [ :yellow       ,  33 ], 
+      [ :blue         ,  34 ], 
+      [ :magenta      ,  35 ], 
+      [ :cyan         ,  36 ], 
+      [ :white        ,  37 ], 
+      [ :on_black     ,  40 ], 
+      [ :on_red       ,  41 ], 
+      [ :on_green     ,  42 ], 
+      [ :on_yellow    ,  43 ], 
+      [ :on_blue      ,  44 ], 
+      [ :on_magenta   ,  45 ], 
+      [ :on_cyan      ,  46 ], 
+      [ :on_white     ,  47 ], 
+    ]
+
+    @@colors.each do |c, v|
+      define_ansicolor_method(c, v)
+    end
+
+    ColoredRegexp = /\e\[([34][0-7]|[0-9])m/
+
+    def uncolored(string = nil)
+      if block_given?
+        yield.gsub(ColoredRegexp, '')
+      elsif string
+        string.gsub(ColoredRegexp, '')
+      elsif respond_to?(:to_str)
+        gsub(ColoredRegexp, '')
+      else
+        ''
+      end
+    end
+
+    module_function
+
+    def colors
+      @@colors.map { |c| c[0] }
+    end
+
+  end
+
+end
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin testing
+
+  require 'test/unit'
+
+  class TC_ANSICode < Test::Unit::TestCase
+
+    include Console::ANSICode
+
+    def test_methods
+      str = red + "Hello" + blue + "World"
+      out = "\e[31mHello\e[34mWorld"
+      assert_equal( out, str )
+    end
+
+    def test_blocks
+      str = red { "Hello" } + blue { "World" }
+      out = "\e[31mHello\e[0m\e[34mWorld\e[0m"
+      assert_equal( out, str )
+    end
+
+  end
+
+=end

data/lib/facets/more/aspects.rb

@@ -0,0 +1,230 @@
+require 'facets/more/inheritor'
+
+module Glue
+
+# An Aspect is a class that defines advices.
+
+class Aspect
+  class << self 
+    def wrap(target, methods = target.instance_methods, pre = :pre, post = :post)
+      target.send(:include, Glue::Aspects) unless target.ancestors.include?(Glue::Aspects)
+      target.wrap(self, :pre => pre, :post => post)
+    end
+
+    alias_method :observe, :wrap
+  end
+
+  def wrap(target, methods = target.instance_methods, pre = :pre, post = :post)
+    target.send(:include, Glue::Aspects) unless target.ancestors.include?(Glue::Aspects)
+    target.wrap(self, :pre => pre, :post => post)
+  end
+  alias_method :observe, :wrap
+end
+
+# Add support for Aspect Oriented Programming (AOP).
+#
+# === Examples
+#
+# class Controller
+#   pre :force_login, :where => :prepend
+#   wrap Benchmark, :on => :index
+#   post :taraa, :on => login
+# end
+# 
+# module Timestamped
+#   pre :on => :og_insert { |this| this.create_time = Time.now }
+#   pre :on => :og_update { |this| this.update_time = Time.now }
+#   pre :on => [:og_insert, :og_update] { |this| this.create_time = Time.now }
+# end
+
+module Aspects
+
+  # Store the code and the metadata (options) for
+  # an Advice.
+
+  Advice = Struct.new(:code, :options)
+
+  # Apply the advices to the target class.
+
+  def self.wrap(target, methods = target.instance_methods)
+    include_advice_modules(target)
+    
+    for m in [methods].flatten
+      args = []
+      target.instance_method(m).arity.times { |i| args << "a#{i}" }
+      args = args.join(',')
+      
+      target.module_eval <<-end_eval, __FILE__, __LINE__ 
+        alias_method :__unwrapped_#{m}, :#{m}
+        def #{m}(#{args})  
+          #{gen_advice_code(m, target.advices, :pre)}
+          __unwrapped_#{m}(#{args})
+          #{gen_advice_code(m, target.advices, :post)}
+        end
+      end_eval
+    end
+  end
+
+  class << self
+    alias_method :apply_advices, :wrap
+  end
+
+  # Include Modules that define advices.
+
+  def self.include_advice_modules(target)
+    add_advices = []
+    del_advices = []
+    
+    for a in target.advices
+      if a.code.is_a?(Module) and (!a.code.class.ancestors.include?(Class))
+        target.module_eval %{ include #{a.code} }
+        
+        options = a.options.reject { |k,v| k == :pre || k == :post }
+
+        method = (a.options[:pre] || 'pre').to_s
+        if a.code.instance_methods.include?(method)
+          options.update(:where => :prepend, :join => :pre)
+          add_advices <<  Advice.new(method.to_sym, options)
+        end
+        
+        method = (a.options[:post] || 'post').to_s
+        if a.code.instance_methods.include?(method)
+          options.update(:where => :append, :join => :post)
+          add_advices <<  Advice.new(method.to_sym, options)
+        end
+        
+        del_advices << a
+      end
+    end
+
+    # Delete the original advices.
+    
+    for a in del_advices
+      target.advices!.delete(a)
+    end
+    
+    # Add the new advices.
+    
+    target.advices!.concat(add_advices)
+  end
+
+  # Generates the code to call the aspects.
+  
+  def self.gen_advice_code(method, advices, join = :pre) # :nodoc: 
+    code = '' 
+
+    advices.each_with_index do |advice, idx|
+      o = options = advice.options
+
+      if only = options[:only] || options[:on]
+        next unless [only].flatten.include?(method.to_sym)
+      elsif except = options[:except]
+        next if [except].flatten.include?(method.to_sym)
+      end
+      
+      advice = advice.code
+
+      if advice.is_a?(Symbol) or advice.is_a?(String)
+        next if o[:join] != join
+        code << "#{advice}; "
+      elsif advice.respond_to?('call')
+        next if o[:join] != join 
+        code << "self.class.advices[#{idx}].code.call(self); "
+      elsif advice.is_a?(Class)
+        if advice.class.ancestors.include?(Class)
+          if m = o[join] and advice.methods.include?(m.to_s)
+            code << "#{advice}.#{m}(self); "
+          end
+        else
+          # Module, allready handled.
+        end
+      else
+        if m = o[join] and advice.methods.include?(m.to_s)
+          code << "self.class.advices[#{idx}].code.#{m}(self); "
+        end
+      end
+    end
+    
+    return code
+  end  
+
+  def self.append_features(base)
+    super
+    base.extend(ClassMethods)
+    base.inheritor :advices, [], :+
+  end
+
+  module ClassMethods
+  
+    # Add a pre (before) advice.
+
+    def pre(*args, &block)
+      o = options = { 
+        :join => :pre,
+        :where => :prepend, 
+      }
+      options.update(args.pop) if args.last.is_a?(Hash)
+
+      if block_given?
+        new_advices = [ Advice.new(block, options) ]
+      else
+        new_advices = args.collect { |a| Advice.new(a, options) }
+      end
+=begin      
+      if options[:where] == :prepend
+        self.advices = advices + self.advices
+      else
+        self.advices = self.advices + advices
+      end
+=end
+      self.advices!.concat(new_advices)
+    end
+    alias_method :before, :pre
+    
+    # Add a post (after) advice.
+
+    def post(*args, &block)
+      o = options = { 
+        :join => :post,
+        :where => :append, 
+      }
+      options.update(args.pop) if args.last.is_a?(Hash)
+
+      if block_given?
+        new_advices = [ Advice.new(block, options) ]
+      else
+        new_advices = args.collect { |a| Advice.new(a, options) }
+      end
+=begin      
+      if options[:where] == :prepend
+        self.advices = advices + self.advices
+      else
+        self.advices = self.advices + advices
+      end
+=end      
+      self.advices!.concat(new_advices)
+    end
+    alias_method :after, :post
+
+    # Add a wrap (arround) aspect. An aspect is a class that 
+    # responds to the before and after advices.  
+  
+    def wrap(*args)
+      o = options = {
+        :pre => :pre,
+        :post => :post
+      }
+      options.update(args.pop) if args.last.is_a?(Hash)
+
+      for aspect in args
+        self.advices! << Advice.new(aspect, options)
+      end
+    end
+    alias_method :around, :wrap
+    alias_method :observer, :wrap
+
+  end  
+
+end
+
+end