attic 0.6.pre.RC1 → 0.9.0.pre.rc2

data/lib/attic.rb

@@ -1,157 +1,172 @@
 
-class NoMetaClass < RuntimeError
-end
-
-# = Object
-#
-# These methods are copied directly from _why's metaid.rb.
-# See: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
-class Object
+# Attic: A special place to store instance variables.
 
-  unless defined?(::Object::NOMETACLASS)
-    # An Array of classes which do not have metaclasses.
-    NOMETACLASS = [Symbol, Integer]
-  end
-
-  def nometaclass?
-    NOMETACLASS.member?(self)
-  end
+require_relative "attic/class_methods"
+require_relative "attic/errors"
+require_relative "attic/instance_methods"
 
-  def metaclass?
-    !NOMETACLASS.member?(self.class)
-  end
+# = Attic
+#
+# == Usage:
+#
+#  require 'attic'
+#  class MyClass
+#    include Attic
+#    attic :name, :age
+#  end
+#
+#  obj = MyClass.new
+#  obj.attic.nickname = 'My Classic Automobile'
+#  obj.attic.secret_age  = 27
+#
+#  obj.nickname      #=> 'My Classic Automobile'
+#  obj.secret_age    #=> 27
+#  obj.to_h          #=> {}
+#
+#    OR
+#
+#  require 'attic'
+#  Attic.construct MyClass, :nickname, :secret_age
+#
+#
+# == Description:
+#
+# Attic is a module that allows you to store instance variables
+# in a dedicated singleton class. This is useful for storing
+# instance variables that you don't want to be available to
+# the public interface of your class. e.g. you want to store
+# a value for the running instance but want to prevent it
+# from being serialized.
+#
+# == Why?
+#
+# == Important Notes:
+#
+# Some objects just straight up are not capable of contructing
+# an attic. `Symbols`, `Integers`, and `Floats` specifically do not
+# have a dedicated singleton classes. These are what ruby
+# internals refer to as "immediate values". They're special
+# in that they are not objects in the traditional sense.
+# They're just values (they're not even instances of a
+# class 😮‍💨).
+#
+# When you call attic on an immediate value you get an error.
+#
+# :sym.attic       #=> raises NoSingleton error
+# 1.attic          #=> Ditto
+# 1.0.1.attic      #=> Ditto again
+#
+#
+# The other objects that do not have singleton classes are
+# `true`, `false`, and `nil`. Calling attic on these don't
+# raise an error but they simply return their class. This
+# is because they are all instances of their same singleton
+# class.
+#
+# true.attic       #=> TrueClass
+# false.attic      #=> FalseClass
+# nil.attic        #=> NilClass
+#
+# Note: this means that every instance of nil
+# returns the exact same singleton class. This is different
+# from the behaviour of all other objects.
+#
+# nil.attic.object_id   #=> 800
+# nil.attic.object_id   #=> 800
+#
+#
+# NilClass, TrueClass, and FalseClass on the otherhand each
+# have their own singleton class. Calling attic on these
+# returns the singleton class for each of them. But again
+# a singleton class for each of them but again they all
+#
+# TrueClass.attic  #=> #<Class:TrueClass>
+# FalseClass.attic #=> #<Class:FalseClass>
+# NilClass.attic   #=> #<Class:NilClass>
+#
+#
+# For comparison, here's what happens with a String (each
+# time attic is called on a new string you get a new
+# singleton)
+#
+# "".attic         #=> #<Class:#<String:0x0001234>>
+# "".attic         #=> #<Class:#<String:0x0005678>>
+# "".attic.object_id #=> 1234
+# "".attic.object_id #=> 5678
+#
+# nil.attic        #=> NilClass
+# nil.attic        #=> NilClass
+# nil.attic.object_id #=> 800
+# nil.attic.object_id #=> 800
+#
+module Attic
+  VERSION = '0.9.0-RC1'.freeze unless defined?(VERSION)
+  attr_reader :all_attic_variables
 
-  # A convenient method for getting the metaclass of the current object.
-  # i.e.
+  # A convenince method at the class level for including
+  # ConstructMethods in the given object specifically.
   #
-  #     class << self; self; end;
+  #   e.g.
   #
-  # 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 be stored in the class itself.
-  def metaclass
-    if self.metaclass?
-      class << self
-        self
-      end
-    else
-      self
-    end
-  end
-
-  def metaclassfly
-    location = self.class
-    attr_name = "@@_attic_#{self.object_id}"
-    unless location.class_variable_defined? attr_name
-      location.class_variable_set attr_name, Class.new
-    end
-    location.class_variable_get attr_name
-  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.
+  #     Add Attic support to all objects available now and
+  #     in the future:
+  #
+  #       Attic.construct(Object)
   #
-  #     self.metaclass.metaclass
+  #     which is equivalent to:
   #
-  def metametaclass
-    self.metaclass.metaclass
+  #       class Object; include Attic::ClassMethods; end
+  #
+  def self.construct(obj)
+    obj.include Attic::ClassMethods
   end
 
