ghazel-slim-attributes 0.6.3.1

data/MIT_LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Stephen Sykes
+
+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

@@ -0,0 +1,44 @@
+SlimAttributes
+==============
+
+This is a small patch to the ActiveRecord Mysql adaptor that stops rails from using the all_hashes / each_hash mechanism - which is what is called when you do a find.
+
+It is faster, and uses less memory.
+
+Measuring with just ActiveRecord code - fetching stuff from the database - we see anything up to a 50% (or more) speed increase, but I suppose it really depends on your system and environment, and what you are doing with the results from the database.  The more columns your tables have, the better the improvement will likely be.  Measure your own system and send me the results!
+
+
+Installation
+============
+
+You're going to need the mysql headers for this to work.
+
+Try:
+gem install slim-attributes -- --with-mysql-config
+or:
+gem install slim-attributes
+
+then add this to environment.rb:
+require 'slim_attributes'
+
+
+Description
+===========
+
+The reason for overriding all_hashes is threefold:
+
+* making a hash of each and every row returned from the database is slow
+* ruby makes frozen copies of each column name string (for the keys) which results in a great many strings which are not really needed
+* we observe that it's not often that all the fields of rows fetched from the database are actually used
+
+So this is an alternative implementation of all_hashes that returns a 'fake hash' which contains a hash of the column names (the same hash of names is used for every row), and also contains the row data in an area memcpy'd directly from the mysql API.
+
+The field contents are then instantiated into Ruby strings on demand - ruby strings are only made if you need them.  Note that if you always look at all the columns when you fetch data from the database then this won't necessarily be faster that the unpatched mysql adapter.  But it won't be much slower either, and we do expect that most times not all the columns from a result set are accessed.
+
+
+===========
+
+No warranty - this gem has been tested, but not in all environments.  However, that said, we are using it in our production environment with good results.
+Please report bugs to sdsykes at symbol gmail pip com.
+
+Copyright (c) 2008 Stephen Sykes, released under the MIT license

data/Rakefile

@@ -0,0 +1,19 @@
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |s|
+    s.name = "slim-attributes"
+    s.summary = "Slim-attributes - lazy instantiation of attributes for ActiveRecord"
+    s.email = "sdsykes@gmail.com"
+    s.homepage = "http://github.com/sdsykes/slim-attributes"
+    s.description = "Slim attributes boosts speed in Rails/Mysql ActiveRecord Models by avoiding
+    instantiating Hashes for each result row, and lazily instantiating attributes as needed."
+    s.authors = ["Stephen Sykes"]
+    s.files = FileList["[A-Z]*", "{ext,lib,test}/**/*"]
+    s.extensions = "ext/extconf.rb"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://
+gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:patch: 3
+:major: 0
+:minor: 6

data/ext/extconf.rb

@@ -0,0 +1,26 @@
+# this code is borrowed from Mysql/Ruby, credit to TOMITA Masahiro
+# it works for me under OS X and Fedora, hope it works for you also
+
+require 'mkmf'
+
+if /mswin32/ =~ RUBY_PLATFORM
+  inc, lib = dir_config('mysql')
+  exit 1 unless have_library("libmysql")
+elsif mc = with_config('mysql-config') then
+  mc = 'mysql_config' if mc == true
+  cflags = `#{mc} --cflags`.chomp
+  exit 1 if $? != 0
+  libs = `#{mc} --libs`.chomp
+  exit 1 if $? != 0
+  $CPPFLAGS += ' ' + cflags
+  $libs = libs + " " + $libs
+else
+  inc, lib = dir_config('mysql', '/usr/local')
+  libs = ['m', 'z', 'socket', 'nsl', 'mygcc']
+  while not find_library('mysqlclient', 'mysql_query', lib, "#{lib}/mysql") do
+    exit 1 if libs.empty?
+    have_library(libs.shift)
+  end
+end
+
+create_makefile("slim_attrib_ext")

data/ext/slim_attrib_ext.c

