facets 2.9.2 → 2.9.3

data/work/consider/lib/more/facets/gem.rb

@@ -1,23 +0,0 @@
-
-module Gem
-
-  def self.active?(gemname)
-    @loaded_specs ||= Hash.new
-    @loaded_specs.key? gemname
-  end
-
-  def self.gemspec(gemname)
-    @loaded_specs[gemname] if active?(gemname)
-  end
-
-  def self.gempath(gemname, subdir=nil)
-    if active?(gemname)
-      if subdir
-        File.join( @loaded_specs[gemname].full_gem_path, subdir )
-      else
-        @loaded_specs[gemname].full_gem_path
-      end
-    end
-  end
-
-end

data/work/consider/lib/more/facets/interface.rb

@@ -1,230 +0,0 @@
-# TITLE:
-#
-#   Interface
-#
-# SUMMARY:
-#
-#   These two interface methods provide a more concise alternative to
-#   Ruby's reflection on class/module methods. Ruby's has these:
-#
-#     methods                instance_methods
-#     public_methods         public_instance_methods
-#     protected_methods      protected_instance_methods
-#     private_methods        private_instance_methods
-#                            singleton_methods
-#
-#  Each of these additionally take an ancestoral parameter. And to
-#  matters worse, #methods and #instance_methods are aliases for
-#  #public_methods and #public_instance_methods respectively, rather
-#  then the collection of all methods, which can be confusing.
-#
-#  The interface library simplifies all this by providing just two
-#  methods to do all of the above: #interface and #instance_interface.
-#  Symbolic parameters are passed to either of these methods as a means
-#  of categorization of method type, providing a much more flexible
-#  means of examing object class and  module interfaces.
-#
-#  Some examples:
-#
-#    Proc.instance_interface(:public, :inherited)
-#
-#    "a string".interface(:singleton)
-#
-# COPYRIGHT:
-#
-#   Copyright (c) 2005 Thomas Sawyer
-#
-# LICENSE:
-#
-#   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.
-#
-# AUTHORS:
-#
-#   - Thomas Sawyer
-
-
-require 'facets/symbol/not'
-
-#
-class Module
-
-  unless const_defined?('METHOD_TYPES')
-  METHOD_TYPES = [
-    :inherited, :ancestors, :local,
-    :public, :private, :protected,
-    :all
-  ]
-  end
-
-  # Provides an improved method lookup routnine.
-  # It returns a list of methods according to symbol(s) given.
-  #
-  # Recognized symbols are:
-  #
-  # * <tt>:public</tt>     include public methods
-  # * <tt>:private</tt>    include private methods
-  # * <tt>:protected</tt>  include protected methods
-  # * <tt>:ancestors</tt>  include all ancestor's methods
-  # * <tt>:inherited</tt>  (same as above)
-  # * <tt>:local</tti>     include non-ancestor methods
-  # * <tt>:all</tt>        include all of the above
-  #
-  # This method also uses the symbol-not system. So you can specify
-  # the inverse of all of the above. For instance ~:public would mean
-  # :private, :protected (see facets/symbol/not).
-  #
-  # If no symbol is given then :public, :local is assumed.
-  # Unrecognized symbols raise an error.
-  #
-  #   module Demo
-  #     def test
-  #       puts("Hello World!")
-  #     end
-  #   end
-  #
-  #   Demo.instance_methods(:local)    #=> ['test']
-  #
-  # To maintain backward compatibility <tt>true</tt> as an intitial argument
-  # is converted to :local, :ancestors (i.e. it includes both).
-  #
-  def instance_interface(*args)
-
-    # for backward compatibility
-    args << true if args.empty?
-
-    case args[0]
-    when TrueClass
-      args.shift
-      args << :ancestors
-      args << :local
-    when FalseClass
-      args.shift
-      args << :local
-    end
-
-    # default public, local
-    args |= [:public] unless [:publix,:private,:protected,:all].any?{ |a| args.include?(a) }
-    args |= [:ancestors,:local] unless [:ancestors,:inherited,:local,:all].any?{ |a| args.include?(a) }
-
-    raise ArgumentError if args.any?{ |a| ! METHOD_TYPES.include?(a) }
-
-    pos, neg = args.partition { |s| ! s.not? }
-
-    m = []
-
-    pos.each do |n|
-      case n
-      when :inherited, :ancestors
-        m |= ( public_instance_methods( true ) - public_instance_methods( false ) )       if pos.include?(:public)
-        m |= ( private_instance_methods( true ) - private_instance_methods( false ) )     if pos.include?(:private)
-        m |= ( protected_instance_methods( true ) - protected_instance_methods( false ) ) if pos.include?(:protected)
-      when :local
-        m |= public_instance_methods( false )    if pos.include?(:public)
-        m |= private_instance_methods( false )   if pos.include?(:private)
-        m |= protected_instance_methods( false ) if pos.include?(:protected)
-      when :all
-        m |= public_instance_methods( true )
-        m |= private_instance_methods( true )
-        m |= protected_instance_methods( true )
-      end
-    end
-
-    neg.each do |n|
-      case n
-      when :public
-        m -= public_instance_methods( true )
-      when :private
-        m -= private_instance_methods( true )
-      when :protected
-        m -= protected_instance_methods( true )
-      when :inherited, :ancestors
-        m -= ( public_instance_methods( true ) - public_instance_methods( false ) )
-        m -= ( private_instance_methods( true ) - private_instance_methods( false ) )
-        m -= ( protected_instance_methods( true ) - protected_instance_methods( false ) )
-      when :local
-        m -= public_instance_methods( false )
-        m -= private_instance_methods( false )
-        m -= protected_instance_methods( false )
-      end
-    end
-
-    m.sort
-  end
-
-  # old-version
-  #     args << :public unless ( args.include?(:private) or args.include?(:protected) )
-  #     args[0] = [ :ancestors, :local ] if TrueClass === args[0]
-  #     args.flatten!
-  #     raise ArgumentError if args.any?{ |a| ! METHOD_SYMBOLS.include?(a) }
-  #     m = []
-  #     a = args.include?( :all )
-  #     i = ( args.include?( :inherited ) or args.include?( :ancestors ) )
-  #     l = ( args.include?( :local ) or args.include?( :no_ancestors ) )
-  #     if a
-  #       m |= public_instance_methods( true )
-  #       m |= private_instance_methods( true )
-  #       m |= protected_instance_methods( true )
-  #     elsif i and l
-  #       m |= public_instance_methods( true ) if args.include?( :public )
-  #       m |= private_instance_methods( true ) if args.include?( :private )
-  #       m |= protected_instance_methods( true ) if args.include?( :protected )
-  #     elsif i
-  #       m |= (public_instance_methods( true ) - public_instance_methods( false )) if args.include?( :public )
-  #       m |= (private_instance_methods( true ) - private_instance_methods( false )) if args.include?( :private )
-  #       m |= (protected_instance_methods( true ) - protected_instance_methods( false )) if args.include?( :protected )
-  #     else
-  #       m |= public_instance_methods( ! l ) if args.include?( :public )
-  #       m |= private_instance_methods( ! l ) if args.include?( :private )
-  #       m |= protected_instance_methods( ! l ) if args.include?( :protected )
-  #     end
-  #     m
-
-end
-
-
-#
-module Kernel
-
-  # Returns a list of methods according to symbol(s) given.
-  #
-  # Usable symbols include:
-  #
-  # * <tt>:inherited</tt> or <tt>:ancestors</tt>
-  # * <tt>:local</tt> or <tt>:no_ancestors</tt>
-  # * <tt>:public</tt>
-  # * <tt>:private</tt>
-  # * <tt>:protected</tt>
-  # * <tt>:singleton</tt>
-  # * <tt>:all</tt>
-  #
-  # It no symbol is given then :public is assumed.
-  # Unrecognized symbols raise an error.
-  #
-  #   def test
-  #     puts("Hello World!")
-  #   end
-  #
-  #   methods(:local)    #=> ['test']
-  #
-  def interface(*args)
-    args = [ :public, :local, :ancestors, :singleton ] if args.empty?
-    sing = args.delete(:singleton) or args.include?(:all)
-    if sing
-      if args.empty?
-        singleton_methods
-      else
-        singleton_methods | self.class.instance_interface(*args)
-      end
-    else
-       self.class.instance_interface(*args)
-    end
-  end
-
-end

