mack-facets 0.8.1 → 0.8.2

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

@@ -0,0 +1,75 @@
+# = 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

@@ -0,0 +1,38 @@
+# 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

@@ -0,0 +1,140 @@
+# = 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

@@ -0,0 +1,162 @@
+# = 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

@@ -0,0 +1,302 @@
+# = 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
+