facets 1.4.1 → 1.4.2

data/lib/facets/core/symbol/to_proc.rb

@@ -1,6 +1,8 @@
 #--
-# Credit goes to Florian Gross (flgr).
+# Credit goes to Florian Gross (flgr) for orignal version.
+# Credit goes to Nobuhiro Imai for latest version.
 #++
+
 class Symbol
 
   # Turn a symbol into a proc calling the method to
@@ -15,8 +17,9 @@ class Symbol
   #   %w{foo bar qux}.map(&:upcase)   #=> ["FOO","BAR","QUX"]
   #   [1, 2, 3].inject(&:+)           #=> 6
   #
+
   def to_proc
-    lambda { |obj, *args| obj.send(self, *args) }
+    Proc.new{|*args| args.shift.__send__(self, *args)}
   end
 
 end
@@ -35,11 +38,17 @@ end
 
   class TCSymbol < Test::Unit::TestCase
 
-    def test_to_proc
+    def test_001
       assert_instance_of(Proc, up = :upcase.to_proc )
       assert_equal( "HELLO", up.call("hello") )
     end
 
+    def test_002
+      q = [[1,2,3], [4,5,6], [7,8,9]].map(&:reverse)
+      a = [[3, 2, 1], [6, 5, 4], [9, 8, 7]]
+      assert_equal( a, q )
+    end
+
   end
 
 =end

data/lib/facets/more/annattr.rb

@@ -19,6 +19,7 @@
 # Copyright:: Copyright (c) 2005 Thomas Sawyer
 # License::   Ruby License
 
+require 'facets/more/inheritor.rb'
 require 'facets/more/annotation.rb'
 
 # = Annotated Attributes

data/lib/facets/more/annotation.rb

@@ -22,7 +22,7 @@
 require 'facets/core/array/merge'
 
 require 'facets/more/openobject'
-require 'facets/more/inheritor'
+#require 'facets/more/inheritor'
 require 'facets/more/nullclass'
 
 # = Annotation
@@ -156,15 +156,18 @@ module ::Kernel
   end
 
   #--
-  # Not sure about this. Perhaps is would be better to
-  # delegate to the singleton class instead?
-  # (Remarking out for the time being.)
-  #
-  #def ann( harg=nil )
-  #  return annotation unless harg
-  #  annotation.__update__( harg )
-  #end
+  # Not sure about this.
   #++
+  def ann( *args )
+    #return annotation unless harg
+    #annotation.__update__( harg )
+    #if singleton_class?
+      (class << self; self; end).ann( *args )
+    #else
+    #  self.class.ann( *args )
+    #end
+  end
+
 end
 
 # Modules and Classes have more sifisticated annotation.

data/lib/facets/more/basicobject.rb

@@ -96,6 +96,7 @@ class BasicObject
   def as(ancestor)
     Self.new(ancestor)
   end
+  alias_method :__as__, :as
 
   # Shadow some other important methods.
   alias_method :__method__, :method
@@ -110,6 +111,13 @@ class BasicObject
   # But in most cases you'll want a few extra methods like #dup too.
   #++
 
+  def self.provide( *meths )
+    base = self.dup
+
+  end
+
+  CONVENTINAL = [ "funcall", "send", "respond_to?", "equal?", "==", "object_id" ] + [ "dup", "clone", "null" ]
+
   EXCLUDE = /(^__|^instance|^object|^initialize$|^initialize_copy$|^null$|^inspect$|^dup$|^clone$|^as$|\?$)/
 
   def self.hide(name)

data/lib/facets/more/classmethods.rb

@@ -41,7 +41,7 @@
 #       puts 'inst_meth'
 #     end
 #
-#     ClassMethods do
+#     class_methods do
 #       def class_meth
 #         "Class Method!"
 #       end
@@ -54,12 +54,7 @@
 #
 #   X.class_meth  #=> "Class Method!"
 #
-# ClassMethods is a capitalized method. This is used because it
-# indeed creates (or reopens) a ClassMethods module in which
-# the given block is evaluated, then the ClassMethods module
-# is extended against the current module.
-#
-# This is equivalent to the older (but still functional) techinique of
+# This is equivalent to the original (but still functional) techinique of
 # putting the class/module methods in a nested ClassMethods module
 # and extending the original module *manually*. Eg.
 #
@@ -83,9 +78,10 @@
 #
 #   X.class_meth  #=> "Class Method!"
 #
