anise 0.1.1

data/COPYING

@@ -0,0 +1,168 @@
+.
+
+                GNU LESSER GENERAL PUBLIC LICENSE
+                     Version 3, 29 June 2007
+
+   Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+   Everyone is permitted to copy and distribute verbatim copies
+   of this license document, but changing it is not allowed.
+
+
+    This version of the GNU Lesser General Public License incorporates
+  the terms and conditions of version 3 of the GNU General Public
+  License, supplemented by the additional permissions listed below.
+
+    0. Additional Definitions. 
+
+    As used herein, "this License" refers to version 3 of the GNU Lesser
+  General Public License, and the "GNU GPL" refers to version 3 of the GNU
+  General Public License.
+
+    "The Library" refers to a covered work governed by this License,
+  other than an Application or a Combined Work as defined below.
+
+    An "Application" is any work that makes use of an interface provided
+  by the Library, but which is not otherwise based on the Library.
+  Defining a subclass of a class defined by the Library is deemed a mode
+  of using an interface provided by the Library.
+
+    A "Combined Work" is a work produced by combining or linking an
+  Application with the Library.  The particular version of the Library
+  with which the Combined Work was made is also called the "Linked
+  Version".
+
+    The "Minimal Corresponding Source" for a Combined Work means the
+  Corresponding Source for the Combined Work, excluding any source code
+  for portions of the Combined Work that, considered in isolation, are
+  based on the Application, and not on the Linked Version.
+
+    The "Corresponding Application Code" for a Combined Work means the
+  object code and/or source code for the Application, including any data
+  and utility programs needed for reproducing the Combined Work from the
+  Application, but excluding the System Libraries of the Combined Work.
+
+    1. Exception to Section 3 of the GNU GPL.
+
+    You may convey a covered work under sections 3 and 4 of this License
+  without being bound by section 3 of the GNU GPL.
+
+    2. Conveying Modified Versions.
+
+    If you modify a copy of the Library, and, in your modifications, a
+  facility refers to a function or data to be supplied by an Application
+  that uses the facility (other than as an argument passed when the
+  facility is invoked), then you may convey a copy of the modified
+  version:
+
+     a) under this License, provided that you make a good faith effort to
+     ensure that, in the event an Application does not supply the
+     function or data, the facility still operates, and performs
+     whatever part of its purpose remains meaningful, or
+
+     b) under the GNU GPL, with none of the additional permissions of
+     this License applicable to that copy.
+
+    3. Object Code Incorporating Material from Library Header Files.
+
+    The object code form of an Application may incorporate material from
+  a header file that is part of the Library.  You may convey such object
+  code under terms of your choice, provided that, if the incorporated
+  material is not limited to numerical parameters, data structure
+  layouts and accessors, or small macros, inline functions and templates
+  (ten or fewer lines in length), you do both of the following:
+
+     a) Give prominent notice with each copy of the object code that the
+     Library is used in it and that the Library and its use are
+     covered by this License.
+
+     b) Accompany the object code with a copy of the GNU GPL and this license
+     document.
+
+    4. Combined Works.
+
+    You may convey a Combined Work under terms of your choice that,
+  taken together, effectively do not restrict modification of the
+  portions of the Library contained in the Combined Work and reverse
+  engineering for debugging such modifications, if you also do each of
+  the following:
+
+     a) Give prominent notice with each copy of the Combined Work that
+     the Library is used in it and that the Library and its use are
+     covered by this License.
+
+     b) Accompany the Combined Work with a copy of the GNU GPL and this license
+     document.
+
+     c) For a Combined Work that displays copyright notices during
+     execution, include the copyright notice for the Library among
+     these notices, as well as a reference directing the user to the
+     copies of the GNU GPL and this license document.
+
+     d) Do one of the following:
+
+         0) Convey the Minimal Corresponding Source under the terms of this
+         License, and the Corresponding Application Code in a form
+         suitable for, and under terms that permit, the user to
+         recombine or relink the Application with a modified version of
+         the Linked Version to produce a modified Combined Work, in the
+         manner specified by section 6 of the GNU GPL for conveying
+         Corresponding Source.
+
+         1) Use a suitable shared library mechanism for linking with the
+         Library.  A suitable mechanism is one that (a) uses at run time
+         a copy of the Library already present on the user's computer
+         system, and (b) will operate properly with a modified version
+         of the Library that is interface-compatible with the Linked
+         Version. 
+
+     e) Provide Installation Information, but only if you would otherwise
+     be required to provide such information under section 6 of the
+     GNU GPL, and only to the extent that such information is
+     necessary to install and execute a modified version of the
+     Combined Work produced by recombining or relinking the
+     Application with a modified version of the Linked Version. (If
+     you use option 4d0, the Installation Information must accompany
+     the Minimal Corresponding Source and Corresponding Application
+     Code. If you use option 4d1, you must provide the Installation
+     Information in the manner specified by section 6 of the GNU GPL
+     for conveying Corresponding Source.)
+
+    5. Combined Libraries.
+
+    You may place library facilities that are a work based on the
+  Library side by side in a single library together with other library
+  facilities that are not Applications and are not covered by this
+  License, and convey such a combined library under terms of your
+  choice, if you do both of the following:
+
+     a) Accompany the combined library with a copy of the same work based
+     on the Library, uncombined with any other library facilities,
+     conveyed under the terms of this License.
+
+     b) Give prominent notice with the combined library that part of it
+     is a work based on the Library, and explaining where to find the
+     accompanying uncombined form of the same work.
+
+    6. Revised Versions of the GNU Lesser General Public License.
+
+    The Free Software Foundation may publish revised and/or new versions
+  of the GNU Lesser General Public License from time to time. Such new
+  versions will be similar in spirit to the present version, but may
+  differ in detail to address new problems or concerns.
+
+    Each version is given a distinguishing version number. If the
+  Library as you received it specifies that a certain numbered version
+  of the GNU Lesser General Public License "or any later version"
+  applies to it, you have the option of following the terms and
+  conditions either of that published version or of any later version
+  published by the Free Software Foundation. If the Library as you
+  received it does not specify a version number of the GNU Lesser
+  General Public License, you may choose any version of the GNU Lesser
+  General Public License ever published by the Free Software Foundation.
+
+    If the Library as you received it specifies that a proxy can decide
+  whether future versions of the GNU Lesser General Public License shall
+  apply, that proxy's public statement of acceptance of any version is
+  permanent authorization for you to choose that version for the
+  Library.
+

