attic 0.4.0 → 0.5.2

data/CHANGES.txt

@@ -1,5 +1,21 @@
 ATTIC, CHANGES
 
+#### 0.5.2 (2010-02-15) ###############################
+
+* CHANGE: Remove hanna dependency
+
+#### 0.5.0 (2009-11-29) ###############################
+
+* FIXED: Classes can now only be extended once
+* FIXED: Don't define the same attic variable more then once
+* FIXED: Don't define instance_variable method for objects which 
+  don't already have one. 
+* CHANGE: attic_vars method is now attic_variables
+* CHANGE: Won't define accessor methods if methods with the same 
+  name already exist.  
+* ADDED: all_instance_variables method (for no metaclasses)
+* ADDED: Explicit attic_variable_set and attic_variable_get methods
+
 
 #### 0.4.0 (2009-07-17) ###############################
 

data/README.rdoc

@@ -1,23 +1,27 @@
-= Attic - v0.4 ALPHA
+= Attic - v0.5
 
-A place for Ruby objects to hide instance variables.
-
-== Alpha Notice
-
-This library is fresh (est 2009-07-06) and barely tested. It's fun to use but not reliable yet.
+A place to hide private instance variables in your Ruby objects.
 
 == Example
 
     require 'attic'
     
-    String.extend Attic
-    String.attic :timestamp
+    class String
+      extend Attic
+      attic :timestamp
+    end
     
     a = "anything"
     a.timestamp = "1980-11-18"
-    a.instance_variables          # => []
-    a.timestamp                   # 1980-11-18
-
+    a.instance_variables                      # => []
+    a.timestamp                               # 1980-11-18
+                                              
+    a.attic_variables                         # => [:timestamp]
+    
+    a.attic_variable_set :tags, [:a, :b, :c]
+    a.attic_variable_get :tags                # [:a, :b, :c]
+    
+    a.attic_variables                         # => [:timestamp, :tags]
  
 == Some objects have no metaclasses
 
@@ -29,7 +33,6 @@ Symbol and Fixnum objects do not have metaclasses so instance variables are hidd
 Via Rubygems, one of:
 
     $ gem install attic
-    $ gem install delano-attic --source http://gems.github.com/
 
 or via download:
 * attic-latest.tar.gz[http://github.com/delano/attic/tarball/latest]

data/Rakefile

@@ -1,10 +1,17 @@
 require 'rubygems'
 require 'rake/clean'
 require 'rake/gempackagetask'
-require 'hanna/rdoctask'
 require 'fileutils'
 include FileUtils
  
+
+begin
+  require 'hanna/rdoctask'
+rescue LoadError
+  require 'rake/rdoctask'
+end
+
+
 task :default => :package
  
 # CONFIG =============================================================

data/attic.gemspec

@@ -1,8 +1,8 @@
 @spec = Gem::Specification.new do |s|
 	s.name = "attic"
   s.rubyforge_project = "attic"
-	s.version = "0.4.0"
-	s.summary = "A place for Ruby objects to hide instance variables."
+	s.version = "0.5.2"
+	s.summary = "A place to hide private instance variables in your Ruby objects."
 	s.description = s.summary
 	s.author = "Delano Mandelbaum"
 	s.email = "delano@solutious.com"
@@ -41,12 +41,14 @@
   attic.gemspec
   lib/attic.rb
   lib/attic/mixins.rb
-  lib/attic/mixins/object.rb
   try/01_mixins_tryouts.rb
   try/10_attic_tryouts.rb
   try/20_accessing_tryouts.rb
   try/25_string_tryouts.rb
   try/30_nometaclass_tryouts.rb
+  try/40_explicit_accessor_tryouts.rb
+  try/X1_metaclasses.rb
+  try/X2_extending.rb
   )
   
   s.has_rdoc = true

data/lib/attic.rb

@@ -6,67 +6,74 @@ require 'attic/mixins'
 # A place to store instance variables. 
 #
 module Attic