-# Lastly, note that #class_inherit is an available alias
-# for #ClassMethods for the sake of backward compatability
-# or if you just insist on using only lowercase methods.
+# Also note that #class_inherit is an available alias
+# for #class_methods for the sake of backward compatability.
+# And #class_extension is alias (potentially) looking forward
+# to a future version on Ruby.
 #
 # == Notes
 #
@@ -124,7 +120,7 @@ class Module
     result
   end
 
-  def ClassMethods( &yld )
+  def class_methods( &yld )
     if const_defined?( :ClassMethods )
       self::ClassMethods.class_eval( &yld )
     else
@@ -134,16 +130,13 @@ class Module
     self::ClassMethods
   end
 
-  # If you prefer not using a capitalized method
-  alias_method :class_methods, :ClassMethods
-
-  # For compatibility with old rendition
-  alias_method :class_inherit, :ClassMethods
+  # For compatibility with old rendition.
+  alias_method :class_inherit, :class_methods
 
 end
 
 class Class
-  undef_method :ClassMethods
+  undef_method :class_methods
   undef_method :class_inherit
 end
 
@@ -164,10 +157,10 @@ end
     # fixture
 
     module N
-      ClassMethods do
+      class_methods do
         def n ; 43 ; end
+        def s ; self ; end
       end
-      #extend ClassMethods
     end
 
     class X
@@ -177,7 +170,7 @@ end
 
     module K
       include N
-      ClassMethods do
+      class_methods do
         def n ; super + 1 ; end
       end
     end
@@ -190,18 +183,22 @@ end
 
     def test_01
       assert_equal( 43, N.n )
+      assert_equal(  N,  N.s )
     end
     def test_02
       assert_equal( 43, X.n )
+      assert_equal(  X, X.s )
     end
     def test_03
       assert_equal( 11, X.new.n )
     end
     def test_04
       assert_equal( 44, K.n )
+      assert_equal(  K, K.s )
     end
     def test_05
       assert_equal( 44, Z.n )
+      assert_equal(  Z, Z.s )
     end
 
   end

data/lib/facets/more/command.rb

