persistent_open_struct 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3ef836525502250c550a58f6988dcd6285d93337
-  data.tar.gz: fff2627187409c4c5109de37858a644771a722d3
+  metadata.gz: c56926b84113f349bff3d7626376aa08f3bacc67
+  data.tar.gz: 52d2e51a904300c09ddff7cd66500a3986772c1a
 SHA512:
-  metadata.gz: 6bd65c8ea98bcbfec8b7e0fea83a8615c6a0be59c3c77ff08326d971f278ea7b97ef7ce2a932d64e1efc4d03075e6ff85c9a026a264220a6809e850e5e8f7ea2
-  data.tar.gz: ceabca536ad1a1015eeb8d409b072cf4386e9b270ff4548d6633f95526039aed13789ddc0f0fa1d7a419908b6e7c89bdffedd74d05b1e6c438f32e25595babcb
+  metadata.gz: c572c33cf67151da6da095d47c55d758bc49ffc21db1bdda311518629f7ac2e12eabc9383e3a0f309b059d603a9371ef748d16acbe0de4bebd9af96238a97c61
+  data.tar.gz: bb0dc99765a194859a37ed1e8e220250a9891013257a64d93b8eb1a7b64b2a033410f220d7725b709e8b409a935810706ffce356b0cf2a7bc4abe6575e7c4f4b

data/Gemfile

@@ -1,5 +1,4 @@
 source 'https://rubygems.org'
 
-gem 'benchmark-ips'
 gem 'ofstruct'
 gemspec

data/README.md

@@ -3,97 +3,113 @@
 
 # PersistentOpenStruct
 
-Are you inserting data in the same format into OpenStruct again and again?
-Wishing OpenStruct wouldn't have to define a new singleton method on each
+Are you inserting data in the same format into `OpenStruct` again and again?
+Wish `OpenStruct` wouldn't have to define a new singleton method on each
 individual object?  Here is your solution!
 
-PersistentOpenStruct defines methods on the class, so as long as you keep using
+`PersistentOpenStruct` defines methods on the class, so as long as you keep using
 the same keys, no new methods will be defined.  The class quickly learns the
 shape of your data, so you can use it with minimal overhead.  (Though of course
 it's still not as fast as doing the work of defining a full-fledged class.)
 
-It obeys the entire interface of OpenStruct, so you can insert it into your code
+It obeys the entire interface of `OpenStruct`, so you can insert it into your code
 without problem!  (Unless you're using `OpenStruct#delete_field` for some reason;
-PersistentOpenStruct refuses to undefine the methods it defines.)
+`PersistentOpenStruct` refuses to undefine the methods it defines.)
 
