lazy_doc 0.1.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MTYzNGFkNWU2YjdkM2I4OGE4YzAyY2UyNmRmOGNmOTFkMWI4ZDQ3Yg==
+  data.tar.gz: !binary |-
+    Nzk4YzFiNjhkMzg1YTI2YTI0YWIwY2QzZGIzYjk1OGE0NDVjYTNmMw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    NmY4NmIwMGRjYmEzYTEwMWI2N2MxY2ZhYTRjYjc2NGNhZjU2NzBjYTllMmM0
+    MzdlOWI1ZmY2ZGMzZmUxM2IwMjE1YWQ5OTE3NTRkZjBjYmIxZWNiNjkyOTk0
+    Y2RjOTYwMzI1M2ViYTAyYjNjZWVlZDBhNzdmMTdlZDY1NzdkZmI=
+  data.tar.gz: !binary |-
+    N2UzNDQ5OGVkNDlkZGQ3MmU0NzU2YzIyNTJiZDI2NDZmN2ZlNTZiN2ZhMmNi
+    ZjkwNDY4M2EwY2YxYWI4MGQxYmUwOWZlNTRmNGE5YTk2ZmVjYzFkODA3ZGZh
+    NDljN2U5ODg5NGQwYWJlOGJhN2IwN2IzMjVlM2I3ZTMzMTViOTY=

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
+.idea

data/.rspec

@@ -0,0 +1 @@
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+lazy_doc

data/.ruby-version

