mighty_struct 0.1.2 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e1befffda2350b4119620bc5a265ec2e7dfa61eb
-  data.tar.gz: 1f9d05937b898767975ce10a400e4f16f69c7a73
+  metadata.gz: f8d7b9936e89b506c81ae023b4f503b838670c6a
+  data.tar.gz: d377473551801d74b6aeafa3a2b008c77690c756
 SHA512:
-  metadata.gz: 809f0eb22a097d19788102ae76d90289c88d8faa76c3a9cefdfae60142aae3aff6c9f4118789ee7f45738af75a09a32a1e0356ea91789bff95a8d2030107985f
-  data.tar.gz: 81da6ad10ef7d667c8b66c1f6c99a44f3679c1a7371e6ee3ad600bf941a4b38848a049d133242708fd4c249ee672d68fb6a2fa56af70ea3df78315387ca67360
+  metadata.gz: 894c82f523a88a02172d576649c41282c7620fde4e57a91b0011139c8d28e9ddd79ea7535b3a7c145fbaaa2f81f2ea853720471cca6a04e21c282e798a5960f2
+  data.tar.gz: 8e5fe24e3cb830edacc15af24e7dd2e8859cd1dc8a4c2171c6d4e44e187a2b73b6b71e39ebe0f36d203bf092b2622e925a47f5fa76645960c808cfef7141a2c7

data/.codeclimate.yml

@@ -0,0 +1,2 @@
+exclude_paths:
+   - "benchmark/*"

data/.travis.yml

@@ -1,5 +1,9 @@
 language: ruby
 rvm:
-  - "2.0"
-  - "2.1"
-  - "2.2"
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - jruby-1.7
+  - jruby-9.0.0.0.pre2
+  - rbx-2.5

data/Gemfile

@@ -3,9 +3,8 @@ source "https://rubygems.org"
 # Specify your gem's dependencies in your gemspec
 gemspec
 
-if !ENV["CI"]
+if !ENV["CI"] && RUBY_ENGINE == "ruby"
   group :development do
-    gem "hashdiff"
     gem "pry",                "~> 0.9.12.6"
     gem "pry-byebug",         "<= 1.3.2"
     gem "pry-rescue",         "~> 1.4.1", github: "ConradIrwin/pry-rescue", branch: :master

data/README.md

@@ -1,28 +1,78 @@
 # MightyStruct
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/mighty_struct`. To experiment with that code, run `bin/console` for an interactive prompt.
+[![Build Status](https://travis-ci.org/msievers/mighty_struct.svg)](https://travis-ci.org/msievers/mighty_struct)
+[![Test Coverage](https://codeclimate.com/github/msievers/mighty_struct/badges/coverage.svg)](https://codeclimate.com/github/msievers/mighty_struct/coverage)
+[![Code Climate](https://codeclimate.com/github/msievers/mighty_struct/badges/gpa.svg)](https://codeclimate.com/github/msievers/mighty_struct)
+[![Dependency Status](https://gemnasium.com/msievers/mighty_struct.svg)](https://gemnasium.com/msievers/mighty_struct)
 
-TODO: Delete this and the text above, and describe your gem
+`MightyStruct` is an object wrapper which gives deep method access to properties. It combines beneficial features from functionally related projects like `OpenStruct` and `Hashie::Mash` into an non-inversive, transparant decorator like object wrapper.
 
-## Installation
+## Key features
 
-Add this line to your application's Gemfile:
+* wraps any object that is an `Enumerable` (e.g `Array` or `Hash`)
+* creates method accessors for any object that additionally responds to `:keys` (e.g. `Hash`)
+* deep method access to object properties
+* property accessors are implemented via methods, not `method_missing`
+  * as a result tab completion in pry works
+* dispite property accessors, the namespace of wrapped objects isn't touched
+* all method calls which don't hit a property accessor are dispatched to the wrapped object
+  * results are again wrapped to instances of MightyStruct if possible
+* the wrapped object can be retrieved at any time using `MightyStruct.to_object(obj)`
+
+## Example
 
 ```ruby