-  VERSION = '0.4.0'
+  VERSION = '0.5.2' unless defined?(VERSION)
+  
+  module InstanceMethods
+    def attic_variables
+      self.class.attic_variables
+    end
+    alias_method :attic_vars, :attic_variables
+    def attic_variable? n
+      self.class.attic_variable? n
+    end
+    def attic_variable_set(n,v)
+      attic_variables << n unless attic_variable? n
+      if metaclass?
+        metaclass.instance_variable_set("@#{n}", v)
+      else
+        instance_variable_set("@___attic_#{n}", v)
+      end
+    end
+    def attic_variable_get(n)
+      if metaclass?
+        metaclass.instance_variable_get("@#{n}")
+      else
+        instance_variable_get("@___attic_#{n}")
+      end
+    end
+  end
   
   def self.included(o)
     raise "You probably meant to 'extend Attic' in #{o}"
   end
   
   def self.extended(o)
+    # This class has already been extended. 
+    return if o.ancestors.member? Attic::InstanceMethods
+    
+    
     ## NOTE: This is just a reminder for a more descerning way to 
     ## include the meta methods, instead of using a global mixin. 
     ##o.class_eval do
     ##  include ObjectHelpers
     ##end
-    
     # Create an instance method that returns the attic variables. 
+    o.send :include, Attic::InstanceMethods
+    #p [:extend, self, o]
+    
+    o.metaclass.instance_variable_set("@attic_variables", [])
     o.class_eval do
-      define_method :attic_vars do
-        self.class.attic_vars
+      def self.inherited(o2)
+        #p [:inherit, self, o2]
+        attic_vars = self.attic_variables.clone
+        o2.metaclass.instance_variable_set("@attic_variables", attic_vars)
       end
-    end
-  end
-  
-  # Create instance methods that store variables in the metaclass. 
-  @@metaclass_proc = proc { |klass,name|
-    klass.class_eval do
-      # Add the attic variables named to the list. Notice that we
-      # cheakily store this in the metameta class so as to not 
-      # disturb the metaclass instance variables. 
-      vars = attic_vars << name
-      metametaclass.instance_variable_set("@attic", vars)
-      
-      define_method(name) do
-        metaclass.instance_variable_get("@#{name}")
-      end
-      define_method("#{name}=") do |val|
-        metaclass.instance_variable_set("@#{name}", val)
+      if method_defined? :instance_variables
+        old_instance_variables = instance_method(:instance_variables)
+        define_method :instance_variables do
+          ret = old_instance_variables.bind(self).call.clone
+          ret.reject! { |v| v.to_s =~ /^@___?attic/ }  # match 2 or 3 underscores
+          ret
+        end
+        define_method :all_instance_variables do
+          old_instance_variables.bind(self).call
+        end
       end
     end
-  }
   
-  # Create instance methods that store variables in unlikely instance vars.
-  @@nometaclass_proc = proc { |klass,name|
-    klass.class_eval do
-      # Add the attic variables named to the list. We use a 
-      # variable with 3 underscores to prevent collisions. 
-      vars = attic_vars << name
-      instance_variable_set("@___attic_vars", vars)
-      
-      define_method(name) do
-        instance_variable_get("@__attic_#{name}")
-      end
-      define_method("#{name}=") do |val|
-        instance_variable_set("@__attic_#{name}", val)
-      end
-      define_method :instance_variables do |*args|
-        ret = super *args
-        ret.reject! { |v| v.to_s =~ /^@___?attic/ }  # match 2 or 3 underscores
-        ret
-      end
-    end
-  }
-
+    
+  end
+  
   
   # A class method for defining variables to store in the attic. 
   # * +junk+ is a list of variables names. Accessor methods are 
@@ -85,15 +92,22 @@ module Attic
   # * <tt>String#timestamp</tt> for setting the value
   #
   def attic *junk
-    #p [:attic, self, metaclass?]
     return metaclass if junk.empty?
-    
-    processor = metaclass? ? @@metaclass_proc : @@nometaclass_proc
-    
-    junk.each do |var|
-      processor.call(self, var)
+    junk.each do |name|
+      next if attic_variable? name
+      self.attic_variables << name
+      
+      unless method_defined? name
+        define_method(name) do
+          attic_variable_get name
+        end
+      end
+      unless method_defined? "#{name}="
+        define_method("#{name}=") do |val|
+          attic_variable_set name, val
+        end
+      end
     end
-    
     attic_vars
   end
   
@@ -102,16 +116,18 @@ module Attic
   #
   #     String.extend Attic
   #     String.attic :timestamp
-  #     String.attic_vars           # => [:timestamp]
+  #     String.attic_variables     # => [:timestamp]
   #