@@ -0,0 +1,210 @@
+// Author: Stephen Sykes
+// http://pennysmalls.com
+
+#include "ruby.h"
+#include "st.h"
+
+#include <mysql.h>
+#include <errmsg.h>
+#include <mysqld_error.h>
+
+#define GetMysqlRes(obj) (Check_Type(obj, T_DATA), ((struct mysql_res*)DATA_PTR(obj))->res)
+#define GetCharPtr(obj) (Check_Type(obj, T_DATA), (char*)DATA_PTR(obj))
+#define GetCharStarPtr(obj) (Check_Type(obj, T_DATA), (char**)DATA_PTR(obj))
+
+VALUE cRowHash, cClass;
+ID pointers_id, row_info_id, field_indexes_id, real_hash_id, to_hash_id;
+
+#define MAX_CACHED_COLUMN_IDS 40
+ID column_ids[MAX_CACHED_COLUMN_IDS];
+
+// from mysql/ruby
+struct mysql_res {
+  MYSQL_RES* res;
+  char freed;
+};
+
+// row info
+#define SLIM_IS_NULL (char)0x01
+#define SLIM_IS_SET (char)0x02
+
+#define GET_COL_IV_ID(str, cnum) (cnum < MAX_CACHED_COLUMN_IDS ? column_ids[cnum] : (sprintf(str, "@col_%ld", cnum), rb_intern(str)))
+
+#define REAL_HASH_EXISTS NIL_P(field_indexes = rb_ivar_get(obj, field_indexes_id))
+
+// This replaces the usual all_hashes method defined in mysql_adaptor.rb
+//
+// It copies the data from the mysql result into allocated memory
+// ready for creating ruby strings from on demand, instead of creating
+// all the data into ruby strings immediately.
+// all_hashes returns an array of result rows
+static VALUE all_hashes(VALUE obj) {
+  MYSQL_RES *res = GetMysqlRes(obj);
+  MYSQL_FIELD *fields = mysql_fetch_fields(res);
+  MYSQL_ROW row;
+  VALUE all_hashes_ary, col_names_hsh, frh;
+  my_ulonglong nr = mysql_num_rows(res);
+  unsigned int nf = mysql_num_fields(res);
+  unsigned int i, j, s, len;
+  unsigned long *lengths;
+  char *row_info_space, **pointers_space, *p;
+
+  // make a hash of column names
+  col_names_hsh = rb_hash_new();
+  for (i=0; i < nf; i++) {
+    rb_hash_aset(col_names_hsh, rb_str_new2(fields[i].name), INT2FIX(i));
+  }
+
+  // make the array of result rows
+  all_hashes_ary = rb_ary_new2(nr);
+
+  for (i=0; i < nr; i++) {
+    row = mysql_fetch_row(res);         // get the row data and lengths from mysql
+    lengths = mysql_fetch_lengths(res);
+    for (s=j=0; j < nf; j++) s += lengths[j];  // s = total of lengths
+    pointers_space = ruby_xmalloc((nf + 1) * sizeof(char *) + s);  // space for data pointers & data
+    if (!pointers_space) {
+      rb_raise(rb_eNoMemError, "out of memory");
+    }
+    p = *pointers_space = (char *)(pointers_space + nf + 1);  // pointer to first data item
+    row_info_space = ruby_xcalloc(nf, 1);  // space for flags for each column in this row
+    if (!row_info_space) {
+      ruby_xfree(pointers_space);
+      rb_raise(rb_eNoMemError, "out of memory");      
+    }
+    for (j=0; j < nf; j++) {
+      len = (unsigned int)lengths[j];
+      if (len) {
+        memcpy(p, row[j], len); // copy row data in
+        p += len;
+      } else if (!row[j]) row_info_space[j] = SLIM_IS_NULL;  // flag so we can handle null
+      pointers_space[j + 1] = p;
+    }
+    frh = rb_class_new_instance(0, NULL, cRowHash);  // create the row object
+    rb_ivar_set(frh, pointers_id, Data_Wrap_Struct(cClass, 0, ruby_xfree, pointers_space));
+    rb_ivar_set(frh, row_info_id, Data_Wrap_Struct(cClass, 0, ruby_xfree, row_info_space));
+    rb_ivar_set(frh, field_indexes_id, col_names_hsh);
+    rb_ary_store(all_hashes_ary, i, frh);  // store it in the array
+  }
+  return all_hashes_ary;
+}
+
+// This does the actual work of creating a ruby string when one is demanded, typically through
+// a call to an active record model property method.
+static VALUE fetch_by_index(VALUE obj, VALUE index) {
+  VALUE contents;
+  char *row_info, **pointers, *start, col_name[16];
+  ID col_id;
+  long col_number = FIX2LONG(index);
+  unsigned int length;
+  row_info = GetCharPtr(rb_ivar_get(obj, row_info_id)) + col_number;  // flags for this column
+  if (*row_info == SLIM_IS_NULL) return Qnil;  // return nil if null from db
+  col_id = GET_COL_IV_ID(col_name, col_number);
+  if (*row_info == SLIM_IS_SET) return rb_ivar_get(obj, col_id);  // was made to a string already
+  pointers = GetCharStarPtr(rb_ivar_get(obj, pointers_id));  // find the data and make ruby string
+  start = pointers[col_number];
+  length = pointers[col_number + 1] - start;
+  contents = rb_tainted_str_new(start, length);
+  rb_ivar_set(obj, col_id, contents);  // it is efficient to save the string in an instance variable
+  *row_info = SLIM_IS_SET;
+  return contents;
+}
+
+// This is the [] method of the row data object.
+// It checks for a real hash, but if none exists it will call fetch_by_index
+static VALUE slim_fetch(VALUE obj, VALUE name) {
+  VALUE field_indexes, hash_lookup;
+  
+  if (REAL_HASH_EXISTS) return rb_hash_aref(rb_ivar_get(obj, real_hash_id), name);
+
+  hash_lookup = rb_hash_aref(field_indexes, name);
+  if (NIL_P(hash_lookup)) return Qnil;
+  return fetch_by_index(obj, hash_lookup);
+}
+
+// This is the []= method of the row data object.
+// It either operates on the real hash if it exists, or sets the appropriate
+// column instance variable
+static VALUE set_element(VALUE obj, VALUE name, VALUE val) {
+  VALUE field_indexes, hash_lookup;
+  long col_number;
+  char col_name[16];
+  ID col_id;
+
+  if (REAL_HASH_EXISTS) return rb_hash_aset(rb_ivar_get(obj, real_hash_id), name, val);
+  
+  hash_lookup = rb_hash_aref(field_indexes, name);  
+  if (NIL_P(hash_lookup)) return rb_hash_aset(rb_funcall(obj, to_hash_id, 0), name, val);
+  col_number = FIX2LONG(hash_lookup);
+  col_id = GET_COL_IV_ID(col_name, col_number);
+  rb_ivar_set(obj, col_id, val);
+  GetCharPtr(rb_ivar_get(obj, row_info_id))[col_number] = SLIM_IS_SET;
+  return val;
+}
+
+// This is the dup method of the row data object.
+// When the query cache is used, the result of all_hashes is dupped before
+// being passed back to the user.
+// Subsequent queries of the same SQL will get another dup of the results.
+// So we must implement dup in an efficient way (without converting to a real hash).
+//
+// Note: this method currently ignores any columns that have been assigned to using
+// []= before calling dup (the original values will be seen in the dup).  This works ok 
+// for active record usage, but perhaps could cause unexpected behaviour if model
+// attributes are dupped by the user after changing them.
+static VALUE slim_dup(VALUE obj) {
+  VALUE frh, field_indexes;
+  int nf, i;
+  char *row_info_space;
+
+  if (REAL_HASH_EXISTS) return rb_obj_dup(rb_ivar_get(obj, real_hash_id));
+
+  nf = RHASH(field_indexes)->tbl->num_entries;
+  row_info_space = ruby_xmalloc(nf);  // dup needs its own set of flags
+  if (!row_info_space) rb_raise(rb_eNoMemError, "out of memory");
+  memcpy(row_info_space, GetCharPtr(rb_ivar_get(obj, row_info_id)), nf);
+  for (i=0; i < nf; i++) row_info_space[i] &= ~SLIM_IS_SET;  // remove any set flags
+  frh = rb_class_new_instance(0, NULL, cRowHash);  // make the new row data object
+  rb_ivar_set(frh, pointers_id, rb_ivar_get(obj, pointers_id));
+  rb_ivar_set(frh, row_info_id, Data_Wrap_Struct(cClass, 0, ruby_xfree, row_info_space));
+  rb_ivar_set(frh, field_indexes_id, field_indexes);
+  return frh;
+}
+
+// This is the has_key? method of the row data object.
+// Calls to model property methods in AR cause a call to has_key?, so it
+// is implemented here in C for speed.
+static VALUE has_key(VALUE obj, VALUE name) {
+  VALUE field_indexes;
+
+  if (REAL_HASH_EXISTS) return (st_lookup(RHASH(rb_ivar_get(obj, real_hash_id))->tbl, name, 0) ? Qtrue : Qfalse);
+  else return (st_lookup(RHASH(field_indexes)->tbl, name, 0) ? Qtrue : Qfalse);
+}
+
+void Init_slim_attrib_ext() {
+  int i;
+  char col_name[16];
+  VALUE c = rb_cObject;
+
+  c = rb_const_get_at(c, rb_intern("Mysql"));
+  c = rb_const_get_at(c, rb_intern("Result"));
+  rb_define_method(c, "all_hashes", (VALUE(*)(ANYARGS))all_hashes, 0);
+  cRowHash = rb_const_get_at(c, rb_intern("RowHash"));
+  cClass = rb_define_class("CObjects", cRowHash);
+  // set up methods
+  rb_define_private_method(cRowHash, "fetch_by_index", (VALUE(*)(ANYARGS))fetch_by_index, 1);
+  rb_define_method(cRowHash, "[]", (VALUE(*)(ANYARGS))slim_fetch, 1);
+  rb_define_method(cRowHash, "[]=", (VALUE(*)(ANYARGS))set_element, 2);
+  rb_define_method(cRowHash, "dup", (VALUE(*)(ANYARGS))slim_dup, 0);
+  rb_define_method(cRowHash, "has_key?", (VALUE(*)(ANYARGS))has_key, 1);  
+  // set up some symbols that we will need
+  pointers_id = rb_intern("@pointers");
+  row_info_id = rb_intern("@row_info");
+  field_indexes_id = rb_intern("@field_indexes");
+  real_hash_id = rb_intern("@real_hash");
+  to_hash_id = rb_intern("to_hash");
+  for(i=0; i < MAX_CACHED_COLUMN_IDS; i++) {
+    sprintf(col_name, "@col_%d", i);
+    column_ids[i] = rb_intern(col_name);
+  }
+}

