metahash-rb 1.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4017650f154dc99effbfb8b354353dc193088eed
+  data.tar.gz: 49824be43db47b292c7326284b2aff91257e021f
+SHA512:
+  metadata.gz: ccdc5d25310105884c35fbbe09c07c7814ccc83953ba33e954abc3403faa862376543f9b17ecd0f3a517b9548dc5f406afcee6d9305a277fed8ceba737e5a36a
+  data.tar.gz: 9fa68441c4516a83050f90efc62b4369d3c5a97c959eb2b5b0b9e37f04cede5dfa014bdecc82c74e629888aead1827bdd4fd3a8238efe68961bb986d8b828c36

data/.gitignore

@@ -0,0 +1,18 @@
+*.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.html

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 TinderBox
+
+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,53 @@
+MetaHash
+========
+
+[![](https://ci.solanolabs.com:443/TinderBox/MetaHash/badges/110842.png?badge_token=a5097ea0ff487d291e94285ed9e4c8fabeca5fd1)](https://ci.solanolabs.com:443/TinderBox/MetaHash/suites/110842)
+[![Code Climate](https://codeclimate.com/github/NullVoxPopuli/MetaHash/badges/gpa.svg)](https://codeclimate.com/github/NullVoxPopuli/MetaHash)
+[![Dependency Status](https://gemnasium.com/NullVoxPopuli/MetaHash.svg)](https://gemnasium.com/NullVoxPopuli/MetaHash)
+
+
+Provides a subclass of Hash and a wrapper around Rails' serialize attribute for object-like access to hashes without validating existence of nested hashes
+
+##  Examples
+#### Access nested hashes using method / object syntax
+
+    h = Metadata.new
+    h # => {}
+    h.outer.inner # => {}
+
+#### Access to values stored in nested hashes via method call syntax
+
+    h = Metadata.new( { outer: { inner: { hash_key: "value" } } } )
+    h.outer.inner.hash_key # => "value"
+
+#### Set values for nested hash structures without the nested hashes having to be initially defined
+
+    h = Metadata.new( {} )
+
+## Using with ActiveRecord
+
+#### In your Gemfile
+
+    gem "metahash-rb"
+
+#### in your ActiveRecord model
+
+    has_metadata
+
+or
+
+    has_metadata :field_not_called_metadata
+
+
+## Support
+
+This gem has been tested with Ruby 2.0, and rails 3.2, 4.1
+
+
+## Contributing
+
+1. Fork the project
+2. Create a new, descriptively named branch
+3. Add Test(s)!
+4. Commit your proposed changes
+5. Submit a pull request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/metahash.rb

@@ -0,0 +1,50 @@
+require "metahash/metadata"
+require "metahash/version"
+require 'active_record'
+
+module MetaHash
+
+  # When an active record object is loaded, convert to Metadata.
+  # If for whatever reason we lose this Metadata class, we can read
+  # the hash by creating class Metadata < Hash; end
+  #
+  # @param [Symbol] serialized_field name of the field to convert to Metadata
+  def has_metadata(serialized_field = "metadata")
+    # tell Active Record that the field is going to be JSON
+    # serialized, because JSON > YAML
+    serialize serialized_field, JSON
+
+    after_initialize do |record|
+      # first check the type of the field
+      # proceed if hash, abort if Metadata
+      if record.has_attribute?(serialized_field)
+        if [Hash, NilClass].include?(record.send(serialized_field).class)
+          # alias the old method / field
+          backup_name = "#{serialized_field}_original".to_sym
+          # alias_method backup_name, serialized_field
+          record.define_singleton_method backup_name, record.method(serialized_field)
+          # name the metadata accessor the same as the original field
+          # rails should automatically serialize this on save
+          initial_value = record.send(backup_name) || {}
+          record.send("#{serialized_field}=", Metadata.new(initial_value))
+        end
+      end
+    end
+
+
+    # create a before_save hook to store a pure Hash in the DB
+    before_save do |record|
+      @temp_metadata = record.send(serialized_field)
+      record.send("#{serialized_field}=", @temp_metadata.to_hash) if @temp_metadata
+    end
+
+    # restore the metadata to the field
+    after_save do |record|
+      record.send("#{serialized_field}=", @temp_metadata) if @temp_metadata
+    end
+
+  end
+
+end
+
+ActiveRecord::Base.send :extend, MetaHash

data/lib/metahash/metadata.rb

@@ -0,0 +1,135 @@
+# MetadataHash - A specific use of ruby's Hash
+#
+# overrides Hash's method missing, providing the following functionality:
+# 1. Access Nested hashes using the method / attribute syntax
+#   i.e.: h = {}
+#     h.middle.inner == {}
+#
+# 2. Access to values stored in nested hashes via method call syntax
+#   i.e.: h = { middle: { inner: { key: "value" } } }
+#     h.middle.inner.key == "value"
+#
+# 3. Set values for nested hash structures without middle nested hashes
+#   having to be defined
+#   i.e.: h = {}
+#     h.middle.inner = 3
+#     h == { middle: { inner: 3 } }
+#
+# 4. Old hash square bracket access still works
+#   i.e.: h = { inner: { key: "value" } }
+#     h[:inner][:key] == "value"
+#
+class Metadata < Hash
+
+  # the hash being passed in will have all its subhashes converted to
+  # metadata hashes.
+  # this is needed to we can have the
+  #
+  # @raise [ArgumentError] if one of the keys is method of Hash
+  # @raise [ArgumentError] if hash is not a type of Hash or Metadata
+  # @param [Hash] hash the structure to convert to Metadata
+  def initialize(hash = {})
+    # for maybe instantiating nested hashes that we
+    # aren't yet sure if they are going to have values or not
+    @empty_nested_hashes = []
+
+    if hash.is_a?(Metadata)
+      # we have nothing to do
+      return hash
+    elsif hash.is_a?(Hash)
+      # recursively create nested metadata objects
+      hash.each do |key, value|
+        if not valid_key?(key)
+          raise ArgumentError.new("Not Allowed. '#{key}' is a reserved method.")
+        end
+
+        self[key] = (
+          if value.is_a?(Hash)
+            Metadata.new(value)
+          elsif value.is_a?(Array)
+            # ensure hashes kept in an array are also converted to metadata
+            array = value.map{ |element|
+              element.is_a?(Hash) ? Metadata.new(element) : element
+            }
+          else
+            value
+          end
+        )
+      end
+    else
+      raise ArgumentError.new("Field must be a Hash or Metadata")
+    end
+  end
+
+
+  # this is what allows functionality mentioned in the class comment to happen
+  # @raise [ArgumentError] if one of the keys is method of Hash
+  def method_missing(method_name, *args)
+    # check for assignment
+    if (key = method_name.to_s).include?("=")
+      key = key.chop.to_sym
+      if not self.valid_key?(key)
+        raise ArgumentError.new("Not Allowed. '#{key}' is a reserved method.")
+      end
+
+      if not @empty_nested_hashes.empty?
+        deepest_metadata = self
+        @empty_nested_hashes.each do |key|
+          deepest_metadata = deepest_metadata[key] = Metadata.new
+        end
+        @empty_nested_hashes = []
+        deepest_metadata[key] = args[0]
+     end
+    else
+      value = self[method_name]
+      if not value
+        @empty_nested_hashes << method_name.to_sym
+        value = self
+      end
+      value
+    end
+
+  end
+
+  # Metdata has indifferent access
+  def [](key)
+    super(key.to_sym)
+  end
+
+  # # Metadata has indifferent access,
+  # # so just say that all the keys are symbols.
+  def []=(key, value)
+    super(key.to_sym, value)
+  end
+
+  # tests the ability to use this key as a key in a hash
+  # @param [Symbol] key
+  # @return [Boolean] whether or not this can be used as a hash key
+  def valid_key?(key)
+    # second parameter says that we are
+    #  looking at private methods as well
+    not self.respond_to?(key, true)
+  end
+
+  # convert to regular hash, recursively
+  def to_hash
+    hash = {}
+    self.each do |k,v|
+      hash[k] = (
+        if v.is_a?(Metadata)
+          v.to_hash
+        elsif v.is_a?(Array)
+          v.map{ |e| e.is_a?(Metadata) ? e.to_hash : e }
+        else
+          v
+        end
+      )
+    end
+
+    hash
+  end
+
+  def to_ary
+    self.to_hash.to_a
+  end
+end

data/lib/metahash/version.rb

@@ -0,0 +1,3 @@
+module MetaHash
+  VERSION = "1.0.1"
+end

data/metahash.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "metahash/version"
+
+Gem::Specification.new do |s|
+  s.name        = "metahash-rb"
+  s.version     = MetaHash::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.license     = "MIT"
+  s.authors     = ["L. Preston Sego III"]
+  s.email       = "LPSego3+dev@gmail.com"
+  s.homepage    = "https://github.com/NullVoxPopuli/MetaHash"
+  s.summary     = "MetaHash-#{MetaHash::VERSION}"
+  s.description = "Provides a subclass of Hash and a wrapper around Rails' serialize attribute for object-like access to hashes without validating existence of nested hashes."
+
+
+  s.files         = `git ls-files`.split($/)
+  s.executables   = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ["lib"]
+
+
+  s.add_runtime_dependency "activerecord", ">= 3.0.0"
+  s.add_development_dependency "bundler"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "sqlite3"
+  s.add_development_dependency "pry-byebug"
+  s.add_development_dependency "codeclimate-test-reporter"
+
+end

data/spec/metadata_spec.rb

@@ -0,0 +1,58 @@
+require "spec_helper"
+
+describe Metadata do
+
+  it "is a hash" do
+    expect(Metadata.new).to be_kind_of(Hash)
+  end
+
+  describe "pruning empty hashes" do
+    let(:m){Metadata.new}
+
+    it "removes empty hashes" do
+      m.a.b.c
+      expect(m.send :prune).to eq Metadata.new
+    end
+
+    it "does not remove valid hashes" do
+      m.a.b = 2
+      expect(m.send :prune).to_not eq Metadata.new
+    end
+
+    it "does not pollute itself with empty hashes" do
+      m.a.b.c
+      expect(m).to eq Metadata.new
+    end
+  end
+
+
+  it "sets a non-exsiting deep value" do
+    m = Metadata.new
+    m.a.b = 2
+    expect(m.a.b).to eq 2
+  end
+
+  it "has indifferent access" do
+    m = Metadata.new(a: 2)
+    expect(m.a).to eq 2
+    expect(m[:a]).to eq 2
+    expect(m["a"]).to eq 2
+  end
+
+  it "allows method-style access to nested hashes" do
+    m = Metadata.new(h)
+    expect(m.outer.inner.k).to eq h[:outer][:inner][:k]
+  end
+
+  it "allows hash-style access to nested hashes" do
+    m = Metadata.new(h)
+    expect(m[:outer][:inner][:k]).to eq h[:outer][:inner][:k]
+  end
+
+  it "does not allow hash keys to conflict with the name of a method of the Hash object" do
+    expect{
+      Metadata.new( outer: { key: "value" } )
+    }.to raise_error
+  end
+
+end

data/spec/metahash_spec.rb

@@ -0,0 +1,54 @@
+require "spec_helper"
+
+describe MetaHash do
+
+
+    before(:each) do
+      m = TestObject.new(metadata: h, name: "MetaHash")
+      m.save
+    end
+
+    after(:each) do
+      TestObject.destroy_all
+    end
+
+    it "converts the chose field to Metadata" do
+      p = TestObject.last
+      expect(p.metadata).to be_kind_of(Metadata)
+    end
+
+    it "instantiates with an empty hash if the field is nil" do
+      p = TestObject.new
+      p.metadata = nil
+      p = TestObject.last
+      expect(p.metadata).to_not be_nil
+      expect(p.metadata).to be_kind_of(Metadata)
+    end
+
+    it "does not modify the original contents of the chosen field on initialization" do
+      p = TestObject.last
+      expect(p.metadata.to_hash).to eq Metadata.new(h)
+    end
+
+    it "creates an alias for the original field's data" do
+      p = TestObject.last
+      expect(p.metadata_original).to eq Metadata.new(h)
+    end
+
+    it "doesn't error when a the attribute is not included in the retrieval of a record" do
+      expect{
+        p = TestObject.select("name")
+      }.to_not raise_error
+    end
+
+    it "converts the field back to a Hash before saving to the database" do
+      db = ActiveRecord::Base.connection.select_all("
+          SELECT metadata
+          FROM test_objects
+        ").last
+      p = db["metadata"]
+      expect(JSON.load(p)).to eq JSON.load(h.to_json)
+    end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+
+require "rubygems"
+require "bundler/setup"
+require "metahash"
+require "pry-byebug" # binding.pry to debug!
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+load File.dirname(__FILE__) + '/support/schema.rb'
+Dir[File.dirname(__FILE__) + '/support/**/*.rb'].each {|file| require file }
+
+
+
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/models/test_object.rb

@@ -0,0 +1,3 @@
+class TestObject < ActiveRecord::Base
+	has_metadata
+end

data/spec/support/sample_hashes.rb

@@ -0,0 +1,9 @@
+def h
+  {
+    outer: {
+      inner: {
+        k: "value"
+      }
+    }
+  }
+end

data/spec/support/schema.rb

@@ -0,0 +1,8 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :test_objects, :force => true do |t|
+  	t.string :name
+  	t.text :metadata
+  end
+end

data/tddium.yml

@@ -0,0 +1,3 @@
+:tddium:
+  :ruby_version: ruby-2.1.2
+  :coverage: true

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification
+name: metahash-rb
+version: !ruby/object:Gem::Version
+  version: 1.0.1
+platform: ruby
+authors:
+- L. Preston Sego III
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-09-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rspec
+  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: sqlite3
+  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: pry-byebug
+  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: codeclimate-test-reporter
+  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: Provides a subclass of Hash and a wrapper around Rails' serialize attribute
+  for object-like access to hashes without validating existence of nested hashes.
+email: LPSego3+dev@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/metahash.rb
+- lib/metahash/metadata.rb
+- lib/metahash/version.rb
+- metahash.gemspec
+- spec/metadata_spec.rb
+- spec/metahash_spec.rb
+- spec/spec_helper.rb
+- spec/support/models/test_object.rb
+- spec/support/sample_hashes.rb
+- spec/support/schema.rb
+- tddium.yml
+homepage: https://github.com/NullVoxPopuli/MetaHash
+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.4.1
+signing_key: 
+specification_version: 4
+summary: MetaHash-1.0.1
+test_files:
+- spec/metadata_spec.rb
+- spec/metahash_spec.rb
+- spec/spec_helper.rb
+- spec/support/models/test_object.rb
+- spec/support/sample_hashes.rb
+- spec/support/schema.rb