carats 0.3.0

data/lib/carat-dev/vars/vars.rb

@@ -0,0 +1,62 @@
+#
+#class Symbol
+#  def ~@
+#    return self, "#{self}=".intern
+#  end
+#end
+
+class Object
+  def iv; @iv; end
+  private :iv
+end
+
+class Module
+  
+  def var(*vars)
+    vars.flatten.each do |v|
+      s = v.to_s
+      case s[-1..-1]
+      when '='
+        s = s[0..-2]
+        class_eval <<-EOS
+          def #{s}=(arg)
+            iv[:#{s}] = arg
+            iv[:#{s}]
+          end
+        EOS
+      else
+        class_eval <<-EOS
+          def #{v}(*args)
+            iv[:#{v}] = args[0] if !args.empty?
+            iv[:#{v}]
+          end
+        EOS
+      end
+    end
+    return *vars
+  end
+end
+
+class Class
+  alias_method :new_orig, :new
+  def new(*args, &block)
+    o = new_orig(*args, &block)
+    o.instance_variable_set('@iv',{})
+    o
+  end
+end
+
+class Module
+  PVars = {}
+  #def var(*vars)
+  #  vars.each do |v|
+  #    class_eval <<-EOS
+  #      def #{v}(*args)
+  #        PVars[self] ||= {}
+  #        PVars[self][#{v}] = args[0] if !args.empty?
+  #        PVars[self][#{v}]
+  #      end
+  #    EOS
+  #  end
+  #end
+end

data/lib/carat/1st.rb

@@ -0,0 +1,58 @@
+# $Id: 1st.rb, v0.2 2004/08/21 transami Exp $
+
+=begin rdoc
+
+= 1st Class Methods
+
+Easy access to method as objects. And they retain state!
+
+=== Example
+
+  def hello
+    puts "Hello World!"
+  end
+  p method(:hello)                      #=> <Method: #hello>
+
+== Comments
+
+  I think the best solution would be using the notation 
+  <tt>::ameth</tt>. This would require some minor changes
+  to Ruby, but with few backward incompatabilites if 
+  parantheticals revert back to the actual method invocation.
+  Although this later stipulation means capitalized methods
+  would not be accessible in this way b/c they would intefere with
+  constant lookup. It's a trade off.
+
+                # Current           Proposed           Alternative
+    Foo.Bar()   # method call       method call        method call
+    Foo.Bar     # method call       method call        method call
+    Foo.bar()   # method call       method call        method call
+    Foo.bar     # method call       method call        method call
+    Foo::Bar()  # method call       method call        1st class method
+    Foo::Bar    # constant lookup   constant lookup    constant lookup
+    Foo::bar()  # method call       method call        1st class method
+    Foo::bar    # method call       1st class method   1st class method
+  
+  Then again this dosen't address bound versus unbound.
+  
+  Which do you prefer?
+    
+== Legal
+
+   Ruby License Copyright (c) 2004 Thomas Sawyer
+
+=end
+
+class Object
+  alias_method :method_pre1st, :method
+  def method(s)
+    ( @__methods__ ||= {} )[s] ||= method_pre1st(s)
+  end
+end
+# not needed
+#class Module
+#  alias_method :instance_method_pre1st, :instance_method
+#  def instance_method(s)
+#    ( @__instance_methods__ ||= {} )[s] ||= instance_method_pre1st(s)
+#  end
+#end

data/lib/carat/ansicolor.rb

@@ -0,0 +1,122 @@
+=begin rdoc
+
+= ANSIColor
+
+== Synopsis
+
+  require 'trix/ansicolor'
+  include Term::ANSIColor
+  
+  p red, "Hello", blue "World"   
+  => "\e[31mHello\e[34mWorld"
+  
+  p red { "Hello" } + blue { "World" }
+  => "\e[31mHello\e[0m\e[34mWorld\e[0m"
+  
+== Author
+
+* Florian Frank <flori@ping.de>
+
+== Legal
+
+Copyright (c)2002-2004 Florian Frank
+
+GNU General Public License (GPL)
+
+== History
+
+  2004-11-30 v0.5  * Ported to Trix collection (transami)
+  
+  2004-09-28 v0.4  * First release on Rubyforge
+                   * Supports Rubygems now
+  
+  2003-10-09 v0.3  * 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 v0.2  * Minor Code Cleanup
+                   * Added cdiff.rb
+
+  2002-06-12 v0.1  * Initial Release
+
+=end
+
+module Term
+
+  module ANSIColor
+  
+    @@attributes = [
+      [ :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 ], 
+    ]
+  
+    @@attributes.each do |c, v|
+      eval %Q{
+          def #{c.to_s}(string = nil)
+              result = "\e[#{v}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
+      }
+    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 attributes
+      @@attributes.map { |c| c[0] }
+    end
+      
+  end
+
+end
+

data/lib/carat/attr.rb

@@ -0,0 +1,342 @@
+=begin
+ 
+$Title: Accessors $
+$Author: transami $
+$Date: 2004-10-06 13:56:57 $
+
+= Description
+
+  The Bill wants more from attributes.
+
+= Usage
+
+== Using Cast Attribute Accessors
+
+  # simple type casting
+  attr_reader :a => :to_s
+
+  # fancy type casting
+  attr_reader :a => 'to_s.capitalize'
+
+  # a powerful reader!
+  attr_reader :a => fn{ |x| eval x }
+
+  # a writer that type checks (use type.rb)
+  attr_writer :a => fn{ |x| big4 x }
+
+  # backwards compatible, cast attributes go at the end
+  attr_accessor :x, :y, :a => :to_s
+
+  # they can also be grouped
+  attr_accessor [:x, :y] => :to_s
+  
+== Using Accessor Shorthand
+
+  A nice shorthand is provided.
+
+    attr :r, :a, :a=, :w=
+  
+  This is the same as doing
+  
+    attr_reader :r
+    attr_accessor :a
+    attr_writer :w
+  
+  Also
+
+    attr :b?, :b!
+  
+  creating
+    
+    def b?
+      @b ? true : @b
+    end
+  
+    def b!(x)
+      @b.replace(x)
+    end
+  
+  The shorthand notation can be used with casting too.
+  
+    attr :a => :to_s
+
+== Using Return Value
+
+  Attribute methods now return a list of the methods created. 
+  This can then be passed to other useful methods.
+  
+    private attr :a
+
+= Authenticate
+  
+  Copyright (C) 2002 T. Sawyer
+  Ruby Distribute License
+  
+  This program is free software.
+  You can distribute/modify this program under
+  the terms of the Ruby Distribute License.
+    
+=end
+
+#require 'facet/hash/update_each'
+
+# Modify module attribute methods.
+# *add define_attribute
+# *redefine old attr_* methods
+# *add attr_setter
+
+class Module
+  
+  # Create an attribute method for reading an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_reader.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_reader :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a
+  #     @a.to_s
+  #   end
+  #
+  def attr_reader(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}; @#{a}#{c} ; end }
+      made << "#{a}".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for writing to an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_writer.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_writer :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a=(x)
+  #     @a = x.to_s
+  #   end
+  #
+  def attr_writer(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('=').chomp('!')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}=(x); @#{a}=x#{c}; end }
+      made << "#{a}=".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for writing to an
+  # instance variable. This is the same as the built
+  # in method, which it replaces, but adds casting.
+  #
+  # Casting allows the addition of a method invocation
+  # on the instance variable. It is defined using a hash
+  # parameter, so all castings must come at the end of a
+  # call to attr_writer.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_accessor :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a
+  #     @a.to_s
+  #   end
+  #
+  #   def a=(x)
+  #     @a = x.to_s
+  #   end
+  #
+  def attr_accessor(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('=')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}; @#{a}#{c} ; end }
+      module_eval %Q{ def #{a}=(x); @#{a}=x#{c}; end }
+      made << "#{a}".to_sym
+      made << "#{a}=".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+
+  # Create an attribute method for boolean testing
+  # of an instance variable in the form of _var?_.
+  #
+  #   require 'facet/module/attr_tester'
+  #
+  #   attr_tester :a
+  #
+  # _is equivalent to_
+  #
+  #   def a?
+  #     @a ? true : @a
+  #   end
+  #
+  # Casting is also supported (see attr_reader).
+  #
+  #   attr_tester :a => :evaluate
+  #
+  # _is equivalent to_
+  #
+  #   def a?
+  #     @a.evaluate ? true : @a
+  #   end
+  #
+  def attr_tester(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip.chomp('?')
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{ def #{a}?; @#{a}#{c} ? true : @#{a}#{c}; end }
+      made << "#{a}?".to_sym
+    }
+    (@__atributes__ ||= []).concat made
+    return *made
+  end
+
+  # Create an attribute method for getting and setting an
+  # instance variable.
+  #
+  #   require 'carat/attr'
+  #
+  #   attr_setter :a
+  #
+  # _is equivalent to_
+  #
+  #   def a(*args)
+  #     if args.size > 0
+  #       @a = args[0]
+  #       self
+  #     else
+  #       @a
+  #     end
+  #   end
+  #
+  # Casting is supported on both getting and setting.
+  #
+  #   attr_setter :a => :to_s
+  #
+  # _is equivalent to_
+  #
+  #   def a(*args)
+  #     @a = args[0].to_s if args.size > 0
+  #     @a.to_s
+  #   end
+  #
+  def attr_setter(*args)
+    made = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    #hargs = (Hash === args.last ? args.pop : {})
+    args.each { |a,c|
+      a = a.to_s.strip
+      c = ".#{c.to_s.strip}".chomp('.')
+      module_eval %Q{
+        def #{a}(*args)
+          args.size > 0 ? ( @#{a}=args[0]#{c} ; self ) : @#{a}#{c}
+        end
+      }
+      made << "#{a}".to_sym
+    }
+    (@__atributes__ ||= []).concat( made )
+    return *made
+  end
+  
+  # DOES ANYONE USE THIS OLD THING?
+  #alias attribute attr
+
+  # The wondrful shortcut.
+  def attr(*args)
+    # Allows compatibility with old definition, while also
+    # extending the capabilites to allow multiple parameters.
+    # This form does not allow casting though.
+    if TrueClass === args.last or FalseClass === args.last or NilClass === args.last
+      if args.pop
+        args.concat( args.collect{ |a|
+          a = a.to_s.strip
+          case a[-1,1]
+          when '=' 
+            a[0..-2]
+          when '?' 
+            "#{a[0..-2]}="
+          else
+            "#{a}="
+          end
+        } )
+      end
+    end
+    #
+    made = []
+    readers = []
+    writers = []
+    testers = []
+    if Hash === args.last
+      args.concat( args.pop.to_a )
+    end
+    args.each do |a,c|
+      a = a.to_s.strip
+      t = a.slice(-1,1)
+      m = a.chomp('!').chomp('=').chomp('?')
+      case t
+      when '='
+        readers << [m,c]
+        writers << [m,c]
+      when '?'
+        testers << [m,c]
+      when '!'
+        writers << [m,c]
+      else
+        readers << [m,c]
+      end
+    end
+    made.concat( [ attr_reader( *readers ) ] )
+    made.concat( [ attr_writer( *writers ) ] )
+    made.concat( [ attr_tester( *testers ) ] )
+    return *made
+  end
+  
+end