valium 0.2.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,19 @@
+source "http://rubygems.org"
+gemspec
+
+rails = ENV['RAILS'] || 'master'
+
+case rails
+when /\// # A path
+  path rails do
+    gem 'activerecord'
+  end
+when /^v/ # A tagged version
+  git 'git://github.com/rails/rails.git', :tag => rails do
+    gem 'activerecord'
+  end
+else
+  git 'git://github.com/rails/rails.git', :branch => rails do
+    gem 'activerecord'
+  end
+end

data/README.md

@@ -0,0 +1,101 @@
+# Valium
+
+Suffering from ActiveRecord instantiation anxiety? Try Valium. It
+saves your CPU and memory for more important things, retrieving
+just the values you're interested in seeing.
+
+## Usage
+
+### In your Gemfile:
+
+    gem 'valium'
+    
+### In your code:
+
+You can select a single value...
+
+```ruby
+Post.where(:published => true)[:title]
+# - OR -
+Post.where(:published => true).value_of :title
+# => ["First Post", "Another Awesome Post", ...]
+```
+
+... or several ...
+
+```ruby
+Employee.where(:title => 'Sr. Monkey Wrangler')[:first_name, :last_name, :hired_at]
+# - OR -
+Employee.where(:title => 'Sr. Monkey Wrangler').value_of :first_name, :last_name, :hired_at
+# => [["Ernie", "Miller", 2009-09-21 08:00:00 -0400],
+      ["Herb", "Myers", 2002-02-13 09:00:00 -0400], ...]
+```
+
+Values returned by Valium will be the data types you'd expect, just
+as though you instantiated the ActiveRecord object and used the
+accessor. This includes serialized attributes:
+
+```ruby
+class Animal < ActiveRecord::Base
+  serialize :extra_info
+end
+
+Animal.where(:genus => 'felis')[:species, :extra_info]
+# => [["catus", {:domestic => true}], ["lolcatus", {:can_has_cheezburger => true}], ...]
+```
+
+## Why would I use this?
+
+It's not uncommon for Rails apps to need only one or two attributes
+from a bunch of ActiveRecord objects. They'll have code like this:
+
+```ruby
+MyModel.some_scope.map(&:id)
+```
+
+Or, if the developer is a bit more clever about saving memory, he
+might use code like this:
+
+```ruby
+MyModel.some_scope.select(:id).map(&:id)
+```
+
+This helps a good deal with memory usage, but even if we cut down 
+on the memory usage a bit, the truth is that no matter what we try,
+**instantiating ActiveRecord objects is slow.**
+
+This is because ActiveRecord provides all kinds of awesome stuff,
+none of which we need, if we're just looking to grab one or two
+values and print them out, or perform a quick calculation, or
+something.
+
+Check out [this gist of a benchmark script and results](https://gist.github.com/1166964)
+to see just how much it can hurt when you're instantiating
+unnecessary ActiveRecord objects.
+
+TL;DR: It hurts *a lot*. For retrieving a single value, using Valium
+is nearly 10x faster than mapping over ActiveRecord objects.
+For multiple values, it's about 5x faster. Even if you're
+deserializing attributes, where more time, proportionally, gets
+spent in the deserialization process than with normal attributes,
+Valium can be up to twice as fast as mapping over ActiveRecord
+objects, in my tests.
+
+## Conclusion
+
+You knew everything I mentioned above, already. In fact,
+you're probably mocking me right now:
+
+"ZOMG OBJECTS USE MEMORY AND INSTANTIATION TAKES CPU CYCLES!
+I R GENIUS!"
+
+Yeah. It's not rocket science. This is just a quick little
+(seriously, around 100 LOC) gem that provides some intuitive 
+syntax around a common pattern and doesn't stomp on any
+existing ActiveRecord functionality. It "just works."
+
+Give it a try. Your code will thank you for it.
+
+## Copyright
+
+Copyright &copy; 2011 [Ernie Miller](http://twitter.com/erniemiller)

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |rspec|
+  rspec.rspec_opts = ['--backtrace']
+end
+
+task :default => :spec
+
+desc "Open an irb session with Valium and the sample data used in specs"
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'console'
+  ARGV.clear
+  IRB.start
+end

data/lib/valium.rb

@@ -0,0 +1,105 @@
+require "valium/version"
+require 'active_record'
+
+module Valium
+  if ActiveRecord::VERSION::MAJOR == 3
+
+    if ActiveRecord::VERSION::MINOR == 0 # We need to use the old deserialize code
+
+      def valium_deserialize(value, klass)
+        if value.is_a?(String) && value =~ /^---/
+          result = YAML::load(value) rescue value
+          if result.nil? || result.is_a?(klass)
+            result
+          else
+            raise SerializationTypeMismatch,
+              "Expected a #{klass}, but was a #{result.class}"
+          end
+        else
+          value
+        end
+      end
+
+    else # we're on 3.1+, yay for coder.load!
+
+      def valium_deserialize(value, coder)
+        coder.load(value)
+      end
+
+    end # Minor version check
+
+    def value_of(*attr_names)
+      attr_names.map! do |attr_name|
+        attr_name = attr_name.to_s
+        attr_name == 'id' ? primary_key : attr_name
+      end
+
+      if attr_names.size > 1
+        valium_select_multiple(attr_names)
+      else
+        valium_select_one(attr_names.first)
+      end
+    end
+
+    alias :[] :value_of
+
+    def valium_select_multiple(attr_names)
+      columns = attr_names.map {|n| columns_hash[n]}
+      coders  = attr_names.map {|n| serialized_attributes[n]}
+
+      connection.select_rows(
+        except(:select).select(attr_names.map {|n| arel_table[n]}).to_sql
+      ).map! do |values|
+        values.each_with_index do |value, index|
+          values[index] = valium_cast(value, columns[index], coders[index])
+        end
+      end
+    end
+
+    def valium_select_one(attr_name)
+      column = columns_hash[attr_name]
+      coder  = serialized_attributes[attr_name]
+
+      connection.select_rows(
+        except(:select).select(arel_table[attr_name]).to_sql
+      ).map! do |values|
+        valium_cast(values[0], column, coder)
+      end
+    end
+
+    def valium_cast(value, column, coder_or_klass)
+      if value.nil? || !column
+        value
+      elsif coder_or_klass
+        valium_deserialize(value, coder_or_klass)
+      else
+        column.type_cast(value)
+      end
+    end
+
+    module Relation
+      def value_of(*args)
+        if args.size > 0 && args.all? {|a| String === a || Symbol === a}
+          args.map! do |attr_name|
+            attr_name = attr_name.to_s
+            attr_name == 'id' ? @klass.primary_key : attr_name
+          end
+
+          if loaded? && (empty? || args.all? {|a| first.attributes.has_key? a})
+            to_a.map {|record| args.map {|a| record[a]}}
+          else
+            scoping { @klass[*args] }
+          end
+        else
+          to_a[*args]
+        end
+      end
+
+      alias :[] :value_of
+    end
+
+  end # Major version check
+end
+
+ActiveRecord::Base.extend Valium
+ActiveRecord::Relation.send :include, Valium::Relation

data/lib/valium/version.rb

@@ -0,0 +1,3 @@
+module Valium
+  VERSION = "0.2.1"
+end

data/spec/console.rb

@@ -0,0 +1,7 @@
+Dir[File.expand_path('../../spec/{helpers,support}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+Schema.create
+
+require 'valium'

data/spec/helpers/valium_helper.rb

@@ -0,0 +1,9 @@
+module ValiumHelper
+  def queries_for
+    $queries_executed = []
+    yield
+    $queries_executed
+  ensure
+    %w{ BEGIN COMMIT }.each { |x| $queries_executed.delete(x) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,42 @@
+require 'active_record'
+
+module ActiveRecord
+  class SQLCounter
+    IGNORED_SQL = [/^PRAGMA /, /^SELECT currval/, /^SELECT CAST/, /^SELECT @@IDENTITY/, /^SELECT @@ROWCOUNT/, /^SAVEPOINT/, /^ROLLBACK TO SAVEPOINT/, /^RELEASE SAVEPOINT/, /^SHOW max_identifier_length/,
+      /SELECT name\s+FROM sqlite_master\s+WHERE type = 'table' AND NOT name = 'sqlite_sequence'/]
+
+    # FIXME: this needs to be refactored so specific database can add their own
+    # ignored SQL.  This ignored SQL is for Oracle.
+    IGNORED_SQL.concat [/^select .*nextval/i, /^SAVEPOINT/, /^ROLLBACK TO/, /^\s*select .* from all_triggers/im]
+
+    def initialize
+      $queries_executed = []
+    end
+
+    def call(name, start, finish, message_id, values)
+      sql = values[:sql]
+
+      unless 'CACHE' == values[:name]
+        $queries_executed << sql unless IGNORED_SQL.any? { |r| sql =~ r }
+      end
+    end
+  end
+  ActiveSupport::Notifications.subscribe('sql.active_record', SQLCounter.new)
+end
+
+Dir[File.expand_path('../{helpers,support}/*.rb', __FILE__)].each do |f|
+  require f
+end
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    puts '=' * 80
+    puts "Running specs against ActiveRecord #{ActiveRecord::VERSION::STRING}..."
+    puts '=' * 80
+    Schema.create
+  end
+
+  config.include ValiumHelper
+end
+
+require 'valium'

data/spec/support/schema.rb

@@ -0,0 +1,50 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => ':memory:'
+)
+
+class Person < ActiveRecord::Base
+  serialize :extra_info
+end
+
+class Widget < ActiveRecord::Base
+  serialize :extra_info
+  set_primary_key :widget_id
+end
+
+module Schema
+  def self.create
+    ActiveRecord::Base.silence do
+      ActiveRecord::Migration.verbose = false
+
+      ActiveRecord::Schema.define do
+        create_table :people, :force => true do |t|
+          t.string   :first_name
+          t.string   :last_name
+          t.integer  :age
+          t.text     :extra_info
+          t.timestamps
+        end
+
+        create_table :widgets, :force => true, :primary_key => :widget_id do |t|
+          t.string   :name
+          t.text     :extra_info
+          t.timestamps
+        end
+      end
+    end
+
+    1.upto(100) do |num|
+      Person.create! :first_name => "Person", :last_name => "Number#{num}", :age => num % 99,
+                     :extra_info => {:a_key => "Value Number #{num}"}
+    end
+
+    1.upto(100) do |num|
+      Widget.create! :name => "Widget #{num}",
+                     :extra_info => {:a_key => "Value Number #{num}"}
+    end
+
+  end
+end

data/spec/valium/valium_spec.rb

@@ -0,0 +1,167 @@
+require 'spec_helper'
+
+describe Valium do
+
+  context 'with a symbol key' do
+    subject { Person[:id] }
+    it { should have(100).ids }
+    it { should eq((1..100).to_a) }
+  end
+
+  context 'with value_of syntax' do
+    subject { Person.value_of :id }
+    it { should have(100).ids }
+    it { should eq((1..100).to_a) }
+  end
+
+  context 'with a string key' do
+    subject { Person['id'] }
+    it { should have(100).ids }
+    it { should eq((1..100).to_a) }
+  end
+
+  context 'with multiple keys' do
+    subject { Person[:id, :last_name] }
+    it { should have(100).elements }
+    it { should eq((1..100).map {|n| [n, "Number#{n}"]})}
+  end
+
+  context 'with a datetime column' do
+    subject { Person[:created_at] }
+    it { should have(100).datetimes }
+    it { should be_all {|d| Time === d}}
+  end
+
+  context 'with a serialized column' do
+    subject { Person[:extra_info] }
+    it { should have(100).hashes }
+    it { should eq 1.upto(100).map {|n| {:a_key => "Value Number #{n}"} }}
+  end
+
+  context 'with an alternate primary key and an :id select' do
+    subject { Widget[:id] }
+    it { should have(100).ids }
+    it { should eq (1..100).to_a}
+  end
+
+  context 'with an alternate primary key and an alternate primary key select' do
+    subject { Widget[:widget_id] }
+    it { should have(100).ids }
+    it { should eq (1..100).to_a}
+  end
+
+  context 'with a scope' do
+    subject { Person.where(:id => [1,50,100])[:last_name] }
+    it { should have(3).last_names }
+    it { should eq ['Number1', 'Number50', 'Number100'] }
+  end
+
+  context 'with a scope and value_of syntax' do
+    subject { Person.where(:id => [1,50,100]).value_of :id }
+    it { should have(3).ids }
+    it { should eq [1,50,100] }
+  end
+
+  context 'with a scope, an alternate primary key, and an :id select' do
+    subject {Widget.where(:widget_id => [1,50,100])[:id] }
+    it { should have(3).ids }
+    it { should eq [1,50,100]}
+  end
+
+  context 'with a scope, an alternate primary key, and an alternate primary key select' do
+    subject { Widget.where(:widget_id => [1,50,100])[:widget_id] }
+    it { should have(3).widget_ids }
+    it { should eq [1,50,100]}
+  end
+
+  context 'with a loaded scope' do
+    subject do
+      Person.where(:id => [1,50,100]).tap do |relation|
+        relation.all
+      end
+    end
+
+    # We'll generate the first query when we call "subject", but won't
+    # need another query
+    specify { queries_for { subject[:id] }.should have(1).query }
+
+    specify { subject[:id, :created_at, :extra_info].
+              should eq Person.where(:id => [1,50,100])[:id, :created_at, :extra_info] }
+  end
+
+  context 'with a loaded scope, an alternate primary key, and an :id select' do
+    subject do
+      Widget.where(:widget_id => [1,50,100]).tap do |relation|
+        relation.all
+      end
+    end
+
+    # We'll generate the first query when we call "subject", but won't
+    # need another query
+    specify { queries_for { subject[:id] }.should have(1).query }
+
+    specify { subject[:id, :created_at, :extra_info].
+              should eq Widget.where(:widget_id => [1,50,100])[:id, :created_at, :extra_info] }
+  end
+
+  context 'with a loaded scope but missing attributes' do
+    subject do
+      Person.select(:id).where(:id => [1,50,100]).tap do |relation|
+        relation.all
+      end
+    end
+
+    # We'll generate the first query when we call "subject", but won't
+    # need another query
+    specify { queries_for { subject[:id] }.should have(1).query }
+
+    # We'll need to run our own query for the attributes
+    specify { queries_for { subject[:first_name] }.should have(2).queries }
+
+    specify { subject[:id, :created_at, :extra_info].
+              should eq Person.where(:id => [1,50,100])[:id, :created_at, :extra_info] }
+  end
+
+  context 'with a loaded scope, an alternate primary key, and missing attributes' do
+    subject do
+      Widget.select(:widget_id).where(:widget_id => [1,50,100]).tap do |relation|
+        relation.all
+      end
+    end
+
+    # We'll generate the first query when we call "subject", but won't
+    # need another query
+    specify { queries_for { subject[:id] }.should have(1).query }
+    specify { queries_for { subject[:widget_id] }.should have(1).query }
+
+    # We'll need to run our own query for the attributes
+    specify { queries_for { subject[:name] }.should have(2).queries }
+
+    specify { subject[:id, :created_at, :extra_info].
+              should eq Widget.where(:widget_id => [1,50,100])[:id, :created_at, :extra_info] }
+  end
+
+  context 'with a scope and multiple keys' do
+    subject { Person.where(:id => [1,50,100])[:last_name, :id, :extra_info] }
+    it { should have(3).elements }
+    it { should eq [1,50,100].map {|n| ["Number#{n}", n, {:a_key => "Value Number #{n}"}]}}
+  end
+
+  context 'with a relation array index' do
+    subject { Person.where(:id => [1,50,100])[1] }
+    it { should eq Person.find(50) }
+  end
+
+  context 'with a relation array start and length' do
+    subject { Person.where(:id => 1..20)[10,3] }
+    it { should have(3).people }
+    it { should eq Person.offset(10).limit(3) }
+  end
+
+  context 'with a relation array range' do
+    subject { Person.where(:id => 1..20)[0..9] }
+    it { should have(10).people }
+    it { should eq Person.first(10) }
+  end
+
+end

data/valium.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "valium/version"
+
+Gem::Specification.new do |s|
+  s.name        = "valium"
+  s.version     = Valium::VERSION
+  s.authors     = ["Ernie Miller"]
+  s.email       = ["ernie@metautonomo.us"]
+  s.homepage    = "http://github.com/ernie/valium"
+  s.summary     = %q{
+    Access attribute values directly, without instantiating ActiveRecord objects.
+  }
+  s.description = %q{
+    Suffering from ActiveRecord instantiation anxiety? Try Valium. It
+    saves your CPU and memory for more important things, retrieving
+    just the values you're interested in seeing.
+  }
+
+  s.rubyforge_project = "valium"
+
+  s.add_dependency 'activerecord', '>= 3.0.2'
+  s.add_development_dependency 'rspec', '~> 2.6.0'
+  s.add_development_dependency 'sqlite3', '~> 1.3.3'
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,97 @@
+--- !ruby/object:Gem::Specification
+name: valium
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+  prerelease: 
+platform: ruby
+authors:
+- Ernie Miller
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-25 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &70159201437300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: *70159201437300
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70159201401980 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *70159201401980
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &70159201388400 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.3
+  type: :development
+  prerelease: false
+  version_requirements: *70159201388400
+description: ! "\n    Suffering from ActiveRecord instantiation anxiety? Try Valium.
+  It\n    saves your CPU and memory for more important things, retrieving\n    just
+  the values you're interested in seeing.\n  "
+email:
+- ernie@metautonomo.us
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- lib/valium.rb
+- lib/valium/version.rb
+- spec/console.rb
+- spec/helpers/valium_helper.rb
+- spec/spec_helper.rb
+- spec/support/schema.rb
+- spec/valium/valium_spec.rb
+- valium.gemspec
+homepage: http://github.com/ernie/valium
+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'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: valium
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Access attribute values directly, without instantiating ActiveRecord objects.
+test_files:
+- spec/console.rb
+- spec/helpers/valium_helper.rb
+- spec/spec_helper.rb
+- spec/support/schema.rb
+- spec/valium/valium_spec.rb