nested_accessors 0.1.3

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    NTlmMmU3YzY3YjFlYmU5NzFhMTJiNjIzOTE2Y2RhMzE4YTMxZmJjZg==
+  data.tar.gz: !binary |-
+    MDlmMDI1Zjg4ZGE0NGM4ZDdjYzQ0ZTI1YjQ5ZDg0M2Y2MjAxMzZmMw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    N2FkOTQ0ZWVlZDViNWY2NmZiMmI4YzRlODEzZWRhMDJmZmQwZWQyYzc3MmYy
+    MDA4NjIzMTlmZDNmMDBlYjVjZTRiNzUyOGRkNjlmMzY4NGQ4NGRjMGNjOTc3
+    ZTk0NmYzNTU1NTlkOTRmZjU4ZDhhMjdlY2FhNjNiMWJkYTA3YTM=
+  data.tar.gz: !binary |-
+    ZjkzODdiMDk5OWRmNDdlNGU5OTg2MDYxZTcyODdlOTNmZDE4NTkxYTBkZTZi
+    NDVhZDJiZjE3OGY0MGYzZWNjMDU0NGUyMmM2NjdmZjQ3MzQ5YzZlYTQ3Y2Fl
+    MDU2NzM4YzA2MTA4ZWZlYWM1OTdhZjNjZDdhZTM2MzBlMzEwNzA=

data/.gitignore