@@ -0,0 +1,307 @@
+# = consoleapp.rb
+#
+# == Copyright (c) 2005 Thomas 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.
+#
+# == Author(s)
+#
+# * Thomas Sawyer
+#
+# == Developer Notes
+#
+#   TODO Add documentation features. (NOT SO SURE NOW!)
+#
+#   TODO Move to console/command.rb, but I'm not sure yet if
+#        adding subdirectories to more/ is a good idea.
+#
+
+# Author::    Thomas Sawyer
+# Copyright:: Copyright (c) 2005 Thomas Sawyer
+# License::   Ruby License
+
+# = Console
+#
+# Console namespace for use by tools specifically designed
+# for command line interfaces.
+
+module Console ; end
+
+# = Console Command
+#
+# Console::Command provides a clean and easy way
+# to create a command line interface for your program.
+# The unique technique utlizes a Commandline to Object
+# Mapping (COM) to make it quick and easy.
+#
+# == Synopsis
+#
+# Let's make an executable called 'mycmd'.
+#
+#   #!/usr/bin/env ruby
+#
+#   require 'facet/console_command'
+#
+#   MyCmd << Console::Command
+#
+#     def _v
+#       $VERBOSE = true
+#     end
+#
+#     def jump
+#       if $VERBOSE
+#         puts "JUMP! JUMP! JUMP!"
+#       else
+#         puts "Jump"
+#       end
+#     end
+#
+#   end
+#
+#   MyCmd.execute
+#
+# Then on the command line:
+#
+#   > mycmd jump
+#   Jump
+#
+#   > mycmd -v jump
+#   JUMP! JUMP! JUMP!
+#
+#--
+# You can also add help information quite easily. If the following code
+# is saved as 'foo' for instance.
+#
+#   MyCmd << Console::Command
+#
+#     help "Dispays the word JUMP!"
+#
+#     def jump
+#       if $VERBOSE
+#         puts "JUMP! JUMP! JUMP!"
+#       else
+#         puts "Jump"
+#       end
+#     end
+#
+#   end
+#
+#   MyCmd.go
+#
+# then by running 'foo help' on the command line, standard help information
+# will be displayed.
+#
+#   foo
+#
+#     jump  Displays the word JUMP!
+#
+#++
+
+class Console::Command
+
+  def self.execute( *args )
+    new.execute( *args )
+  end
+
+  # Do not let this pass through on to
+  # any included module.
+
+  def initialize ; end
+
+  # Execute the command.
+
+  def execute( *argv )
+    argv = argv.empty? ? ARGV : argv
+
+    # process options
+
+    argv2 = argv.collect { |arg|
+      if md = %r{^-(\w+)}.match( arg )
+        if md[1].size > 1
+          md[1].split(//).collect { |c| "-#{c}" }
+        else
+          arg
+        end
+      else
+        arg
+      end
+    }.flatten
+
+    args = argv2.dup
+
+    i = 0;
+    while i < args.size
+      if md = %r{^[-]}.match( args[i] )
+        opt = args[i].gsub('-','_')
+        if self.respond_to?( opt )
+          m = method( opt )
+          c = m.arity
+          if c > 0
+            m.call(*args[i+1..i+c])
+            args[i..i+c] = nil
+            i += c
+          else
+            m.call
+            args[i] = nil
+          end
+        else
+          $stderr << "Unknown option '#{args[i]}'\n"
+          exit -1
+        end
+      end
+      i += 1
+    end
+
+    args.compact!
+
+    # no secondary commands
+
+    if self.respond_to?(:main)
+      main( *args )
+
+    # secondary commands
+
+    elsif not args.empty?
+      if self.respond_to?( args.first )
+        __send__( *args )
+      else
+        if self.private_methods.include?( "no_command_error" )
+          no_command_error( *args )
+        else
+          $stderr << "Non-applicable command #{args.join(' ')}\n"
+          exit -1
+        end
+      end
+
+    # default secondary command
+
+    elsif self.respond_to?( :default )
+      default(*args)
+
+    # error
+
+    else
+      if self.private_methods.include?( "no_action_error" )
+        no_action_error( *args )
+      else
+        $stderr << "Nothing to do.\n"
+        exit -1
+      end
+
+    end
+
+  end
+
+#   # We include a module here so you can define your own help command
+#   # and call #super to utilize this one.
+#
+#   module Help
+#
+#     def help
+#       opts = help_options
+#       s = ""
+#       s << "#{File.basename($0)}\n\n"
+#       unless opts.empty?
+#         s << "OPTIONS\n"
+#         s << help_options
+#         s << "\n"
+#       end
+#       s << "COMMANDS\n"
+#       s << help_commands
+#       puts s
+#     end
+#
+#     private
+#
+#     def help_commands
+#       help = self.class.help
+#       bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+#       lines = []
+#       help.each { |cmd, str|
+#         cmd = cmd.to_s
+#         if cmd !~ /^_/
+#           lines << "  " + cmd + (" " * (bufs - cmd.size)) + str
+#         end
+#       }
+#       lines.join("\n")
+#     end
+#
+#     def help_options
+#       help = self.class.help
+#       bufs = help.keys.collect{ |a| a.to_s.size }.max + 3
+#       lines = []
+#       help.each { |cmd, str|
+#         cmd = cmd.to_s
+#         if cmd =~ /^_/
+#           lines << "  " + cmd.gsub(/_/,'-') + (" " * (bufs - cmd.size)) + str
+#         end
+#       }
+#       lines.join("\n")
+#     end
+#
+#     module ClassMethods
+#
+#       def help( str=nil )
+#         return (@help ||= {}) unless str
+#         @current_help = str
+#       end
+#
+#       def method_added( meth )
+#         if @current_help
+#           @help ||= {}
+#           @help[meth] = @current_help
+#           @current_help = nil
+#         end
+#       end
+#
+#     end
+#
+#   end
+#
+#   include Help
+#   extend Help::ClassMethods
+
+end
+
+
+
+#  _____         _
+# |_   _|__  ___| |_
+#   | |/ _ \/ __| __|
+#   | |  __/\__ \ |_
+#   |_|\___||___/\__|
+#
+
+=begin test
+
+  require 'test/unit'
+
+  class TCCommand < Test::Unit::TestCase
+
+    class MyCmd < Console::Command
+
+      def _x ; $X = true ; end
+
+      def _y ; $Y = true ; end
+
+      def go ; $output = [$X, $Y] ; end
+
+    end
+
+    MyCmd.execute( '-x', '-y', 'go' )
+
+    def test_001
+      assert_equal( [true, true], $output )
+    end
+
+  end
+
+=end