-  def attic_vars
-    if metaclass?
-      metametaclass.instance_variable_get("@attic") || []
-    else
-      instance_variable_get("@___attic_vars") || []
-    end
+  def attic_variables
+    a = self.metaclass.instance_variable_get("@attic_variables")
+    a ||= self.metaclass.instance_variable_set("@attic_variables", [])
+    a
+  end
+  alias_method :attic_vars, :attic_variables
+
+  def attic_variable?(n)
+    attic_variables.member? n
   end
-  
   
 end
 

data/lib/attic/mixins.rb

@@ -1,3 +1,68 @@
+class NoMetaClass < RuntimeError
+end
 
-require 'attic/mixins/object'
+# = Object
+#
+# These methods are copied directly from _why's metaid.rb. 
+# See: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+class Object
+  
+  # An Array of classes which do not have metaclasses.
+  NOMETACLASS = [Symbol, Fixnum].freeze
+  
+  def nometaclass?
+    NOMETACLASS.member?(self)
+  end
+  
+  def metaclass?
+    !NOMETACLASS.member?(self.class)
+  end
+  
+  # A convenient method for getting the metaclass of the current object.
+  # i.e.
+  #
+  #     class << self; self; end;
+  #
+  # NOTE: Some Ruby class do not have meta classes (see: NOMETACLASS). 
+  # For these classes, this method returns the class itself. That means
+  # the instance variables will stored in the class itself. 
+  def metaclass
+    if !self.metaclass?
+      raise NoMetaClass, self
+    else
+      class << self; self; end; 
+    end
+  end
+  
+  # Execute a block +&blk+ within the metaclass of the current object.
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+  
+  # Add an instance method called +name+ to metaclass for the current object.
+  # This is useful because it will be available as a singleton method
+  # to all subclasses too. 
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+  
+  # Add a class method called +name+ for the current object's class. This
+  # isn't so special but it maintains consistency with meta_def. 
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  
+  # A convenient method for getting the metaclass of the metaclass
+  # i.e.
+  #
+  #     self.metaclass.metaclass
+  #
+  def metametaclass; self.metaclass.metaclass; end
+
+  def metameta_eval &blk; metametaclass.instance_eval &blk; end
+
+  def metameta_def name, &blk
+    metameta_eval { define_method name, &blk }
+  end
+  
+end
 

data/try/01_mixins_tryouts.rb

@@ -1,5 +1,5 @@
 group "Mixins"
-library :attic, 'lib'
+library :attic, "lib"
 
 tryouts "Object" do
   if Tryouts.sysinfo.ruby == "1.9.1"

data/try/10_attic_tryouts.rb

@@ -5,6 +5,7 @@ tryouts "Basics" do
   drill "can extend Attic", true do
     class ::Worker
       extend Attic
+      def kind() :true end
     end
     # 1.9                             # 1.8
     Worker.methods.member?(:attic) || Worker.methods.member?('attic')
@@ -25,6 +26,18 @@ tryouts "Basics" do
     w.respond_to? :size
   end
   
+  drill "can access attic attributes explicitly", 2 do
+    w = Worker.new
+    w.attic_variable_set :size, 2
+    w.attic_variable_get :size
+  end
+  
+  drill "won't define a method if on already exists", :true do
+    Worker.attic :kind
+    a = Worker.new
+    a.kind
+  end
+  
 end
 
 

data/try/30_nometaclass_tryouts.rb

@@ -1,5 +1,5 @@
 group "No Meta Class"
-library :attic, 'lib'
+library :attic, "lib"
 tryouts "Basics" do
   
   dream :class, Array
@@ -13,13 +13,12 @@ tryouts "Basics" do
    :any.metaclass
   end
   
-  ## NOTE: fails
   drill "Symbol instances don't cross streams", [:roger, nil] do
     Symbol.extend Attic
     Symbol.attic :name
-    a = :any
+    a, b = :symbol1, :symbol2
     a.name = :roger
-    [a.name, :another.name]
+    [a.name, b.name]
   end
   
   drill "metaclass? method exists", true do
@@ -28,7 +27,30 @@ tryouts "Basics" do
   end
   
   drill "metaclass? method is false for a Symbol", false do
