vin_exploder 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,47 @@
+PATH
+  remote: .
+  specs:
+    vin_exploder (0.1.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.8)
+      activesupport (= 3.0.8)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.8)
+      activemodel (= 3.0.8)
+      activesupport (= 3.0.8)
+      arel (~> 2.0.10)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.8)
+    arel (2.0.10)
+    builder (2.1.2)
+    diff-lcs (1.1.2)
+    i18n (0.5.0)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.3)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    sequel (3.24.1)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.5)
+    sqlite3 (1.3.3)
+    tzinfo (0.3.27)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (>= 3.0.0)
+  rspec (>= 2.6.0)
+  sequel
+  simplecov
+  sqlite3
+  vin_exploder!

data/README.textile

@@ -0,0 +1,74 @@
+h1. VinExploder
+
+A ruby library for retrieving and caching Vehicle Identification Number (VIN) lookups. 
+
+h2. How to install
+
+*Bundler*
+
+<pre>
+  gem vin_exploder
+</pre>
+
+*Rubygems*
+
+<pre>
+  gem install vin_exploder
+</pre>
+
+h2. How to use
+
+Using the vin exploder will require a decoding service adapter. Thankfully one is available in the Vinquery "gem":http://github.com/tinomen/vinquery
+
+<pre>
+  require 'vin_exploder'
+  # require the Vinquery.com adapter
+  require 'vinquery/vin_exploder/adapter'
+  
+  # tell vin_exploder to use the Vinquery.com adapter and pass it's required config
+  VinExploder.config.adapter :vinquery, {:url => 'VINQUERY_URL', :access_code => 'ACCESS_CODE', :report_type => 'REPORT_TYPE'}
+  # request the decoded VIN data
+  vin_explosion = VinExploder.get('1FTWX31R19EB18840')
+  
+  vin_explosion.valid? # true
+  vin_explosion.make   # Ford
+</pre>
+
+h3. Rails use
+
+Create an initializer for the config
+
+<pre>
+  require 'vin_exploder'
+  require 'vinquery/vin_exploder/adapter'
+  
+  VinExploder.config.adapter :vinquery, {:url => 'VINQUERY_URL', :access_code => 'ACCESS_CODE', :report_type => 'REPORT_TYPE'}
+</pre>
+
+h3. Optional Cache
+
+To save on the cost of looking up a VIN multiple times setup a cache
+
+<pre>
+  require 'vin_exploder'
+  # require the Sequel based cache store
+  require 'vin_exploder/cache/sequel_cache_store'
+  # require the Vinquery.com adapter
+  require 'vinquery/vin_exploder/adapter'
+  
+  # tell vin_exploder to use the Sequel based cache store adapter and pass in the connection config
+  VinExploder.config.cache_store :sequel_cache_store, "mysql://localhost:3896/vin_cache"
+  
+  # tell vin_exploder to use the Vinquery.com adapter and pass it's required config
+  VinExploder.config.adapter :vinquery, {:url => 'VINQUERY_URL', :access_code => 'ACCESS_CODE', :report_type => 'REPORT_TYPE'}
+  
+  # request the decoded VIN data
+  vin_explosion = VinExploder.get('1FTWX31R19EB18840')
+  
+  vin_explosion.valid? #=> true
+  vin_explosion.make   #=> Ford
+  
+  # decoded VIN data is retrieved from cache
+  vin_explosion2 = VinExploder.get('1FTWX31R19EB18840')
+  vin_explosion2.make   #=> Ford
+</pre>

data/lib/vin_exploder/adapter.rb

@@ -0,0 +1,47 @@
+
+module VinExploder
+  
+  module Decode
+    
+    class VinExploderAdapterError < StandardError; end
+    
+    class AbstractAdapter
+      
+      def initialize(options={})
+        @options = options
+      end
+      
+      # Fetch, normalize and return the decoded data as a hash.
+      #
+      # *vin*::  
+      #    The Vehicle Identification Number
+      #
+      # == Returns:
+      # An array containing the decoded data hash.
+      # 
+      # Should an error occur while decoding the vin the hash should 
+      # include a key of :errors with an array of errors 
+      # in the form of: {'error name' => 'error message'}
+      # 
+      # Normalize the hash from the vendor to use keys known by VinExploder.
+      # All keys should be made into symbols following the ruby snake case convention.
+      #
+      # The keys that must be normalized are as follows:
+      # make
+      # model
+      # year => YYYY
+      # driveline => FWD|4WD|AWD
+      # body_style
+      # fuel_type => GAS|DIESEL|HYBRID
+      # trim_level
+      # 
+      # All remaining keys should be symbols but can remain vendor specific
+      def explode(vin)
+        raise NotImplementedError.new("Unimplemented explode method.")
+      end
+      
+    end
+    
+  end
+  
+end

data/lib/vin_exploder/cache/activerecord_cache_store.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+require 'Base64'
+
+module VinExploder
+module Cache
+  
+  # A VinExploder cache adapter using ActiveRecord for saving the decoded vin attributes.
+  #
+  # this store assumes a model with 2 attributes:
+  # - *key*: the first 8, 10th and 11th characters of the vin
+  # - *data*: A hash of the decoded vin attributes
+  class ActiveRecordCacheStore < Store
+    
+    def initialize(options = {})
+      super
+      @model = options[:model_class]
+    end
+    
+    def read(vin)
+      key = make_vin_cache_key(vin)
+      obj = @model.find_by_key(key)
+      obj.data unless obj.nil?
+    end
+    
+    def write(vin, hash)
+      key = make_vin_cache_key(vin)
+      obj = @model.new :key => key, :data => hash
+      obj.save
+      hash
+    end
+    
+    def delete(vin)
+      key = make_vin_cache_key(vin)
+      obj = @model.find_by_key(key)
+      deleted = obj.delete()
+      !deleted.nil?
+    end
+    
+  end
+  
+end
+end

data/lib/vin_exploder/cache/sequel_cache_store.rb

@@ -0,0 +1,40 @@
+require 'sequel'
+require 'Base64'
+
+module VinExploder
+module Cache
+  
+  # A VinExploder cache adapter using Sequel for saving the decoded vin attributes.
+  #
+  # this store assumes there are 2 columns on the table:
+  # - *key*: the first 8, 10th and 11th characters of the vin
+  # - *data*: A hash of the decoded vin attributes
+  class SequelCacheStore < Store
+    
+    def initialize(options = {})
+      super
+      @connection = Sequel.connect(options)
+    end
+    
+    def read(vin)
+      key = make_vin_cache_key(vin)
+      data = @connection[:vins].where(:key => key).first
+      Marshal.load(data[:data]) unless data.nil?
+    end
+    
+    def write(vin, hash)
+      key = make_vin_cache_key(vin)
+      @connection[:vins].insert(:key => key, :data => Marshal.dump(hash))
+      hash
+    end
+    
+    def delete(vin)
+      key = make_vin_cache_key(vin)
+      result = @connection[:vins].where(:key => key).delete
+      result > 0
+    end
+    
+  end
+  
+end
+end

data/lib/vin_exploder/cache.rb

@@ -0,0 +1,76 @@
+
+module VinExploder
+  
+  module Cache
+    
+    
+    # An abstract cache store class that acts as a null cache as well
+    class Store
+      
+      attr_reader :connection
+      
+      # Create a new cache.
+      def initialize(options = nil)
+        @options = options ? options.dup : {}
+      end
+      
+      # Fetches VIN data from the cache using the given key. If the VIN has been
+      # cached, then the VIN attributes are returned.
+      #
+      # If the VIN is not in the cache (a cache miss occurred),
+      # then nil will be returned. However, if a block has been passed, then
+      # that block will be run in the event of a cache miss. The return value
+      # of the block will be written to the cache under the given VIN,
+      # and that return value will be returned.
+      #
+      #   cache.write("VIN_NUMBER", {:make => 'Ford', :model => 'F150'})
+      #   cache.fetch("VIN_NUMBER")  # => {:make => 'Ford', :model => 'F150'}
+      #
+      #   cache.fetch("VIN_NUMBER_2")   # => nil
+      #   cache.fetch("VIN_NUMBER_2") do
+      #     {:make => 'Dodge', :model => '1500'}
+      #   end
+      #   cache.fetch("VIN_NUMBER_2")   # => {:make => 'Dodge', :model => '1500'}
+      #
+      def fetch(vin)
+        if block_given?
+          hash = read(vin)
+          if hash.nil?
+            hash = yield 
+            write(vin, hash)
+          end
+        else
+          hash = read(vin)
+        end
+      end
+    
+      # Fetches VIN data from the cache, using the given key. If VIN has
+      # been cached with the given key, then the VIN attributes are returned. Otherwise,
+      # nil is returned.
+      def read(vin)
+        nil
+      end
+    
+      # Writes the value to the cache, with the key.
+      def write(vin, hash)
+        hash
+      end
+      
+      # Deletes an entry in the cache. Returns +true+ if an entry is deleted.
+      def delete(vin)
+        true
+      end
+      
+      protected
+      
+      # the cache key for vins should be based on characters 0-8, 10-11. 
+      # Position 9 is a checksum value and should not be used in the key.
+      def make_vin_cache_key(vin)
+        key = vin.slice(0,8)
+        key << vin.slice(10,2)
+      end
+    
+    end
+  end
+  
+end

data/lib/vin_exploder/configuration.rb

@@ -0,0 +1,45 @@
+
+module VinExploder
+  
+  class Configuration
+    
+    attr_accessor :cache_options, :adapter_options
+    
+    def initialize
+      @cache_store = nil
+      @cache_options = {}
+      @adapter = nil
+      @adapter_options = {}
+    end
+    
+    def cache_store(*args)
+      if args.empty?
+        case @cache_store
+        when Symbol
+          VinExploder::Cache.const_get(@cache_store.to_s.split('_').map{|s| s.capitalize }.join)
+        else
+          @cache_store
+        end
+      else
+        @cache_store = args.shift
+        @cache_options = args.shift || {}
+      end
+    end
+    
+    def adapter(*args)
+      if args.empty?
+        case @adapter
+        when Symbol
+          VinExploder::Decode.const_get(@adapter.to_s.split('_').map{|s| s.capitalize }.join)
+        else
+          @adapter
+        end
+      else
+        @adapter = args.shift
+        @adapter_options = args.shift || {}
+      end
+    end
+    
+  end
+  
+end

data/lib/vin_exploder/exploder.rb

@@ -0,0 +1,30 @@
+module VinExploder
+  
+  class MissingAdapter < StandardError
+  end
+  
+  class Exploder
+    
+    def initialize(adapter, cache=nil)
+      raise MissingAdapter.new("No vin decoding vendor adapter has been provided.") if adapter.nil?
+      @cache = cache ? cache : Cache::Store.new
+      @adapter = adapter
+    end
+    
+    # Get vin Explosion.
+    #
+    # == Parameters
+    # vin:: vehicle identification number 
+    #
+    # == Return
+    # An Explosion object containing the decoded vin attributes
+    def get(vin)
+      hash = @cache.fetch(vin) do
+        # get from vender adapter
+        @adapter.explode(vin)
+      end
+      Explosion.new vin, hash, hash.delete(:errors)
+    end
+    
+  end
+end

data/lib/vin_exploder/explosion.rb

@@ -0,0 +1,40 @@
+require 'yaml'
+
+module VinExploder
+  
+  class Explosion
+    
+    attr_reader :vin, :success, :errors, :make, :model, :year, :driveline, :body_style, :fuel_type, :all
+    
+    def initialize(vin, vin_hash, errors={})
+      @vin = vin
+      @all = vin_hash
+      @make = @all[:make]
+      @model = @all[:model]
+      @year = @all[:year]
+      @driveline = @all[:driveline]
+      @body_style = @all[:body_style]
+      @fuel_type = @all[:fuel_type]
+      @trim_level = @all[:trim_level]
+      @errors = errors.nil? ? {} : errors
+      @success = @errors.empty?
+    end
+    
+    def valid?
+      @success
+    end
+    alias :success? :valid?
+    
+    # def _dump(level=-1)
+    #   [@vin, @all.to_yaml].join('^')
+    # end
+    # 
+    # def self._load(args)
+    #   a = *args.split('^')
+    #   hash = YAML.load(a[1])
+    #   new(a[0], hash)
+    # end
+    
+  end
+  
+end

data/lib/vin_exploder/version.rb

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

data/lib/vin_exploder.rb

@@ -0,0 +1,19 @@
+
+module VinExploder
+  
+  def self.explode(vin)
+    cache = VinExploder.config.cache_store ? VinExploder.config.cache_store.new(VinExploder.config.cache_options) : nil
+    adapter = VinExploder.config.adapter.new(VinExploder.config.adapter_options)
+    exploder = Exploder.new(adapter, cache)
+    explosion = exploder.get(vin)
+  end
+  
+  def self.config
+    @@config ||= VinExploder::Configuration.new()
+  end
+  
+end
+
+require 'vin_exploder/cache'
+require 'vin_exploder/explosion'
+require 'vin_exploder/exploder'

data/spec/abstract_adapter_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+require 'vin_exploder/adapter'
+
+module VinExploder
+module Decode
+  
+describe AbstractAdapter do
+  
+  it "should raise an NotImplementedError on explode" do
+    expect { AbstractAdapter.new.explode("VIN") }.to raise_error(NotImplementedError)
+  end
+  
+end
+
+end
+end

data/spec/cache/activerecord_cache_store_spec.rb

@@ -0,0 +1,74 @@
+require 'spec_helper'
+require 'sqlite3'
+require 'vin_exploder/cache'
+require 'vin_exploder/cache/activerecord_cache_store'
+
+module VinExploder
+module Cache
+  
+  class TestArCacheStore < ActiveRecord::Base 
+    attr_accessor :vin, :make
+    serialize :data
+    def initialize(attributes={})
+      super attributes
+      key = attributes.delete(:key)
+      # @data = attributes[:data]
+      @attributes = {'key' => key, 'vin' => attributes[:vin], 'make' => attributes[:make], 'data' => attributes[:data]}
+    end
+  end
+
+describe ActiveRecordCacheStore do
+  
+  before(:all) do
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ':memory:')
+    ActiveRecord::Schema.define do
+      create_table :test_ar_cache_stores, :force => true do |t|
+        t.column :key,       :string
+        t.column :vin,       :string
+        t.column :make,       :string
+        t.column :data,      :text
+      end
+    end
+    
+    @store = ActiveRecordCacheStore.new :model_class => TestArCacheStore
+    
+  end
+  
+  after(:each) do
+    TestArCacheStore.delete_all
+  end
+  
+  it "should read and write a hash" do
+    hash = @store.read("fake_vin_number")
+    hash.should be_nil
+    @store.write("fake_vin_number", {:vin => 'fake_vin_number', :make => 'Ford'})
+    hash = @store.read("fake_vin_number")
+    hash.should_not be_nil
+    hash[:make].should == 'Ford'
+  end
+  
+  it "should fetch and cache new vins" do
+    hash = @store.fetch("fake_vin_number") do
+      {:vin => 'fake_vin_number', :make => 'Ford'}
+    end
+    hash2 = @store.read("fake_vin_number")
+    hash[:vin].should == hash2[:vin]
+  end
+  
+  it "should delete a vin from the cache" do
+    hash = @store.read("fake_vin_number")
+    hash.should be_nil
+    @store.write(:fake_vin_number, {:vin => 'fake_vin_number', :make => 'Ford'})
+    hash = @store.read("fake_vin_number")
+    hash.should_not be_nil
+    hash[:make].should == 'Ford'
+    deleted = @store.delete("fake_vin_number")
+    deleted.should == true
+    hash = @store.read("fake_vin_number")
+    hash.should be_nil
+  end
+  
+end
+
+end
+end