-This gives a noticeable performance boost.  Here are the results of the benchmark
-found at
-[`benchmark/benchmark.rb`](http://github.com/amcaplan/persistent_open_struct/blob/master/benchmark/benchmark.rb);
-included are
-results for [`OpenFastStruct`](http://github.com/arturoherrero/ofstruct) as
-well, to get a sense of alternative solutions.
+This gives a noticeable performance boost.  Here are the results of the
+benchmark found at
+[`benchmark/benchmark.rb`](http://github.com/amcaplan/persistent_open_struct/blob/master/benchmark/benchmark.rb)
+run on Ruby 2.3.1; the final benchmark is most representative of the average case.
 
-``` ruby
-require 'benchmark/ips'
-require 'ostruct'
-require_relative '../lib/persistent_open_struct'
-
-Benchmark.ips do |x|
-  input_hash = { foo: :bar }
-  x.report('OpenStruct') do
-    OpenStruct.new(input_hash)
-  end
-
-  x.report('PersistentOpenStruct') do
-    PersistentOpenStruct.new(input_hash)
-  end
-end
+Also included are results for
+[`OpenFastStruct`](http://github.com/arturoherrero/ofstruct) as well, to get a
+sense of alternative solutions.
 
-puts "\n\n"
+More is better.
 
-Benchmark.ips do |x|
-  x.report('OpenStruct') do
-    OpenStruct.new.foo = :bar
-  end
-
-  x.report('PersistentOpenStruct') do
-    PersistentOpenStruct.new.foo = :bar
-  end
-end
 ```
-And the results:
-```
-$ ruby benchmark/benchmark.rb 
+$ ruby benchmark/benchmark.rb
 Initialization benchmark
 
+Warming up --------------------------------------
+          OpenStruct    88.289k i/100ms
+PersistentOpenStruct    78.440k i/100ms
+      OpenFastStruct    81.306k i/100ms
+        RegularClass   200.536k i/100ms
 Calculating -------------------------------------
-          OpenStruct    17.082k i/100ms
-PersistentOpenStruct    61.316k i/100ms
-      OpenFastStruct    62.589k i/100ms
-        RegularClass   122.018k i/100ms
--------------------------------------------------
-          OpenStruct    192.534k (± 3.4%) i/s -    973.674k
-PersistentOpenStruct    955.081k (± 3.1%) i/s -      4.783M
-      OpenFastStruct    980.760k (± 4.2%) i/s -      4.945M
-        RegularClass      3.615M (± 4.4%) i/s -     18.059M
+          OpenStruct    981.150k (± 7.8%) i/s -      4.944M in   5.069950s
+PersistentOpenStruct    898.432k (± 9.5%) i/s -      4.471M in   5.022044s
+      OpenFastStruct      1.059M (± 5.6%) i/s -      5.366M in   5.086061s
+        RegularClass      3.860M (± 9.6%) i/s -     19.251M in   5.034804s
+
+Comparison:
+        RegularClass:  3859650.0 i/s
+      OpenFastStruct:  1058578.4 i/s - 3.65x slower
+          OpenStruct:   981149.5 i/s - 3.93x slower
+PersistentOpenStruct:   898431.6 i/s - 4.30x slower
+
 
 
 Assignment Benchmark
 
+Warming up --------------------------------------
+          OpenStruct   199.451k i/100ms
+PersistentOpenStruct   214.181k i/100ms
+      OpenFastStruct    99.324k i/100ms
+        RegularClass   312.190k i/100ms
 Calculating -------------------------------------
-          OpenStruct   119.904k i/100ms
-PersistentOpenStruct   120.998k i/100ms
-      OpenFastStruct    67.418k i/100ms
-        RegularClass   152.935k i/100ms
--------------------------------------------------
-          OpenStruct      3.707M (± 4.7%) i/s -     18.585M
-PersistentOpenStruct      3.753M (± 4.0%) i/s -     18.755M
-      OpenFastStruct      1.133M (± 2.6%) i/s -      5.731M
-        RegularClass      9.155M (± 4.8%) i/s -     45.728M
+          OpenStruct      4.505M (± 5.4%) i/s -     22.538M in   5.019146s
+PersistentOpenStruct      4.375M (± 4.2%) i/s -     21.846M in   5.002085s
+      OpenFastStruct      1.405M (± 5.0%) i/s -      7.052M in   5.033620s
+        RegularClass     11.113M (± 5.2%) i/s -     55.570M in   5.015664s
+
+Comparison:
+        RegularClass: 11112511.1 i/s
+          OpenStruct:  4504735.3 i/s - 2.47x slower
+PersistentOpenStruct:  4375412.9 i/s - 2.54x slower
+      OpenFastStruct:  1404724.1 i/s - 7.91x slower
+
 
 
 Access Benchmark
 
+Warming up --------------------------------------
+          OpenStruct   256.277k i/100ms
+PersistentOpenStruct   259.536k i/100ms
+      OpenFastStruct   227.602k i/100ms
+        RegularClass   260.242k i/100ms
+Calculating -------------------------------------
+          OpenStruct      6.798M (± 5.0%) i/s -     34.085M in   5.027391s
+PersistentOpenStruct      6.539M (± 6.0%) i/s -     32.702M in   5.019393s
+      OpenFastStruct      4.875M (± 4.0%) i/s -     24.353M in   5.004194s
+        RegularClass      6.654M (± 4.7%) i/s -     33.311M in   5.018183s
+
+Comparison:
+          OpenStruct:  6797834.1 i/s
+        RegularClass:  6653907.4 i/s - same-ish: difference falls within error
+PersistentOpenStruct:  6538883.0 i/s - same-ish: difference falls within error
+      OpenFastStruct:  4875059.7 i/s - 1.39x slower
+
+
+
+All-Together benchmark
+
+Warming up --------------------------------------
+          OpenStruct    14.490k i/100ms
+PersistentOpenStruct    63.043k i/100ms
+      OpenFastStruct    47.777k i/100ms
+        RegularClass   197.293k i/100ms
 Calculating -------------------------------------
-          OpenStruct   134.887k i/100ms
-PersistentOpenStruct   134.239k i/100ms
-      OpenFastStruct   120.480k i/100ms
-        RegularClass   134.040k i/100ms
--------------------------------------------------
-          OpenStruct      5.558M (± 3.2%) i/s -     27.787M
-PersistentOpenStruct      5.531M (± 4.3%) i/s -     27.653M
-      OpenFastStruct      3.996M (± 4.7%) i/s -     20.000M
-        RegularClass      5.562M (± 3.5%) i/s -     27.880M
+          OpenStruct    155.130k (± 4.5%) i/s -    782.460k in   5.054693s
+PersistentOpenStruct    764.359k (± 6.6%) i/s -      3.846M in   5.053760s
+      OpenFastStruct    546.809k (± 4.7%) i/s -      2.771M in   5.079275s
+        RegularClass      3.674M (± 9.1%) i/s -     18.348M in   5.054680s
+
+Comparison:
+        RegularClass:  3673779.6 i/s
+PersistentOpenStruct:   764359.4 i/s - 4.81x slower
+      OpenFastStruct:   546808.8 i/s - 6.72x slower
+          OpenStruct:   155130.1 i/s - 23.68x slower
 ```
 
 ## Installation
@@ -126,11 +142,12 @@ datum2.respond_to?(:foo) #=> true
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/persistent_open_struct/fork )
+1. Fork it ( https://github.com/amcaplan/persistent_open_struct/fork )
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create a new Pull Request
 
-Pull requests will not be considered without tests of whatever you seek to
-change, unless you are submitting a performance improvement.
+Changes to functionality require testing.  Performance improvements should
+include before/after benchmarks (or ideally just update the results in the
+README above).

data/benchmark/benchmark.rb

@@ -30,6 +30,8 @@ Benchmark.ips do |x|
   x.report('RegularClass') do
     RegularClass.new(input_hash)
   end
+
+  x.compare!
 end
 
 puts "\n\nAssignment Benchmark\n\n"
@@ -55,6 +57,8 @@ Benchmark.ips do |x|
   x.report('RegularClass') do
     rgc.foo = :bar
   end
+
+  x.compare!
 end
 
 puts "\n\nAccess Benchmark\n\n"
@@ -80,4 +84,37 @@ Benchmark.ips do |x|
   x.report('RegularClass') do
     pos.foo
   end
+
+  x.compare!
+end
+
+puts "\n\nAll-Together benchmark\n\n"
+
+Benchmark.ips do |x|
+  input_hash = { foo: :bar }
+  x.report('OpenStruct') do
+    os = OpenStruct.new(input_hash)
+    os.foo = :bar
+    os.foo
+  end
+
+  x.report('PersistentOpenStruct') do
+    pos = PersistentOpenStruct.new(input_hash)
+    pos.foo = :bar
+    pos.foo
+  end
+
+  x.report('OpenFastStruct') do
+    ofs = OpenFastStruct.new(input_hash)
+    ofs.foo = :bar
+    ofs.foo
+  end
+
+  x.report('RegularClass') do
+    rgc = RegularClass.new(input_hash)
+    rgc.foo = :bar
+    rgc.foo
+  end
+
+  x.compare!
 end

data/lib/persistent_open_struct.rb

@@ -1,6 +1,8 @@
-require 'ostruct'
+class PersistentOpenStruct
+  # The following 2 methods are altered from the original OpenStruct.
+  # Everything else is copied from OpenStruct on Ruby 2.2. (The performance
+  # enhancements in 2.3 don't make sense for this implementation.)
 
-class PersistentOpenStruct < OpenStruct
   def new_ostruct_member(name)
     name = name.to_sym
     unless respond_to?(name)
@@ -14,4 +16,119 @@ class PersistentOpenStruct < OpenStruct
   def delete_field(name)
     @table.delete(name)
   end
+
+  # From here on was copied from https://github.com/ruby/ruby/blob/3c7a96bfa2d21336d985ceda544c4ccabafebed5/lib/ostruct.rb
+  # to avoid changes to internals negatively affecting performance.
+
+  def initialize(hash=nil)
+    @table = {}
+    if hash
+      hash.each_pair do |k, v|
+        k = k.to_sym
+        @table[k] = v
+        new_ostruct_member(k)
+      end
+    end
+  end
+
+  def initialize_copy(orig)
+    super
+    @table = @table.dup
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def to_h
+    @table.dup
+  end
+
+  def each_pair
+    return to_enum(__method__) { @table.size } unless block_given?
+    @table.each_pair{|p| yield p}
+  end
+
+  def marshal_dump
+    @table
+  end
+
+  def marshal_load(x)
+    @table = x
+    @table.each_key{|key| new_ostruct_member(key)}
+  end
+
+  def modifiable
+    begin
+      @modifiable = true
+    rescue
+      raise RuntimeError, "can't modify frozen #{self.class}", caller(3)
+    end
+    @table
+  end
+  protected :modifiable
+
+  def method_missing(mid, *args) # :nodoc:
+    mname = mid.id2name
+    len = args.length
+    if mname.chomp!('=')
+      if len != 1
+        raise ArgumentError, "wrong number of arguments (#{len} for 1)", caller(1)
+      end
+      modifiable[new_ostruct_member(mname)] = args[0]
+    elsif len == 0
+      @table[mid]
+    else
+      err = NoMethodError.new "undefined method `#{mid}' for #{self}", mid, args
+      err.set_backtrace caller(1)
+      raise err
+    end
+  end
+
+  def [](name)
+    @table[name.to_sym]
+  end
+
+  def []=(name, value)
+    modifiable[new_ostruct_member(name)] = value
+  end
+
+  InspectKey = :__inspect_key__ # :nodoc:
+
+  def inspect
+    str = "#<#{self.class}"
+
+    ids = (Thread.current[InspectKey] ||= [])
+    if ids.include?(object_id)
+      return str << ' ...>'
+    end
+
+    ids << object_id
+    begin
+      first = true
+      for k,v in @table
+        str << "," unless first
+        first = false
+        str << " #{k}=#{v.inspect}"
+      end
+      return str << '>'
+    ensure
+      ids.pop
+    end
+  end
+  alias :to_s :inspect
+
+  attr_reader :table # :nodoc:
+  protected :table
+
+  def ==(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table == other.table
+  end
+
+  def eql?(other)
+    return false unless other.kind_of?(OpenStruct)
+    @table.eql?(other.table)
+  end
+
+  def hash
+    @table.hash
+  end
 end

data/lib/persistent_open_struct/version.rb

@@ -1,5 +1,5 @@
 require 'ostruct'
 
 class PersistentOpenStruct < OpenStruct
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/persistent_open_struct.gemspec

@@ -22,4 +22,5 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "bundler", "~> 1.6"
   spec.add_development_dependency 'rake', '~> 10.4', '>= 10.4.2'
   spec.add_development_dependency 'minitest', '~> 5.4', '>= 5.4.3'
+  spec.add_development_dependency 'benchmark-ips', '~> 2.6'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: persistent_open_struct
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - amcaplan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-14 00:00:00.000000000 Z
+date: 2016-07-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -64,6 +64,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 5.4.3
+- !ruby/object:Gem::Dependency
+  name: benchmark-ips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
 description: Unlike OpenStruct, which defines singleton methods on an object, PersistentOpenStruct
   defines methods on the class.  This is useful when storing many hashes with the
   same keys as OpenStructs.
@@ -105,7 +119,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.5
+rubygems_version: 2.5.1
 signing_key: 
 specification_version: 4
 summary: A variant of OpenStruct that persists defined methods