-  def metameta_eval &blk
-    metametaclass.instance_eval blk
+  def self.included(obj)
+    raise Runtime, "Did you to `extend Attic`` in #{obj}"
   end
 
-  def metameta_def name, &blk
-    metameta_eval { define_method name, &blk }
-  end
-end
+  def self.extended(obj)
+    # If the class has already been extended, we don't need
+    # to add the class methods again.
+    return if obj.ancestors.member? self
 
+    # Add the instance methods for accessing attic variables
+    obj.send :include, Attic::InstanceMethods
 
+    # If the object doesn't have a dedicated singleton class
+    # an exception will be raised so it can be caught and
+    # handled appropriately.
+    obj.attic.instance_variable_defined?("@attic_variables")
 
-# = Attic
-#
-# A place to store instance variables.
-#
-module Attic
-  VERSION = '0.6-RC1' unless defined?(VERSION)
+    obj.attic.instance_variable_set("@attic_variables", [])
 
-  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
-      # binding.pry
-      metaclassfly.instance_variable_set("@___attic_#{n}", v)
+    def obj.inherited(klass)
+      super
+      attic_vars = self.attic_variables.clone
+      klass.attic.instance_variable_set("@attic_variables", attic_vars)
     end
-    def attic_variable_get(n)
-      metaclassfly.instance_variable_get("@___attic_#{n}")
-    end
-    def get_binding
-      binding
-    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
-
-    # Add the instance methods for accessing attic variables
-    o.send :include, Attic::InstanceMethods
-
-    o.metaclass.instance_variable_set("@attic_variables", [])
-    o.class_eval do
-      def self.inherited(o2)
-        attic_vars = self.attic_variables.clone
-        o2.metaclass.instance_variable_set("@attic_variables", attic_vars)
+    if method_defined? :instance_variables
+      instance_variables_orig = instance_method(:instance_variables)
+      define_method :instance_variables do
+        ret = _instance_variables_orig.bind(self).call.clone
+        ret.reject! { |v| v.to_s =~ /^@___?attic/ }  # match 2 or 3 underscores
+        ret
       end
-      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
+      define_method :all_instance_variables do
+        _instance_variables_orig.bind(self).call
       end
     end
+
+  rescue TypeError => e
+    raise NoSingleton, obj, caller
   end
 
   # A class method for defining variables to store in the attic.
-  # * +junk+ is a list of variables names. Accessor methods are
+  # * +names+ is a list of variables names. Accessor methods are
   #   created for each variable name in the list.
   #
-  # Returns the list of attic variable names or if not junk was
-  # given, returns the metaclass.
+  # Returns the list of attic variable names or if no names were
+  # given, returns the attic.
   #
   # e.g.
   #
@@ -162,24 +177,28 @@ module Attic
   # * <tt>String#timestamp</tt> for getting the value
   # * <tt>String#timestamp</tt> for setting the value
   #
-  def attic *junk
-    return metaclass if junk.empty?
-    junk.each do |name|
+  def attic(*names)
+    return all_attic_variables if names.empty?
+
+    names.each do |name|
       next if attic_variable? name
-      self.attic_variables << name
 
-      unless method_defined? name
+      self.all_attic_variables << name
+
+      unless method_defined?(name)
         define_method(name) do
           attic_variable_get name
         end
       end
-      unless method_defined? "#{name}="
+
+      unless method_defined?("#{name}=")
         define_method("#{name}=") do |val|
           attic_variable_set name, val
         end
       end
     end
-    attic_vars
+
+    all_attic_variables
   end
 
   # Returns an Array of attic variables for the current class.
@@ -189,18 +208,29 @@ module Attic
   #     String.attic :timestamp
   #     String.attic_variables     # => [:timestamp]
   #
-  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_variables
+  #   a = attic.instance_variable_get('@attic_variables')
+  #   a ||= attic.instance_variable_set('@attic_variables', [])
+  #   a
+  # end
+  # alias attic_vars attic_variables
 
-  def attic_variable?(n)
-    attic_variables.member? n
+  def attic_variable?(name)
+    attic_variables.member? name
   end
-
 end
 
 # - Module#instance_method returns an UnboundMethod
 #   - http://ruby-doc.org/core/classes/Module.html#M001659
+
+# Add some candy when we're in irb
+if defined?(IRB)
+  require 'irb/completion'
+  IRB.conf[:PROMPT][:ATTIC] = {
+    PROMPT_I: "attic> ",
+    PROMPT_S: "attic%l> ",
+    PROMPT_C: "attic* ",
+    RETURN:   "=> %s\n\n"
+  }
+  IRB.conf[:PROMPT_MODE] = :ATTIC
+end

data/try/01_mixins_tryouts.rb