data/lib/slim_attributes.rb

@@ -0,0 +1,54 @@
+# Author: Stephen Sykes
+# http://pennysmalls.com
+
+require 'mysql'
+
+class Mysql::Result; class RowHash; end; end
+
+require 'slim_attrib_ext'
+
+class Mysql::Result
+  class RowHash
+    def marshal_dump
+      to_hash
+    end
+    
+    def marshal_load(hash)
+      @real_hash = hash
+    end
+
+    alias_method :include?, :has_key?
+
+    def keys
+      @real_hash ? @real_hash.keys : @field_indexes.keys
+    end
+
+    # If you want to do anything other than [], []=, dup, keys and has_key? then 
+    # we'll handle that by doing the operation on a real ruby hash.
+    # This should be the exception though, and the efficiencies of using slim-attributes
+    # are lost when this happens.
+    def to_hash
+      return @real_hash if @real_hash
+      @real_hash = {}
+      @field_indexes.each_pair {|name, index| @real_hash[name] = fetch_by_index(index)}
+      @field_indexes = nil
+      @real_hash
+    end
+
+    def to_a
+      to_hash.to_a
+    end
+    
+    # Load up all the attributes before a freeze
+    alias_method :regular_freeze, :freeze
+    
+    def freeze
+      to_hash.freeze
+      regular_freeze
+    end
+    
+    def method_missing(name, *args, &block)
+      to_hash.send(name, *args, &block)
+    end
+  end
+end

