mack-facets 0.8.2 → 0.8.3

data/lib/gems/facets-2.4.5/lib/lore/facets/yaml.rb

@@ -1,75 +0,0 @@
-# = YAML Extensions
-#
-# YAML related extenstions.
-#
-# The Kernel method #yaml is a shortcut to YAML::load.
-#
-#   yaml %{
-#     a: 1
-#     b: 2
-#   }
-#
-# produes
-#
-#   {:a=>1, :b=>2}
-#
-# File.yaml? provides a way to check if a file is a YAML
-# formatted file.
-#
-#   File.yaml?('project.yaml')  #=> true
-#   File.yaml?('project.xml')   #=> false
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copyright
-#
-# Copyright (c) 2006 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.
-
-require 'yaml'
-
-module Kernel
-  # Convenience method for loading YAML.
-  #
-  def yaml(*args,&blk)
-    YAML.load(*args,&blk)
-  end
-
-  # As with #to_yaml but removes the header line (i.e. '---') to create a "YAML fragment".
-  #
-  def to_yamlfrag
-    y = to_yaml
-    y.sub!(/---\ */, '')
-    y
-  end
-end
-
-class File
-  # Is a file a YAML file?
-  #
-  # Note this isn't perfect. At present it depends on the use
-  # use of an initial document separator (eg. '---'). With
-  # YAML 1.1 the %YAML delaration will be manditory, so in the
-  # future this can be adapted to fit that standard.
-  #
-  def self.yaml?(file)
-    File.open(file) do |f|
-      until f.eof?
-        line = f.gets
-        break true if line =~ /^---/
-        break false unless line =~ /^(\s*#.*?|\s*)$/
-      end
-    end
-  end
-end
-

data/lib/gems/facets-2.4.5/lib/lore/facets/zlib.rb

@@ -1,38 +0,0 @@
-# A convenient wrapper for the zlib standard library that allows
-# compression/decompression of strings with gzip.
-
-module Zlib
-
-  #class Stream < StringIO
-  #  def close; rewind; end
-  #end
-
-  # Decompresses a gzipped string.
-  def self.decompress(source)
-    GzipReader.new(StringIO.new(source)).read
-  end
-
-  # Compresses a string using gzip.
-  def self.compress(source)
-    output = StringIO.new
-    class << output
-      def close; rewind; end
-    end
-    gz = GzipWriter.new(output)
-    gz.write(source)
-    gz.close
-    output.string
-  end
-
-  # Inflate a deflated sting.
-  def self.inflate(string)
-    Inflate.inflate(string)
-  end
-
-  # Deflate a string.
-  def self.deflate(string, level=DEFAULT_COMPRESSION)
-    Deflate.deflate(string, level)
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/more/facets/1stclassmethod.rb

@@ -1,140 +0,0 @@
-# = First Class Methods
-#
-# Gives Ruby 1st class methods.
-#
-# Easy access to method as objects, and they retain state!
-#
-#   def hello
-#     puts "Hello World!"
-#   end
-#
-#   m1 = method!(:hello)   #=> <Method: #hello>
-#
-#   def m1.annotate
-#     "simple example"
-#   end
-#
-#   m2 = method!(:hello)
-#   m2.annotate  #=> "simple example"
-#
-# Easy access to method as objects, and they retain state!
-#
-#   module K
-#     def hello
-#       puts "Hello World!"
-#     end
-#   end
-#   p K.instance_method!(:hello)   #=> <UnboundMethod: #hello>
-#
-# CAUTION! This it is currently limited to the scope of the
-# current module/class.
-#
-# == Notes
-#
-# Should 1st Class Methods be part of Ruby proper?
-#
-# Perhaps 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           Alternate
-#                   ----------------- ------------------ -------------------
-#     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?
-#
-# == Authors
-#
-# * Thomas Sawyer
-#
-# == Copying
-#
-# 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.
-
-#
-module Kernel
-
-  # Easy access to method as objects, and they retain state!
-  #
-  #   def hello
-  #     puts "Hello World!"
-  #   end
-  #
-  #   m1 = method!(:hello)   #=> <Method: #hello>
-  #
-  #   def m1.annotate
-  #     "simple example"
-  #   end
-  #
-  #   m2 = method!(:hello)
-  #   m2.annotate  #=> "simple example"
-
-  def method!(s)
-    ( @__methods__ ||= {} )[s] ||= method(s)
-  end
-
-  private
-
-  # Returns the method object of the current method.
-  #--
-  # TODO Should there be a #this! ?
-  #++
-  def this
-    line = nil
-    caller(1).each do |line|
-      line = /\`([^\']+)\'/.match(line)
-      break if line
-    end
-    if line
-      name = line[1]
-      return method(name)
-    else
-      nil # ?
-    end
-  end
-
-end
-
-#
-class Module
-
-  # Easy access to method as objects, and they retain state!
-  #
-  #   module K
-  #     def hello
-  #       puts "Hello World!"
-  #     end
-  #   end
-  #   p K.instance_method!(:hello)   #=> <UnboundMethod: #hello>
-  #
-  # NOTE: This is limited to the scope of the current module/class.
-
-  def instance_method!(s)
-    #( @@__instance_methods__ ||= {} )[s] ||= instance_method(s)  # TODO when fixed
-    ( @__instance_methods__ ||= {} )[s] ||= instance_method(s)
-  end
-
-end
-

data/lib/gems/facets-2.4.5/lib/more/facets/advisable.rb

@@ -1,162 +0,0 @@
-# = Advisable
-#
-# Add before, after and around advice in dynamic fashion.
-#
-# == Authors
-#
-# * TransAspect
-#
-# == Copying
-#
-# Copyright (c) 2007 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.
-
-require 'facets/1stclassmethod'
-require 'facets/unboundmethod/arguments'
-
-# = Advisable
-#
-# Advisable provides a means of using before, after and
-# around adivce.
-
-module Advisable
-
-  def advice_before
-    @advice_before ||= {} #Hash.new{|h,k| h[k] = []}
-  end
-
-  def advice_after
-    @advice_after ||= {} #Hash.new{|h,k| h[k] = []}
-  end
-
-  def advice_around
-    @advice_around ||= {} #Hash.new{|h,k| h[k] = []}
-  end
-
-  def before(meth, &block)
-    name = "#{meth}:before#{block.object_id}"
-    define_method(name, &block)
-    (advice_before[meth.to_sym] ||= []) << name
-  end
-
-  def after(meth, &block)
-    name = "#{meth}:after#{block.object_id}"
-    define_method(name, &block)
-    (advice_after[meth.to_sym] ||= []) << name
-  end
-
-  def around(meth, &block)
-    name = "#{meth}:around#{block.object_id}"
-    define_method(name, &block)
-    (advice_around[meth.to_sym] ||= []) << name
-  end
-
-  # Advise a method.
-
-  def advise(meth)
-    #return false if defined?(meth_origin)
-    args = instance_method(meth).arguments
-
-    module_eval(<<-END, __FILE__, __LINE__)
-      alias_method '#{meth}_origin', '#{meth}'
-      def #{meth}(#{args})
-        target = method!('#{meth}_origin')
-
-        unless target.advised
-          ancs = self.class.ancestors.select{ |anc| anc.respond_to?(:advice_before) }
-          target.advice_before = ancs.collect{ |anc| anc.advice_before[:'#{meth}'] }
-          target.advice_after  = ancs.collect{ |anc| anc.advice_after[:'#{meth}'] }
-          target.advice_around = ancs.collect{ |anc| anc.advice_around[:'#{meth}'] }
-          target.advised = true
-        end
-
-        target.call_with_advice(self, *[#{args}])
-      end
-    END
-  end
-
-  #advise(:method_added)
-
-  #after :method_added do |meth|
-  #  advise(meth) unless defined?("#{meth}_orig")
-  #end
-
-  def method_added(meth)
-    return if meth == :method_added
-    @added_stack ||= []
-    return if @added_stack.last == meth
-    return if /_(origin)$/ =~ meth.to_s
-    return if /:(before|after|around)/ =~ meth.to_s
-    @added_stack << meth
-    #return if instance_methods(false).include?("#{meth}_orig")
-    advise(meth)
-    @added_stack.pop
-  end
-
-  # Extensions for Method class.
-
-  module Method
-
-    attr_accessor :advised
-
-    attr_reader :advice_before
-    attr_reader :advice_after
-    attr_reader :advice_around
-
-    def advised?
-      @advised
-    end
-
-    def advice_before=(set); @advice_before = set.flatten.compact; end
-    def advice_after=(set) ;  @advice_after = set.flatten.compact; end
-    def advice_around=(set); @advice_around = set.flatten.compact; end
-
-    # Call with advice.
-
-    def call_with_advice(obj, *args, &blk)
-      advice_before.each do |name|
-        #advice.call(*args, &blk)
-        obj.send(name, *args, &blk)
-      end
-
-      target = lambda{ call(*args, &blk) }
-      advice_around.each do |name|
-        target = lambda_target(obj, name, target, *args, &blk)
-      end
-      ret = target.call
-
-      advice_after.reverse_each do |name|
-        #advice.call(*args, &blk)
-        obj.send(name, *args, &blk)
-      end
-
-      return ret
-    end
-
-    private
-
-    # Using separate method for this prevents infinite loop.
-
-    def lambda_target(obj, name, target, *args, &blk)
-      lambda do
-        #advice.call(target, *args, &blk)
-        obj.send(name, target, *args, &blk)
-      end
-    end
-
-  end
-
-end
-
-class Method #:nodoc:
-  include Advisable::Method
-end
-

data/lib/gems/facets-2.4.5/lib/more/facets/annotations.rb

@@ -1,302 +0,0 @@
-# = Annotation
-#
-# Annotations allows you to annontate objects, including methods with arbitrary
-# "metadata". These annotations don't do anything in themselves. They are
-# merely comments. But you can put them to use. For instance an attribute
-# validator might check for an annotation called :valid and test against it.
-#
-# Annotation is an OpenObject, and is used across the board for keeping annotations.
-#
-# Annotation class serves for both simple and inherited cases depending on whether
-# a base class is given.
-#
-#   class X
-#     attr :a
-#     ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
-#
-#     def validate
-#       instance_variables.each { |iv|
-#         if validator = self.class.ann(iv)[:valid]
-#           value = instance_variable_get(iv)
-#           unless validator.call(vale)
-#             raise "Invalid value #{value} for #{iv}"
-#           end
-#         end
-#       }
-#     end
-#
-#   end
-#
-# == Authors
-#
-# * Thomas Sawyer
-# * George Moschovitis
-#
-# == History
-#
-# * 2006-11-07 trans  Created this ultra-concise version of annotations.
-#
-# == Todo
-#
-# * Might be nice to have a default object of annotation, eg. the next
-#   method defined, like how +desc+ annotates a rake +task+.
-# * The ann(x).name notation is kind of nice. Would like to add that
-#   back-in if reasonable. Basically this require heritage to be an OpenObject
-#   rather than just a hash.
-#
-# == Copying
-#
-# Copyright (c) 2005 Thomas Sawyer, George Moschovitis
-#
-# 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.
-
-warn "Libary facets/annotations.rb will be deprecated and spun spun off as new project."
-
-require 'facets/hash/to_h'
-require 'facets/hash/rekey'
-require 'facets/hash/op'
-
-# = Annotation
-#
-# Annotations allows you to annontate objects, including methods with arbitrary
-# "metadata". These annotations don't do anything in themselves. They are
-# merely comments. But you can put them to use. For instance an attribute
-# validator might check for an annotation called :valid and test against it.
-#
-# Annotation is an OpenObject, and is used across the board for keeping annotations.
-#
-# Annotation class serves for both simple and inherited cases depending on whether
-# a base class is given.
-#
-# == Synopsis
-#
-#   class X
-#     attr :a
-#     ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
-#
-#     def validate
-#       instance_variables.each { |iv|
-#         if validator = self.class.ann(iv)[:valid]
-#           value = instance_variable_get(iv)
-#           unless validator.call(vale)
-#             raise "Invalid value #{value} for #{iv}"
-#           end
-#         end
-#       }
-#     end
-#
-#   end
-
-#--
-# By using a global veriable rather the definining a class instance variable
-# for each class/module, it is possible to quicky scan all annotations for the
-# entire system. To do the same without this would require scanning through
-# the ObjectSpace. (Still which is better?)
-#
-#$annotations = Hash.new { |h,k| h[k] = {} }
-#++
-
-class Module
-
-  def annotations
-    #$annotations[self]
-    @annotations ||= {}
-  end
-
-  def heritage(ref)
-    ref = ref.to_sym
-    ancestors.inject({}) { |memo, ancestor|
-      ancestor.annotations[ref] ||= {}
-      ancestor.annotations[ref] + memo
-    }
-  end
-
-  # Set or read annotations.
-
-  def ann( ref, keys_or_class=nil, keys=nil )
-    return heritage(ref) unless keys_or_class or keys
-
-    if Class === keys_or_class
-      keys ||= {}
-      keys[:class] = keys_or_class
-    else
-      keys = keys_or_class
-    end
-
-    if Hash === keys
-      ref = ref.to_sym
-      annotations[ref] ||= {}
-      annotations[ref].update(keys.rekey)
-    else
-      key = keys.to_sym
-      heritage(ref)[key]
-    end
-  end
-
-  # To change an annotation's value in place for a given class or module
-  # it first must be duplicated, otherwise the change may effect annotations
-  # in the class or module's ancestors.
-
-  def ann!( ref, keys_or_class=nil, keys=nil )
-    #return heritage(ref) unless keys_or_class or keys
-    return annotations[ref] unless keys_or_class or keys
-
-    if Class === keys_or_class
-      keys ||= {}
-      keys[:class] = keys_or_class
-    else
-      keys = keys_or_class
-    end
-
-    if Hash === keys
-      ref = ref.to_sym
-      annotations[ref] ||= {}
-      annotations[ref].update(keys.rekey)
-    else
-      key = keys.to_sym
-      annotations[ref][key] = heritage(ref)[key].dup
-    end
-  end
-
-end
-
-# TITLE
-#
-#   Annotated Attributes
-#
-# DESCRIPTION:
-#
-#   This framework modifies the attr_* methods to allow easy
-#   addition of annotations.
-#
-# 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
-#   - George Moschovitis
-
-require 'facets/annotations.rb'
-require 'facets/inheritor.rb'
-
-# = Annotated Attributes
-#
-# This framework modifies the attr_* methods to allow easy addition of annotations.
-# It the built in attribute methods (attr, attr_reader, attr_writer and attr_accessor),
-# to allow annotations to added to them directly rather than requireing a separate
-# #ann statement.
-#
-#   class X
-#     attr :a, :valid => lambda{ |x| x.is_a?(Integer) }
-#   end
-#
-# See annotation.rb for more information.
-#
-# NOTE This library was designed to be backward compatible with the
-# standard versions of the same methods.
-
-class ::Module
-
-  inheritor :instance_attributes, [], :|
-
-  def attr( *args )
-    args.flatten!
-    case args.last
-    when TrueClass
-      args.pop
-      attr_accessor( *args )
-    when FalseClass
-      args.pop
-      attr_reader( *args )
-    else
-      attr_reader( *args )
-    end
-  end
-
-  alias :plain_reader :attr_reader
-  alias :plain_writer :attr_writer
-  alias :plain_accessor :attr_accessor
-
-  code = ''
-
-  [ :_reader, :_writer, :_accessor].each do |m|
-
-    code << %{
-      def attr#{m}(*args)
-        args.flatten!
-
-        harg={}; while args.last.is_a?(Hash)
-          harg.update(args.pop)
-        end
-
-        raise ArgumentError if args.empty? and harg.empty?
-
-        if args.empty?        # hash mode
-          harg.each { |a,h| attr#{m}(a,h) }
-        else
-          klass = harg[:class] = args.pop if args.last.is_a?(Class)
-
-          args.each { |a|
-            plain#{m} a
-            a = a.to_sym
-            ann(a,harg)
-          }
-          instance_attributes!.concat( args )  #merge!
-
-          # Use this callback to customize for your needs.
-          if respond_to?(:attr_callback)
-            attr_callback(self, args, harg)
-          end
-
-          # return the names of the attributes created
-          return args
-        end
-      end
-    }
-
-  end
-
-  class_eval( code )
-
-  # TODO Should attribute alias be kept?
-  alias_method :attribute, :attr_accessor
-
-  # Return list of attributes that have a :class annotation.
-  #
-  #   class MyClass
-  #     attr_accessor :test
-  #     attr_accessor :name, String, :doc => 'Hello'
-  #     attr_accessor :age, Fixnum
-  #   end
-  #
-  #   MyClass.instance_attributes # => [:test, :name, :age, :body]
-  #   MyClass.classified_attributes # => [:name, :age]
-
-  def classified_attributes
-    instance_attributes.find_all do |a|
-      self.ann(a, :class)
-    end
-  end
-
-end
-