persistent_open_struct 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 3ef836525502250c550a58f6988dcd6285d93337
+  data.tar.gz: fff2627187409c4c5109de37858a644771a722d3
+SHA512:
+  metadata.gz: 6bd65c8ea98bcbfec8b7e0fea83a8615c6a0be59c3c77ff08326d971f278ea7b97ef7ce2a932d64e1efc4d03075e6ff85c9a026a264220a6809e850e5e8f7ea2
+  data.tar.gz: ceabca536ad1a1015eeb8d409b072cf4386e9b270ff4548d6633f95526039aed13789ddc0f0fa1d7a419908b6e7c89bdffedd74d05b1e6c438f32e25595babcb

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.0
+  - 2.1.0

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 amcaplan
+
+MIT License
+
+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

@@ -0,0 +1,136 @@
+[![Gem Version](https://badge.fury.io/rb/persistent_open_struct.svg)](http://badge.fury.io/rb/persistent_open_struct)
+![Travis badge](https://travis-ci.org/amcaplan/persistent_open_struct.svg?branch=master)
+
+# 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
+individual object?  Here is your solution!
+
+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
+without problem!  (Unless you're using `OpenStruct#delete_field` for some reason;
+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.
+
+``` 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
+
+puts "\n\n"
+
+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 
+Initialization benchmark
+
+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
+
+
+Assignment Benchmark
+
+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
+
+
+Access Benchmark
+
+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
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'persistent_open_struct'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install persistent_open_struct
+
+## Usage
+Note: requires Ruby 2.1.0 or above.
+
+``` ruby
+class MyDataStructure < PersistentOpenStruct
+end
+
+datum1 = MyDataStructure.new(foo: :bar)
+
+datum2 = MyDataStructure.new
+datum2.respond_to?(:baz) #=> false
+datum2.respond_to?(:foo) #=> true
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/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.

data/Rakefile

@@ -0,0 +1,10 @@
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+desc "Run tests"
+task :default => :test

data/benchmark/benchmark.rb

@@ -0,0 +1,83 @@
+require 'benchmark/ips'
+require 'ostruct'
+require 'ofstruct'
+require_relative '../lib/persistent_open_struct'
+
+class RegularClass
+  attr_accessor :foo
+
+  def initialize(args)
+    @foo = args[:foo]
+  end
+end
+
+puts "Initialization benchmark\n\n"
+
+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
+
+  x.report('OpenFastStruct') do
+    OpenFastStruct.new(input_hash)
+  end
+
+  x.report('RegularClass') do
+    RegularClass.new(input_hash)
+  end
+end
+
+puts "\n\nAssignment Benchmark\n\n"
+
+Benchmark.ips do |x|
+  os = OpenStruct.new(foo: :bar)
+  pos = PersistentOpenStruct.new(foo: :bar)
+  ofs = OpenFastStruct.new(foo: :bar)
+  rgc = RegularClass.new(foo: :bar)
+
+  x.report('OpenStruct') do
+    os.foo = :bar
+  end
+
+  x.report('PersistentOpenStruct') do
+    pos.foo = :bar
+  end
+
+  x.report('OpenFastStruct') do
+    ofs.foo = :bar
+  end
+
+  x.report('RegularClass') do
+    rgc.foo = :bar
+  end
+end
+
+puts "\n\nAccess Benchmark\n\n"
+
+Benchmark.ips do |x|
+  os = OpenStruct.new(foo: :bar)
+  pos = PersistentOpenStruct.new(foo: :bar)
+  ofs = OpenFastStruct.new(foo: :bar)
+  rgc = RegularClass.new(foo: :bar)
+
+  x.report('OpenStruct') do
+    os.foo
+  end
+
+  x.report('PersistentOpenStruct') do
+    pos.foo
+  end
+
+  x.report('OpenFastStruct') do
+    ofs.foo
+  end
+
+  x.report('RegularClass') do
+    pos.foo
+  end
+end

data/lib/persistent_open_struct.rb

@@ -0,0 +1,17 @@
+require 'ostruct'
+
+class PersistentOpenStruct < OpenStruct
+  def new_ostruct_member(name)
+    name = name.to_sym
+    unless respond_to?(name)
+      self.class.send(:define_method, name) { @table[name] }
+      self.class.send(:define_method, "#{name}=") { |x| modifiable[name] = x }
+    end
+    name
+  end
+  protected :new_ostruct_member
+
+  def delete_field(name)
+    @table.delete(name)
+  end
+end

data/lib/persistent_open_struct/version.rb

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

data/persistent_open_struct.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'persistent_open_struct/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "persistent_open_struct"
+  spec.version       = PersistentOpenStruct::VERSION
+  spec.authors       = ["amcaplan"]
+  spec.email         = ["ariel.caplan@vitals.com"]
+  spec.summary       = %q{A variant of OpenStruct that persists defined methods}
+  spec.description   = %q{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.}
+  spec.homepage      = "http://github.com/amcaplan/persistent_open_struct"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.required_ruby_version = '>= 2.1.0'
+  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'
+end

data/test/test_helper.rb

@@ -0,0 +1,2 @@
+require 'minitest/autorun'
+require 'minitest/unit'

data/test/test_persistent_open_struct.rb

@@ -0,0 +1,150 @@
+require 'test_helper'
+require 'persistent_open_struct'
+
+class PersistentOpenStructTest < Minitest::Test
+  def test_initialize
+    h = {name: "John Smith", age: 70, pension: 300}
+    assert_equal h, PersistentOpenStruct.new(h).to_h
+    assert_equal h, PersistentOpenStruct.new(PersistentOpenStruct.new(h)).to_h
+    assert_equal h, PersistentOpenStruct.new(Struct.new(*h.keys).new(*h.values)).to_h
+  end
+
+  def test_equality
+    o1 = PersistentOpenStruct.new
+    o2 = PersistentOpenStruct.new
+    assert_equal(o1, o2)
+
+    o1.a = 'a'
+    refute_equal(o1, o2)
+
+    o2.a = 'a'
+    assert_equal(o1, o2)
+
+    o1.a = 'b'
+    refute_equal(o1, o2)
+
+    o2 = Object.new
+    o2.instance_eval{@table = {:a => 'b'}}
+    refute_equal(o1, o2)
+  end
+
+  def test_inspect
+    foo = PersistentOpenStruct.new
+    assert_equal("#<PersistentOpenStruct>", foo.inspect)
+    foo.bar = 1
+    foo.baz = 2
+    assert_equal("#<PersistentOpenStruct bar=1, baz=2>", foo.inspect)
+
+    foo = PersistentOpenStruct.new
+    foo.bar = PersistentOpenStruct.new
+    assert_equal('#<PersistentOpenStruct bar=#<PersistentOpenStruct>>', foo.inspect)
+    foo.bar.foo = foo
+    assert_equal('#<PersistentOpenStruct bar=#<PersistentOpenStruct foo=#<PersistentOpenStruct ...>>>', foo.inspect)
+  end
+
+  def test_frozen
+    o = PersistentOpenStruct.new
+    o.a = 'a'
+    o.freeze
+    assert_raises(RuntimeError) {o.b = 'b'}
+    refute_respond_to(o, :b)
+    assert_raises(RuntimeError) {o.a = 'z'}
+    assert_equal('a', o.a)
+    o = PersistentOpenStruct.new :a => 42
+    def o.frozen?; nil end
+    o.freeze
+    assert_raises(RuntimeError, '[ruby-core:22559]') {o.a = 1764}
+  end
+
+  def test_delete_field
+    o = PersistentOpenStruct.new
+    refute_respond_to(o, :foobar)
+    refute_respond_to(o, :foobar=)
+    o.foobar = :baz
+    assert_equal(o.foobar, :baz)
+    assert_respond_to(o, :foobar)
+    assert_respond_to(o, :foobar=)
+    o.delete_field(:foobar)
+    assert_equal(nil, o.foobar)
+    assert_respond_to(o, :foobar)
+    assert_respond_to(o, :foobar=)
+  end
+
+  def test_setter
+    os = PersistentOpenStruct.new
+    os[:foo] = :bar
+    assert_equal :bar, os.foo
+    os['foo'] = :baz
+    assert_equal :baz, os.foo
+  end
+
+  def test_getter
+    os = PersistentOpenStruct.new
+    os.foo = :bar
+    assert_equal :bar, os[:foo]
+    assert_equal :bar, os['foo']
+  end
+
+  def test_to_h
+    h = {name: "John Smith", age: 70, pension: 300}
+    os = PersistentOpenStruct.new(h)
+    to_h = os.to_h
+    assert_equal(h, to_h)
+
+    to_h[:age] = 71
+    assert_equal(70, os.age)
+    assert_equal(70, h[:age])
+
+    assert_equal(h, PersistentOpenStruct.new("name" => "John Smith", "age" => 70, pension: 300).to_h)
+  end
+
+  def test_each_pair
+    h = {name: "John Smith", age: 70, pension: 300}
+    os = PersistentOpenStruct.new(h)
+    assert_equal '#<Enumerator: #<PersistentOpenStruct name="John Smith", age=70, pension=300>:each_pair>', os.each_pair.inspect
+    assert_equal [[:name, "John Smith"], [:age, 70], [:pension, 300]], os.each_pair.to_a
+    assert_equal 3, os.each_pair.size
+  end
+
+  def test_eql_and_hash
+    os1 = PersistentOpenStruct.new age: 70
+    os2 = PersistentOpenStruct.new age: 70.0
+    assert_equal os1, os2
+    assert_equal false, os1.eql?(os2)
+    refute_equal os1.hash, os2.hash
+    assert_equal true, os1.eql?(os1.dup)
+    assert_equal os1.hash, os1.dup.hash
+  end
+
+  def test_method_missing
+    os = PersistentOpenStruct.new
+    e = assert_raises(NoMethodError) { os.foobarbaz true }
+    assert_equal :foobarbaz, e.name
+    assert_equal [true], e.args
+    assert_match(/#{__callee__}/, e.backtrace[0])
+    e = assert_raises(ArgumentError) { os.send :foobarbaz=, true, true }
+    assert_match(/#{__callee__}/, e.backtrace[0])
+  end
+
+  def test_method_reuse
+    os = PersistentOpenStruct.new
+    refute_respond_to(os, :hello)
+    refute_respond_to(os, :hello=)
+    os.hello = 'world'
+    os2 = PersistentOpenStruct.new
+    assert_respond_to(os2, :hello)
+    assert_respond_to(os2, :hello=)
+  end
+
+  PersistentOpenStructClass1 = Class.new(PersistentOpenStruct)
+  PersistentOpenStructClass2 = Class.new(PersistentOpenStruct)
+
+  def test_method_segregation
+    os1a = PersistentOpenStructClass1.new
+    os1a.a_thing = 'value'
+    os1b = PersistentOpenStructClass1.new
+    assert_respond_to(os1b, :a_thing)
+    os2 = PersistentOpenStructClass2.new
+    refute_respond_to(os2, :a_thing)
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: persistent_open_struct
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- amcaplan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 10.4.2
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.4'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.4.3
+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.
+email:
+- ariel.caplan@vitals.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- benchmark/benchmark.rb
+- lib/persistent_open_struct.rb
+- lib/persistent_open_struct/version.rb
+- persistent_open_struct.gemspec
+- test/test_helper.rb
+- test/test_persistent_open_struct.rb
+homepage: http://github.com/amcaplan/persistent_open_struct
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A variant of OpenStruct that persists defined methods
+test_files:
+- test/test_helper.rb
+- test/test_persistent_open_struct.rb