data/test/benchmark.rb

@@ -0,0 +1,34 @@
+# Author: Stephen Sykes
+# http://pennysmalls.com
+
+require 'rubygems'
+require 'active_record'
+require File.dirname(__FILE__) + "/products"
+require File.dirname(__FILE__) + "/slim_db_test_utils"
+
+SlimDbTestUtils.connect_and_create_db
+Product.create_large_product_table
+Product.make_some_products
+
+def do_benchmark(name)
+  start_t = Time.now
+
+  2000.times do |n|
+    product = Product.find(:all)[n % 100]
+    x = product.name
+    y = product.comment
+    z = product.created_at
+  end
+
+  end_t = Time.now
+  time_taken = end_t - start_t
+  puts "#{name}: #{time_taken}s"
+  time_taken
+end
+
+time1 = do_benchmark("Without slim-attributes")
+require 'slim_attributes'
+time2 = do_benchmark("With slim-attributes")
+puts "Diff: #{"%.2f"%(100 - time2 / time1 * 100)}%"
+
+SlimDbTestUtils.remove_db

data/test/database.yml

@@ -0,0 +1,6 @@
+slim_attributes_test:
+  adapter: mysql
+  database: slim_attributes_test
+  username: your_username
+  password: your_password
+  socket: /tmp/mysql.sock

