key_struct 0.4.0 → 0.4.1

data/README.rdoc

@@ -134,6 +134,7 @@ Requires ruby >= 1.9.2.  (Has been tested on MRI 1.9.2 and MRI 1.9.3)
 
 Release Notes:
 
+* 0.4.1 - Cache anonymous classes to avoid TypeError: superclass mismatch.  Nicer strings for anonymous classes.  Internals change: use base class rather than metaprogramming.
 * 0.4.0 - Introduce class introspection
 * 0.3.1 - Bug fix: to_hash when a value is an array.  Was raising ArgumentError for Hash
 * 0.3.0 - Introduced to_s and inspect

data/lib/key_struct/key_struct.rb

@@ -1,11 +1,11 @@
 module KeyStruct
 
   def self.reader(*keys)
-    define_key_struct(:attr_reader, keys)
+    fetch_key_struct(:reader, keys)
   end
 
   def self.accessor(*keys)
-    define_key_struct(:attr_accessor, keys)
+    fetch_key_struct(:accessor, keys)
   end
 
   instance_eval do
@@ -14,51 +14,89 @@ module KeyStruct
 
   private
 
-  def self.define_key_struct(access, keys) 
-
-    defaults = (Hash === keys.last) ? keys.pop : {}
-    keys += defaults.keys
+  class Base
+    include Comparable
 