@@ -0,0 +1,21 @@
+.DS_Store
+*.sublime*
+.git-old
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+Readme.txt

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+gem 'rake'
+
+# Specify your gem's dependencies in nested_accessors.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Oskar L-B
+
+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,142 @@
+[![Build Status](https://travis-ci.org/avocade/nested_accessors.png?branch=master)](https://travis-ci.org/avocade/nested_accessors) [![Code Climate](https://codeclimate.com/github/avocade/nested_accessors.png)](https://codeclimate.com/github/avocade/nested_accessors)
+
+NestedAccessors
+==============
+
+This class lets you quickly add serialized, nested hash accessors in ActiveRecord
+model objects, using regular `text` database columns.
+
+```ruby
+class Person < ActiveRecord::Base
+  include NestedAccessors
+
+  nested_accessor :info, [ :name, :phone ]
+end
+```
+
+This would synthesize accessors to the `name` and `phone` properties contained
+in the `info` hash.
+
+```ruby
+foo = Foo.new
+foo.name = "bar"
+foo.phone = "+46-123-45678"
+foo.info #=> { "name" => "bar", "phone" => "+46-123-45678" }
+```
+
+If we want just a single `name` accessor we can remove the array:
+
+```ruby
+nested_accessor :info, :name
+```
+
+
+Installation
+------------
+
+- Add the gem to your `Gemfile`:
+
+        source :rubygems
+        gem 'nested_accessors', :git => 'git@github.com:avocade/nested_accessors.git'
+
+- Run `bundle install`
+
+
+Dependencies
+------------
+
+Requires `ActiveRecord` for the `serialize` class method. _(To be
+reconsidered.)_
+
+
+Nested hash
+------------
+
+You can nest accessors one level deep. To add more than one
+nested hash accessor to `address` we specify `street` and `city`
+inside an array.
+
+```ruby
+nested_accessor :info, address: [ :street, :city ]
+```
+
+This gives:
+
+```ruby
+object.address_street  # these two are nested inside the "address" hash
+object.address_city
+```
+
+To just specify just one accessor, eg `address[street]`, we can simplify:
+
+```ruby
+nested_accessor :info, address: street
+```
+
+**Note**: The hash keys are always strings, never symbols. This is for
+consistency of input/output.
+
+
+Testing
+-------
+
+Run the `minitest` specs using:
+
+    rake
+
+
+TODO
+-----
+
+- Add assertion checking for args
+- Switch to using `supermodel` gem for testing `active_model` serialize
+  dependency properly instead of stubbing it out
+- Allow setting default value for each accessor, eg `last_name: "Doe"`
+- Create object wrappers for each nested hash, so can get accessors like `person.address.street` for `person[address][street]`
+- Add two-level nesting, eg `foo[bar][name][surname]`
+- Array with nested Hash objects inside, eg `foo[bar][1][name]`
+- Perhaps switch convention to always use symbolic keys instead of
+stringified keys, so can use new ruby 1.9 hash syntax:
+
+        foo.info = { name: "Anders" }
+        foo.info[:name]
+
+- Add typed arguments for each accessor (defaults to `String`)
+
+        nested_accessor :info, phone: Integer
+
+Author
+------
+
+Oskar Boethius Lissheim is a Product Designer and iOS &amp; Ruby on Rails developer. He currently lives in Gothenburg, Sweden.
+
+You can reach him on App.net at
+[@avocade](http://alpha.app.net/avocade), or
+[Twitter](http://twitter.com/avocade).
+
+
+License
+-------
+
+This code is offered under the MIT License.
+
+Copyright &copy; 2012 Oskar Boethius Lissheim.
+
+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/Rakefile

@@ -0,0 +1,10 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+task default: :test
+
+require 'rake/testtask'
+Rake::TestTask.new do |i|
+  i.test_files = FileList['spec/*_spec.rb']
+  i.verbose = true
+end

data/lib/nested_accessors.rb

@@ -0,0 +1,113 @@
+require_relative "nested_accessors/version"
+require_relative "nested_accessors/railtie" if defined? Rails
+
+module NestedAccessors
+  def self.included(base)
+    base.extend ClassMethods
+  end
+
+  module ClassMethods
+    ##
+    # Creates new method +nested_accessor+ for adding dynamic accessors to nested hashes, using:
+    #   <tt>nested_accessor :pz_settings, confirmation_token: String, subsettings: { foo: String, bar: Integer }</tt>
+    def nested_accessor(name, *args)
+      self.class_eval do
+        serialize name, Hash
+      end
+
+      args.each do |an_arg|
+        if an_arg.is_a? Hash
+          # nested_accessor :info, address: [:foo]
+          an_arg.each do |subroot,propnames|
+            if propnames.is_a? Array  # eg "address: [:city, :zipcode]"
+              define_first_level_nesting_methods_for_subroot(name, subroot, Hash, propnames)
+            elsif propnames == Array  # eg "address: Array"
+              define_first_level_nesting_methods_for_subroot(name, subroot, Array)
+            elsif propnames.is_a? Symbol  # eg "auth: :facebook"
+              define_first_level_nesting_methods_for_subroot(name, subroot, Hash, [propnames])
+            elsif propnames.is_a? Hash  # eg "subregion: { address: [:street, :city] }"
+              propnames.each do |subsubroot,subpropnames|
+                define_first_level_nesting_methods_for_subroot(name, subroot, Hash, [subsubroot])
+                define_second_level_nesting_methods(subroot, subsubroot, subpropnames)
+              end
+            end
+          end
+        elsif an_arg.is_a? Array
+          an_arg.each do |a_propname|
+            define_first_level_nesting_methods_for_property(name, a_propname)
+          end
+        elsif an_arg.is_a? Symbol
+          define_first_level_nesting_methods_for_property(name, an_arg)
+        end
+      end
+    end
+  end
+end
+
+# HELPER METHODS
+def define_first_level_nesting_methods_for_property(root, propname)
+  class_eval <<-RUBY, __FILE__, __LINE__+1
+    def #{propname}=(val)
+      #{root}.store("#{propname}", val.to_s)
+    end
+
+    def #{propname}
+      #{root}.store("#{propname}", nil) unless (#{root}.has_key?("#{propname}"))
+      #{root}.fetch "#{propname}"
+    end
+  RUBY
+end
+
+def define_first_level_nesting_methods_for_subroot(root, subroot, subroot_type, propnames=nil)
+  subroot_value = case subroot_type.to_s
+    when "Array" then []
+    else {}
+  end
+
+  class_eval <<-RUBY, __FILE__, __LINE__+1
+    def #{subroot}
+      #{root}.store("#{subroot}", #{subroot_value}) unless (#{root}.has_key?("#{subroot}") and #{root}.fetch("#{subroot}").is_a?(#{subroot_value}.class))
+      #{root}.fetch "#{subroot}"
+    end
+  RUBY
+
+  if propnames
+    propnames.each do |a_propname|
+      self.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{subroot}_#{a_propname}=(val)
+          #{subroot}.store("#{a_propname}".to_s, val.to_s)
+        end
+
+        def #{subroot}_#{a_propname}
+          #{subroot}.store("#{a_propname}", nil) unless (#{subroot}.has_key?("#{a_propname}"))
+          #{subroot}.fetch "#{a_propname}".to_s
+        end
+      RUBY
+    end
+  end
+end
+
+def define_second_level_nesting_methods(subroot, subsubroot, propnames)
+  self.class_eval <<-RUBY, __FILE__, __LINE__+1
+    def #{subroot}_#{subsubroot}
+      #{subroot}.store("#{subsubroot}", {}) unless (#{subroot}.has_key?("#{subsubroot}") and #{subroot}.fetch("#{subsubroot}").is_a?(Hash))
+      #{subroot}.fetch "#{subsubroot}"
+    end
+  RUBY
+
+  if propnames
+    propnames.each do |a_propname|
+      self.class_eval <<-RUBY, __FILE__, __LINE__+1
+        def #{subroot}_#{subsubroot}_#{a_propname}=(val)
+          #{subroot}_#{subsubroot}.store("#{a_propname}", val.to_s)
+        end
+
+        def #{subroot}_#{subsubroot}_#{a_propname}
+          #{subroot}_#{subsubroot}.store("#{a_propname}", nil) unless (#{subroot}_#{subsubroot}.has_key?("#{a_propname}"))
+          #{subroot}_#{subsubroot}.fetch "#{a_propname}"
+        end
+      RUBY
+    end
+  end
+end
+

data/lib/nested_accessors/railtie.rb

@@ -0,0 +1,9 @@
+module NestedAccessors
+  class Railtie < Rails::Railtie
+    initializer 'nested_accessors' do
+      ActiveSupport.on_load :active_record do
+        include NestedAccessors
+      end
+    end
+  end
+end

data/lib/nested_accessors/version.rb

@@ -0,0 +1,3 @@
+module NestedAccessors
+  VERSION = "0.1.3"
+end

data/nested_accessors.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/nested_accessors/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Oskar Boethius Lissheim"]
+  gem.email         = ["oskar@OLBproductions.com"]
+  gem.homepage      = "http://OLBproductions.com"
+  gem.description   = %q{Quickly add serialized, nested hash accessors in ActiveRecord model objects}
+  gem.summary       = %q{Without having to write your own accessor methods for getting at serialized hash properties}
+  gem.homepage      = "http://OLBproductions.com"
+  gem.license      = 'MIT'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.name          = "nested_accessors"
+  gem.require_paths = ["lib"]
+  gem.version       = NestedAccessors::VERSION
+  gem.extra_rdoc_files = ['README.md']
+
+  gem.add_development_dependency "minitest"
+  gem.add_development_dependency "simple_mock"
+  gem.add_development_dependency "minitest-colorize"
+end

data/spec/nested_accessors_spec.rb

@@ -0,0 +1,179 @@
+require 'minitest/autorun'
+require 'minitest/spec'
+require 'simple_mock'
+require 'minitest-colorize'
+
+require_relative '../lib/nested_accessors'
+
+# STUBBING OUT active_record "serialized" class method
+class Person  #< ActiveRecord::Base  # must inherit from activerecord to get "serialize" class method
+  # Stubs out the "serialize :name, Hash" method
+  # So don't have to use activerecord
+  # Creates eg a :info hash accessor and returns hash
+  def self.serialize(name, klass)
+    attr_accessor name
+    define_method name do
+      @serialized_hash = {} if @serialized_hash.nil?
+      @serialized_hash
+    end
+  end
+
+  # must include module after the serialize method has been defined (it's defined in the superclass when inherited from activerecord)
+  include NestedAccessors
+
+  # USAGE in active_record model:
+  # nested_accessor :info, :phone, address: [ :street, :zipcode ]
+end
+
+# SPECS
+describe NestedAccessors do
+  describe 'init method for hash accessors' do
+    it 'should init root object to Hash if blank or not a Hash' do
+      Person.class_eval %q{ nested_accessor :info }
+      Person.new.info.class.must_equal Hash
+    end
+
+    describe "with phone accessor" do
+      before(:each) do
+        Person.class_eval %q{ nested_accessor :info, :phone }
+      end
+
+      let(:person) { Person.new }
+
+      it 'should use stringified keys' do
+        person.phone = "12378"
+        person.info.keys.must_include "phone"
+      end
+
+      it 'should init key to nil if blank' do
+        person.info.keys.must_be_empty
+        person.phone.must_be_nil  # shouldn't raise exception since it couldn't find the key
+      end
+
+      it 'sets up accessors for first level of nesting' do
+        person.phone = "123-2345"
+        person.phone.must_equal "123-2345"
+      end
+
+      it 'read accessor should return value typed to String by default (to_s)' do
+        person.phone = 123
+        person.phone.must_equal "123"
+      end
+
+      it 'write accessor should save value typed to String' do
+        person.phone = 234
+        person.info["phone"].must_equal "234"
+      end
+
+      it 'each subvalue should be nil if regular value param' do
+        person.info["phone"].must_be_nil
+        person.info["address"].must_be_nil
+      end
+
+      it 'can set multiple properties if first param is Array type' do
+        Person.class_eval %q{ nested_accessor :info, [:phone1, :phone2] }
+        person = Person.new
+        person.info["phone1"] = "2365"
+        person.phone1.must_equal "2365"
+        person.phone2 = "9090"
+        person.info["phone2"].must_equal "9090"
+      end
+    end
+
+    describe 'subhashes' do
+      it 'should init as hash if gets Array with multiple params for a property name in Hash' do
+        # Gives self.info["address"]["street"] and ["city"]
+        Person.class_eval %q{ nested_accessor :info, address: [:street, :city] }
+        person = Person.new
+        person.address.must_be_kind_of Hash
+        person.address["city"] = "Goteborg"
+        person.address["city"].must_equal "Goteborg"
+      end
+
+      it 'should init subhash to nil value if blank' do
+        Person.class_eval %q{ nested_accessor :info, address: [:street, :city] }
+        person = Person.new
+        person.address.must_be_kind_of Hash
+        person.address_street.must_be_nil  # shouldn't raise exception since it couldn't find the key
+      end
+
+      it 'should init with just one param in array' do
+        Person.class_eval %q{ nested_accessor :info, snub: [:identifier] }
+        person = Person.new
+        person.snub.must_be_kind_of Hash
+        person.snub_identifier = "Achaplan"
+        person.snub_identifier.must_equal "Achaplan"
+      end
+
+      it 'should init with just one param symbol in hash as well' do
+        Person.class_eval %q{ nested_accessor :info, auth: :facebook }
+        person = Person.new
+        person.auth.must_be_kind_of Hash
+        person.auth_facebook = "12k3j"
+        person.auth_facebook.must_equal "12k3j"
+      end
+
+      it 'should create shallow accessor methods for each hash propname' do
+        Person.class_eval %q{ nested_accessor :bank, branch: [:designator, :account_number] }
+        person = Person.new
+        person.branch.must_be_kind_of Hash
+        person.branch_designator = "123"
+        person.branch_designator.must_equal "123"
+        person.branch_account_number = "999"
+        person.branch_account_number.must_equal "999"
+      end
+
+      # it 'should perhaps create accessor methods on the subroot object, for each subparam in hash' do
+      #   Person.class_eval %q{ nested_accessor :info, address: [:street, :city] }
+      #   person = Person.new
+      #   person.address.must_be_kind_of Hash
+      #   # the subroot method must thus return an object and define attr_accessor methods on it for each propname
+      #   person.address.street = "Storgatan"
+      #   person.address.street.must_equal "Storgatan"
+      #   person.address.city = "Bigtown"
+      #   person.address.city.must_equal "Bigtown"
+      # end
+    end
+
+    it 'should init subvalue with Array if type set to array for accessor' do
+      # nested_accessor :info, balls: Array
+      #=> self.info["Balls"] == []
+      Person.class_eval %q{ nested_accessor :things, balls: Array }
+      person = Person.new
+      person.balls.must_be_kind_of Array
+      person.balls << "bob"
+      person.balls << "alice"
+      person.balls.must_include "bob"
+      person.balls.must_include "alice"
+    end
+
+    describe 'second level nesting' do
+      it 'sets up accessors for two level deep hash' do
+        # nested_accessor :info, subregion: { address: [:street, :city] }
+        #=> foo.info[address][subregion] = {}
+        # Person.class_eval %q{ nested_accessor :home, subregion: { address: [:street, :city] } }
+        Person.class_eval %q{ nested_accessor :home, budget: { heating: [:highest, :lowest] } }
+        person = Person.new
+        person.budget_heating.must_be_kind_of Hash
+        person.budget.must_be_kind_of Hash
+        person.budget.has_key?("heating").must_equal true  # can only test that hash has the key after we've used the subregion command since that instantiates the nested hash
+        person.budget_heating_highest = "32 C"
+        person.budget_heating_highest.must_equal "32 C"
+        person.budget_heating_lowest = "10 C"
+        person.budget_heating_lowest.must_equal "10 C"
+      end
+
+      it 'should init deep hash values to nil value if blank' do
+        Person.class_eval %q{ nested_accessor :place, location: { coordinate: [:lat, :lon] } }
+        person = Person.new
+        person.location_coordinate.must_be_kind_of Hash
+        person.location_coordinate_lat.must_be_nil  # shouldn't raise exception since it couldn't find the key
+      end
+
+      it 'should set deep hash values and not overwrite others in the same subhash' do
+        # TODO: Must test so we don't just write a new hash when changing a value
+      end
+    end
+  end
+end
+

metadata

@@ -0,0 +1,99 @@
+--- !ruby/object:Gem::Specification
+name: nested_accessors
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Oskar Boethius Lissheim
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-04 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  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: simple_mock
+  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: minitest-colorize
+  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'
+description: Quickly add serialized, nested hash accessors in ActiveRecord model objects
+email:
+- oskar@OLBproductions.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- README.md
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/nested_accessors.rb
+- lib/nested_accessors/railtie.rb
+- lib/nested_accessors/version.rb
+- nested_accessors.gemspec
+- spec/nested_accessors_spec.rb
+homepage: http://OLBproductions.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Without having to write your own accessor methods for getting at serialized
+  hash properties
+test_files:
+- spec/nested_accessors_spec.rb