@@ -0,0 +1 @@
+ruby-1.9.3-p448

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.9.3"
+
+script: bundle exec rspec

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Ryan Oglesby
+
+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,84 @@
+# LazyDoc
+
+NOTE: LazyDoc is currently in alpha and is not quite ready for use.
+
+[![Build Status](https://travis-ci.org/ryanoglesby08/lazy-doc.png)](https://travis-ci.org/ryanoglesby08/lazy-doc)
+
+
+
+An implementation of the [Embedded Document](http://martinfowler.com/bliki/EmbeddedDocument.html) pattern for POROs.
+
+LazyDoc provides a declarative DSL for extracting deeply nested values from a JSON document. The embedded JSON is lazily
+parsed so that needed attributes from the document are only parsed when accessed. Finally, parsed values are cached
+so that subsequent access does not access the JSON again.
+
+*Currently, LazyDoc only supports JSON. XML support will be added later.*
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'lazy_doc'
+
+## DSL Options
+
+1. Basic usage. `access`: `access :name` will look for a property called 'name' at the top level of the embedded document.
+2. `access :name, :phone, :address` will look for all three properties. *This option does not currently support using any options.*
+3. `via`: `access :job, via: [:profile, :occupation]` will look for a property called 'job' by parsing through
+'profile' -> 'occupation'.
+4. `default`: `access :currency, default: 'USD'` will use the default value of 'USD' if the currency attribute is set to an empty value (`empty?` or `nil?`)
+5. `finally`: `access :initials, finally: lambda { |initials| initials.upcase }` will call the supplied block, passing in
+'initials,' and will return the result of that block.
+6. `as`: `access :profile, as: Profile` will pass the sub-document found at 'profile' into a new 'Profile' object, and will return
+the newly constructed Profile object. This is great for constructing nested LazyDoc relationships.
+7. `extract`: `access :customers, extract: :name` will make the assumption that the attribute 'customers' will be an array of objects and will extract the 'name' property from each object and return an array of 'names' (This would be the equivalent of the Enumerable#map method)
+
+
+
+## Example Usage
+
+```ruby
+class User
+    include LazyDoc::DSL
+
+    access :name                                        # Access the attribute "name"
+    access :address, via: :streetAddress                # Access the attribute "streetAddress"
+    access :job, via: [:profile, :occupation, :title]   # Access the attribute "title" found at "profile" -> "occupation"
+
+    def initialize(json)
+      lazily_embed(json)                                # Initialize the LazyDoc object
+    end
+end
+
+json = '{"name": "George Washington", "streetAddress": "The White House", "profile": {"occupation": {"title": "President"}}}'
+user = User.new(json)
+puts user.name
+puts user.address
+puts user.job
+```
+
+## To Do
+
+1. DONE - Full path parsing more than just top level.  ex: `access :name, via: [:profile, :basic_info, :name]`
+2. DONE - Error throwing for incorrectly specified paths
+3. DONE - Default value if json is null or empty. ex: `access :currency, default: 'USD'`
+4. DONE - Transforms. ex: `access :name, finally: lambda { |name| name.gsub('-',' ') }`
+5. DONE - Objects from sub-trees.  ex: `access :profile, as: Profile` (This would construct a LazyDoc Profile object and pass the json found at "profile" to it)
+6. Collections.
+    - DONE - Map. For example, extract array of customer names from array of customers. ex: `access :customers, extract: :name`
+    - Objects from collection. Instead of extracting just the name, extract whole objects like in #5.  ex:  `access :customers, as: Customer`
+    - Other Collection manipulations, select, inject, etc
+7. Joins
+    - Using previously defined attributes. ex: `join :address, from: [:street, :city, :state:, :zip]`
+    - Defining attributes in place.
+8. DONE - Multiple simple paths in one line (ex: `access :name, :street, :city, :state`)
+9. Infer camelCase to snake_case and vice versa in JSON ex: `access :customer_name` (Where the json has customerName)
+10. XML support
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"

data/lazy_doc.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/lazy_doc/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Ryan Oglesby"]
+  gem.email         = ["ryan.oglesby08@gmail.com"]
+  gem.description   = %q{LazyDoc provides a declarative DSL for extracting deeply nested values from a JSON document}
+  gem.summary       = %q{An implementation of the Embedded Document pattern for POROs}
+  gem.homepage      = "https://github.com/ryanoglesby08/lazy-doc"
+
+  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          = "lazy_doc"
+  gem.require_paths = ["lib"]
+  gem.version       = LazyDoc::VERSION
+
+  gem.license       = 'MIT'
+
+  gem.add_development_dependency "rspec"
+  gem.add_development_dependency "pry-debugger"
+end

data/lib/lazy_doc.rb

@@ -0,0 +1,5 @@
+require 'lazy_doc/attribute_not_found_error'
+require 'lazy_doc/commands'
+require 'lazy_doc/dsl'
+require 'lazy_doc/memoizer'
+require 'lazy_doc/version'

data/lib/lazy_doc/attribute_not_found_error.rb

@@ -0,0 +1,3 @@
+module LazyDoc
+  class AttributeNotFoundError < StandardError ;end
+end

data/lib/lazy_doc/commands.rb

@@ -0,0 +1,10 @@
+module LazyDoc
+  module Commands
+  end
+end
+
+require 'lazy_doc/commands/as_class_command'
+require 'lazy_doc/commands/default_value_command'
+require 'lazy_doc/commands/extract_command'
+require 'lazy_doc/commands/finally_command'
+require 'lazy_doc/commands/via_command'

data/lib/lazy_doc/commands/as_class_command.rb

@@ -0,0 +1,13 @@
+module LazyDoc::Commands
+  class AsClassCommand
+    attr_reader :klass
+
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def execute(value)
+      klass.nil? ? value : klass.new(value.to_json)
+    end
+  end
+end

data/lib/lazy_doc/commands/default_value_command.rb

@@ -0,0 +1,19 @@
+module LazyDoc::Commands
+  class DefaultValueCommand
+    attr_reader :default
+
+    def initialize(default)
+      @default = default
+    end
+
+    def execute(value)
+      use_default?(value) ? default : value
+    end
+
+    private
+
+    def use_default?(value)
+      !default.nil? && (value.nil? || value.empty?)
+    end
+  end
+end

data/lib/lazy_doc/commands/extract_command.rb

@@ -0,0 +1,15 @@
+module LazyDoc::Commands
+  class ExtractCommand
+
+    attr_reader :attribute_to_extract
+
+    def initialize(attribute_to_extract)
+      @attribute_to_extract = attribute_to_extract
+    end
+
+    def execute(value)
+      attribute_to_extract.nil? ? value : value.map { |element| element[attribute_to_extract.to_s] }
+    end
+  end
+
+end

data/lib/lazy_doc/commands/finally_command.rb

@@ -0,0 +1,15 @@
+module LazyDoc::Commands
+  class FinallyCommand
+    attr_reader :transformation
+
+    NO_OP_TRANSFORMATION = lambda { |value| value }
+
+    def initialize(transformation)
+      @transformation = transformation || NO_OP_TRANSFORMATION
+    end
+
+    def execute(value)
+      transformation.call(value)
+    end
+  end
+end

data/lib/lazy_doc/commands/via_command.rb

@@ -0,0 +1,21 @@
+module LazyDoc::Commands
+  class ViaCommand
+    attr_reader :path
+
+    def initialize(path)
+      @path = [path].flatten
+    end
+
+    def execute(document)
+      path.inject(document) do |final_value, attribute|
+        unless final_value.has_key?(attribute.to_s)
+          raise LazyDoc::AttributeNotFoundError.new("Unable to access #{attribute} via #{path.join(', ')}")
+        end
+
+        final_value[attribute.to_s]
+      end
+    end
+
+  end
+
+end

data/lib/lazy_doc/dsl.rb

@@ -0,0 +1,86 @@
+require 'json'
+
+module LazyDoc
+  module DSL
+    def self.included(base)
+      base.extend ClassMethods
+    end
+
+    def lazily_embed(json)
+      @_embedded_doc_source = json
+    end
+
+    private
+
+    def memoizer
+      @_memoizer ||= Memoizer.new
+    end
+
+    def embedded_doc
+      @_embedded_doc ||= JSON.parse(@_embedded_doc_source)
+    end
+
+
+    module ClassMethods
+      def access(*arguments)
+        attributes, options = extract_from(arguments)
+
+        if attributes.size == 1
+          define_access_method_for(attributes[0], options)
+        else
+          define_access_methods_for(attributes)
+        end
+      end
+
+      def define_access_method_for(attribute, options)
+        create_method(attribute,  Commands::ViaCommand.new(options[:via] || attribute),
+                                  Commands::DefaultValueCommand.new(options[:default]),
+                                  Commands::AsClassCommand.new(options[:as]),
+                                  Commands::ExtractCommand.new(options[:extract]),
+                                  Commands::FinallyCommand.new(options[:finally]))
+      end
+
+      def define_access_methods_for(attributes)
+        attributes.each do |attribute|
+          create_method(attribute, Commands::ViaCommand.new(attribute))
+        end
+
+      end
+
+      def create_method(attribute, required_command, *optional_commands)
+        define_method attribute do
+          memoizer.memoize attribute do
+            value = required_command.execute(embedded_doc)
+
+            optional_commands.inject(value) do |final_value, command|
+              final_value = command.execute(final_value)
+              final_value
+            end
+          end
+
+        end
+
+      end
+
+      def extract_from(arguments)
+        arguments << {} unless arguments.last.is_a? Hash
+
+        options = arguments.pop
+        attributes = [arguments].flatten
+
+        verify_arguments(attributes, options)
+
+        [attributes, options]
+      end
+
+      def verify_arguments(attributes, options)
+        if attributes.size > 1 && !options.empty?
+          raise ArgumentError, 'Options provided for multiple attributes'
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/lazy_doc/memoizer.rb

@@ -0,0 +1,12 @@
+module LazyDoc
+  class Memoizer
+    def memoize(attribute)
+      attribute_variable_name = "@#{attribute}"
+      unless instance_variable_defined?(attribute_variable_name)
+        instance_variable_set(attribute_variable_name, yield)
+      end
+
+      instance_variable_get(attribute_variable_name)
+    end
+  end
+end

data/lib/lazy_doc/version.rb

@@ -0,0 +1,3 @@
+module LazyDoc
+  VERSION = '0.1.0'
+end

data/spec/acceptance/basic_behavior_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../spec_helper'
+
+describe 'basic behavior with a simple JSON document' do
+  class Friends
+    include LazyDoc::DSL
+
+    access :best_friend, via: :bestFriend
+    access :lover
+
+    def initialize(json)
+      lazily_embed(json)
+    end
+  end
+
+  class User
+    include LazyDoc::DSL
+
+    access :name
+    access :phone, :zip
+    access :home_town
+    access :address, via: :streetAddress
+    access :job_title, via: [:profile, :occupation, :title]
+    access :born_on, via: [:profile, :bornOn], finally: lambda { |born_on| born_on.to_i }
+    access :friends, as: Friends
+    access :father, default: 'Chuck Palahniuk'
+    access :fight_club_rules, via: [:fightClub, :rules], extract: :title
+
+    def initialize(json)
+      lazily_embed(json)
+    end
+
+  end
+
+  let(:json_file) { File.read(File.join(File.dirname(__FILE__), 'support/user.json')) }
+
+  subject(:user) { User.new(json_file) }
+
+  its(:name) { should == 'Tyler Durden' }
+  its(:phone) { should == '288-555-0153' }
+  its(:zip) { should == '00000' }
+  its(:address) { should == 'Paper Street' }
+  its(:job_title) { should == 'Soap Maker' }
+  its(:born_on) { should == 1999 }
+  specify { expect { user.home_town }.to raise_error(LazyDoc::AttributeNotFoundError) }
+  its(:father) { should == 'Chuck Palahniuk' }
+
+  context 'friends' do
+    let(:friends) { user.friends }
+
+    specify { expect(friends.best_friend).to eq('Brad Pitt') }
+    specify { expect(friends.lover).to eq('Helena Bonham Carter') }
+  end
+
+  its(:fight_club_rules) { should == ['You do not talk about Fight Club',
+                                      'You DO NOT talk about Fight Club',
+                                      'If someone says stop or goes limp, taps out the fight is over'] }
+end

data/spec/acceptance/support/user.json

@@ -0,0 +1,25 @@
+{
+  "name": "Tyler Durden",
+  "phone": "288-555-0153",
+  "streetAddress": "Paper Street",
+  "zip": "00000",
+  "profile": {
+    "bornOn": "1999",
+    "occupation": {
+      "title": "Soap Maker",
+      "salary": 0
+    }
+  },
+  "father": null,
+  "friends": {
+    "bestFriend": "Brad Pitt",
+    "lover": "Helena Bonham Carter"
+  },
+  "fightClub": {
+    "rules": [
+      {"number": 1, "title": "You do not talk about Fight Club"},
+      {"number": 2, "title": "You DO NOT talk about Fight Club"},
+      {"number": 3, "title": "If someone says stop or goes limp, taps out the fight is over"}
+    ]
+  }
+}

data/spec/lib/lazy_doc/commands/as_class_command_spec.rb

@@ -0,0 +1,42 @@
+require_relative '../../../spec_helper'
+
+module LazyDoc
+  describe Commands::AsClassCommand do
+    class Foo
+      def initialize(value)
+      end
+    end
+
+    let(:value) { {foo: 'bar'} }
+
+    context 'acts like a Command' do
+      subject(:command) { Commands::AsClassCommand.new(Foo) }
+
+      it_behaves_like 'the Command interface'
+    end
+
+    it 'constructs an object of the specified class' do
+      as_class_command = Commands::AsClassCommand.new(Foo)
+
+      as_class_value = as_class_command.execute(value)
+
+      expect(as_class_value).to be_a Foo
+    end
+
+    it 'returns the original value when the specified class is blank' do
+      as_class_command = Commands::AsClassCommand.new(nil)
+
+      as_class_value = as_class_command.execute(value)
+
+      expect(as_class_value).to eq(value)
+    end
+
+    it 'passes the value as json to the specified class' do
+      as_class_command = Commands::AsClassCommand.new(Foo)
+
+      Foo.should_receive(:new).with("{\"foo\":\"bar\"}")
+
+      as_class_command.execute(value)
+    end
+  end
+end

data/spec/lib/lazy_doc/commands/default_value_command_spec.rb

@@ -0,0 +1,60 @@
+require_relative '../../../spec_helper'
+
+module LazyDoc
+  describe Commands::DefaultValueCommand do
+    context 'acts like a Command' do
+      subject(:command) { Commands::DefaultValueCommand.new('default value') }
+
+      it_behaves_like 'the Command interface'
+    end
+
+    let(:default) { Commands::DefaultValueCommand.new(default_value) }
+
+    context 'when there is a default value' do
+      let(:default_value) { 'default value' }
+
+      it 'returns the default value when the supplied value is nil' do
+        final_value = default.execute(nil)
+
+        expect(final_value).to eq(default_value)
+      end
+
+      it 'returns the default value when the supplied value is empty' do
+        final_value = default.execute('')
+
+        expect(final_value).to eq(default_value)
+      end
+
+      it 'returns the supplied value when it is not nil' do
+        final_value = default.execute('supplied value')
+
+        expect(final_value).to eq('supplied value')
+      end
+
+    end
+
+    context 'when there is not a default value' do
+      let(:default_value) { nil }
+
+      it 'returns the supplied value even when the supplied value is nil' do
+        final_value = default.execute(nil)
+
+        expect(final_value).to eq(nil)
+      end
+
+      it 'returns the supplied value even when the supplied value is empty' do
+        final_value = default.execute('')
+
+        expect(final_value).to eq('')
+      end
+
+      it 'returns the supplied value when the supplied value is not nil or empty' do
+        final_value = default.execute('supplied value')
+
+        expect(final_value).to eq('supplied value')
+      end
+    end
+
+  end
+
+end

data/spec/lib/lazy_doc/commands/extract_command_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../../../spec_helper'
+
+module LazyDoc
+  describe Commands::ExtractCommand do
+    context 'acts like a Command' do
+      subject(:command) { Commands::ExtractCommand.new('attribute to extract') }
+
+      it_behaves_like 'the Command interface'
+    end
+
+    it 'returns an array of the extracted attribute' do
+      extract = Commands::ExtractCommand.new(:name)
+
+      names = [{'name' => 'Brian'}, {'name' => 'Chris'}, {'name' => 'Mary'}]
+      extracted_names = extract.execute(names)
+
+      expect(extracted_names).to eq(['Brian', 'Chris', 'Mary'])
+    end
+
+    it 'returns the original value when there is no specified attribute to extract' do
+      extract = Commands::ExtractCommand.new(nil)
+
+      extracted_value = extract.execute('foo')
+
+      expect(extracted_value).to eq('foo')
+    end
+  end
+end

data/spec/lib/lazy_doc/commands/finally_command_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../../../spec_helper'
+
+module LazyDoc
+  describe Commands::FinallyCommand do
+    let(:value) { 'hello world' }
+
+    context 'acts like a Command' do
+      subject(:command) { Commands::FinallyCommand.new(nil) }
+
+      it_behaves_like 'the Command interface'
+    end
+
+    it 'transforms the supplied value with the supplied transformation' do
+      transformation = lambda { |value| value.upcase }
+      finally = Commands::FinallyCommand.new(transformation)
+
+      final_value = finally.execute(value)
+
+      expect(final_value).to eq('HELLO WORLD')
+    end
+
+    it 'uses a no op transformation when the supplied transformation is blank' do
+      finally = Commands::FinallyCommand.new(nil)
+
+      final_value = finally.execute(value)
+
+      expect(final_value).to eq('hello world')
+    end
+  end
+end

data/spec/lib/lazy_doc/commands/via_command_spec.rb

@@ -0,0 +1,36 @@
+require_relative '../../../spec_helper'
+
+module LazyDoc
+  describe Commands::ViaCommand do
+    context 'acts like a Command' do
+      subject(:command) { Commands::ViaCommand.new(:foo) }
+
+      it_behaves_like 'the Command interface'
+    end
+
+    it 'extracts an attribute from a document' do
+      document = {'foo' => 'bar'}
+      via = Commands::ViaCommand.new(:foo)
+
+      final_value = via.execute(document)
+
+      expect(final_value).to eq('bar')
+    end
+
+    it 'extracts a nested attribute from a document' do
+      document = {'foo' => {'bar' => {'blarg' => 'baz'}}}
+      via = Commands::ViaCommand.new([:foo, :bar, :blarg])
+
+      final_value = via.execute(document)
+
+      expect(final_value).to eq('baz')
+    end
+
+    it 'raises AttributeNotFoundError when the document does not contain the path' do
+      document = {'foo' => {'bar' => {'blarg' => 'baz'}}}
+      via = Commands::ViaCommand.new([:foo, :wizz])
+
+      expect { via.execute(document) }.to raise_error(AttributeNotFoundError)
+    end
+  end
+end

data/spec/lib/lazy_doc/dsl_spec.rb

@@ -0,0 +1,143 @@
+require_relative '../../spec_helper'
+
+module LazyDoc
+  describe DSL do
+    describe '.access' do
+      let(:json) { '{"foo":"bar", "blarg":"wibble"}' }
+
+      subject(:test_find) { Object.new }
+
+      before do
+        class << test_find
+          include LazyDoc::DSL
+        end
+      end
+
+      it 'defines a method for the name of the attribute' do
+        test_find.singleton_class.access :foo
+
+        expect(test_find).to respond_to :foo
+      end
+
+      it 'assumes the attribute name is sufficient to find the attribute' do
+        test_find.singleton_class.access :foo
+        test_find.lazily_embed(json)
+
+        expect(test_find.foo).to eq("bar")
+      end
+
+      it 'caches the json attribute for subsequent access' do
+        test_find.singleton_class.access :foo
+        test_find.lazily_embed(json)
+
+        expect(test_find.foo).to eq("bar")
+
+        test_find.stub(:embedded_doc) { nil }
+
+        expect(test_find.foo).to eq("bar")
+      end
+
+      it 'provides simple access to more than one attribute' do
+        test_find.singleton_class.access :foo, :blarg
+        test_find.lazily_embed(json)
+
+        expect(test_find.foo).to eq("bar")
+        expect(test_find.blarg).to eq("wibble")
+      end
+
+      it 'raises ArgumentError when more than one attribute is accessed with options' do
+        expect { test_find.singleton_class.access :foo, :blarg, as: Foo}.to raise_error(ArgumentError, 'Options provided for multiple attributes')
+      end
+
+      context 'via' do
+        it 'defines a method that accesses a named json attribute' do
+          test_find.singleton_class.access :my_foo, via: :foo
+          test_find.lazily_embed(json)
+
+          expect(test_find.my_foo).to eq("bar")
+        end
+
+        it 'defines a method that accesses a named json attribute through a json path' do
+          json = '{"bar": {"foo":"Hello World"}}'
+          test_find.singleton_class.access :foo, via: [:bar, :foo]
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq('Hello World')
+        end
+      end
+
+      context 'finally' do
+        it 'executes a block on the the attribute at the json path' do
+          test_find.singleton_class.access :foo, finally: lambda { |foo| foo.upcase }
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq('BAR')
+        end
+      end
+
+      context 'as' do
+        let(:json) { '{"foo": {"bar": "Hello"}}'}
+
+        class Foo
+          include LazyDoc::DSL
+
+          access :bar
+
+          def initialize(json)
+            lazily_embed(json)
+          end
+        end
+
+        it 'embeds a sub-object into another user defined object' do
+          test_find.singleton_class.access :foo, as: Foo
+          test_find.lazily_embed(json)
+
+          foo = test_find.foo
+
+          expect(foo).to be_a(Foo)
+          expect(foo.bar).to eq('Hello')
+        end
+
+        it 'calls the finally method on the sub-object defined by "as"' do
+          class Foo
+            def bar_baz; bar + ' World' end
+          end
+          test_find.singleton_class.access :foo, as: Foo, finally: lambda { |foo| foo.bar_baz }
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq('Hello World')
+        end
+      end
+
+      context 'default' do
+        it 'returns the default value when the json value is null' do
+          json = '{"foo": null}'
+          test_find.singleton_class.access :foo, default: 'hello world'
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq('hello world')
+        end
+
+        it 'returns the json value when the json value is not null' do
+          test_find.singleton_class.access :foo, default: 'hello world'
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq('bar')
+        end
+      end
+
+      context 'extract' do
+        it 'extracts the specified property name from each element in the array' do
+          json = '{"foo":[{"bar": "1"}, {"bar": "2"}, {"bar": "3"}]}'
+          test_find.singleton_class.access :foo, extract: :bar
+          test_find.lazily_embed(json)
+
+          expect(test_find.foo).to eq(['1','2','3'])
+        end
+      end
+
+    end
+
+  end
+
+end

data/spec/lib/lazy_doc/memoizer_spec.rb

@@ -0,0 +1,22 @@
+require_relative '../../spec_helper'
+
+module LazyDoc
+  describe Memoizer do
+    let(:memoizer) { Memoizer.new }
+
+    it 'returns the value of the block' do
+      memoized_value = memoizer.memoize(:foo) { 'hello world' }
+
+      expect(memoized_value).to eq('hello world')
+    end
+
+    it 'returns the original block value given for subsequent access to the attribute' do
+      memoizer.memoize(:foo) { 'hello world' }
+
+      memoized_value = memoizer.memoize(:foo) { :doesnt_matter }
+
+      expect(memoized_value).to eq('hello world')
+    end
+
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'pry'
+
+require_relative '../lib/lazy_doc'
+require_relative 'support/shared_examples'

data/spec/support/shared_examples.rb

@@ -0,0 +1,5 @@
+shared_examples 'the Command interface' do
+  it 'responds to execute' do
+    expect(command).to respond_to :execute
+  end
+end

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: lazy_doc
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Ryan Oglesby
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-14 00:00:00.000000000 Z
+dependencies:
+- !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: pry-debugger
+  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: LazyDoc provides a declarative DSL for extracting deeply nested values
+  from a JSON document
+email:
+- ryan.oglesby08@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-gemset
+- .ruby-version
+- .travis.yml
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lazy_doc.gemspec
+- lib/lazy_doc.rb
+- lib/lazy_doc/attribute_not_found_error.rb
+- lib/lazy_doc/commands.rb
+- lib/lazy_doc/commands/as_class_command.rb
+- lib/lazy_doc/commands/default_value_command.rb
+- lib/lazy_doc/commands/extract_command.rb
+- lib/lazy_doc/commands/finally_command.rb
+- lib/lazy_doc/commands/via_command.rb
+- lib/lazy_doc/dsl.rb
+- lib/lazy_doc/memoizer.rb
+- lib/lazy_doc/version.rb
+- spec/acceptance/basic_behavior_spec.rb
+- spec/acceptance/support/user.json
+- spec/lib/lazy_doc/commands/as_class_command_spec.rb
+- spec/lib/lazy_doc/commands/default_value_command_spec.rb
+- spec/lib/lazy_doc/commands/extract_command_spec.rb
+- spec/lib/lazy_doc/commands/finally_command_spec.rb
+- spec/lib/lazy_doc/commands/via_command_spec.rb
+- spec/lib/lazy_doc/dsl_spec.rb
+- spec/lib/lazy_doc/memoizer_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples.rb
+homepage: https://github.com/ryanoglesby08/lazy-doc
+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.6
+signing_key: 
+specification_version: 4
+summary: An implementation of the Embedded Document pattern for POROs
+test_files:
+- spec/acceptance/basic_behavior_spec.rb
+- spec/acceptance/support/user.json
+- spec/lib/lazy_doc/commands/as_class_command_spec.rb
+- spec/lib/lazy_doc/commands/default_value_command_spec.rb
+- spec/lib/lazy_doc/commands/extract_command_spec.rb
+- spec/lib/lazy_doc/commands/finally_command_spec.rb
+- spec/lib/lazy_doc/commands/via_command_spec.rb
+- spec/lib/lazy_doc/dsl_spec.rb
+- spec/lib/lazy_doc/memoizer_spec.rb
+- spec/spec_helper.rb
+- spec/support/shared_examples.rb