-gem 'mighty_struct'
+require "mighty_struct"
+
+hash = {
+  a: [
+    { b: 1 },
+    { b: 2 },
+  ],
+}
+
+# create it from some hash or array
+mighty_struct = MightyStruct.new(hash)
+
+# access deeply nested properties 
+mighty_struct.a[0].b # => 1
+
+# call methods transparently on the wrapped objects
+mighty_struct.a.last.b # => 2
+
+# get back the original object ... look ma', it's still the same hash
+MightyStruct.to_object(mighty_struct).eql?(hash) # => true
 ```
 
-And then execute:
+Or play with it on your own. It's just one command (line) away.
+
+```bash
+git clone https://github.com/msievers/mighty_struct.git && cd mighty_struct && bundle && bin/console
+```
+
+## Another of this "method invocation" hashes? Really?!
+
+Before I started coding this, I tried the following three alternatives
+
+* `OpenStruct`
+* `recursive-open-struct`
+* `Hashie::Mash`
 
-    $ bundle
+But neither of them provided everything I wanted.
 
-Or install it yourself as:
+                   | MightyStruct | OpenStruct | recursive-open-struct | Hashie::Mash
+---                | :----------: | :--------: | :-------------------: | :----------:
+deep method access | :heavy_check_mark: | :heavy_multiplication_x: | (:heavy_check_mark:) | :heavy_check_mark:
+real method accessors | :heavy_check_mark: | :heavy_check_mark: | :heavy_check_mark: | :heavy_multiplication_x:
+works without object dupping | :heavy_check_mark: | :heavy_multiplication_x: | :heavy_multiplication_x: | :heavy_multiplication_x:
+transparent method dispatching | :heavy_check_mark: | :heavy_multiplication_x: | :heavy_multiplication_x: | :heavy_multiplication_x:
+original object retrieval | :heavy_check_mark: | :heavy_multiplication_x: | :heavy_multiplication_x: | :heavy_multiplication_x:
 
-    $ gem install mighty_struct
+## Why are real methods as property accessors cool?
 
-## Usage
+Method accessors for object properties can either be implemented via `method_missing` or by defining (singleton) methods. The benefit of real methods is, that if you are using a debugger (e.g. `pry`), you can use tab completion to discover methods defined on a object. This does not work for `method_missing` based accessors.
 
-TODO: Write usage instructions here
+With real method accessors in place, playing with a `mighty_struct` within `pry` just feels like working within a shell.
 
 ## Development
 
@@ -32,7 +82,7 @@ To install this gem onto your local machine, run `bundle exec rake install`. To
 
 ## Contributing
 
-1. Fork it ( https://github.com/[my-github-username]/mighty_struct/fork )
+1. Fork it ( https://github.com/msievers/mighty_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`)

data/Rakefile

@@ -6,9 +6,7 @@ RSpec::Core::RakeTask.new(:spec)
 task :default => :spec
 
 task :benchmark do
-  require_relative "./benchmark/joffrey/mab_document"
-  require_relative "./benchmark/joffrey/mab_xml_parser"
+  require_relative "./benchmark/mighty_struct/mighty_struct_versus_others"
 
-  #Benchmark::Joffrey::MabDocument.new.call
-  Benchmark::Joffrey::MabXmlParser.new.call
+  Benchmark::MightyStruct::MightyStructVersusOthers.new.call
 end

data/benchmark/mighty_struct.rb

@@ -0,0 +1,4 @@
+require "benchmark/ips"
+
+class Benchmark::MightyStruct
+end

data/benchmark/mighty_struct/mighty_struct_versus_others.rb

@@ -0,0 +1,60 @@
+require "hashie/mash"
+require "mighty_struct"
+require "pry"
+require_relative "../mighty_struct"
+
+class Benchmark::MightyStruct::MightyStructVersusOthers
+  def call
+    hash = {
+      a: 1,
+      b: {
+        c: 2,
+        "d" => 3,
+        e: [
+          {
+            f: 4
+          }
+        ]
+      }
+    }
+
+    puts "\n"
+
+    Benchmark.ips do |x|
+      puts "Hashie::Mash.new(hash)"
+      puts "MightyStruct.new(hash)"
+      puts "OpenStruct.new(hash)"
+      puts "\n"
+
+      x.report("Hashie::Mash") { Hashie::Mash.new(hash) }
+      x.report("MightyStruct") { MightyStruct.new(hash) }
+      x.report("OpenStruct") { OpenStruct.new(hash) }
+
+      x.compare!
+    end
+
+    [:enabled, :disabled].each do |_caching_mode|
+      puts "Hashie::Mash.new(hash).b.c"
+      puts "MightyStruct.new(hash, caching: :#{_caching_mode}).b.c"
+      puts "OpenStruct.new(hash).b.c"
+      puts "\n"
+
+      Benchmark.ips do |x|
+        hashie_mash = Hashie::Mash.new(hash)
+        mighty_struct = MightyStruct.new(hash, caching: _caching_mode)
+        open_struct = OpenStruct.new(hash)
+        open_struct.b = OpenStruct.new(open_struct.b)
+
+        if hashie_mash.b.c != hash[:b][:c] || mighty_struct.b.c != hash[:b][:c] || open_struct.b.c != hash[:b][:c]
+          raise
+        end
+
+        x.report("Hashie::Mash") { hashie_mash.b.c }
+        x.report("MightyStruct") { mighty_struct.b.c }
+        x.report("OpenStruct") { open_struct.b.c }
+
+        x.compare!
+      end
+    end
+  end
+end