@@ -0,0 +1,17 @@
+require 'attic'
+
+## has metaclass", 'Object' do
+if Tryouts.sysinfo.ruby.to_s == "1.9.1"
+  Object.new.metaclass.superclass.to_s
+else
+  'Object'
+end
+#=> 'Object'
+
+## has metametaclass", '#<Class:Object>' do
+if Tryouts.sysinfo.ruby.to_s >= "1.9.1"
+  Object.new.metaclass.superclass.to_s
+else
+  '#<Class:Object>'
+end
+#=> 'Object'

data/try/10_attic_tryouts.rb

@@ -0,0 +1,41 @@
+require 'attic'
+  
+## can extend Attic
+class ::Worker
+  extend Attic
+  def kind() :true end
+end
+# 1.9                             # 1.8
+Worker.methods.member?(:attic) || Worker.methods.member?('attic')
+#=> true
+  
+## can't include Attic raises exception
+begin
+  class ::Worker
+    include Attic
+  end
+rescue => RuntimeError
+  :success
+end
+#=> :success
+
+## can define attic attribute
+Worker.attic :size
+w = Worker.new
+#w.attic :size
+p Worker.instance_methods(false)
+p Worker.methods.sort
+w.respond_to? :size
+#=> true 
+  
+## can access attic attributes explicitly"
+w = Worker.new
+w.attic_variable_set :size, 2
+w.attic_variable_get :size
+#=> 2
+  
+## won't define a method if on already exists
+Worker.attic :kind
+a = Worker.new
+a.kind
+#=> :true

data/try/20_accessing_tryouts.rb

@@ -0,0 +1,29 @@
+require 'attic'
+class ::Worker
+  extend Attic
+  attic :size
+end
+
+  
+## save an instance variable the long way
+w = Worker.new
+w.metametaclass.instance_variable_set '@mattress', 'S&F'
+w.metametaclass.instance_variable_get '@mattress'
+#=> 'S&F'
+  
+## save an instance variable the short way
+w = Worker.new
+w.size = :california_king
+w.size
+#=> :california_king
+  
+## new instances don't cross streams
+w = Worker.new
+w.size
+#=> nil
+  
+## instance variables are hidden
+w = Worker.new
+w.metametaclass.instance_variable_set '@mattress', 'S&F'
+w.instance_variables
+## []

data/try/25_string_tryouts.rb

@@ -0,0 +1,32 @@
+require 'attic'
+
+## String can extend Attic
+    String.extend Attic
+    String.respond_to? :attic
+#=> true
+  
+## save an instance variable the long way
+s = ""
+s.metametaclass.instance_variable_set '@mattress', 'S&F'
+s.metametaclass.instance_variable_get '@mattress'
+#=> 'S&F'
+
+## can create attributes
+String.attic :goodies
+#=> [:goodies]
+  
+## save an instance variable the short way
+s = ""
+s.goodies = :california_king
+p s.instance_variables
+p s.attic_vars
+s.goodies
+#=> :california_king
+  
+## String instances don't cross streams
+String.extend Attic
+String.attic :name
+a = "any"
+a.name = :roger
+a.name == "".name
+#=> false

data/try/30_nometaclass_tryouts.rb

@@ -0,0 +1,68 @@
+require_relative "../lib/attic"
+
+Attic.construct Symbol #, :name
+
+## has list of no metaclass classes
+NoSingletonError::MEMBERS
+#=> [Symbol, Integer]
+
+# ## Symbol metaclass does not raise an exception
+# begin
+#   :any.attic.class
+# rescue NoSingletonError
+#   :failed
+# end
+# #=> :failed
+
+## Accessing Symbol metaclass raises an exception
+begin
+  :any.attic.class
+rescue NoSingletonError
+  :failed
+end
+#=> :failed
+
+## Symbol instances don't cross streams
+Symbol.extend Attic
+Symbol.attic :name
+a, b = :symbol1, :symbol2
+a.name = :roger
+[a.name, b.name]
+#=> [:roger, nil]
+
+## attic? method exists
+Symbol.extend Attic
+:any.respond_to? :attic?
+#=> true
+
+## attic? method is false for a Symbol", false do
+:any.attic?
+#=> false
+
+## 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
+#=> [:@___attic_name]
+
+## An Integer's attic vars appear in `all_instance_variables` do
+Integer.extend Attic
+Integer.attic :_name
+a, b = 1, 2
+a._name = :roger
+a.all_instance_variables
+#=> [:@___attic_name]
+
+## 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
+#=> []
+
+## knows attic variables, [:name] do
+Symbol.attic_variables
+#=> [:name]

data/try/40_explicit_accessor_tryouts.rb

@@ -0,0 +1,17 @@
+require 'attic'
+
+class ::Worker
+  extend Attic
+end
+  
+## can set value", 100 do
+a = Worker.new
+a.attic_variable_set :space, 100
+a.attic_variable_get :space
+#=> 100
+  
+## doesn't create accessor methods", false do
+a = Worker.new
+a.attic_variable_set :space, 100
+a.respond_to? :space
+#=> false

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]
+
+
+
+
+