data/work/consider/lib/more/facets/plugin.rb

@@ -1,153 +0,0 @@
-#! /usr/local/bin/ruby
-
-#  Copyright (c) 2006-2007 Frédéric Senault.  All rights reserved.
-#
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions
-# are met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. Redistributions in binary form must reproduce the above copyright
-#    notice, this list of conditions and the following disclaimer in the
-#    documentation and/or other materials provided with the distribution.
-# 3. Neither the name of Frédéric Senault or any contributors may be
-#    used to endorse or promote products derived from this software
-#    without specific prior written permission.
-#
-# THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
-# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
-# FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-# DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
-# OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-# HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-# OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
-# SUCH DAMAGE.
-
-class Plugin
-  class << self
-    include Enumerable
-    attr_accessor :plugin_file_name, :plugin_file_mtime, :plugin_loaded_files
-    attr_reader :plugin_sub_classes, :plugin_objects
-    def purge_sub_classes!
-      @plugin_objects = nil
-      @plugin_loaded_files = nil
-      @plugin_file_name = nil
-      @plugin_file_mtime = nil
-      @plugin_sub_classes.each do |c|
-        Object.send(:remove_const, c.to_s)
-      end
-      @plugin_sub_classes = nil
-    end
-    def reload!
-      purge_sub_classes!
-      self.load!
-    end
-    def reload
-      if(@plugin_sub_classes) then
-        @plugin_sub_classes.each do |c|
-          if(File.mtime(c.plugin_file_name) != c.plugin_file_mtime) then
-            @plugin_objects.delete(@plugin_objects.find { |o| o.instance_of? c })
-            @plugin_sub_classes.delete(c)
-            @plugin_loaded_files.delete(c.plugin_file_name)
-            Object.send(:remove_const, c.to_s)
-          end
-        end
-      end
-      self.load!
-    end
-    def load!
-      @plugin_create_objects = true if(@plugin_create_objects.nil?)
-      @plugin_load_glob ||= File.dirname(__FILE__) + '/' +
-        self.to_s.downcase + (self.to_s =~ /s$/i ? '' : 's') +
-        '/*.rb'
-      @plugin_loaded_files ||= []
-      Dir.glob(@plugin_load_glob).each do |f|
-        unless(@plugin_loaded_files.include? f) then
-          @plugin_file_name = f
-          @plugin_file_mtime = File.mtime(f)
-          @plugin_loaded_files << f
-          begin
-            load f
-          rescue Exception => e
-            raise e unless(@plugin_ignore_errors)
-          end
-        end
-      end
-      @plugin_sub_classes ||= []
-      @plugin_objects ||= []
-      if(@plugin_new_sub_classes) then
-        @plugin_new_sub_classes.each do |c|
-          begin
-            c.plugin_validate!
-            @plugin_sub_classes << c
-            if(@plugin_create_objects) then
-              o = c.new()
-              @plugin_objects << o
-            end
-          rescue Exception => e
-            raise e unless(@plugin_ignore_errors)
-          end
-        end
-        @plugin_new_sub_classes.clear
-      end
-      @plugin_sub_classes.sort!
-      if(@plugin_create_objects) then
-        @plugin_objects.sort! { |a, b| a.class <=> b.class }
-      end
-    end
-    def each
-      @plugin_autoload = true unless(@plugin_autoload)
-      reload if(@plugin_autoload)
-      @plugin_objects.each do |o|
-        yield o
-      end
-    end
-    def <=>(other)
-      order <=> other.order
-    end
-
-    def plugin_validate!
-      if(@plugin_implements) then
-        r = (@plugin_implements - self.instance_methods.collect { |mn| mn.to_sym })
-        if(r.length > 0) then
-          raise "Load error in #{superclass.plugin_file_name} : " \
-                "#{self.to_s} must implement #{r.join(', ')}."
-        end
-      end
-    end
-    def plugin_must_implement(*methods)
-      @plugin_implements ||= []
-      methods.flatten.each { |mn| @plugin_implements << mn.to_sym }
-    end
-    def plugin_load_glob(p)
-      if(p[0,1] != '/') then
-        p = File.dirname(__FILE__) + '/' + p
-      end
-      @plugin_load_glob = p
-    end
-    def plugin_ignore_errors(v)
-      @plugin_ignore_errors = v
-    end
-    def plugin_create_objects(v)
-      @plugin_create_objects = v
-    end
-    def plugin_autoload(v)
-      @plugin_autoload = v
-    end
-    def inherited(c)
-      @plugin_new_sub_classes ||= [] unless(@plugin_new_sub_classes)
-      @plugin_new_sub_classes << c
-      if(@plugin_implements) then
-        c.plugin_must_implement(@plugin_implements)
-        c.plugin_file_name = @plugin_file_name || File.dirname(__FILE__)
-        c.plugin_file_mtime = @plugin_file_mtime || File.mtime(__FILE__)
-      end
-    end
-    def order
-      999
-    end
-  end
-end