data/bin/console

@@ -6,9 +6,10 @@ require "mighty_struct"
 # You can add fixtures and/or initialization code here to make experimenting
 # with your gem easier. You can also use a different console, if you like.
 
-# (If you use this, don't forget to add pry to your Gemfile!)
-# require "pry"
-# Pry.start
-
-require "irb"
-IRB.start
+begin
+  require "pry"
+  Pry.start
+rescue LoadError
+  require "irb"
+  IRB.start
+end

data/lib/mighty_struct.rb

@@ -1,29 +1,36 @@
 require "mighty_struct/version"
 
 class MightyStruct
-  def self.define_property_accessors!(mighty_struct, object)
-    if object.is_a?(Hash)
-      object.keys.each do |_key|
-        class_eval <<-EORUBY, __FILE__, __LINE__ + 1
-          def #{_key}
-            value = @object[#{_key.is_a?(Symbol) ? ':' << _key.to_s : '"' << _key << '"'}]
-            self.class.new?(value) ? self.class.new(value) : value
-          end
-        EORUBY
-      end
-    end
+  def self.new?(object)
+    object.is_a?(Enumerable)
   end
 
-  def self.new?(object)
-    object.is_a?(Array) || object.is_a?(Hash)
+  # in order not to pollute the instance's method namespace this is a class method
+  def self.to_object(object)
+    object.is_a?(self) ? object.instance_variable_get(:@object) : object
   end
 
-  def initialize(object)
+  def initialize(object, options = {})
     unless self.class.new?(object)
       raise ArgumentError.new("Cannot create a an instance of #{self.class} for the given object!")
     end
 
-    self.class.define_property_accessors!(self, @object = object)
+    @cache = {}
+    @cache_mode = options[:caching] || :enabled
+
+    if (@object = object).respond_to?(:keys)
+      object.keys.each do |_key|
+        unless respond_to?(_key)
+          define_singleton_method(_key) do
+            if @cache_mode == :disabled
+              self.class.new?(value = @object[_key]) ? self.class.new(value) : value
+            else
+              @cache[_key] ||= self.class.new?(value = @object[_key]) ? self.class.new(value) : value
+            end
+          end
+        end
+      end
+    end
   end
 
   #
@@ -31,6 +38,7 @@ class MightyStruct
   #
   def method_missing(method_name, *arguments, &block)
     if @object.respond_to?(method_name)
+      @cache.clear if @cache_mode == :smart # clear the properties cache if we are smart
       result = @object.send(method_name, *arguments, &block)
 
       # ensure that results of called methods are mighty structs again

data/lib/mighty_struct/version.rb

@@ -1,3 +1,3 @@
 class MightyStruct
-  VERSION = "0.1.2"
+  VERSION = "0.1.4"
 end

data/mighty_struct.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency "benchmark-ips"
   spec.add_development_dependency "bundler",   ">= 1.3"
+  spec.add_development_dependency "hashie"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec",     ">= 3.0.0",  "< 4.0.0"
   spec.add_development_dependency "simplecov", ">= 0.8.0"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mighty_struct
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.4
 platform: ruby
 authors:
 - Michael Sievers
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-05-20 00:00:00.000000000 Z
+date: 2015-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -38,6 +38,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -92,12 +106,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".codeclimate.yml"
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
 - Gemfile
 - README.md
 - Rakefile
+- benchmark/mighty_struct.rb
+- benchmark/mighty_struct/mighty_struct_versus_others.rb
 - bin/console
 - bin/setup
 - lib/mighty_struct.rb
@@ -122,7 +139,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.7
 signing_key: 
 specification_version: 4
 summary: A mighty struct which combines OpenStruct like method access with reasonable