polaroid 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bcc0c39513e0b9468561e2d3bcf13e917dda9fb1
+  data.tar.gz: 5f61fe411b563dc1bddef7389edda3684ad6eb78
+SHA512:
+  metadata.gz: 2eed4a6e80f15591b16bec0e972a53439957a44f1595c4dc5930116efcaa44d549c50895c37f8293fb8cc90c53e36d43196f02bc50956e536bf1e882f34496ed
+  data.tar.gz: 32aca9025f1217ad821a220534096465ccbcc697345e512dfa5aec3fda4ced875fe650dcb1c17eb6e0426f30acfd00aade004e402c046e2250599a6f9c0b3718

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Paul Kwiatkowski
+
+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,110 @@
+# Polaroid
+
+Polaroid provides shortcuts to capture the state of a Ruby object, and can construct a fake object later to mimic that state.
+
+## Why?
+
+Never send a Hash to do an Object's job. Method dispatch is faster and method calls look cleaner than nested\['braces'\]\['everywhere'\] in your code.
+
+## But why would you ever need that?
+
+The use case that inspired Polaroid involved using a background worker to send an Email. The email was being templated from a single View-Model object. Rather than shuffling database primary keys across a queue (be it Redis, or a real messaging system like Rabbit) and bothering the database later, we can just build the View-Model now, capture its state as JSON, and send that off to the Mailer.
+
+But that requires the templates now access data from a Hash. And you should never send a Hash to do an Object's job.
+
+Well, since we were already pulling these values from an object, why not just push them back into a Fake that shares the same interface of the View-Model? Or at least as much interface as we care about.
+
+This is just one use case I have found.
+
+## Simple Example
+
+In a class of which you would like to have a Snapshot, include a new instance of Polaroid, passing it the list of messages you would like to capture. These are not limited to attributes, but can be any message name. It is highly encouraged that the chosen messages be idempotent and side-effect-free wherever possible.
+
+An example of a Person class with two attributes, and a method which selects
+
+```ruby
+class Person
+  include Polaroid.new(:name, :age, :favorite_drinks)
+
+  attr_reader :name, :age, :favorites
+
+  def initialize(name, age, favorites)
+    @name       = name
+    @age        = age
+    @favorites  = favorites
+  end
+
+  def favorite_drinks
+    favorites.select { |fav| drink?(fav) }
+  end
+
+  def favorite_foods
+    favorites.select { |fav| food?(fav) }
+  end
+
+  def drink?(str)
+    %w[coffee beer wine tea water juice].include?(str)
+  end
+
+  def food?(str)
+    %w[omelete burrito ramen pie yogurt].include?(str)
+  end
+end
+```
+
+And if we make a `Person` instance, we can take a snapshot, which by default is just a `Hash`.
+
+```ruby
+pat = Person.new('Patrick', 25, ['beer', 'coffee', 'ramen', 'pie'])
+# => #<Person @name="Patrick", @age=25, @favorites=["beer", "coffee", "ramen", "pie"]>
+pat.age
+# => 25
+pat.favorite_drinks
+# => ["beer", "coffee"]
+pat.favorite_foods
+# => ["ramen", "pie"]
+snapshot = pat.take_shapshot
+# => { name: "Patrick", age: 25, favorite_drinks: ["beer", "coffee"] }
+```
+
+But now we can take that snapshot Hash and build a fake Person (actual class is `Person::Snapshot`) that responds to all the messages we chose to record from the original `Person`:
+
+```ruby
+fake_pat = Person.build_from_snapshot(snapshot)
+# => #<struct Person::Snapshot name="Patrick", age=25, favorite_drinks=["beer", "coffee"]>
+fake_pat.age
+# => 25
+fake_pat.favorite_drinks
+# => ["beer", "coffee"]
+```
+
+However, since we did not record the whole `favorites` array, nor did we ask the message `favorite_foods` be included our snapshot, the `Person::Snapshot` does not respond to `favorite_foods`:
+
+```ruby
+fake_pat.favorite_foods
+# => NoMethodError: undefined method `favorite_foods' for #<Person::Snapshot>
+```
+
+## Hashes? But I want JSON!
+
+Of course you do. So the `take_snapshot` and `build_from_snapshot` methods also take a trailing `format` parameter:
+
+```ruby
+pat = Person.new('Patrick', 25, ['beer', 'coffee', 'ramen', 'pie'])
+json_snapshot = snapshot.take_snapshot(pat, :json)
+# => "{\"name\":\"Patrick\",\"age\":25,\"favorite_drinks\":[\"beer\",\"coffee\"]}"
+Person.build_from_snapshot(json_snapshot, :json)
+# => #<struct Person::Snapshot name="Patrick", age=25, favorite_drinks=["beer", "coffee"]>
+```
+
+Right now the only accepted formats are `:hash` and `:json`. If there are other serialization formats that people care about, I would be happy to have them included.
+
+
+## Contributing
+
+1. Fork it ( http://github.com/swifthand/polaroid/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 new Pull Request
+

data/Rakefile

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

data/lib/polaroid.rb

@@ -0,0 +1,47 @@
+class Polaroid < Module
+
+  VERSION = "0.0.3"
+
+  def initialize(*messages)
+    @messages = messages
+    @polaroid_struct_class = ImmutableStruct.new(*messages)
+    define_capture_method
+    freeze
+  end
+
+  # Build the fake class for internal use in the including class' namespace.
+  def included(base)
+    base.const_set(:Snapshot, @polaroid_struct_class)
+    base.extend(ClassMethods)
+  end
+
+
+private #######################################################################
+
+  # Give the class a #take_snapshot instance method, which records the result
+  # of sending an instance the assigned messages, and returns them as a Hash.
+  def define_capture_method
+    messages = @messages
+    take_snapshot = ->(format = :hash) {
+      snapshot = self.class::Snapshot.new(*(messages.map { |msg| self.send(msg) })).to_h
+      format == :json ? snapshot.to_json : snapshot
+    }
+    define_method(:take_snapshot, &take_snapshot)
+  end
+
+
+  module ClassMethods
+    def build_from_snapshot(snapshot_hash, format = :hash)
+      case format
+      when :hash
+        # This line intentionally left blank
+      when :json
+        snapshot_hash = JSON.parse(snapshot_hash).map.with_object({}) do |(k, v), hash|
+          hash[k.to_sym] = v
+        end
+      end
+      self::Snapshot.new(snapshot_hash)
+    end
+  end
+
+end

data/polaroid.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'polaroid'
+
+Gem::Specification.new do |spec|
+  spec.name           = "polaroid"
+  spec.version        = Polaroid::VERSION
+  spec.platform       = Gem::Platform::RUBY
+  spec.authors        = ["Paul Kwiatkowski"]
+  spec.email          = ["paul@groupraise.com"]
+  spec.summary        = %q{Polaroid provides shortcuts to capture the state of a Ruby object, and can construct a fake object later to mimic that state.}
+  spec.description    = %q{Polaroid provides shortcuts to capture the state of a Ruby object, and can construct a fake object later to represents that state. The goal is to "Never send a Hash to do an Object's job" when performing common tasks such as, sending data to a background worker as JSON, or otherwise.}
+  spec.homepage       = "https://github.com/swifthand/polaroid"
+  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.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "immutable_struct", "~> 1.1"
+  spec.add_runtime_dependency "json", "~> 1.8"
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: polaroid
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Paul Kwiatkowski
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: immutable_struct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+description: Polaroid provides shortcuts to capture the state of a Ruby object, and
+  can construct a fake object later to represents that state. The goal is to "Never
+  send a Hash to do an Object's job" when performing common tasks such as, sending
+  data to a background worker as JSON, or otherwise.
+email:
+- paul@groupraise.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/polaroid.rb
+- polaroid.gemspec
+homepage: https://github.com/swifthand/polaroid
+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.2.1
+signing_key: 
+specification_version: 4
+summary: Polaroid provides shortcuts to capture the state of a Ruby object, and can
+  construct a fake object later to mimic that state.
+test_files: []