faster_open_struct 0.1

data/README.md

@@ -0,0 +1,15 @@
+## Faster::OpenStruct
+
+Up to 40 (!) times more memory efficient version of OpenStruct
+
+Differences from Ruby MRI OpenStruct:
+
+1. Doesn't `dup` passed initialization hash (NOTE: only reference to hash is stored)
+
+2. Doesn't convert hash keys to symbols (by default string keys are used,
+   with fallback to symbol keys)
+
+3. Creates methods on the fly on `OpenStruct` class, instead of singleton class.
+   Uses `module_eval` with string to avoid holding scope references for every method.
+
+4. Refactored, crud clean, spec covered :)

data/lib/faster_open_struct.rb

@@ -0,0 +1,116 @@
+module Faster
+  # ## Faster::OpenStruct
+  #
+  # Up to 40 (!) times more memory efficient version of OpenStruct
+  #
+  # Differences from Ruby MRI OpenStruct:
+  #
+  # 1. Doesn't `dup` passed initialization hash (NOTE: only reference to hash is stored)
+  #
+  # 2. Doesn't convert hash keys to symbols (by default string keys are used,
+  #    with fallback to symbol keys)
+  #
+  # 3. Creates methods on the fly on `OpenStruct` class, instead of singleton class.
+  #    Uses `module_eval` with string to avoid holding scope references for every method.
+  #
+  # 4. Refactored, crud clean, spec covered :)
+  #
+  class OpenStruct
+    # Undefine particularly nasty interfering methods on Ruby 1.8
+    undef :type if method_defined?(:type)
+    undef :id if method_defined?(:id)
+    
+    def initialize(hash = nil)
+      @hash = hash || {}
+      @initialized_empty = hash == nil
+    end
+
+    def method_missing(method_name_sym, *args)
+      if method_name_sym.to_s[-1] == ?=
+        if args.size != 1
+          raise ArgumentError, "wrong number of arguments (#{args.size} for 1)", caller(1)
+        end
+
+        if self.frozen?
+          raise TypeError, "can't modify frozen #{self.class}", caller(1)
+        end
+
+        __new_ostruct_member__(method_name_sym.to_s.chomp("="))
+        send(method_name_sym, args[0])
+      elsif args.size == 0
+        __new_ostruct_member__(method_name_sym)
+        send(method_name_sym)
+      else
+        raise NoMethodError, "undefined method `#{method_name_sym}' for #{self}", caller(1)
+      end
+    end
+
+    def __new_ostruct_member__(method_name_sym)
+      self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+      def #{ method_name_sym }
+        @hash.fetch("#{ method_name_sym }", @hash[:#{ method_name_sym }]) # read by default from string key, then try symbol
+                                                                          # if string key doesn't exist
+      end
+      END_EVAL
+
+      unless method_name_sym.to_s[-1] == ?? # can't define writer for predicate method
+        self.class.module_eval <<-END_EVAL, __FILE__, __LINE__ + 1
+        def #{ method_name_sym }=(val)
+          if @hash.key?("#{ method_name_sym }") || @initialized_empty       # write by default to string key (when it is present
+                                                                            # in initialization hash or initialization hash
+                                                                            # wasn't provided)
+            @hash["#{ method_name_sym }"] = val                             # if it doesn't exist - write to symbol key
+          else
+            @hash[:#{ method_name_sym }] = val
+          end
+        end
+        END_EVAL
+      end
+    end
+
+    def empty?
+      @hash.empty?
+    end
+
+    #
+    # Compare this object and +other+ for equality.
+    #
+    def ==(other)
+      return false unless other.is_a?(self.class)
+      @hash == other.instance_variable_get(:@hash)
+    end
+
+    InspectKey = :__inspect_key__ # :nodoc:    
+
+    #
+    # Returns a string containing a detailed summary of the keys and values.
+    #
+    def inspect
+      str = "#<#{ self.class }"
+      str << " #{ @hash.map { |k, v| "#{ k }=#{ v.inspect }" }.join(", ") }" unless @hash.empty?
+      str << ">"
+    end
+
+    def inspect_with_reentrant_guard(default = "...")
+      Thread.current[InspectKey] ||= []
+
+      if Thread.current[InspectKey].include?(self)
+        return default # reenter detected
+      end
+
+      Thread.current[InspectKey] << self
+
+      begin
+        inspect_without_reentrant_guard
+      ensure
+        Thread.current[InspectKey].pop
+      end
+    end
+
+    alias_method :inspect_without_reentrant_guard, :inspect
+    alias_method :inspect, :inspect_with_reentrant_guard
+
+    alias :to_s :inspect
+  end
+end
+

data/lib/faster_open_struct_spec.rb

@@ -0,0 +1,160 @@
+require 'rspec/core'
+require 'rspec/expectations'
+require 'rspec/matchers'
+require 'ostruct'
+
+share_examples_for "OpenStruct-like object" do
+  describe "initialization from Hash" do
+    describe "with symbol keys" do
+      it "creates reader method" do
+        @klass.new(:a => 42).a.should == 42
+      end
+
+      it "creates writer method" do
+        @klass.new(:a => 42).tap { |fos| fos.a = "hi!" }.a.should == "hi!"
+      end
+    end
+
+    describe "with string keys" do
+      it "creates reader method" do
+        @klass.new("a" => 42).a.should == 42
+      end
+
+      it "creates writer method" do
+        @klass.new(:b => 1).tap { |fos| fos.a = "hi!" }.a.should == "hi!"
+      end
+
+      it "creates predicate method" do
+        @klass.new(:a? => 1).a?.should == 1
+      end
+    end
+  end
+
+  describe "initialization with writers" do
+    it "creates reader method when writer is called" do
+      @klass.new.tap { |fos| fos.a = 42 }.a.should == 42
+    end
+
+    it "creates writer method when writer is called" do
+      @klass.new.tap { |fos| fos.a = 42; fos.a = "hi!" }.a.should == "hi!"
+    end
+  end
+
+  describe "comparison" do
+    it "should compare like underlying initialization hashes" do
+      @klass.new(:a => 42).should == @klass.new(:a => 42)
+    end
+
+    it "should compare like underlying created hashes" do
+      @klass.new.tap { |fos| fos.a = 42 }.should == @klass.new.tap { |fos| fos.a = 42 }
+    end
+
+    it "should compare like underlying initialization altered hashes" do
+      @klass.new(:a => 42).tap { |fos| fos.b = "hi!" }.should == @klass.new(:a => 42).tap { |fos| fos.b = "hi!" }
+    end
+  end
+
+  describe "error reporting" do
+    it "should report when too much writer arguments are supplied" do
+      lambda { @klass.new.send(:a=, 1, 2) }.should raise_error(ArgumentError, /wrong number of arguments .2 for 1./)
+    end
+    
+    it "should report when too little writer arguments are supplied" do
+      lambda { @klass.new.send(:a=) }.should raise_error(ArgumentError, /wrong number of arguments .0 for 1./)
+    end
+
+    it "should report when non-writer method is called with arguments" do
+      lambda { @klass.new.a(1) }.should raise_error(NoMethodError, /undefined method `a'/)
+    end
+
+    it "should raise exception when modifying frozen" do
+      lambda { @klass.new.freeze.a = 1 }.should raise_error(TypeError, /can't modify frozen/)
+    end
+  end
+
+  describe "marshaling" do
+    it "should survive loading from marshaled state" do
+      os = @klass.new(:a => 42).tap { |fos| fos.b = "hi!" }
+      os.a
+      survivor = Marshal.load(Marshal.dump(os))
+      survivor.a.should == 42
+      survivor.b.should == "hi!"
+    end
+  end
+  
+  describe "#inspect" do
+    it "works" do
+      @klass.new(:a => 42).tap { |fos| fos.b = "hi!" }.inspect.should match(%r{^#<.*OpenStruct a=42, b="hi!">$})
+    end
+
+    it "handles self-recursive cases" do
+      os = @klass.new
+      os.a = os
+      os.inspect.should match(%r{^#<(Faster::|)OpenStruct a=#<(Faster::|)OpenStruct \.\.\.>>$}x)
+    end
+
+    it "handles deep self-recursive cases" do
+      os = @klass.new
+      os.a = @klass.new
+      os.a.a = os
+      os.inspect.should match(%r{^#<(Faster::|)OpenStruct a=#<(Faster::|)OpenStruct \.\.\.>>\z}x)
+    end
+  end
+end
+
+describe "Faster::OpenStruct" do
+  before(:each) do
+    Faster.send(:remove_const, :OpenStruct) if defined?(Faster::OpenStruct)
+    load "./faster_open_struct.rb"
+    @klass = Faster::OpenStruct
+    
+    if Faster::OpenStruct.method_defined?(:a) ||
+            Faster::OpenStruct.method_defined?(:b) ||
+            Faster::OpenStruct.method_defined?(:a?)
+      raise "reloading hack failed, clean test state is not guaranteed"
+    end
+  end
+
+  it_should_behave_like "OpenStruct-like object"
+
+  it "reponds to empty? to work seamlessly with ActiveSupport" do
+    @klass.new.empty?.should == true
+    @klass.new(:a => 1).empty?.should == false
+    @klass.new.tap { |os| os.a = 1 }.empty?.should == false
+  end
+
+  it "undefines commonly interfering methods" do
+    @klass.new.type == nil
+    @klass.new.id == nil
+  end
+
+  if GC.respond_to?(:enable_stats) && !ENV["SKIP_PERFORMANCE"]
+    describe "performance gains" do
+      def allocated_by_block(allocations = 10_000)
+        GC.clear_stats
+        GC.disable_stats
+        GC.start
+        GC.enable_stats
+        before = GC.allocated_size
+        eater = []
+        allocations.times { eater << yield }
+        GC.allocated_size - before
+      end
+
+      it "should take 40 times less memory compared to OpenStruct" do
+        open_struct = allocated_by_block { OpenStruct.new({ :a => 1 }) }
+        faster_open_struct = allocated_by_block { Faster::OpenStruct.new({ :a => 1 }) }
+        (open_struct.to_f / faster_open_struct).should > 40
+      end
+    end
+  else
+    it "Use REE to test permormance gains"
+  end
+end
+
+describe OpenStruct do
+  before(:each) do
+    @klass = OpenStruct
+  end
+  it_should_behave_like "OpenStruct-like object"
+end

data/lib/gist_yard_readme.rb

@@ -0,0 +1,5 @@
+require "yard"
+YARD.parse(File.expand_path("../faster_open_struct.rb", __FILE__))
+File.open(File.expand_path("../../README.md", __FILE__), "w") do |f|
+  f.write(P("Faster::OpenStruct").docstring)
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification 
+name: faster_open_struct
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Evgeniy Dolzhenko
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-11 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Up to 40 (!) times more memory efficient version of OpenStruct
+email: 
+- dolzenko@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- README.md
+- lib/faster_open_struct.rb
+- lib/faster_open_struct_spec.rb
+- lib/gist_yard_readme.rb
+has_rdoc: true
+homepage: https://github.com/dolzenko/faster_open_struct
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Up to 40 (!) times more memory efficient version of OpenStruct
+test_files: []
+