-    Class.new.tap{ |klass| klass.class_eval do
-      include Comparable
-      send access, *keys
-
-      define_singleton_method(:keys) { keys }
-      define_singleton_method(:defaults) { defaults }
+    class << self
+      attr_reader :keys, :defaults, :access
+    end
 
-      define_method(:initialize) do |args={}|
-        args = defaults.merge(args)
-        keys.each do |key|
-          instance_variable_set("@#{key}".to_sym, args.delete(key))
-        end
-        raise ArgumentError, "Invalid argument(s): #{args.keys.map(&:inspect).join(' ')} -- KeyStruct accepts #{keys.map(&:inspect).join(' ')}" if args.any?
+    def initialize(args={})
+      args = self.class.defaults.merge(args)
+      self.class.keys.each do |key|
+        instance_variable_set("@#{key}".to_sym, args.delete(key))
       end
+      raise ArgumentError, "Invalid argument(s): #{args.keys.map(&:inspect).join(' ')} -- KeyStruct accepts #{self.class.keys.map(&:inspect).join(' ')}" if args.any?
+    end
 
-      define_method(:==) do |other|
-        keys.all?{|key| other.respond_to?(key) and self.send(key) == other.send(key)}
-      end
+    def ==(other)
+      self.class.keys.all?{|key| other.respond_to?(key) and self.send(key) == other.send(key)}
+    end
 
-      define_method(:<=>) do |other|
-        keys.each do |key|
-          cmp = (self.send(key) <=> other.send(key))
-          return cmp unless cmp == 0
-        end
-        0
+    def <=>(other)
+      self.class.keys.each do |key|
+        cmp = (self.send(key) <=> other.send(key))
+        return cmp unless cmp == 0
       end
+      0
+    end
 
-      define_method(:to_hash) do
-        Hash[*keys.map{ |key| [key, self.send(key)]}.flatten(1)]
-      end
+    def to_hash
+      Hash[*self.class.keys.map{ |key| [key, self.send(key)]}.flatten(1)]
+    end
 
-      define_method(:to_s) do
-        "[#{self.class.name} #{keys.map{|key| "#{key}:#{self.send(key)}"}.join(' ')}]"
-      end
+    def to_s
+      "[#{self.class.display_name} #{self.class.keys.map{|key| "#{key}:#{self.send(key)}"}.join(' ')}]"
+    end
 
-      define_method(:inspect) do
-        "<#{self.class.name}:0x#{self.object_id.to_s(16)} #{keys.map{|key| "#{key}:#{self.send(key).inspect}"}.join(' ')}>"
-      end
+    def inspect
+      "<#{self.class.display_name}:0x#{self.object_id.to_s(16)} #{self.class.keys.map{|key| "#{key}:#{self.send(key).inspect}"}.join(' ')}>"
+    end
 
+    def self.display_name
+      self.name || "KeyStruct.#{access}"
     end
+  end
+
+
+  # for anonymous superclasses, such as
+  #
+  #    class Foo < KeyStruct[:a, :b]
+  #    end
+  #
+  #  we want to be sure that if the code gets re-executed (e.g. the file
+  #  gets loaded twice) the superclass will be the same object otherwise
+  #  ruby will raise a TypeError: superclass mismatch.  So keep a cache of
+  #  anonymous KeyStructs
+  #
+  #  But don't reuse the class if it has a name, i.e. if it was assigned to
+  #  a constant.  If somebody does
+  #
+  #     Foo = KeyStruct[:a, :b]
+  #     Bar = KeyStruct[:a, :b]
+  #
+  #  they should get different class definitions, in particular because the
+  #  classname is used in #to_s and #inspect
+  #
+  def self.fetch_key_struct(access, keys)
+    @cache ||= {}
+    signature = [access, keys]
+    @cache.delete(signature) if @cache[signature] and @cache[signature].name
+    @cache[signature] ||= define_key_struct(access, keys)
+  end
+
+  def self.define_key_struct(access, keys) 
+    keys = keys.dup
+    defaults = (Hash === keys.last) ? keys.pop.dup : {}
+    keys += defaults.keys
+
+    Class.new(Base).tap{ |klass|
+      klass.class_eval do
+        @keys = keys
+        @defaults = defaults
+        @access = access
+        send "attr_#{access}", *keys
+      end
     }
   end
 

data/lib/key_struct/version.rb

@@ -1,3 +1,3 @@
 module KeyStruct
-  VERSION = "0.4.0"
+  VERSION = "0.4.1"
 end

data/spec/key_struct_spec.rb

@@ -51,6 +51,42 @@ shared_examples "a keystruct" do |method|
 
   end
 
+  context "definition" do
+    it "can handle a default that's an array" do
+      expect { KeyStruct.send(method, :a => []) }.should_not raise_error
+    end
+
+    it "reuses existing anonymous class definition" do
+      k = KeyStruct.send(method, :a, :b => 3)
+      j = KeyStruct.send(method, :a, :b => 3)
+      k.should equal j
+    end
+
+    it "does not reuse non-anonymous class definition" do
+      begin
+        K = KeyStruct.send(method, :a, :b => 3)
+        j = KeyStruct.send(method, :a, :b => 3)
+        K.should_not equal j
+      ensure
+        Object.send(:remove_const, :K)
+      end
+    end
+
+  end
+
+  context "returning hash" do
+
+    it "returns hash using to_hash" do
+      KeyStruct.send(method, :a => 3, :b => 4).new.to_hash.should == {:a => 3, :b => 4}
+    end
+
+    it "returns hash using to_hash when value is array" do
+      KeyStruct.send(method, :a => 3, :b => [[1,2], [3,4]]).new.to_hash.should == {:a => 3, :b => [[1,2],[3,4]]}
+    end
+
+  end
+
+
   context "comparison" do
 
     before(:each) do 
@@ -84,35 +120,43 @@ shared_examples "a keystruct" do |method|
 
   end
 
-  it "returns hash using to_hash" do
-    KeyStruct.send(method, :a => 3, :b => 4).new.to_hash.should == {:a => 3, :b => 4}
-  end
 
-  it "returns hash using to_hash when value is array" do
-    KeyStruct.send(method, :a => 3, :b => [[1,2], [3,4]]).new.to_hash.should == {:a => 3, :b => [[1,2],[3,4]]}
-  end
+  context "string display" do
 
-  it "can handle a default that's an array" do
-    expect { KeyStruct.send(method, :a => []) }.should_not raise_error
-  end
+    context "when anonymous" do
 
-  context "display as a string" do
+      before(:each) do
+        @klass = KeyStruct.send(method, :a => 3, :b => "hello")
+      end
 
-    around(:each) do |example|
-      PrintMe = @klass = KeyStruct.send(method, :a => 3, :b => "hello")
-      example.run
-      Object.send(:remove_const, :PrintMe)
-    end
+      it "should be nice for :to_s" do
+        @klass.new.to_s.should == "[KeyStruct.#{method} a:3 b:hello]"
+      end
 
-    it "should be nice for :to_s" do
-      @klass.new.to_s.should == "[PrintMe a:3 b:hello]"
+      it "should be detailed for :inspect" do
+        @klass.new.inspect.should match /<KeyStruct.#{method}:0x[0-9a-f]+ a:3 b:"hello">/
+      end
     end
 
-    it "should be detailed for :inspect" do
-      @klass.new.inspect.should match /<PrintMe:0x[0-9a-f]+ a:3 b:"hello">/
+    context "when named" do
+      around(:each) do |example|
+        PrintMe = @klass = KeyStruct.send(method, :a => 3, :b => "hello")
+        example.run
+        Object.send(:remove_const, :PrintMe)
+      end
+
+      it "should be nice for :to_s" do
+        @klass.new.to_s.should == "[PrintMe a:3 b:hello]"
+      end
+
+      it "should be detailed for :inspect" do
+        @klass.new.inspect.should match /<PrintMe:0x[0-9a-f]+ a:3 b:"hello">/
+      end
     end
+
   end
 
+
 end
 
 describe "KeyStruct" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: key_struct
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.4.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-05-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70338235182700 !ruby/object:Gem::Requirement
+  requirement: &70230512662240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70338235182700
+  version_requirements: *70230512662240
 - !ruby/object:Gem::Dependency
   name: simplecov
-  requirement: &70338235177160 !ruby/object:Gem::Requirement
+  requirement: &70230512661380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70338235177160
+  version_requirements: *70230512661380
 - !ruby/object:Gem::Dependency
   name: simplecov-gem-adapter
-  requirement: &70338235172560 !ruby/object:Gem::Requirement
+  requirement: &70230512660520 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70338235172560
+  version_requirements: *70230512660520
 description: Defines KeyStruct analogous to Struct, but constructor takes keyword
   arguments
 email: