velocity 0.0.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/Gemfile

@@ -0,0 +1,22 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem "activerecord", "~> 3.0.0"
+gem "activesupport", "~> 3.0.0"
+
+group :development do
+  gem "jeweler"
+  gem "pg"
+  gem "mysql2"
+  gem "thoughtbot-shoulda"
+  gem "simplecov"
+  gem "terminal-table"
+  gem "term-ansicolor"
+  gem "turn", ">= 0.8.2"
+  gem "ansi"
+  gem "faker"
+end

data/Gemfile.lock

@@ -0,0 +1,53 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    activemodel (3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activesupport (3.0.7)
+    ansi (1.2.3)
+    arel (2.0.9)
+    builder (2.1.2)
+    faker (0.9.5)
+      i18n (~> 0.4)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    mysql2 (0.2.6)
+    pg (0.10.1)
+    rake (0.8.7)
+    simplecov (0.4.2)
+      simplecov-html (~> 0.4.4)
+    simplecov-html (0.4.4)
+    term-ansicolor (1.0.5)
+    terminal-table (1.4.2)
+    thoughtbot-shoulda (2.11.1)
+    turn (0.8.2)
+      ansi (>= 1.2.2)
+    tzinfo (0.3.26)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activerecord (~> 3.0.0)
+  activesupport (~> 3.0.0)
+  ansi
+  faker
+  jeweler
+  mysql2
+  pg
+  simplecov
+  term-ansicolor
+  terminal-table
+  thoughtbot-shoulda
+  turn (>= 0.8.2)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Pascal Houliston
+
+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.rdoc

@@ -0,0 +1,89 @@
+= Velocity
+
+Provides a barebones, but supremely quick way of querying your ActiveRecord database.
+
+Velocity uses adapter-specific optimizations (only pg, and mysql2 support planned for now) to reduce memory consumption
+and processing time **significantly** when working with large amounts of data. This is typically useful in situations like 
+reporting or cached web services where you just need quick access to the rows in your database.
+
+For now, this is mostly achieved by avoiding the creation of any Ruby data structures (lazy column and row loading), but
+there are plans to use asynchronous queries with perhaps fibres or threads to speed processing up further.
+
+Supported adapters: PostgreSQL
+
+== How to
+
+Include the query module into your ActiveRecord model
+
+  class Foo < ActiveRecord::Base
+    include Velocity::Query
+  end
+  
+This adds a .data() method onto your model class. Use this pretty much like the ActiveRecord 3 query interface.
+
+  Foo.data.where(:designation => 'Superfoo').limit(1000).order('name ASC').each do |foo|
+    puts foo.title
+  end
+  
+What should immediately apparent is that rather than getting a list of ActiveRecord model instances (i.e. Foo), you get an
+iterator object. This object consists of accessor methods reflecting all the fields in your query.
+
+*N.B:* Only simple where(), limit(), order(), group(), and joins() calls are supported.
+
+Using the joins() method essentially results in a LEFT JOIN (in contrast to normal ActiveRecord), and the primary key
+of the joined association is automatically selected as foos_id (where foos is your joined table name).
+
+== Debugging
+
+You can inspect the attributes of a row by calling:
+
+  Foo.data.each do |row|
+    puts row.inspect
+  end
+ 
+  >> #Velocity::MappedRow --> {"id"=>"100759", "some_string_field"=>"Value A"}
+ 
+
+== Velocity development 
+
+Please copy config/database.sample.yml to config/database.yml and adjust to your system settings.
+
+  > rake test
+  
+The first time you run the tests a large test database will be created (for the performance tests), so
+it is likely to take a very very long time on the first run.
+ 
+
+== Contributing to velocity
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== License
+
+Copyright (c) 2011 Pascal Houliston
+
+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/Rakefile

@@ -0,0 +1,39 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+require 'jeweler'
+
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "velocity"
+  gem.homepage = "http://github.com/pascalh1011/velocity"
+  gem.license = "MIT"
+  gem.summary = %Q{Provides a barebones, but supremely quick way of querying your ActiveRecord database.}
+  gem.description = %Q{Provides a barebones, but supremely quick way of querying your ActiveRecord database.}
+  gem.email = "101pascal@gmail.com"
+  gem.authors = ["Pascal Houliston"]
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :migrate do
+  require File.join(File.dirname(__FILE__), 'test', 'helper')
+  require 'active_record'
+  load TEST_ROOT.join('db', 'migrations.rb')
+end
+
+task :default => :test
+

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/config/database.sample.yml

@@ -0,0 +1,5 @@
+adapter: sqlite3
+database: db/test.sqlite3
+pool: 5
+timeout: 5000
+

data/config/schema.rb

@@ -0,0 +1,38 @@
+require 'faker'
+
+ActiveRecord::Schema.define(:version => 1) do
+  create_table(:foos) do |t|
+    t.string :some_string_field
+    t.string :another_string_field
+    t.integer :some_integer_field
+    t.float :some_float_field
+    t.text :some_text_field
+    t.integer :some_indexed_field
+  end
+  
+  create_table(:bars) do |t|
+    t.integer :foo_id
+    t.string :a_string_field
+  end
+  
+  add_index :foos, :some_indexed_field
+  add_index :bars, :foo_id
+end
+
+puts "Setting up database, this may take a while..."
+
+fake_sentences = []
+10.times { fake_sentences << Faker::Lorem.sentence }
+paragraphs = Faker::Lorem.paragraphs
+
+Foo.transaction do
+  100000.times do
+    Foo.create!(:some_string_field => fake_sentences[rand(9)], :another_string_field => fake_sentences[rand(9)], :some_integer_field => rand(9999999), :some_float_field => rand(), :some_text_field => paragraphs, :some_indexed_field => 1)
+  end
+end
+
+Bar.transaction do
+  Foo.select('id').find_each do |foo|
+    Bar.create!(:foo_id => foo.id, :a_string_field => fake_sentences[rand(9)])
+  end
+end

data/lib/velocity.rb

@@ -0,0 +1,5 @@
+require 'active_record'
+require 'active_support'
+
+# Module we're extending ActiveRecord with
+require 'velocity/query'

data/lib/velocity/data_query_map.rb

@@ -0,0 +1,85 @@
+require 'velocity/mapped_row'
+require 'velocity/results/postgresql'
+
+module Velocity
+  class DataQueryMap
+    def initialize(model_binding, force_adapter = nil)
+      begin
+        @handler = "Velocity::#{force_adapter || model_binding.connection.adapter_name}Result".constantize
+      rescue NameError
+        raise "Velocity does not currently support the #{model_binding.connection.adapter_name} adapter.\n Head on over to http://github.com/pascalh1011/velocity to add an issue, or if you're feeling generous, submit an appropriate handler for your database adapter."
+      end
+
+      @model = model_binding
+      @results = nil # For accepting last query (from Result)
+      @fields = ""
+      @conditions = []
+      @orders = []
+      @joins = []
+     
+      # Prepare and proxy methods pertaining to results onto the Result object (after performing the query)
+      (@handler.instance_methods-@handler.superclass.instance_methods+[:inspect, :to_yaml]).each do |method|
+        define_singleton_method(method) do |*arguments, &block|
+          prepare_and_run_query
+          @results.send(method, *arguments, &block)
+        end
+      end
+    end
+    
+    def select(fields='')
+      @fields = [@fields, fields].join(', ') unless fields.blank?
+      self
+    end
+    
+    def limit(limit=nil)
+      @limit = limit.to_i
+      self
+    end
+    
+    def where(conditions={})
+      @conditions << @model.send(:sanitize_sql_for_conditions, conditions) unless conditions.empty?
+      self
+    end
+    
+    def joins(*list_of_associations)
+      @joins += list_of_associations.flatten unless list_of_associations.empty?
+      self
+    end
+    
+    def order(field_and_direction='')
+      @orders << field_and_direction unless field_and_direction.blank?
+      self
+    end
+    
+    def all
+      limit(0)
+      prepare_and_run_query
+      @results
+    end
+    
+    private
+    def prepare_and_run_query
+      fields = "#{@model.table_name}.*" if @fields.blank?
+      
+      unless @joins.blank?
+        joins = @joins.collect do |association|
+          association_reflection = @model.reflect_on_association(association)
+          raise "#{@model.class}: No association found named #{association}" unless association_reflection
+          
+          if @fields.blank?
+            fields += ", #{association_reflection.klass.table_name}.*, #{association_reflection.klass.table_name}.#{association_reflection.klass.primary_key} AS #{association_reflection.klass.table_name}_#{association_reflection.klass.primary_key}"
+          end
+          foreign_key = (association_reflection.respond_to?(:foreign_key))? association_reflection.foreign_key.to_s : association_reflection.primary_key_name.to_s
+          "LEFT JOIN #{association_reflection.table_name} ON #{association_reflection.klass.table_name}.#{foreign_key} = #{@model.table_name}.#{association_reflection.klass.primary_key}"
+        end.join(" ")
+      end
+
+      limit = (@limit.to_i > 0)? "LIMIT #{@limit}" : ""
+      conditions = "WHERE #{@conditions.join(' AND ')}" unless @conditions.blank?
+      orders = "ORDER BY #{@orders.join(', ')}" unless @orders.blank?
+              
+      sql = "SELECT #{fields} FROM #{@model.table_name} "+[joins, conditions, orders, limit].reject(&:blank?).join(' ')
+      @results = @handler.new(sql, @model.connection)
+    end
+  end
+end

data/lib/velocity/mapped_row.rb

@@ -0,0 +1,9 @@
+module Velocity
+  class MappedRow
+    attr_accessor :tuple
+    
+    def inspect
+      "#Velocity::MappedRow --> #{attributes.inspect}"
+    end
+  end
+end

data/lib/velocity/query.rb

@@ -0,0 +1,13 @@
+require 'velocity/data_query_map'
+
+module Velocity
+  module Query
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      def data
+        return DataQueryMap.new(self)
+      end
+    end
+  end
+end

data/lib/velocity/results/postgresql.rb

@@ -0,0 +1,73 @@
+module Velocity
+  class PostgreSQLResult
+    class PostgreSQLMappedRow < MappedRow
+  
+      def initialize(pg_query)
+        @fields = pg_query.fields
+        @pg_query = pg_query
+        
+        # It is imperitive that the adapter return the array in the same sequence of fields provided above
+        # If this isn't the case, some re-ordering of the field KEYS should take place
+        @fields.each_with_index do |field, index|
+          define_singleton_method(field) do
+            pg_query.getvalue(@tuple, index)
+          end
+        end
+      end
+      
+      def attributes
+        @pg_query[@tuple] # Try to avoid calling this, its relatively slow.
+      end
+    end
+    
+    def initialize(sql, adapter)
+      @results = adapter.execute(sql)
+      @mapping = PostgreSQLMappedRow.new(@results)
+      @num_tuples = @results.num_tuples
+    end
+    
+    def collect(&block)
+      @collected = []    
+      @results.num_tuples.times do |tuple|
+        @mapping.tuple = tuple
+        @collected << yield(@mapping)
+      end
+      cleanup
+      @collected
+    end
+    
+    def first
+      self.[](0)
+    end
+    
+    def [](index)
+      @mapping.tap do |mapping|
+        mapping.tuple = index
+      end
+    end
+    
+    def inspect
+      collect(&:attributes).inspect
+    end
+    
+    def to_yaml
+      collect(&:attributes).to_yaml
+    end
+    
+    def each(&block)
+      @results.num_tuples.times do |tuple|
+        @mapping.tuple = tuple
+        yield(@mapping)
+      end
+      cleanup
+    end
+    
+    def length
+      @num_tuples
+    end
+    
+    def cleanup
+      @results.clear
+    end
+  end
+end

data/test/helper.rb

@@ -0,0 +1,49 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'test'
+  add_filter 'config'
+end
+require 'test/unit'
+require 'turn'
+require 'shoulda'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'velocity'
+require 'terminal-table/import'
+
+class TestRoot
+  def initialize
+    @dir = Dir.pwd
+  end
+ 
+  def to_s
+    @dir
+  end
+  
+  def join(*args)
+    File.join(@dir, args)
+  end
+end
+
+TEST_ROOT = TestRoot.new
+
+ActiveRecord::Base.establish_connection(YAML::load_file(TEST_ROOT.join('config', 'database.yml')))
+Dir[TEST_ROOT.join('test', 'models', '*.rb')].each { |f| require(f) }
+
+unless Foo.table_exists?
+  require TEST_ROOT.join('config', 'schema')
+end
+
+
+class Test::Unit::TestCase
+end

data/test/models/bar.rb

@@ -0,0 +1,5 @@
+class Bar < ActiveRecord::Base
+  belongs_to :foo
+  
+  include Velocity::Query
+end

data/test/models/foo.rb

@@ -0,0 +1,5 @@
+class Foo < ActiveRecord::Base
+  has_many :bars, :dependent => :destroy
+  
+  include Velocity::Query
+end

data/test/test_performance.rb

@@ -0,0 +1,47 @@
+require 'helper'
+
+class TestPerformance < Test::Unit::TestCase
+  def measure(&block)
+    t = Time.now.to_f
+    yield
+    ((Time.now.to_f-t)*1000.0).round
+  end
+  
+  # TODO: Nice way of getting actual memory consumption
+  def memory
+    return 0 unless RUBY_PLATFORM.match(/linux/i) # Will be happy to remove this if someone can confirm it's working on other OS's :)
+    sleep 0.1
+    `ps -o rss= -p #{Process.pid}`.to_i
+  end
+
+
+  should "perform favourably compared to ActiveRecord" do
+    t = table
+    t.headings = ['Name', 'Total Rows', 'Total Processing Time (ms)', 'Memory Consumed (KB)']
+    count = Foo.count('id')
+    base = memory
+    private_set = nil
+    
+    ar = measure do
+      collection = []    
+      Foo.find_each do |result|
+        collection << result.some_integer_field
+      end
+      private_set=memory-base
+      collection
+    end
+    t << ['ActiveRecord', count, ar, private_set]
+  
+    base = memory
+    v = measure do
+      collection = []
+      Foo.data.each do |result|
+        collection << result.some_integer_field
+      end     
+      private_set = memory-base
+      collection
+    end
+    t << ['Velocity', count, v, private_set]
+    puts t    
+  end
+end

data/test/test_velocity.rb

@@ -0,0 +1,90 @@
+require 'helper'
+
+class TestVelocity < Test::Unit::TestCase
+  def setup
+    @foo_a = Foo.create(:some_string_field => "Value A")
+    @foo_b = Foo.create(:some_string_field => "Value A", :another_string_field => "Value B")
+    @foo_a.bars.create(:a_string_field => "A")
+    @foo_b.bars.create(:a_string_field => "B")
+  end
+  
+  def teardown
+    @foo_a.destroy
+    @foo_b.destroy
+  end
+  
+  should "return a Velocity::DataQueryMap with expected API methods when included in an ActiveRecord model" do
+    assert_equal(Velocity::DataQueryMap, Foo.data.class)
+    
+    expected_api_methods = [:select, :joins, :limit, :where, :order]
+    
+    expected_api_methods.each do |method|
+      assert(Foo.data.respond_to?(method), "Velocity::DataQueryMap should respond to #{method}")
+      instance = Foo.data
+      assert_equal(instance, instance.send(method), "Velocity::DataQueryMap.#{method} should return an instance of itself (for chaining)")
+    end
+  end
+  
+  should "return the first result matching when given a where clause" do
+    first_match = Foo.data.where(:some_string_field => "Value A").first
+    Foo.columns_hash.keys.each do |column|
+      assert(first_match.respond_to?(column), "Single result should respond to column #{column}")
+    end
+    assert_equal("Value A", first_match.some_string_field)
+    assert(first_match.inspect.include?("Value A"))
+
+    second_match = Foo.data.where(:some_string_field => "Value A").where(:another_string_field => "Value B").first
+
+    Foo.columns_hash.keys.each do |column|
+      assert(second_match.respond_to?(column), "Single result should respond to column #{column}")
+    end
+    assert_equal("Value A", second_match.some_string_field)
+    assert_equal("Value B", second_match.another_string_field)
+  end
+  
+  should "return an iterator for all results" do
+    results_via_reflection = Foo.data.where(:some_string_field => "Value A")
+    results_via_iterator = Foo.data.where(:some_string_field => "Value A").all # Note the all()
+    
+    [results_via_reflection, results_via_iterator].each do |results|
+      results.each do |result|
+       Foo.columns_hash.keys.each do |column|
+         assert(result.respond_to?(column), "Single result should respond to column #{column}")
+         assert_equal(result.some_string_field, "Value A")
+       end
+      end
+    end
+    assert_equal(2, results_via_iterator.length)
+  end
+  
+  should "respond provide a simple inspection API for debugging" do
+    all_results = Foo.data.where(:some_string_field => "Value A")
+
+    assert(all_results.inspect.include?('Value B'), "inspect() method should work as per default")
+    assert(all_results.to_yaml.include?('Value B'), "to_yaml() method should work as per default")
+  end
+  
+  should "return results in the correct order" do
+    results = Foo.data.where(:some_string_field => "Value A").order("another_string_field ASC").collect { |r| r.another_string_field }
+    
+    assert_equal("Value B", results.first)
+    assert_nil(results.last)
+  end
+  
+  should "join associations when requested and return appropriate columns" do
+    results = Foo.data.where(:some_string_field => "Value A").joins(:bars)
+    
+    results.each do |result|
+      Foo.columns_hash.merge(Bar.columns_hash).keys.each do |column|
+        assert(result.respond_to?(column), "Result should respond to #{column} (may be from association)")
+      end
+      assert(result.respond_to?("bars_id"), "Should include the association's primary key")
+    end
+  end
+  
+  should "inform the user if their database is unsupported" do
+    assert_raise RuntimeError do
+      Velocity::DataQueryMap.new(Foo, "HappyRainbowAdapter")
+    end
+  end
+end

data/velocity.gemspec

@@ -0,0 +1,99 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{velocity}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Pascal Houliston"]
+  s.date = %q{2011-05-03}
+  s.description = %q{Provides a barebones, but supremely quick way of querying your ActiveRecord database.}
+  s.email = %q{101pascal@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.rdoc",
+    "Rakefile",
+    "VERSION",
+    "config/database.sample.yml",
+    "config/schema.rb",
+    "lib/velocity.rb",
+    "lib/velocity/data_query_map.rb",
+    "lib/velocity/mapped_row.rb",
+    "lib/velocity/query.rb",
+    "lib/velocity/results/postgresql.rb",
+    "test/helper.rb",
+    "test/models/bar.rb",
+    "test/models/foo.rb",
+    "test/test_performance.rb",
+    "test/test_velocity.rb",
+    "velocity.gemspec"
+  ]
+  s.homepage = %q{http://github.com/pascalh1011/velocity}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Provides a barebones, but supremely quick way of querying your ActiveRecord database.}
+  s.test_files = [
+    "test/helper.rb",
+    "test/models/bar.rb",
+    "test/models/foo.rb",
+    "test/test_performance.rb",
+    "test/test_velocity.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activerecord>, ["~> 3.0.0"])
+      s.add_runtime_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_development_dependency(%q<jeweler>, [">= 0"])
+      s.add_development_dependency(%q<pg>, [">= 0"])
+      s.add_development_dependency(%q<mysql2>, [">= 0"])
+      s.add_development_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_development_dependency(%q<simplecov>, [">= 0"])
+      s.add_development_dependency(%q<terminal-table>, [">= 0"])
+      s.add_development_dependency(%q<term-ansicolor>, [">= 0"])
+      s.add_development_dependency(%q<turn>, [">= 0.8.2"])
+      s.add_development_dependency(%q<ansi>, [">= 0"])
+      s.add_development_dependency(%q<faker>, [">= 0"])
+    else
+      s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
+      s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+      s.add_dependency(%q<jeweler>, [">= 0"])
+      s.add_dependency(%q<pg>, [">= 0"])
+      s.add_dependency(%q<mysql2>, [">= 0"])
+      s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+      s.add_dependency(%q<simplecov>, [">= 0"])
+      s.add_dependency(%q<terminal-table>, [">= 0"])
+      s.add_dependency(%q<term-ansicolor>, [">= 0"])
+      s.add_dependency(%q<turn>, [">= 0.8.2"])
+      s.add_dependency(%q<ansi>, [">= 0"])
+      s.add_dependency(%q<faker>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activerecord>, ["~> 3.0.0"])
+    s.add_dependency(%q<activesupport>, ["~> 3.0.0"])
+    s.add_dependency(%q<jeweler>, [">= 0"])
+    s.add_dependency(%q<pg>, [">= 0"])
+    s.add_dependency(%q<mysql2>, [">= 0"])
+    s.add_dependency(%q<thoughtbot-shoulda>, [">= 0"])
+    s.add_dependency(%q<simplecov>, [">= 0"])
+    s.add_dependency(%q<terminal-table>, [">= 0"])
+    s.add_dependency(%q<term-ansicolor>, [">= 0"])
+    s.add_dependency(%q<turn>, [">= 0.8.2"])
+    s.add_dependency(%q<ansi>, [">= 0"])
+    s.add_dependency(%q<faker>, [">= 0"])
+  end
+end
+

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification 
+name: velocity
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Pascal Houliston
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-03 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: jeweler
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: pg
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: mysql2
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: thoughtbot-shoulda
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: terminal-table
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id008
+- !ruby/object:Gem::Dependency 
+  name: term-ansicolor
+  requirement: &id009 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id009
+- !ruby/object:Gem::Dependency 
+  name: turn
+  requirement: &id010 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.8.2
+  type: :development
+  prerelease: false
+  version_requirements: *id010
+- !ruby/object:Gem::Dependency 
+  name: ansi
+  requirement: &id011 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id011
+- !ruby/object:Gem::Dependency 
+  name: faker
+  requirement: &id012 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  prerelease: false
+  version_requirements: *id012
+description: Provides a barebones, but supremely quick way of querying your ActiveRecord database.
+email: 101pascal@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- config/database.sample.yml
+- config/schema.rb
+- lib/velocity.rb
+- lib/velocity/data_query_map.rb
+- lib/velocity/mapped_row.rb
+- lib/velocity/query.rb
+- lib/velocity/results/postgresql.rb
+- test/helper.rb
+- test/models/bar.rb
+- test/models/foo.rb
+- test/test_performance.rb
+- test/test_velocity.rb
+- velocity.gemspec
+has_rdoc: true
+homepage: http://github.com/pascalh1011/velocity
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 547612753
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Provides a barebones, but supremely quick way of querying your ActiveRecord database.
+test_files: 
+- test/helper.rb
+- test/models/bar.rb
+- test/models/foo.rb
+- test/test_performance.rb
+- test/test_velocity.rb