data/spec/cache/cache_store_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+module VinExploder
+module Cache
+
+describe Store do
+  
+  describe '#read' do
+    it 'should return the cached vin explosion' do
+      Store.new.read('DOESNTMATTER').should == nil
+    end
+    it 'should return nil if no explosion found' do
+      Store.new.read('DOESNTMATTER').should == nil
+    end
+  end
+  
+  describe '#write' do
+    it 'should return the value that was written' do
+      Store.new.write('VIN', 'EXPLODED_VIN').should == 'EXPLODED_VIN'
+      Store.new.read('VIN').should == nil
+    end
+  end
+  
+  describe '#fetch' do
+    it 'should execute the block and pass through #write' do
+      store = Store.new
+      store.should_receive(:write).with('VIN', 'EXPLODED_VIN').exactly(1).times { 'EXPLODED_VIN' }
+      store.fetch('VIN') do
+        'EXPLODED_VIN'
+      end.should == 'EXPLODED_VIN'
+    end
+    
+    it 'should return nil with no block' do
+      store = Store.new
+      store.should_receive(:read).with('VIN').exactly(1).times { 'EXPLODED_VIN' }
+      store.fetch('VIN').should == 'EXPLODED_VIN'
+    end
+  end
+  
+  describe '#delete' do
+    it 'should return true if cache item was deleted' do
+      Store.new.delete('VIN').should == true
+    end
+  end
+
+end
+
+end
+end

data/spec/cache/sequel_cache_store_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'sqlite3'
+require 'sequel'
+require 'vin_exploder/cache'
+require 'vin_exploder/cache/sequel_cache_store'
+
+module VinExploder
+module Cache
+
+describe SequelCacheStore do
+  
+  before(:all) do
+    @db_config = {:adapter => "sqlite"}
+    @store = SequelCacheStore.new @db_config
+    @store.connection.create_table(:vins) do
+      String :key, :unique=>true, :size=>10
+      String :data, :null=>false, :text=>true
+    end
+  end
+  
+  after(:each) do
+    @store.connection[:vins].truncate
+  end
+  
+  it "should initialize" do
+    @store.class.should == SequelCacheStore
+  end
+  
+  it "should read and write a hash" do
+    hash = @store.read(:fake_vin_number)
+    hash.should be_nil
+    @store.write(:fake_vin_number, {:vin => 'fake_vin_number', :make => 'Ford'})
+    hash = @store.read(:fake_vin_number)
+    hash.should_not be_nil
+    hash[:make].should == 'Ford'
+  end
+  
+  it "should fetch and cache new vins" do
+    hash = @store.fetch(:fake_vin_number) do
+      {:vin => 'fake_vin_number', :make => 'Ford'}
+    end
+    hash2 = @store.read(:fake_vin_number)
+    hash[:vin].should == hash2[:vin]
+  end
+  
+  it "should delete a vin from the cache" do
+    hash = @store.read(:fake_vin_number)
+    hash.should be_nil
+    @store.write(:fake_vin_number, {:vin => 'fake_vin_number', :make => 'Ford'})
+    hash = @store.read(:fake_vin_number)
+    hash.should_not be_nil
+    hash[:make].should == 'Ford'
+    deleted = @store.delete(:fake_vin_number)
+    deleted.should == true
+    hash = @store.read(:fake_vin_number)
+    hash.should be_nil
+  end
+  
+end
+
+end
+end

data/spec/configuration_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'vin_exploder/configuration'
+
+module VinExploder
+
+describe Configuration do
+  
+  describe '#cache_store' do
+    it 'should return nil if no cache is set' do
+      c = Configuration.new
+      c.cache_store.should == nil
+    end
+    
+    it 'should convert a symbol to a camel case constant within the VinExploder::Cache scope' do
+      class VinExploder::Cache::TestSymbolConst; end
+      c = Configuration.new
+      c.cache_store :test_symbol_const
+      c.cache_store.should == VinExploder::Cache::TestSymbolConst
+    end
+    
+    it 'should return the constant previously set' do
+      c = Configuration.new
+      c.cache_store String
+      c.cache_store.should == String
+    end
+  end
+  
+  describe '#adapter' do
+    it 'should return nil where no adapter defined' do
+      c = Configuration.new
+      c.adapter.should == nil
+    end
+    
+    it 'should convert a symbol to a camel case constant within the VinExploder::Decode scope' do
+      class VinExploder::Decode::TestSymbolConst; end
+      c = Configuration.new
+      c.adapter :test_symbol_const
+      c.adapter.should == VinExploder::Decode::TestSymbolConst
+    end
+    
+    it 'should return the constant previously set' do
+      c = Configuration.new
+      c.adapter String
+      c.adapter.should == String
+    end
+  end
+  
+end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+if ENV["COVERAGE"]
+  require 'simplecov'  
+  SimpleCov.start 'rails' 
+end
+
+require "bundler"
+Bundler.setup
+
+require 'rspec'
+
+require 'vin_exploder'
+
+RSpec.configure do |config|
+
+end

