attic 0.6.pre.RC1 → 1.0.0.pre.RC2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cab1b37cf99fda2d7f47b898c998af908e2c8f4dcdde31ae66cd34d7c337a993
-  data.tar.gz: 7d579f1320f3493b6639705d316aaf1197f77aa20894ecff84abd0a34a162124
+  metadata.gz: 65eaa51d7ee74a1e97bef40a3cdb0c6cb8c78ca29e0cd8f8bb55e0cba641f664
+  data.tar.gz: fbc75d2a1063522b54edfc6d608a2f4599ac2b34c39a92aa400b138138f19cd8
 SHA512:
-  metadata.gz: 920f145e1b3eb27151653a69be076fe3224c82e2781695209e2017ac4634708855dc0331ad254a9765bd185f25e566b1c6a712bc6118668c201ec0fa240239fc
-  data.tar.gz: e0e4204bd76ae3f76c7c3a51166c278f69b2152db651a2ccd28ce8d559f281bfbf18e253713608fad2d9d488b96f52d3397070de7cc606842c3f47971db1276a
+  metadata.gz: 2a54f4d47b2aa70d9a8d6ee30578d5c06360e9e5c2ffd3c5dfa196086b40122dfee3d84b079cbabd9a24076262b8d8b4521d50a649fe111c3f8f3b80d20945da
+  data.tar.gz: b06ab0a4a824c1536046f4d36ee0a42ce0e5315e214ef398955cf45f7046c56937d93333102044a1a4607fbe4780dd176d0377569126320e81f623c220527c16

data/.gitignore

@@ -0,0 +1,18 @@
+.DS_Store
+.bundle
+.byebug*
+.history
+.devcontainer
+.vscode
+*.env
+*.log
+*.md
+*.txt
+!LICENSE.txt
+.ruby-version
+appendonlydir
+Gemfile.lock
+etc/config
+log
+tmp
+vendor

data/.rubocop.yml

@@ -0,0 +1,28 @@
+AllCops:
+  NewCops: enable
+  TargetRubyVersion: 3.1, 3.2
+  EnabledByDefault: false
+
+Style/StringLiterals:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  Enabled: true
+  EnforcedStyle: double_quotes
+
+Layout/LineLength:
+  Enabled: true
+  Max: 120
+
+Metrics/CyclomaticComplexity:
+  Enabled: false
+
+Layout/HashAlignment:
+  Enabled: false
+
+Lint/Void:
+  Enabled: false
+
+Metrics/MethodLength:
+  Enabled: false

data/Gemfile

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+source "https://rubygems.org"
+
+ruby '>= 3.1'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+# bundle install --without production
+# bundle install --with development
+# bundle install --without development
+group "development" do
+  gem "byebug"
+  gem "pry"
+  gem "pry-doc"
+  gem "rubocop"
+  gem "tryouts", '2.2.0.pre.RC1'
+end

data/Gemfile.lock

@@ -0,0 +1,62 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ast (2.4.2)
+    byebug (11.1.3)
+    coderay (1.1.3)
+    drydock (0.6.9)
+    json (2.7.2)
+    language_server-protocol (3.17.0.3)
+    method_source (1.0.0)
+    parallel (1.24.0)
+    parser (3.3.0.5)
+      ast (~> 2.4.1)
+      racc
+    pry (0.14.2)
+      coderay (~> 1.1)
+      method_source (~> 1.0)
+    pry-doc (1.5.0)
+      pry (~> 0.11)
+      yard (~> 0.9.11)
+    racc (1.7.3)
+    rainbow (3.1.1)
+    regexp_parser (2.9.0)
+    rexml (3.2.6)
+    rubocop (1.62.1)
+      json (~> 2.3)
+      language_server-protocol (>= 3.17.0)
+      parallel (~> 1.10)
+      parser (>= 3.3.0.2)
+      rainbow (>= 2.2.2, < 4.0)
+      regexp_parser (>= 1.8, < 3.0)
+      rexml (>= 3.2.5, < 4.0)
+      rubocop-ast (>= 1.31.1, < 2.0)
+      ruby-progressbar (~> 1.7)
+      unicode-display_width (>= 2.4.0, < 3.0)
+    rubocop-ast (1.31.2)
+      parser (>= 3.3.0.4)
+    ruby-progressbar (1.13.0)
+    storable (0.10.pre.RC1)
+    sysinfo (0.9.0.pre.RC1)
+      drydock (< 1.0)
+      storable (= 0.10.pre.RC1)
+    tryouts (2.2.0.pre.RC1)
+      sysinfo (= 0.9.0.pre.RC1)
+    unicode-display_width (2.5.0)
+    yard (0.9.36)
+
+PLATFORMS
+  arm64-darwin-22
+
+DEPENDENCIES
+  byebug
+  pry
+  pry-doc
+  rubocop
+  tryouts (= 2.2.0.pre.RC1)
+
+RUBY VERSION
+   ruby 3.2.0p0
+
+BUNDLED WITH
+   2.4.12

data/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2009-2024 delano
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,54 +1,146 @@
-# Attic - v0.6-RC1 (2021-07-01)
+# Attic - v1.0-RC1 (2024-04-01)
 
-A place to hide private instance variables in your Ruby objects.
+A place to hide private instance variables in your Ruby objects: in the attic.
+
+## Description
+
+Attic is a Ruby library that provides a place to hide private instance variables in your Ruby objects: in the attic.
+
+Like, _why though_? Well sometimes you want to hide thing from the public interface of your object. You could use the `@@` prefix to place them at the class level but then you can't use them on a per-instance basis without creating a new data structure to store them. Attic does this for you in a transparent way using the Ruby singleton classes that are already there**.
+
+
+### Example
 
-## Example
 
 ```ruby
     require 'attic'
 
+    # Extend a class with Attic
     class String
       extend Attic
+
+      # Add an instance variable to the attic. All instances
+      # of this class will have this variable available.
       attic :timestamp
     end
 
-    a = "anything"
-    a.timestamp = "1980-11-18"
+    # Instantiate a new String object
+    a = "A lovely example of a string"
+
+    # Set and get the timestamp
+    a.timestamp = "1990-11-18"
+    a.timestamp                               # => "1990-11-18"
+
+    # The timestamp is not visible in the public interface
     a.instance_variables                      # => []
-    a.timestamp                               # 1980-11-18
 
+    # But it is available in the attic
     a.attic_variables                         # => [:timestamp]
 
+    # If you prefer getting your hands dirty, you can also
+    # interact with the attic at a lower level.
     a.attic_variable_set :tags, [:a, :b, :c]
-    a.attic_variable_get :tags                # [:a, :b, :c]
+    a.attic_variable_get :tags                # => [:a, :b, :c]
 
+    # Looking at the attic again shows that the timestamp
+    # is still there too.
     a.attic_variables                         # => [:timestamp, :tags]
 ```
 
-## Some objects have no metaclasses
 
-Symbol objects do not have metaclasses so instance variables are hidden in the object itself.
+### **Objects without singleton classes
 
+Symbol, Integer, Float, TrueClass, FalseClass, NilClass, and Integer are all objects that do not have singleton classes. TrueClass, FalseClass, and NilClass are all singletons themselves. Integer is a singleton of Integer.
 
-## Installation
+These objects do not have metaclasses so the attic is hidden in the object itself.
+
+### Explore in irb
+
+```shell
+    $ irb -r attic
+```
+
+---
 
-Via Rubygems, one of:
+## Installation
 
 ```shell
     $ gem install attic
 ```
 
+```shell
+    $ bundle install attic
+```
+
 or via download:
-* attic-latest.tar.gz[http://github.com/delano/attic/tarball/latest]
-* attic-latest.zip[http://github.com/delano/attic/zipball/latest]
+* [attic-latest.tar.gz](https://github.com/delano/attic/tarball/latest)
+* [attic-latest.zip](https://github.com/delano/attic/zipball/latest)
+
+
+## Proofs
 
+Tested the following code in IRB for Ruby 2.6.8 and 3.0.2:
 
-## Credits
+```ruby
+    rquire 'pp'
+
+    test_values = [:sym, 1, 1.01, Symbol, Integer, Float, String, TrueClass, FalseClass, NilClass, '', true, false, nil]
 
-* `gems@solutious.com` (@delano)
+    results = test_values.map do |value|
+      { value: value,
+        class: value.class,
+        attic: [value.attic?, value.attic? && value.attic.object_id] }
+    end
+```
+
+which produced the same results for both.
+
+```ruby
+    attic> RUBY_VERSION
+    => "3.2.0"
+
+    pp results
+    [
+      {:value=>:sym,        :class=>Symbol,       :attic=>[false, false]},
+      {:value=>1,           :class=>Integer,      :attic=>[false, false]},
+      {:value=>1.01,        :class=>Float,        :attic=>[false, false]},
+      {:value=>Symbol,      :class=>Class,        :attic=>[true, 564680]},
+      {:value=>Integer,     :class=>Class,        :attic=>[true, 564700]},
+      {:value=>Float,       :class=>Class,        :attic=>[true, 564720]},
+      {:value=>String,      :class=>Class,        :attic=>[true, 564740]},
+      {:value=>TrueClass,   :class=>Class,        :attic=>[true, 564760]},
+      {:value=>FalseClass,  :class=>Class,        :attic=>[true, 564780]},
+      {:value=>NilClass,    :class=>Class,        :attic=>[true, 564800]},
+      {:value=>"",          :class=>String,       :attic=>[true, 602880]}
+      {:value=>true,        :class=>TrueClass,    :attic=>[true, 13840]},
+      {:value=>false,       :class=>FalseClass,   :attic=>[true, 13860]},
+      {:value=>nil,         :class=>NilClass,     :attic=>[true, 40]}
+    ]
+```
+```ruby
+    attic> RUBY_VERSION
+    => "2.6.8"
+
+    pp results
+    [
+      {:value=>:sym,        :class=>Symbol,       :attic=>[false, false]},
+      {:value=>1,           :class=>Integer,      :attic=>[false, false]},
+      {:value=>1.01,        :class=>Float,        :attic=>[false, false]},
+      {:value=>Symbol,      :class=>Class,        :attic=>[true, 2844115920]},
+      {:value=>Integer,     :class=>Class,        :attic=>[true, 2844089400]},
+      {:value=>Float,       :class=>Class,        :attic=>[true, 2844087700]},
+      {:value=>String,      :class=>Class,        :attic=>[true, 2844122580]},
+      {:value=>TrueClass,   :class=>Class,        :attic=>[true, 2844136260]},
+      {:value=>FalseClass,  :class=>Class,        :attic=>[true, 2844136000]},
+      {:value=>NilClass,    :class=>Class,        :attic=>[true, 2844139060]},
+      {:value=>"",          :class=>String,       :attic=>[true, 2845261220]},
+      {:value=>true,        :class=>TrueClass,    :attic=>[true, 2844136280]},
+      {:value=>false,       :class=>FalseClass,   :attic=>[true, 2844136020]},
+      {:value=>nil,         :class=>NilClass,     :attic=>[true, 2844139080]}
+    ]
+```
 
 
 ## License
 
 MIT
-

data/attic.gemspec

@@ -1,20 +1,23 @@
-@spec = Gem::Specification.new do |s|
-	s.name = "attic"
-	s.version = "0.6-RC1"
-	s.summary = "When in doubt, store it in the attic"
-	s.description = "Attic: a place to hide metadata about the class or variable itself (e.g. SHA hash summaries)."
-	s.author = "Delano Mandelbaum"
-	s.email = "gems@solutious.com"
-	s.homepage = "http://github.com/delano/attic"
-  s.executables = %w[]
-  s.require_paths = %w[lib]
-  s.extra_rdoc_files = %w[README.md]
-  s.licenses = ["MIT"]  # https://spdx.org/licenses/MIT-Modern-Variant.html
-  s.rdoc_options = ["--line-numbers", "--title", s.summary, "--main", "README.md"]
-  s.files = %w(
-    README.md
-    Rakefile
-    attic.gemspec
-    lib/attic.rb
-  )
+Gem::Specification.new do |s|
+  s.name        = "attic"
+  s.version     = "1.0.0-RC2"
+  s.summary     = "When in doubt, store it in the attic"
+  s.description = "Attic: a place to hide metadata about the class or variable itself (e.g. SHA hash summaries)."
+  s.authors     = ["Delano Mandelbaum"]
+  s.email       = "gems@solutious.com"
+  s.homepage    = "https://github.com/delano/attic"
+  s.license     = "MIT"
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = "exe"
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.required_ruby_version = Gem::Requirement.new(">= 2.6.0")
+
+  s.add_dependency "rake", ">= 13.0.6"
+
+  # Add development dependencies
+  s.add_development_dependency "rspec", "~> 3.0"
+  s.add_development_dependency "rubocop", "~> 1.0"
 end

data/lib/attic/class_methods.rb

@@ -0,0 +1,66 @@
+#
+# = Attic::ClassMethods
+#
+module Attic
+  # Adds a few methods for accessing the metaclass of an
+  # object. We do this with great caution since the Object
+  # class is as global as it gets in Ruby.
+  module ClassMethods
+    # A list of all the attic variables defined for this class.
+    attr_reader :attic_variables
+
+    # A quick way to check if the current object already has a
+    # dedicated singleton class. We want to know this because
+    # this is where our attic variables will be stored.
+    def attic?
+      return false if NoSingletonError.member? self
+
+      # NOTE: Calling this on an object for the first time lazily
+      # creates a singleton class for itself. Another way of doing
+      # the same thing is to attempt defining a singleton method
+      # for the object. In either case, objects that cannot have
+      # cannot have a dedicated singleton class (e.g. nil, true,
+      # false) will raise a TypeError. We rescue this and add the
+      # object to the NoSingletonError list so we don't keep
+      # trying to access its singleton class over and over.
+      !singleton_class.nil?
+
+    rescue TypeError
+      # Remember for next time.
+      NoSingletonError.add_member self
+      false
+    end
+
+    def attic(name=nil)
+      return singleton_class if name.nil?
+
+      name = name.normalize
+
+      self.attic_variables << name unless attic_variable? name
+
+      safe_name = "@_attic_#{name}"
+      instance_variable_set(safe_name, name)
+    end
+
+    def attic_variable?(name)
+      attic_variables.include? name.normalize
+    end
+
+    def attic_variable_set(name, val)
+      unless attic_variable? name
+        attic_variables << name.normalize
+      end
+      attic.instance_variable_set("@_attic_#{name}", val)
+    end
+
+    def attic_variable_get(name)
+      instance_variable_get("@_attic_#{name}")
+    end
+
+    protected
+
+    def normalize(name)
+      name.to_s.gsub(/\@[\?\!\=]$/, '_').to_sym
+    end
+  end
+end

data/lib/attic/core_ext.rb

@@ -0,0 +1,70 @@
+
+class NoMetaClass < RuntimeError
+end
+
+# = Object
+#
+# These methods are copied directly from _why's metaid.rb.
+# See: http://whytheluckystiff.net/articles/seeingMetaclassesClearly.html
+class Object
+
+  unless defined?(::Object::NOMETACLASS)
+    # An Array of classes which do not have metaclasses.
+    NOMETACLASS = [Symbol, Integer].freeze
+  end
+
+  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/lib/attic/errors.rb

@@ -0,0 +1,52 @@
+
+# Attic: A special place to store instance variables.
+
+class NoMetaClass < RuntimeError
+end
+
+# = NoSingletonError
+#
+# This error is raised when an attempt is made to access the
+# attic of an object which does not have a singleton class.
+#
+# This is a TypeError because it is not an exceptional
+# condition. It is simply a condition that is not supported
+# by the Attic module.
+#
+# == Usage
+#
+#   require 'attic'
+#   class MyClass
+#     include Attic
+#     attic :name, :age
+#   end
+#
+class NoSingletonError < TypeError
+  unless defined?(MEMBERS)
+    # A Set of classes which do not have singleton classes
+    # (i.e. meta classes). This is used to prevent an exception
+    # the first time an attic is accessed. It's populated
+    # dynamically at start time by simply checking whether
+    # the object has a singleton. This only needs to be
+    # done once per class.
+    #
+    # We use a set here to avoid having to deal with duplicate
+    # values. Realistically there are only a few classes that
+    # do not have singleton classes. We could hard code them
+    # here which is not lost on us.
+    #
+    MEMBERS = Set.new
+  end
+
+  # Check if the given object is a member of the NoSingleton
+  # members list. This checks for the object itself and all
+  # of its ancestors. See the docs for `Enumerable#===` for
+  # more details.
+  def self.member?(obj)
+    MEMBERS === obj
+  end
+
+  def self.add_member(obj)
+    MEMBERS.merge [self]
+  end
+end

data/lib/attic/instance_methods.rb

@@ -0,0 +1,36 @@
+#
+
+# = Attic::InstanceMethods
+#
+module Attic
+  # Adds a few methods for object instances to access the
+  # attic variables of their class.
+  module InstanceMethods
+
+    def attic
+      raise NoSingleton, self, caller unless attic?
+
+      singleton_class
+
+    rescue TypeError
+      NoSingleton.add_member self
+    end
+
+    def attic_variables
+      self.class.attic_variables
+    end
+
+    def attic_variable?(name)
+      self.class.attic_variable? name
+    end
+
+    def attic_variable_set(name, val)
+      attic_variables << name unless attic_variable? name
+      attic.instance_variable_set("@___attic_#{name}", val)
+    end
+
+    def attic_variable_get(name)
+      attic.instance_variable_get("@___attic_#{name}")
+    end
+  end
+end

data/lib/attic.rb

@@ -1,157 +1,174 @@
 
-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)
 
-  # 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
+  # Friendly exception to say we're not to be included
+  #
+  def self.included(obj)
+    raise RuntimeError, "Did you mean 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
+    def obj.inherited(klass)
+      super
+      attic_vars = self.attic_variables.clone
+      klass.attic.instance_variable_set("@attic_variables", attic_vars)
     end
-    def attic_variable_set(n,v)
-      attic_variables << n unless attic_variable? n
-      # binding.pry
-      metaclassfly.instance_variable_set("@___attic_#{n}", v)
-    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 an Array of all attic variables for the current
+  # class unless no arguments are given in which case it
+  # returns its singleton.
   #
   # e.g.
   #
@@ -162,24 +179,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 singleton_class if names.empty?
+
+    names.each do |name|
       next if attic_variable? name
+
       self.attic_variables << name
 
-      unless method_defined? 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
+
+    attic_variables  # only after defining new attic vars
   end
 
   # Returns an Array of attic variables for the current class.
@@ -190,17 +211,27 @@ module Attic
   #     String.attic_variables     # => [:timestamp]
   #
   def attic_variables
-    a = self.metaclass.instance_variable_get("@attic_variables")
-    a ||= self.metaclass.instance_variable_set("@attic_variables", [])
+    a = attic.instance_variable_get('@attic_variables')
+    a ||= attic.instance_variable_set('@attic_variables', [])
     a
   end
-  alias_method :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,65 @@
+require_relative '../lib/attic'
+
+#
+# Tests for the Object mixins that Attic relies on.
+#
+
+## Has a valid NoMetaClass exception class
+NoMetaClass < RuntimeError
+#=> true
+
+## Has a pre-populated array of built-ins without a metaclass
+begin
+    Object::NOMETACLASS
+rescue NameError => e
+    e.class
+end
+#=> NameError
+
+## Has Object#metaclass method
+Object.new.respond_to? :metaclass
+#=> false
+
+## Has Object#singleton_class method
+Object.new.respond_to? :singleton_class
+#=> true
+
+## Object#singleton_class is a class
+Object.new.singleton_class.class
+#=> Class
+
+## Object#singleton_class is a class
+Object.new.singleton_class.object_id.class
+#=> Integer
+
+## Object#singleton_class is a class
+a = Object.new
+b = Object.new
+a.singleton_class.object_id == b.singleton_class.object_id
+#=> false
+
+## Object#singleton_class is an Object class
+Object.new.singleton_class.superclass
+#=> Object
+
+## Object#singleton_class is equivalent to `class << self; self; end;`
+a = Object.new
+a.singleton_class == (class << a; self; end)
+#=> true
+
+## Integer doesn't have a singleton_class
+Integer.singleton_class?
+#=> false
+
+## Symbol doesn't have a singleton_class
+Symbol.singleton_class?
+#=> false
+
+## Object has a singleton_class
+Object.singleton_class?
+#=> false
+
+## Object#singleton_class is equivalent to Object#singleton_class
+a = Object.new
+a.singleton_class == a.singleton_class
+#=> true

data/try/10_attic_tryouts.rb

@@ -0,0 +1,51 @@
+require_relative '../lib/attic'
+
+#
+# Tests for the Attic module
+#
+
+## A class we define can extend Attic
+class ::ExampleClass
+  extend Attic
+  def kind() :unlikely_value end
+end
+ExampleClass.methods.member?(:attic)
+#=> true
+
+## Trying to include Attic raises an exception
+begin
+  class ::ExampleClass
+    include Attic
+  end
+rescue => e
+  e.class
+end
+#=> RuntimeError
+
+## Can define attic variables at class level
+ExampleClass.attic :size
+w = ExampleClass.new
+w.respond_to? :size
+#=> true
+
+## Accessing attic vars at the instance level fails
+begin
+  w = ExampleClass.new
+  w.attic :size, 2
+rescue => e
+  e.class
+end
+#=> NoMethodError
+
+## Can access attic vars the long way though
+w = ExampleClass.new
+w.attic_variable_set :size, 2
+w.attic_variable_get :size
+#=> 2
+
+## Won't clobber an existing method with the same name
+## NOTE: But also won't tell you it didn't define the method
+ExampleClass.attic :kind
+a = ExampleClass.new
+a.kind
+#=> :unlikely_value

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

metadata

@@ -1,53 +1,104 @@
 --- !ruby/object:Gem::Specification
 name: attic
 version: !ruby/object:Gem::Version
-  version: 0.6.pre.RC1
+  version: 1.0.0.pre.RC2
 platform: ruby
 authors:
 - Delano Mandelbaum
-autorequire: 
-bindir: bin
+autorequire:
+bindir: exe
 cert_chain: []
-date: 2021-07-22 00:00:00.000000000 Z
-dependencies: []
+date: 2024-04-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 13.0.6
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
 description: 'Attic: a place to hide metadata about the class or variable itself (e.g.
   SHA hash summaries).'
 email: gems@solutious.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- README.md
+extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rubocop.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
 - README.md
 - Rakefile
 - attic.gemspec
 - lib/attic.rb
-homepage: http://github.com/delano/attic
+- lib/attic/class_methods.rb
+- lib/attic/core_ext.rb
+- lib/attic/errors.rb
+- lib/attic/instance_methods.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
+homepage: https://github.com/delano/attic
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
-rdoc_options:
-- "--line-numbers"
-- "--title"
-- When in doubt, store it in the attic
-- "--main"
-- README.md
+post_install_message:
+rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.6.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">"
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.2.21
-signing_key: 
+rubygems_version: 3.4.12
+signing_key:
 specification_version: 4
 summary: When in doubt, store it in the attic
 test_files: []