subtle 0.3.4

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/.rvmrc

@@ -0,0 +1,55 @@
+#!/usr/bin/env bash
+
+# This is an RVM Project .rvmrc file, used to automatically load the ruby
+# development environment upon cd'ing into the directory
+
+# First we specify our desired <ruby>[@<gemset>], the @gemset name is optional.
+environment_id="ruby-1.9.3-p0@subtle"
+
+#
+# Uncomment following line if you want options to be set only for given project.
+#
+# PROJECT_JRUBY_OPTS=( --1.9 )
+
+#
+# First we attempt to load the desired environment directly from the environment
+# file. This is very fast and efficient compared to running through the entire
+# CLI and selector. If you want feedback on which environment was used then
+# insert the word 'use' after --create as this triggers verbose mode.
+#
+if [[ -d "${rvm_path:-$HOME/.rvm}/environments" \
+  && -s "${rvm_path:-$HOME/.rvm}/environments/$environment_id" ]]
+then
+  \. "${rvm_path:-$HOME/.rvm}/environments/$environment_id"
+
+  if [[ -s "${rvm_path:-$HOME/.rvm}/hooks/after_use" ]]
+  then
+    . "${rvm_path:-$HOME/.rvm}/hooks/after_use"
+  fi
+else
+  # If the environment file has not yet been created, use the RVM CLI to select.
+  if ! rvm --create  "$environment_id"
+  then
+    echo "Failed to create RVM environment '${environment_id}'."
+    return 1
+  fi
+fi
+
+#
+# If you use an RVM gemset file to install a list of gems (*.gems), you can have
+# it be automatically loaded. Uncomment the following and adjust the filename if
+# necessary.
+#
+# filename=".gems"
+# if [[ -s "$filename" ]]
+# then
+#   rvm gemset import "$filename" | grep -v already | grep -v listed | grep -v complete | sed '/^$/d'
+# fi
+
+# If you use bundler, this might be useful to you:
+# if command -v bundle && [[ -s Gemfile ]]
+# then
+#   bundle install
+# fi
+
+

data/.travis.yml

@@ -0,0 +1,12 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - jruby-18mode
+  - jruby-19mode
+  - rbx-18mode
+  - rbx-19mode
+  - ruby-head
+  - jruby-head
+  - ree

data/Gemfile

@@ -0,0 +1,14 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'blankslate'
+gem 'mocha'
+
+
+gem 'minitest'
+group :development do
+  gem 'guard'
+  gem 'guard-minitest', :git => 'git://github.com/aspiers/guard-minitest.git'
+  gem 'ruby_gntp'
+end

data/Guardfile

@@ -0,0 +1,12 @@
+guard 'minitest' do
+  watch(%r|^test/test_(.*)\.rb|)
+  watch(%r|^lib/(.*)([^/]+)\.rb|)     { |m| "test/#{m[1]}test_#{m[2]}.rb" }
+  watch(%r|^test/test_helper\.rb|)    { "test" }
+  watch(%r|^lib/(.*)\.rb|)            { |m| "test/test_#{m[1]}.rb" }
+
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})         { |m| "spec/lib/#{m[1]}_spec.rb" }
+  watch(%r{^lib/subtle/(.+)\.rb$})         { |m| "spec/subtle/#{m[1]}_spec.rb" }
+  watch(%r{^spec/models/.+\.rb$})   { ["spec/models", "spec/acceptance"] }
+  watch('spec/spec_helper.rb')      { "spec" }
+end

data/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Darren Cauthon
+
+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,123 @@
+# Subtle
+
+
+
+I don't like "grab-bag" method libraries any more than anybody, but also like everybody:  I'll make an exception for **MINE**. :)
+
+## Installation
+Add this line to your application's Gemfile:
+
+    gem 'subtle'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    gem install subtle
+
+## Usage
+
+### Arrays to Objects
+
+This feature exists to make the creation of sets of objects with data easily.
+
+* Create an array of symbols of symbols that match the properties on the objects you want, and
+* Pass a block that returns an array of arrays with matching data. 
+
+````ruby
+records = [:first_name, :last_name].to_objects { 
+  [
+    ["John", "Galt"], 
+    ["Howard", "Roark"],
+    ["Dagny", "Taggart"]
+  ]}
+
+records[0].first_name  # "John"
+records[0].last_name   # "Galt"
+
+records[1].first_name  # "Howard"
+records[1].last_name   # "Roark"
+
+records[2].first_name  # "Dagny"
+records[2].last_name   # "Taggart"
+````
+
+### Safety Proc
+
+This feature was written because I hate wrapping code in begin/rescue/end blocks.  If I have a line of code and I don't particularly care if it fails, I have to wrap it in three more lines of care to stop exceptions.
+
+To me, this is most useful in import work or one-off processes where I might want to check to run a small block of code regardless of whether it fails.  This could lead to less code not just because of the lost begin/rescue/end lines, but because code can be written without concern of whether it will fail (nil checks, etc.).
+
+````ruby
+person.name = document.at_xpath('./h1').text
+
+# if this call fails then we will move on
+-> { person.bio = document.xpath('./div[@class="bio_info"]//span').text }.call_safely
+
+# if this call fails then the second block will be called
+-> { person.special = document.xpath('./div[@class="active"]//a')[1].text == "special" }.call_safely { person.special = false }
+````
+
+### Param Constructor
+
+One thing I liked about C# was the ability to instantiate my objects like this:
+
+````c#
+var person = new Person() { FirstName = "John", LastName = "Galt" };
+````
+
+This syntax is not built into Ruby syntax today, but it does exist in Rails models.  So I took that idea from Rails and wrote an implementation that works like this:
+
+````ruby
+class Person
+  params_constructor
+  attr_accessor :first_name, :last_name
+end
+
+person = Person.new(first_name: "John", last_name: "Galt")
+````
+
+### Proc to Object
+
+I was inspired to write this feature while dealing with some bad Rails code. A programmer wrote a before_filter on ApplicationController that made a big, expensive web service call to pass the users current weather information to the view.  This weather information was shown in various places on the site, but there were many pages on the site where the data was not being used at all.
+
+A thought came to me... *would it be possible to create an object that does the work to instantiate itself, but only when it is referenced?*
+
+Well, this doesn't quite do that, but it's close.  It lets you turn this:
+
+````ruby
+  before_filter do
+    service = BigExpensiveWeatherService.new
+    # we just paid the price right now
+    @weather_results = service.an_expensive_web_call
+  end
+````
+
+into this:
+
+````ruby
+  before_filter do
+    # we haven't paid the price for this call
+    @weather_results = -> do
+      service = BigExpensiveWeatherService.new
+      service.an_expensive_web_call
+    end.to_object
+  end
+````
+
+With both, you could do this:
+
+````haml
+  %span
+    = @weather_results.temperature
+````
+
+But with the latter, the call to execute the big web service won't be made until .temperature is called.  Future calls to methods on @weather_results will use the same object passed from the Proc.
+
+I know, I know... there are lots of reasons **NOT** to do this, and I'm not saying to do this all the time, but it's neat to know that it is possible.
+
+
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require 'rake/testtask'
+
+task :default => [:test]
+
+Rake::TestTask.new do |t|
+  t.libs.push "lib"
+  t.test_files = FileList['spec/subtle/*_spec.rb']
+  t.verbose = true
+end

data/lib/subtle.rb

@@ -0,0 +1,6 @@
+require File.dirname(__FILE__) + '/subtle/cover.rb'
+Dir[File.dirname(__FILE__) + '/subtle/*.rb'].each {|file| require file }
+
+module Subtle
+  # Your code goes here...
+end

data/lib/subtle/array_to_object.rb