data/work/consider/lib/more/facets/recorder.rb

@@ -1,54 +0,0 @@
-module Sow
-
-  # Manifest captures the actions a generator performs.  Instantiate
-  # a manifest with an optional target object, hammer it with actions,
-  # then replay or rewind on the object of your choice.
-  #
-  # Example:
-  #   recorder = Recorder.new { |m|
-  #     m.make_directory '/foo'
-  #     m.create_file '/foo/bar.txt'
-  #   }
-  #   recorder.replay(creator)
-  #   recorder.rewind(destroyer)
-  #
-  # TODO: Use Facets recorder in future version?
-
-  class Recorder
-    attr_reader :target
-
-    # Take a default action target.  Yield self if block given.
-    def initialize(target = nil)
-      @target, @actions = target, []
-      yield self if block_given?
-    end
-
-    # Record an action.
-    def method_missing(action, *args, &block)
-      @actions << [action, args, block]
-    end
-
-    # Replay recorded actions.
-    def replay(target = nil)
-      send_actions(target || @target, @actions)
-    end
-
-    # Rewind recorded actions.
-    def rewind(target = nil)
-      send_actions(target || @target, @actions.reverse)
-    end
-
-    # Erase recorded actions.
-    def erase
-      @actions = []
-    end
-
-    private
-      def send_actions(target, actions)
-        actions.each do |method, args, block|
-          target.send(method, *args, &block)
-        end
-      end
-  end
-
-end