data/test/products.rb

@@ -0,0 +1,40 @@
+# Author: Stephen Sykes
+# http://pennysmalls.com
+
+class Product < ActiveRecord::Base
+  
+  def self.create_product_table
+    ActiveRecord::Base.connection.drop_table(:products) rescue ActiveRecord::StatementInvalid
+    ActiveRecord::Base.connection.create_table(:products) do |t|
+      t.column :name, :string, :limit => 60
+      t.column :created_at, :datetime
+      t.column :number, :integer
+      t.column :nil_test, :string
+      t.column :comment, :text
+    end
+  end
+
+  def self.create_large_product_table
+    ActiveRecord::Base.connection.drop_table(:products) rescue ActiveRecord::StatementInvalid
+    ActiveRecord::Base.connection.create_table(:products) do |t|
+      t.column :name, :string, :limit => 60
+      t.column :created_at, :datetime
+      t.column :number, :integer
+      t.column :nil_test, :string
+      t.column :comment, :text
+      40.times {|n| t.column "test_col_#{n}", :string}
+    end
+  end
+
+
+  def self.make_some_products
+    100.times do |n|
+      Product.create(:name=>"product_#{n}", :number=>n, :comment=>"Made by the test suite")
+    end
+  end
+  
+  def attributes_iv
+    @attributes
+  end
+
+end

data/test/slim_attributes_test.rb

@@ -0,0 +1,169 @@
+# Author: Stephen Sykes
+# http://pennysmalls.com
+
+require 'rubygems'
+require 'active_record'
+require 'active_record/version'
+require 'slim_attributes'
+require 'test/unit'
+require File.dirname(__FILE__) + "/products"
+require File.dirname(__FILE__) + "/slim_db_test_utils"
+
+class SlimAttributesTest < Test::Unit::TestCase
+  def setup
+    SlimDbTestUtils.connect_and_create_db
+    Product.create_product_table
+    Product.make_some_products
+  end
+
+  def test_finds_all
+    items = Product.find(:all)
+    assert items.size == 100, "must find all 100 items"
+  end
+
+  def test_items_have_correct_attributes
+    items = Product.find(:all, :order=>"id")
+    items.each_index do |i|
+      check_attributes_for(items[i], i)
+    end
+  end
+
+  def test_item_attributes_can_be_changed
+    item = Product.find(:first)
+    old_name = item.name.dup
+    item.name << "more"
+    assert_equal old_name + "more", item.name, "change must stick"
+    item.nil_test = "not a nil"
+    assert_equal "not a nil", item.nil_test, "change must stick"
+    item.name = "something else"
+    assert_equal "something else", item.name, "change must stick"
+    item.save
+    item = Product.find(:first)
+    assert_equal "something else", item.name, "change must persist in DB"
+    assert_equal "not a nil", item.nil_test, "change must persist in DB"
+  end
+
+  def test_item_attributes_to_a_works
+    item = Product.find_by_id(1)
+    arr = item.attributes_iv.to_a
+    expected = [["id","1"], ["name", "product_0"], ["number","0"], ["comment","Made by the test suite"], ["created_at", item.created_at_before_type_cast], ["nil_test", nil]]
+    arr.each do |a|
+      assert expected.include?(a), "array must match"
+    end
+  end
+
+  def test_item_can_be_marshalled
+    item = Product.find_by_id(1)
+    mi = Marshal.load(Marshal.dump(item))
+    check_attributes_for(mi, 0)
+  end
+  
+  def test_has_key_and_include
+    item = Product.find_by_id(1)
+    assert item.attributes_iv.has_key?("name"), "must have key name"
+    assert item.attributes_iv.include?("name"), "must have key name"
+    assert !item.attributes_iv.has_key?("name1"), "must not have key name1"
+    assert !item.attributes_iv.include?("name1"), "must not have key name1"
+  end
+
+  def test_keys
+    item = Product.find_by_id(1)
+    assert_equal ["id", "name", "created_at", "number", "comment", "nil_test"].sort, item.attributes_iv.keys.sort, "keys must work"
+  end
+
+  def test_to_hash
+    item = Product.find_by_id(1)
+    expected = {"id"=>"1", "name"=>"product_0", "number"=>"0", "comment"=>"Made by the test suite", "created_at"=>item.created_at_before_type_cast, "nil_test"=>nil}
+    hash = item.attributes_iv.to_hash
+    assert_equal Hash, hash.class, "to_hash must result in a Hash"
+    assert_equal expected, hash, "to_hash must work"
+  end
+  
+  def test_fake_hash_can_be_updated
+    item = Product.find_by_id(1)
+    old_name = item.name
+    item.attributes_iv.update("name"=>"foobar")
+    assert_equal "foobar", item.name, "update must work"
+    item.name_will_change! if ActiveRecord::VERSION::STRING >= "2.1.0"
+    item.save
+    item = Product.find_by_id(1)
+    assert_equal "foobar", item.name, "update must work and stick through db"
+    assert_equal 0, item.number, "other attributes must not be changed in db"
+    item.name = old_name
+    item.save
+  end
+
+  def test_can_assign_to_non_columns_in_hash
+    item = Product.find_by_id(1)
+    fh = item.attributes_iv
+    fh["something"] = 23
+    fh[:symbol] = "23"
+    assert_equal 23, fh["something"], "assignment to non col"
+    assert_equal "23", fh[:symbol], "assignment to non col"
+    assert fh.keys.include?("something"), "keys must include new"
+    assert fh.keys.include?(:symbol), "keys must include new"
+    assert fh.keys.include?("name"), "keys must still include old"
+    assert_equal 23, item.something, "non col becomes accessible with method call"
+  end
+
+  def test_key_can_be_deleted
+    item = Product.find_by_id(1)
+    fh = item.attributes_iv
+    fh.delete("name")
+    assert_nil fh["name"], "name must be nil now"
+    assert_raises(ActiveRecord::MissingAttributeError, "name must raise on method call") {item.name}
+  end
+  
+  def test_gc
+    GC.start
+    assert true, "gc didn't crash"
+  end
+  
+  # rails query cache uses dup
+  def test_dup
+    items = Product.find(:all)
+    attr_dup = items[0].attributes_iv.dup
+    assert_equal "product_0", attr_dup["name"], "name must be correct in dup'd attributes"
+    attr_dup = items[0].attributes_iv.dup
+    assert_equal "product_0", attr_dup["name"], "name must be correct in dup'd attributes 2nd time"
+  end
+
+  def test_cached_result
+    ActiveRecord::Base.connection.cache do
+      item1 = Product.find_by_id(1)
+      item1.name = "foo"
+      item2 = Product.find_by_id(1)
+      assert_equal "product_0", item2.name, "name must be original from cached query"
+      item3 = Product.find_by_id(1)
+      item1.name = "bar"
+      assert_equal "product_0", item3.name, "name must be original from cached query"
+      item2.name << "_test"
+# unmodified rails fails this test - but does it matter either way?
+      check_attributes_for(item3, 0)
+    end
+  end
+  
+  def test_accessing_destroyed_object_attributes
+    item1 = Product.find_by_id(1)
+    assert_equal false, item1.frozen?
+    item1.destroy  # object is frozen
+    assert_equal true, item1.frozen?
+    check_attributes_for(item1, 0)
+    assert_raises(TypeError) {item1.name = "another product"}
+  end
+
+  def teardown
+    SlimDbTestUtils.remove_db
+  end
+
+  private
+
+  def check_attributes_for(item, i)
+    assert_equal "product_#{i}", item.name, "item name must be right"
+    assert_equal i, item.number, "item number must be right"
+    assert_equal i + 1, item.id, "item id must be right"
+    assert_equal "Made by the test suite", item.comment, "item comment must be right"
+    assert ((1.minute.ago)..(Time.now)) === item.created_at, "item created_at must be reasonable"
+    assert_nil item.nil_test, "nil_test must be nil"
+  end
+end