@@ -0,0 +1,32 @@
+class Array
+
+  def to_objects(&blk)
+    records = blk.call
+    return [] if records.empty?
+    records.map { |record| create_object_for_this_record(record) }
+  end
+
+  private
+
+  def create_object_for_this_record(record)
+    result = Object.new
+    self.each_with_index do |property_name, index|
+      value = get_the_value(record, index)
+      add_reader_for(result, property_name, value)
+    end
+    result
+  end
+
+  def get_the_value(value, index)
+    return value unless value.kind_of?(Array)
+    value[index]
+  end
+
+  def add_reader_for(result, property_name, this_value)
+    result.instance_variable_set("@#{property_name}", this_value)
+    result.instance_eval("
+    class << self
+      attr_accessor :#{property_name}
+    end")
+  end
+end

data/lib/subtle/cover.rb

@@ -0,0 +1,29 @@
+require 'blankslate'
+
+module Subtle
+  module CoverMethods
+    def initialize(subject)
+      @subject = subject
+    end
+
+    def method_missing(meth, *args, &blk)
+      @subject.send(meth, *args, &blk)
+    rescue
+      Subtle::Cover.new Object.new
+    end
+
+    def the_original_subject
+      @subject
+    end
+  end
+
+  module StrictCoverMethods
+    def method_missing(meth, *args, &blk)
+      @subject.send(meth, *args, &blk)
+    end
+  end
+
+  class Cover < ::BlankSlate
+    include Subtle::CoverMethods
+  end
+end

data/lib/subtle/lambda_to_object.rb

@@ -0,0 +1,5 @@
+class Proc
+  def to_object
+    Subtle::LazyCover.new self
+  end
+end

data/lib/subtle/lazy_cover.rb

@@ -0,0 +1,27 @@
+module Subtle
+  class LazyCover < Cover
+    include Subtle::StrictCoverMethods
+
+    def initialize(block)
+      @block = block
+    end
+
+    alias :the_original_subject_from_the_base_class :the_original_subject
+    def the_original_subject
+      setup_the_subject
+      the_original_subject_from_the_base_class
+    end
+
+    private
+
+    alias :old_method_missing :method_missing
+    def method_missing(meth, *args, &blk)
+      setup_the_subject
+      old_method_missing meth, *args, &blk
+    end
+
+    def setup_the_subject
+      @subject = @block.call if @subject.nil?
+    end
+  end
+end

data/lib/subtle/param_constructor.rb

@@ -0,0 +1,10 @@
+class Object
+  def param_constructor
+    self.class_eval('
+    def initialize(params={})
+      params.each do |attr, value|
+        self.public_send("#{attr}=", value)
+      end if params
+    end')
+  end
+end

data/lib/subtle/safety_proc.rb

@@ -0,0 +1,7 @@
+class Proc
+  def call_safely
+    self.call
+  rescue
+    yield if block_given?
+  end
+end

data/lib/subtle/version.rb

@@ -0,0 +1,3 @@
+module Subtle
+  VERSION = "0.3.4"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'mocha'
+require 'minitest/spec'
+require 'minitest/autorun'
+require './lib/subtle.rb'

data/spec/subtle/array_to_object_spec.rb

@@ -0,0 +1,99 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "arrays to objects" do
+
+  [:name, :street].each do |property|
+    describe "with an array with one symbol named #{property.to_s}" do
+      describe "and no data" do
+        before do
+          @values = [property].to_objects { [] }
+        end
+
+        it "should return an empty array" do
+          @values.must_be_empty
+        end
+      end
+
+      ["Dangy", "Taggart"].each do |name|
+        describe "and one record with #{name}" do
+          before do
+            @values = [property].to_objects { [name] }
+          end
+
+          it "should return one record" do
+            @values.count.must_equal 1
+          end
+
+          it "should have a property with the name of Dangy" do
+            @values[0].send(property).must_equal name
+          end
+        end
+      end
+
+      describe "and two records with John and Howard" do
+        before do
+          @values = [property].to_objects {["John", "Howard"]}
+        end
+
+        it "should return two records" do
+          @values.count.must_equal 2
+        end
+
+        it "should set the first to John" do
+          @values[0].send(property).must_equal "John" 
+        end
+
+        it "should set the second to Howard" do
+          @values[1].send(property).must_equal "Howard"
+        end
+      end
+    end
+
+    describe "with an array with two symbols named first_name and last_name" do
+      describe "with 'Ellis' and 'Wyatt'" do
+        before do
+          @values = [:first_name, :last_name].to_objects { [['Ellis', 'Wyatt']] }
+        end
+
+        it "should return one record" do
+          @values.count.must_equal 1
+        end
+
+        it "should set the first name to Ellis" do
+          @values[0].first_name.must_equal 'Ellis'
+        end
+
+        it "should set the last name to Wyatt" do
+          @values[0].last_name.must_equal 'Wyatt'
+        end
+      end
+
+      describe "with 'Ellis' and 'Wyatt', then 'Dagny' and 'Taggart'" do
+        before do
+          @values = [:first_name, :last_name].to_objects { [['Ellis', 'Wyatt'], ['Dagny', 'Taggart']] }
+        end
+
+        it "should return one record" do
+          @values.count.must_equal 2
+        end
+
+        it "should set the first name to Ellis on the first record" do
+          @values[0].first_name.must_equal 'Ellis'
+        end
+
+        it "should set the last name to Wyatt on the first record" do
+          @values[0].last_name.must_equal 'Wyatt'
+        end
+
+        it "should set the first name to Dagny on the second record" do
+          @values[1].first_name.must_equal 'Dagny'
+        end
+
+        it "should set the last name to Wyatt on the second record" do
+          @values[1].last_name.must_equal 'Taggart'
+        end
+      end
+    end
+  end
+  
+end

data/spec/subtle/cover_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Subtle::Cover do
+  before do
+  end
+
+  describe "when given an Object" do
+    before do
+      @view_model = Subtle::Cover.new Object.new
+    end
+
+    it "should not throw an exception on methods that do not exist" do
+      @view_model.not_this
+      @view_model.or_this_either
+    end
+
+    it "should return an object if the method does not exist" do
+      @view_model.should_be_a_view_model.wont_be_nil
+      @view_model.another_test.wont_be_nil
+    end
+
+    it "should return new view models each time on methods that do not exist" do
+      first = @view_model.one_call
+      second = @view_model.second_call
+
+      first.object_id.wont_equal @view_model.object_id
+      second.object_id.wont_equal @view_model.object_id
+      first.object_id.wont_equal second.object_id
+    end
+  end
+
+  describe "when given a Person object" do
+    class Person
+      attr_accessor :first_name, :last_name
+    end
+
+    before do
+      @person = Person.new
+      @view_model = Subtle::Cover.new @person
+    end
+
+    [["John", "Galt"], ["Howard", "Roark"]].each do |name|
+      describe "with name of #{name[0]} #{name[1]}" do
+        before do
+          @person.first_name = name[0]
+          @person.last_name = name[1]
+        end
+
+        it "should return John as the first name" do
+          @view_model.first_name.must_equal name[0]
+        end
+
+        it "should return Galt as the last name" do
+          @view_model.last_name.must_equal name[1]
+        end
+      end
+    end
+  end
+
+  describe "when given an object that uses a block" do
+    class Thing
+      class << self
+        attr_accessor :test_value
+      end
+      def test(&blk)
+        blk.call
+      end
+    end
+
+    before do
+      @thing = Thing.new
+      @view_model = Subtle::Cover.new @thing
+    end
+
+    it "should call the block" do
+      @view_model.test do
+        Thing.test_value = true
+      end
+      Thing.test_value.must_equal true
+    end
+  end
+
+  [1, "abc", Object.new].each do |subject|
+    describe "#the_original_subject" do
+      before do
+        @cover = Subtle::Cover.new subject
+      end
+
+      it "should return the original" do
+        @cover.the_original_subject.must_equal subject
+      end
+    end
+  end
+end

data/spec/subtle/lambda_to_object_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "lambda to object" do
+
+  describe "to_object on a lambda that returns nil" do
+    before do
+      @value = -> { nil }.to_object
+    end
+
+    it "should remember the original value is nil" do
+      @value.the_original_subject.must_equal nil 
+    end
+  end
+
+  describe "to_object on a lambda that returns an integer" do
+    before do
+      @value = -> { 1 }.to_object
+    end
+
+    it "should remember the original value is 1" do
+      @value.the_original_subject.must_equal 1
+    end
+
+    it "should be able to use the value as an integer" do
+      (@value + 1).must_equal 2
+    end
+  end
+
+  describe "to_object on a lambda, but never accessing the variable" do
+    before do
+      @was_called = false
+      @value = -> { raise 'it was called' }.to_object
+    end
+
+    it "should not be called" do
+      #will throw an exception if it was called above 
+    end
+  end
+end

data/spec/subtle/lazy_cover_spec.rb

@@ -0,0 +1,66 @@
+require 'mocha'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class LazyCoverTest
+  class << self
+    attr_accessor :was_called
+  end
+end
+
+describe Subtle::LazyCover do
+
+  it "should not call the block passed to it" do
+    lazy = Subtle::LazyCover.new(-> { raise 'was called' })
+  end
+
+  it "should call the block passed to it when things are references" do
+    LazyCoverTest.was_called = false
+    lazy = Subtle::LazyCover.new(-> { LazyCoverTest.was_called = true })
+    LazyCoverTest.was_called.must_equal false
+    lazy.to_s
+    LazyCoverTest.was_called.must_equal true
+  end
+
+  it "should call the block passed to it only once" do
+    LazyCoverTest.was_called = 0
+    lazy = Subtle::LazyCover.new(-> { LazyCoverTest.was_called = LazyCoverTest.was_called + 1 })
+    LazyCoverTest.was_called.must_equal 0
+    lazy.to_s
+    LazyCoverTest.was_called.must_equal 1
+    lazy.to_s
+    LazyCoverTest.was_called.must_equal 1
+  end
+
+  it "should return the same exceptions passed from its base class methods" do
+
+    object = Object.new
+    object.stubs(:defined_method).returns("yes")
+
+    lazy = Subtle::LazyCover.new(-> { object })
+    lazy.defined_method.must_equal "yes"
+    was_called = false
+    begin
+      lazy.not_a_defined_method
+    rescue NoMethodError
+      was_called = true
+    end
+    was_called.must_equal true
+  end
+
+  describe "the original subject" do
+    it "should call the block passed to it" do
+      Subtle::LazyCover.new(-> { 0 }).the_original_subject.must_equal 0
+      Subtle::LazyCover.new(-> { "x" }).the_original_subject.must_equal "x"
+    end
+
+    it "should only call the block passed to it once" do
+      LazyCoverTest.was_called = 0
+      lazy = Subtle::LazyCover.new(-> { LazyCoverTest.was_called += 1 })
+      lazy.the_original_subject
+      LazyCoverTest.was_called.must_equal 1
+      lazy.the_original_subject
+      LazyCoverTest.was_called.must_equal 1
+    end
+  end
+
+end

data/spec/subtle/param_constructor_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class ParamConstructorTest
+  param_constructor
+  attr_accessor :first_name, :last_name
+end
+
+describe "param_constructor" do
+  it "should let the object be instantiated with a hash" do
+    test = ParamConstructorTest.new(first_name: "John", last_name: "Galt")
+    test.first_name.must_equal "John"
+    test.last_name.must_equal "Galt"
+  end
+
+  it "should allow the object to be instantiated with no params" do
+    test = ParamConstructorTest.new
+    # should not throw an error
+  end
+end

data/spec/subtle/safety_proc_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module SafetyProc
+  class << self
+    attr_accessor :called
+  end
+end
+
+describe "Safety Proc" do
+  describe "a proc that will throw an exception" do
+    before do
+      SafetyProc.called = false
+      @proc = -> do 
+        SafetyProc.called = true
+        raise 'k'
+      end
+    end
+
+    it "should trap the exception yet still call the method" do
+      @proc.call_safely
+      SafetyProc.called.must_equal true
+    end
+  end
+
+  describe "a proc with a block to call on error" do
+    before do
+      SafetyProc.called = false
+    end
+
+    it "call the block" do
+      @proc = -> { raise 'k' }.call_safely { SafetyProc.called = true }
+      SafetyProc.called.must_equal true
+    end
+  end
+end

data/subtle.gemspec

@@ -0,0 +1,22 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/subtle/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Darren Cauthon"]
+  gem.email         = ["darren@cauthon.com"]
+  gem.description   = %q{A few small updates to make even more concise Ruby.}
+  gem.summary       = %q{A few small updates to make even more concise Ruby.}
+  gem.homepage      = "http://www.github.com/darrencauthon/subtle"
+
+  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          = "subtle"
+  gem.require_paths = ["lib"]
+  gem.version       = Subtle::VERSION
+
+  # specify any dependencies here; for example:
+  gem.add_runtime_dependency 'blankslate'
+  gem.add_development_dependency 'mocha'
+  gem.add_development_dependency 'rake'
+end

metadata

@@ -0,0 +1,130 @@
+--- !ruby/object:Gem::Specification
+name: subtle
+version: !ruby/object:Gem::Version
+  version: 0.3.4
+  prerelease: 
+platform: ruby
+authors:
+- Darren Cauthon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-08-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: blankslate
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A few small updates to make even more concise Ruby.
+email:
+- darren@cauthon.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- .travis.yml
+- Gemfile
+- Guardfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/subtle.rb
+- lib/subtle/array_to_object.rb
+- lib/subtle/cover.rb
+- lib/subtle/lambda_to_object.rb
+- lib/subtle/lazy_cover.rb
+- lib/subtle/param_constructor.rb
+- lib/subtle/safety_proc.rb
+- lib/subtle/version.rb
+- spec/spec_helper.rb
+- spec/subtle/array_to_object_spec.rb
+- spec/subtle/cover_spec.rb
+- spec/subtle/lambda_to_object_spec.rb
+- spec/subtle/lazy_cover_spec.rb
+- spec/subtle/param_constructor_spec.rb
+- spec/subtle/safety_proc_spec.rb
+- subtle.gemspec
+homepage: http://www.github.com/darrencauthon/subtle
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 867729927420554654
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 867729927420554654
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: A few small updates to make even more concise Ruby.
+test_files:
+- spec/spec_helper.rb
+- spec/subtle/array_to_object_spec.rb
+- spec/subtle/cover_spec.rb
+- spec/subtle/lambda_to_object_spec.rb
+- spec/subtle/lazy_cover_spec.rb
+- spec/subtle/param_constructor_spec.rb
+- spec/subtle/safety_proc_spec.rb