data/spec/vin_exploder_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'vin_exploder'
+
+class VinExploder::Decode::TestAdapter; end
+
+module VinExploder
+
+describe Exploder do
+  
+  describe '#new' do
+    it "should raise a MissingAdapter error if nil is provided to initialize" do
+      expect { Exploder.new(nil) }.to raise_error(MissingAdapter)
+    end
+  
+    it "should raise a ArgumentError error if no arguments are provided to initialize" do
+      expect { Exploder.new }.to raise_error(ArgumentError)
+    end
+  
+    it "should initialize with a default cache store when no cache argument is passed" do
+      s = VinExploder::Cache::Store.new
+      VinExploder::Cache::Store.should_receive(:new).exactly(1).times { s }
+      e = Exploder.new(double("Adapter"))
+    end
+  end
+  
+  describe '#get' do
+    it "should get a vin Explosion" do
+      a = double("Adapter")
+      a.should_receive(:explode) { {} }
+      e = Exploder.new(a)
+      ex = e.get('VIN')
+      ex.class.should == VinExploder::Explosion 
+      ex.valid?.should == true
+      ex.success?.should == true
+    end
+  end
+  
+  describe "VinExploder#explode" do
+    it "should return an Explosion object" do
+      ta = VinExploder::Decode::TestAdapter.new
+      ta.should_receive(:explode) { {} }
+      VinExploder::Decode::TestAdapter.should_receive(:new){ ta }
+      
+      VinExploder.config.adapter :test_adapter
+      VinExploder.explode("VIN").class.should == Explosion
+    end
+  end
+  
+end
+
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification 
+name: vin_exploder
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.1.0
+platform: ruby
+authors: 
+- Jake Mallory
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-20 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.6.0
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :development
+  version_requirements: *id005
+description: A caching client for vin decoding web services. The caching allows the consumer to avoid the cost of secondary lookups.
+email: tinomen@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- Gemfile
+- Gemfile.lock
+- README.textile
+files: 
+- lib/vin_exploder/adapter.rb
+- lib/vin_exploder/cache/activerecord_cache_store.rb
+- lib/vin_exploder/cache/sequel_cache_store.rb
+- lib/vin_exploder/cache.rb
+- lib/vin_exploder/configuration.rb
+- lib/vin_exploder/exploder.rb
+- lib/vin_exploder/explosion.rb
+- lib/vin_exploder/version.rb
+- lib/vin_exploder.rb
+- Gemfile
+- Gemfile.lock
+- README.textile
+- spec/abstract_adapter_spec.rb
+- spec/cache/activerecord_cache_store_spec.rb
+- spec/cache/cache_store_spec.rb
+- spec/cache/sequel_cache_store_spec.rb
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
+- spec/vin_exploder_spec.rb
+homepage: http://github.com/tinomen/vin_exploder
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --title
+- A caching client for vin decoding services
+- --main
+- README.textile
+- --line-numbers
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.7.2
+signing_key: 
+specification_version: 3
+summary: A caching client for vin decoding services
+test_files: 
+- spec/abstract_adapter_spec.rb
+- spec/cache/activerecord_cache_store_spec.rb
+- spec/cache/cache_store_spec.rb
+- spec/cache/sequel_cache_store_spec.rb
+- spec/configuration_spec.rb
+- spec/spec_helper.rb
+- spec/vin_exploder_spec.rb