data/test/slim_db_test_utils.rb

@@ -0,0 +1,38 @@
+# Author: Stephen Sykes
+# http://pennysmalls.com
+
+module SlimDbTestUtils
+  DB_NAME = "slim_attributes_test"
+
+  def self.db_config
+    @config ||= YAML.load(File.read(File.dirname(__FILE__) + "/database.yml"))
+    @config[DB_NAME]
+  end
+
+  def self.connect_and_create_db
+    connect_with_config(db_config)
+    unless ActiveRecord::Base.connected?  # database did not exist (as expected)
+      connect_with_config(db_config.merge({"database"=>nil}))
+      ActiveRecord::Base.connection.create_database(db_config["database"])
+      connect_with_config(db_config)
+    end
+  end
+  
+  def self.connect_with_config(config)
+    begin
+      ActiveRecord::Base.establish_connection(config)
+      ActiveRecord::Base.connection
+    rescue Mysql::Error
+    end
+  end
+  
+  def self.remove_db
+    if ActiveRecord::Base.connected?
+      ActiveRecord::Base.connection.execute("DROP DATABASE #{db_config["database"]}")
+    end
+  end
+  
+  def self.import_sql(file)
+    `mysql -p#{db_config["password"]} -u #{db_config["username"]} #{db_config["database"]} < #{File.dirname(__FILE__)}/#{file}`
+  end
+end

metadata

@@ -0,0 +1,65 @@
+--- !ruby/object:Gem::Specification 
+name: ghazel-slim-attributes
+version: !ruby/object:Gem::Version 
+  version: 0.6.3.1
+platform: ruby
+authors: 
+- Stephen Sykes
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-07-12 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: Slim attributes boosts speed in Rails/Mysql ActiveRecord Models by avoiding instantiating Hashes for each result row, and lazily instantiating attributes as needed.
+email: sdsykes@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- README
+files: 
+- MIT_LICENCE
+- Rakefile
+- README
+- VERSION.yml
+- ext/extconf.rb
+- ext/slim_attrib_ext.c
+- lib/slim_attributes.rb
+- test/benchmark.rb
+- test/database.yml
+- test/products.rb
+- test/slim_attributes_test.rb
+- test/slim_db_test_utils.rb
+has_rdoc: true
+homepage: http://github.com/sdsykes/slim-attributes
+post_install_message: 
+rdoc_options: 
+- --inline-source
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Slim-attributes - lazy instantiation of attributes for ActiveRecord
+test_files: []
+