-    :any.class.metaclass?
+    :any.metaclass?
+  end
+  
+  dream [:@___attic_name]
+  drill "A Symbol's attic vars appear in all_instance_variables" do
+    Symbol.extend Attic
+    Symbol.attic :name
+    a, b = :symbol1, :symbol2
+    a.name = :roger
+    a.all_instance_variables
+  end
+  
+  dream []
+  drill "A Symbol's attic vars do not appear in instance_variables" do
+    Symbol.extend Attic
+    Symbol.attic :name
+    a, b = :symbol1, :symbol2
+    a.name = :roger
+    a.instance_variables
+  end
+  
+  
+  drill "knows attic variables", [:name] do
+    Symbol.attic_variables
   end
   
 end

data/try/40_explicit_accessor_tryouts.rb

@@ -0,0 +1,23 @@
+group "Attic"
+library :attic, "lib"
+tryouts "Explicit accessors" do
+
+  setup do
+    class ::Worker
+      extend Attic
+    end
+  end
+  
+  drill "can set value", 100 do
+    a = Worker.new
+    a.attic_variable_set :space, 100
+    a.attic_variable_get :space
+  end
+  
+  drill "doesn't create accessor methods", false do
+    a = Worker.new
+    a.attic_variable_set :space, 100
+    a.respond_to? :space
+  end
+  
+end

data/try/X1_metaclasses.rb

@@ -0,0 +1,112 @@
+# $ ruby tryouts/metaclasses.rb
+
+class Object
+  
+  # A convenient method for getting the metaclass of the current object.
+  # i.e.
+  #
+  #     class << self; self; end;
+  #
+  def metaclass; class << self; self; end; end
+
+  # Execute a block +&blk+ within the metaclass of the current object.
+  def meta_eval &blk; metaclass.instance_eval &blk; end
+  
+  # Add an instance method called +name+ to metaclass for the current object.
+  # This is useful because it will be available as a singleton method
+  # to all subclasses too. 
+  def meta_def name, &blk
+    meta_eval { define_method name, &blk }
+  end
+  
+  # Add a class method called +name+ for the current object's class. This
+  # isn't so special but it maintains consistency with meta_def. 
+  def class_def name, &blk
+    class_eval { define_method name, &blk }
+  end
+
+  
+  # A convenient method for getting the metaclass of the metaclass
+  # i.e.
+  #
+  #     self.metaclass.metaclass
+  #
+  def metametaclass; self.metaclass.metaclass; end
+
+  def metameta_eval &blk; metametaclass.instance_eval &blk; end
+
+  def metameta_def name, &blk
+    metameta_eval { define_method name, &blk }
+  end
+  
+end
+
+# Create an instance method
+class NamedArray1
+  class_eval do
+    define_method(:name) do
+      :roger
+    end
+  end
+end
+p [1, NamedArray1.new.name]
+
+# Create getter and setter instance methods
+class NamedArray2
+  class_eval do
+    define_method(:name) do
+      instance_variable_get("@name")
+    end
+    define_method(:name=) do |val|
+      instance_variable_set("@name", val)
+    end
+  end
+end
+a = NamedArray2.new
+a.name = :roger
+p [2, a.name, a.instance_variables]
+
+# Create getter and setter instance methods,
+# store instance variable in metaclass
+class NamedArray3
+  class_eval do
+    define_method(:name) do
+      metaclass.instance_variable_get("@name")
+    end
+    define_method(:name=) do |val|
+      metaclass.instance_variable_set("@name", val)
+    end
+  end
+end
+a = NamedArray3.new
+a.name = :roger
+p [3, a.name, a.instance_variables, a.metaclass.instance_variables]
+
+# Create a module with the which puts the functionality 
+# in NamedArray3 into a class method. 
+module StorageArea
+  def store *junk
+    junk.each do |name|
+      class_eval do
+        define_method(name) do
+          metaclass.instance_variable_get("@#{name}")
+        end
+        define_method("#{name}=") do |val|
+          metaclass.instance_variable_set("@#{name}", val)
+        end
+      end
+    end
+  end
+end
+class NamedArray4
+  extend StorageArea
+  store :name
+end
+a = NamedArray4.new
+a.name = :roger
+p [4, a.name, a.instance_variables, a.metaclass.instance_variables]
+
+
+
+
+

data/try/X2_extending.rb