data/HISTORY

@@ -0,0 +1,16 @@
+== 0.0.0 // 2008-03-04
+
+* Started project.
+
+
+# Keep a running list of changes by version and date here.
+# This is uploaded as the ChangeLog in the release process.
+# It's better to keep a manual log, rather then use the log
+# generated by the SCM because the SCM log will have gritty
+# details with which end-users will not be concerned.
+#
+# If you want to use the SCM log anyway, you can of course
+# do so. Just "cp log/Changelog.txt CHANGES" prior to release.
+# (We might provide an automated option for this in the
+# future, but for now its a manual task.)
+

data/MANIFEST

@@ -0,0 +1,26 @@
+test
+test/test_toplevel_attribute.rb
+test/test_attribute.rb
+test/test_annotatable.rb
+test/suite.rb
+test/test_toplevel_annotatable.rb
+RELEASE
+README
+HISTORY
+meta
+meta/require
+meta/created
+meta/homepage
+meta/summary
+meta/abstract
+meta/license
+meta/authors
+meta/contact
+lib
+lib/anise
+lib/anise/attributes.rb
+lib/anise/annotations.rb
+lib/anise/annotatable.rb
+lib/anise.rb
+VERSION
+COPYING

data/README

@@ -0,0 +1,66 @@
+= Annotable
+
+  http://anise.rubyforge.org
+
+
+== INTRODUCTION
+
+Annotable is an Annotations Systems for the Ruby programming
+lanaguage. Unlike other annotations system it is not a comment-based
+system. Rather, it is a dynamic annotations system operating at runtime.
+
+
+== RELEASE NOTES
+
+Please see the RELEASE file.
+
+
+== RECENT CHANGES
+
+Please see the HISTORY file.
+
+
+== INSTALLATION
+
+To install with RubyGems simply open a console and type:
+
+  gem install annotable
+
+To manually install you will need Setup.rb (see http://setup.rubyforge.org).
+Then download the tarball package and do:
+
+  $ tar -xvzf anise-0.4.0.tgz
+  $ cd annotated-0.4.0.tgz
+  $ sudo setup.rb all
+
+
+== TESTING
+
+We recommend using Turn (http://turn.rubyforge.org) to run Anise's
+unit tests.
+
+  $ turn test/test_*
+
+But we have include a script test/suite.rb so you can easily run the
+unit tests with the testrb command:
+
+  $ testrb test/suite.rb
+
+or with Ruby alone:
+
+  $ ruby -rtest/unit test/suite.rb
+
+
+== USAGE
+
+For the moment please see the API documentation to learn how to use the library.
+
+
+== LICENSE
+
+Copyright (c) 2008 TigerOps
+
+This program is ditributed under the terms of the LGPL License.
+
+Please see COPYING file for details.
+

data/RELEASE

@@ -0,0 +1,11 @@
+= Anise 0.1 hits the streets.
+
+This is the initial release of Anise.
+
+Anise is a spin off the the Facets annotations.rb library.
+It includes the Annotations functionality, and adds
+a mixin, Annotatable, that makes it easy to add new
+annotations on the fly.
+
+  http://anise.rubyforge.org
+

data/VERSION

@@ -0,0 +1 @@
+anise 0.1.1 beta (2008-09-27)

data/lib/anise/annotatable.rb

@@ -0,0 +1,60 @@
+module Anise
+  require 'anise/annotations.rb'
+
+  # = Annotatable
+  #
+  # Annotatable allows for the create of dynamic
+  # method annotations which attach to the next
+  # method defined.
+  #
+  #   class X
+  #     include Anise::Annotatable
+  #
+  #     annotation :doc
+  #
+  #     doc "See waht I mean?"
+  #     def see
+  #       # ...
+  #     end
+  #   end
+  #
+  #   X.ann(:see, :doc) #=> "See what I mean?"
+  #
+  # TODO: This must work when included in a module or
+  #       class and also when included at the toplevel.
+  #
+  module Annotatable
+
+    def self.append_features(base)
+      if base == Object
+        Module.send(:include, self)  # FIXME: Module ?
+      else
+        base.extend self
+      end
+    end
+
+    def pending_annotations
+      @pending_annotations ||= []
+    end
+
+    def annotation(name)
+      (class << self; self; end).instance_eval do
+        define_method(name) do |*args|
+          pending_annotations << [name, args]
+        end
+      end
+    end
+
+    def method_added(sym)
+      pending_annotations.each do |name, args|
+        ann sym, name => args
+      end
+      @pending_annotations = []
+    end
+
+  end
+
+end
+
+# Copyright (c) 2005, 2008 TigerOps
+

data/lib/anise/annotations.rb

@@ -0,0 +1,114 @@
+require 'facets/hash/rekey' # FIXME: remove dependency
+require 'facets/hash/op'    # FIXME: remove dependency
+
+# = Annotations
+#
+# Annotations allows you to annontate objects, including methods with arbitrary
+# "metadata". These annotations don't do anything in themselves. They are
+# merely data. But you can put them to use. For instance an attribute
+# validator might check for an annotation called :valid and test against it.
+#
+# == Synopsis
+#
+#   class X
+#     attr :a
+#     ann :@a, :valid => lambda{ |x| x.is_a?(Integer) }
+#
+#     def validate
+#       instance_variables.each do |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
+#
+#   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] = {} }
+#++
+#
+# TODO: 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.
+#
+#--
+# History Note
+#
+# * 2006-11-07 trans  Created this ultra-concise version of annotations.
+#++
+
+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
+
+# Copyright (c) 2005, 2008 TigerOps
+

data/lib/anise/attributes.rb

@@ -0,0 +1,122 @@
+require 'facets/inheritor' # remove dependency?
+
+module Anise
+  require 'anise/annotations'
+
+  module Annotatable
+
+    # = Annotated Attributes
+    #
+    # This framework modifies the major attr_* methods to allow easy addition of annotations.
+    # It modifies 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.
+    #
+    module Attributes
+
+      def self.append_features(base)
+        base.extend self
+        base.module_eval do
+          inheritor :instance_attributes, [], :|
+
+          annotatable_attribute_method(:attr_reader)
+          annotatable_attribute_method(:attr_writer)
+          annotatable_attribute_method(:attr_accessor)
+        end
+      end
+
+      #
+      def annotatable_attribute_method(attr_method_name)
+        attr_method = method(attr_method_name)
+
+        (class << self; self; end).instance_eval do 
+
+          define_method(attr_method_name) do |*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| send(attr_method_name,a,h) }
+            else
+              klass = harg[:class] = args.pop if args.last.is_a?(Class)
+
+              attr_method.call(*args)
+
+              args.each { |a|
+                ann(a.to_sym,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
+      end
+
+      # 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
+
+      # This define a simple adjustment to #attr to allow it to handle the boolean argument and
+      # to be able to accept attributes. It's backward compatible and is not needed for Ruby 1.9
+      # which gets rid of the secondary argument.
+      #
+      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
+
+    end
+
+  end
+
+end
+
+# Copyright (c) 2005, 2008 TigerOps
+

data/lib/anise.rb

@@ -0,0 +1 @@
+require 'anise/annotatable'

data/meta/abstract

@@ -0,0 +1 @@
+Annable is an annotations systems for the Ruby programming lanaguage.

data/meta/authors

@@ -0,0 +1 @@
+trans <transfire@gmail.com>

data/meta/contact

@@ -0,0 +1 @@
+tigerops-community@rubyforge.org

data/meta/created

@@ -0,0 +1 @@
+2008-02-21

data/meta/homepage

@@ -0,0 +1 @@
+http://

data/meta/license

@@ -0,0 +1 @@
+Ruby

data/meta/require

@@ -0,0 +1 @@
+facets >2.4.0

data/meta/summary

@@ -0,0 +1 @@
+Dynamic Annotation for Ruby

data/test/suite.rb

@@ -0,0 +1,8 @@
+$: << 'lib'
+
+tests = Dir[File.join(File.dirname(__FILE__), 'test_*')]
+
+tests.each do |t|
+  require t
+end
+

data/test/test_annotatable.rb

@@ -0,0 +1,28 @@
+require 'anise/annotatable'
+
+class Test_Annotatable < Test::Unit::TestCase
+
+  include Anise::Annotatable
+
+  annotation :req
+
+  req 'r'
+
+  def a
+    "a"
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['r']}, self.class.ann(:a) )
+  end
+
+  req 's'
+
+  attr :b
+
+  def test_annotated
+    assert_equal( {:req=>['s']}, self.class.ann(:b) )
+  end
+
+end
+

data/test/test_attribute.rb

@@ -0,0 +1,16 @@
+require 'anise/attributes'
+
+class Test_Attribute < Test::Unit::TestCase
+
+  include Anise::Annotatable::Attributes
+
+  attr :q
+
+  attr :a, :x => 1
+
+  def test_attr_a
+    assert_equal( {:x=>1}, self.class.ann(:a) )
+  end
+
+end
+

data/test/test_toplevel_annotatable.rb

@@ -0,0 +1,32 @@
+=begin
+require 'annotable'
+require 'test/unit'
+
+include Annotatable
+
+annotation :req
+
+class Test_Annotatable < Test::Unit::TestCase
+
+  annotation :req
+
+  req 'r'
+
+  def a
+    "a"
+  end
+
+  def test_annotated
+    assert_equal( {:req=>['r']}, self.class.ann(:a) )
+  end
+
+  req 's'
+
+  attr :b
+
+  def test_annotated
+    assert_equal( {:req=>['s']}, self.class.ann(:b) )
+  end
+
+end
+=end

data/test/test_toplevel_attribute.rb

@@ -0,0 +1,27 @@
+=begin
+require 'annotable/attributes'
+require 'test/unit'
+
+include Annotatable::Attributes
+
+$self = self
+
+attr :b, :y => 1
+
+class Test_Attribute_Toplevel < Test::Unit::TestCase
+
+  attr :q
+
+  attr :a, :x => 1
+
+  def test_attr_a
+    assert_equal( {:x=>1}, self.class.ann(:a) )
+  end
+
+  def test_attr_b
+    assert_equal( {:y=>1}, $self.class.ann(:b) )
+  end
+
+end
+=end
+

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: anise
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- tigerops-community@rubyforge.org
+- trans <transfire@gmail.com>
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-17 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 2.4.0
+    version: 
+description: Annable is an annotations systems for the Ruby programming lanaguage.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- MANIFEST
+- RELEASE
+- HISTORY
+- VERSION
+- COPYING
+files: 
+- MANIFEST
+- test
+- test/test_toplevel_attribute.rb
+- test/test_attribute.rb
+- test/test_annotatable.rb
+- test/suite.rb
+- test/test_toplevel_annotatable.rb
+- RELEASE
+- README
+- HISTORY
+- meta
+- meta/require
+- meta/created
+- meta/homepage
+- meta/summary
+- meta/abstract
+- meta/license
+- meta/authors
+- meta/contact
+- lib
+- lib/anise
+- lib/anise/attributes.rb
+- lib/anise/annotations.rb
+- lib/anise/annotatable.rb
+- lib/anise.rb
+- VERSION
+- COPYING
+has_rdoc: true
+homepage: http://
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --title
+- anise api
+- --main
+- README
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: anise
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Annable is an annotations systems for the Ruby programming lanaguage.
+test_files: 
+- test/test_toplevel_attribute.rb
+- test/test_attribute.rb
+- test/test_annotatable.rb
+- test/suite.rb
+- test/test_toplevel_annotatable.rb