@@ -0,0 +1,27 @@
+$:.unshift './lib'
+require 'attic'
+
+class A 
+  extend Attic
+  attic :andy
+end
+
+class B < A
+  attic :size
+end
+
+class C
+  extend Attic
+  attic :third
+end
+
+a, b, c = A.new, B.new, C.new
+
+a.andy, b.andy = 1, 2
+
+p [a.respond_to?(:andy), b.respond_to?(:andy)] # true, true
+p [a.andy, b.andy]                             # 1, 2
+
+p [a.class.attic_vars, b.class.attic_vars, c.class.attic_vars]  
+
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: attic
 version: !ruby/object:Gem::Version 
-  version: 0.4.0
+  version: 0.5.2
 platform: ruby
 authors: 
 - Delano Mandelbaum
@@ -9,11 +9,11 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-17 00:00:00 -04:00
+date: 2010-02-15 00:00:00 -05:00
 default_executable: 
 dependencies: []
 
-description: A place for Ruby objects to hide instance variables.
+description: A place to hide private instance variables in your Ruby objects.
 email: delano@solutious.com
 executables: []
 
@@ -31,12 +31,14 @@ files:
 - attic.gemspec
 - lib/attic.rb
 - lib/attic/mixins.rb
-- lib/attic/mixins/object.rb
 - try/01_mixins_tryouts.rb
 - try/10_attic_tryouts.rb
 - try/20_accessing_tryouts.rb
 - try/25_string_tryouts.rb
 - try/30_nometaclass_tryouts.rb
+- try/40_explicit_accessor_tryouts.rb
+- try/X1_metaclasses.rb
+- try/X2_extending.rb
 has_rdoc: true
 homepage: http://github.com/delano/attic
 licenses: []
@@ -45,7 +47,7 @@ post_install_message:
 rdoc_options: 
 - --line-numbers
 - --title
-- A place for Ruby objects to hide instance variables.
+- A place to hide private instance variables in your Ruby objects.
 - --main
 - README.rdoc
 require_paths: 
@@ -65,9 +67,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: attic
-rubygems_version: 1.3.2
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
-summary: A place for Ruby objects to hide instance variables.
+summary: A place to hide private instance variables in your Ruby objects.
 test_files: []
 

data/lib/attic/mixins/object.rb

@@ -1,67 +0,0 @@
-class NoMetaClass < RuntimeError
-end
-
-# = Object
-#
-# These methods are copied directly from _why's metaid.rb. 
-# See: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-class Object
-  
-  # An Array of classes which do not have metaclasses.
-  NOMETACLASS = [Symbol, Fixnum].freeze
-  
-  def metaclass?
-    #p [:metaclass?, self, !NOMETACLASS.member?(self)]
-    !NOMETACLASS.member?(self)
-  end
-  
-  # FIX: metaclass should check self or self.class? ??? Check previous version
-  
-  # A convenient method for getting the metaclass of the current object.
-  # i.e.
-  #
-  #     class << self; self; end;
-  #
-  # NOTE: Some Ruby class do not have meta classes (see: NOMETACLASS). 
-  # For these classes, this method returns the class itself. That means
-  # the instance variables will stored in the class itself. 
-  def metaclass
-    #p [:metaclass, self, self.class, self.class.metaclass?]
-    if !self.class.metaclass?
-      raise NoMetaClass, self
-    else
-      class << self; self; end; 
-    end
-  end
-
-  # Execute a block +&blk+ within the metaclass of the current object.
-  def meta_eval &blk; metaclass.instance_eval &blk; end
-  
-  # Add an instance method called +name+ to metaclass for the current object.
-  # This is useful because it will be available as a singleton method
-  # to all subclasses too. 
-  def meta_def name, &blk
-    meta_eval { define_method name, &blk }
-  end
-  
-  # Add a class method called +name+ for the current object's class. This
-  # isn't so special but it maintains consistency with meta_def. 
-  def class_def name, &blk
-    class_eval { define_method name, &blk }
-  end
-
-  
-  # A convenient method for getting the metaclass of the metaclass
-  # i.e.
-  #
-  #     self.metaclass.metaclass
-  #
-  def metametaclass; self.metaclass.metaclass; end
-
-  def metameta_eval &blk; metametaclass.instance_eval &blk; end
-
-  def metameta_def name, &blk
-    metameta_eval { define_method name, &blk }
-  end
-  
-end