hash_extension 0.0.1 → 0.0.2

data/History.txt

@@ -1,3 +1,7 @@
+== 0.0.2 2008-02-08
+* 1 major enhancement:
+  * Addition of ActiveRecord extensions that return hashes
+
 == 0.0.1 2008-01-21
 
 * 1 major enhancement:

data/lib/hash_extension.rb

@@ -7,4 +7,89 @@ class Hash
       self[method_string]
     end
   end
+end
+
+module ActiveRecord
+  class Base
+    class << self
+
+      def find_by_sql_as_hashes(sql)
+        connection.select_all(sanitize_sql(sql))
+      end
+
+      def find_as_hashes(*args)
+        options = extract_options_from_args!(args)
+        if options.include?(:include)
+          raise ActiveRecord::StatementInvalid, "find_as_hashes cannot accept :include options!"
+        end
+        validate_find_options(options)
+        set_readonly_option!(options)
+
+        case args.first
+        when :first
+          find_initial_as_hashes(options)
+        when :all
+          find_every_as_hashes(options)
+        else
+          find_from_ids_as_hashes(args, options)
+        end
+      end
+
+      private
+
+      def find_every_as_hashes(options)
+        connection.select_all(construct_finder_sql(options))
+      end
+
+      def find_initial_as_hashes(options)
+        find_every_as_hashes(options.merge(:limit => 1))
+      end
+
+
+      def find_from_ids_as_hashes(ids, options)
+        expects_array = ids.first.kind_of?(Array)
+        return ids.first if expects_array && ids.first.empty?
+
+        ids = ids.flatten.compact.uniq
+
+        case ids.size
+        when 0
+          raise RecordNotFound, "Couldn't find #{name} without an ID"
+        when 1
+          result = find_one_as_hash(ids.first, options)
+          expects_array ? [ result ] : result
+        else
+          find_some_as_hashes(ids, options)
+        end
+      end
+
+      def find_one_as_hash(id, options)
+        conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
+        options.update :conditions => "#{table_name}.#{connection.quote_column_name(primary_key)} = #{quote_value(id,columns_hash[primary_key])}#{conditions}"
+
+        # Use find_every(options).first since the primary key condition
+        # already ensures we have a single record. Using find_initial adds
+        # a superfluous :limit => 1.
+        if result = find_every_as_hashes(options).first
+          result
+        else
+          raise ActiveRecord::RecordNotFound, "Couldn't find #{name} with ID=#{id}#{conditions}"
+        end
+      end
+
+      def find_some_as_hashes(ids, options)
+        conditions = " AND (#{sanitize_sql(options[:conditions])})" if options[:conditions]
+        ids_list   = ids.map { |id| quote_value(id,columns_hash[primary_key]) }.join(',')
+        options.update :conditions => "#{table_name}.#{connection.quote_column_name(primary_key)} IN (#{ids_list})#{conditions}"
+
+        result = find_every_as_hashes(options)
+
+        if result.size == ids.size
+          result
+        else
+          raise RecordNotFound, "Couldn't find all #{name.pluralize} with IDs (#{ids_list})#{conditions}"
+        end
+      end
+    end  
+  end
 end

data/lib/hash_extension/version.rb

@@ -2,7 +2,7 @@ module HashExtension #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
     MINOR = 0
-    TINY  = 1
+    TINY  = 2
 
     STRING = [MAJOR, MINOR, TINY].join('.')
   end

data/website/index.html

@@ -33,12 +33,12 @@
     <h1>hash_extension</h1>
     <div id="version" class="clickable" onclick='document.location = "http://rubyforge.org/projects/hash_extension"; return false'>
       <p>Get Version</p>
-      <a href="http://rubyforge.org/projects/hash_extension" class="numbers">0.0.1</a>
+      <a href="http://rubyforge.org/projects/hash_extension" class="numbers">0.0.2</a>
     </div>
     <h2>What</h2>
 
 
-	<p>hash_extension is a Ruby on Rails plug-in that makes hashes more object-like.  When you request a lot of objects with an ActiveRecord query, there&#8217;s a lot of overhead in creating those objects that come back.  If you&#8217;re not modifying, just displaying them or performing local calculations before display, you don&#8217;t need to suffer that overhead.  It turns out it&#8217;s much faster to get back hash objects.  This plug-in makes it a snap to replace a query that returns ActiveRecord objects with one that returns hashes.</p>
+	<p>hash_extension is a Ruby on Rails plug-in that does two things.  First, it provides ActiveRecord finder methods that return hashes.  Second, it makes hashes more object-like.  Why?  When you request a lot of objects with an ActiveRecord query, there&#8217;s a lot of overhead in creating the objects that come back.  If you&#8217;re not modifying the records, but just displaying them or performing local calculations before display, you don&#8217;t need to suffer the overhead of creating heavy ActiveRecord objects.  It turns out it&#8217;s much faster to get back hash objects.  This plug-in makes it a snap to replace a query that returns ActiveRecord objects with one that returns hashes.</p>
 
 
 	<h2>Installing</h2>
@@ -50,7 +50,7 @@
 	<h2>The basics</h2>
 
 
-	<p>The hash_extension plug-in allows you to treat hashes like objects.  E.g,. instead of:</p>
+	<p>The hash_extension plug-in allows you to treat hashes like objects, and to get back hashes from (almost) standard ActiveRecord queries.  E.g,. instead of:</p>
 
 
 	<p><pre class='syntax'><span class="ident">hash</span><span class="punct">['</span><span class="string">foo</span><span class="punct">']</span></pre></p>
@@ -74,6 +74,17 @@
 	<p><pre class='syntax'><span class="ident">hash</span><span class="punct">['</span><span class="string">foo</span><span class="punct">']</span> <span class="punct">=</span> <span class="punct">'</span><span class="string">bar</span><span class="punct">'</span></pre></p>
 
 
+	<p>Two variants of basic ActiveRecord query types are supported&#8212;find and find_by_sql, inventively recast as find_as_hashes and find_by_sql_as_hashes.  E.g.,</p>
+
+
+	<p><pre class='syntax'>
+<span class="constant">Foo</span><span class="punct">.</span><span class="ident">find_as_hashes</span><span class="punct">(</span><span class="symbol">:all</span><span class="punct">)</span>
+<span class="constant">Foo</span><span class="punct">.</span><span class="ident">find_as_hashes</span><span class="punct">(</span><span class="symbol">:first</span><span class="punct">)</span>
+<span class="constant">Foo</span><span class="punct">.</span><span class="ident">find_as_hashes</span><span class="punct">(</span><span class="symbol">:all</span><span class="punct">,</span> <span class="symbol">:conditions</span> <span class="punct">=&gt;</span> <span class="punct">&quot;</span><span class="string">bar = 'baz'</span><span class="punct">&quot;)</span>
+<span class="constant">Foo</span><span class="punct">.</span><span class="ident">find_by_sql_as_hashes</span><span class="punct">(&quot;</span><span class="string">select * where fubar = 'some_complex_stuff'</span><span class="punct">&quot;)</span>
+</pre></p>
+
+
 	<p>The trunk repository is <code>svn://rubyforge.org/var/svn/hash_extension/trunk</code> for anonymous access.</p>
 
 
@@ -95,10 +106,10 @@
 	<p>You can replace it with this:</p>
 
 
-	<p><pre class='syntax'><span class="constant">MyObject</span><span class="punct">.</span><span class="ident">connection</span><span class="punct">.</span><span class="ident">select</span><span class="punct">(&quot;</span><span class="string">select * from my_objects</span><span class="punct">&quot;)</span></pre></p>
+	<p><pre class='syntax'><span class="constant">MyObject</span><span class="punct">.</span><span class="ident">find_as_hashes</span><span class="punct">(&quot;</span><span class="string">select * from my_objects</span><span class="punct">&quot;)</span></pre></p>
 
 
-	<p>The same data is returned, but without the overhead of creating large, complex ActiveRecord objects.  The rest of your code will continue to behave as expected, because the object-like access will now work correct with the hashes returned by connection.select.  If someone would like to contribute extensions to ActiveRecord that would create finders that automatically return hashes, e.g., &#8220;find_as_hashes(:all)&#8221;, I&#8217;d be thrilled to include it as part of this plug-in.</p>
+	<p>The same data is returned, but without the overhead of creating large, complex ActiveRecord objects.  The rest of your code will continue to behave as expected, because the object-like access will now work correctly with the hashes returned by these methods.</p>
 
 
 	<h2>License</h2>
@@ -107,12 +118,21 @@
 	<p>This code is free to use under the terms of the <span class="caps">MIT</span> license.</p>
 
 
+	<h2>Credits.</h2>
+
+
+	<p>The initial release only provided the extension to hash that made them act more like objects.  I posed the challenge: &#8220;If someone would like to contribute extensions to ActiveRecord that would create finders that automatically return hashes, e.g., &#8220;find_as_hashes(:all)&#8221;, I&#8217;d be thrilled to include it as part of this plug-in.&#8221;  Elliot Laster rose to the challenge and provided the ActiveRecord extension available in the 0.0.2 release.</p>
+
+
+	<p>The new call to action is to provide some unit tests!  Ideally, they should use migrations to set up dummy tables, test against them, then tear down those tables.  Anyone up for it?  :-)</p>
+
+
 	<h2>Contact</h2>
 
 
 	<p>Comments are welcome. Send an email to <a href="mailto:dan@chak.org">Dan Chak</a>.</p>
     <p class="coda">
-      <a href="FIXME email">FIXME full name</a>, 21st January 2008<br>
+      <a href="FIXME email">FIXME full name</a>, 9th February 2008<br>
       Theme extended from <a href="http://rb2js.rubyforge.org/">Paul Battley</a>
     </p>
 </div>

data/website/index.txt

@@ -2,7 +2,7 @@ h1. hash_extension
 
 h2. What
 
-hash_extension is a Ruby on Rails plug-in that makes hashes more object-like.  When you request a lot of objects with an ActiveRecord query, there's a lot of overhead in creating those objects that come back.  If you're not modifying, just displaying them or performing local calculations before display, you don't need to suffer that overhead.  It turns out it's much faster to get back hash objects.  This plug-in makes it a snap to replace a query that returns ActiveRecord objects with one that returns hashes.
+hash_extension is a Ruby on Rails plug-in that does two things.  First, it provides ActiveRecord finder methods that return hashes.  Second, it makes hashes more object-like.  Why?  When you request a lot of objects with an ActiveRecord query, there's a lot of overhead in creating the objects that come back.  If you're not modifying the records, but just displaying them or performing local calculations before display, you don't need to suffer the overhead of creating heavy ActiveRecord objects.  It turns out it's much faster to get back hash objects.  This plug-in makes it a snap to replace a query that returns ActiveRecord objects with one that returns hashes.
 
 h2. Installing
 
@@ -10,7 +10,7 @@ h2. Installing
 
 h2. The basics
 
-The hash_extension plug-in allows you to treat hashes like objects.  E.g,. instead of:
+The hash_extension plug-in allows you to treat hashes like objects, and to get back hashes from (almost) standard ActiveRecord queries.  E.g,. instead of:
 
 <pre syntax="ruby">hash['foo']</pre>
 
@@ -26,6 +26,16 @@ you can say:
 
 <pre syntax="ruby">hash['foo'] = 'bar'</pre>
 
+Two variants of basic ActiveRecord query types are supported -- find and find_by_sql, inventively recast as find_as_hashes and find_by_sql_as_hashes.  E.g.,
+
+<pre syntax="ruby">
+Foo.find_as_hashes(:all)
+Foo.find_as_hashes(:first)
+Foo.find_as_hashes(:all, :conditions => "bar = 'baz'")
+Foo.find_by_sql_as_hashes("select * where fubar = 'some_complex_stuff'")
+</pre>
+
+
 The trunk repository is <code>svn://rubyforge.org/var/svn/hash_extension/trunk</code> for anonymous access.
 
 h2. From Rails
@@ -40,14 +50,20 @@ Anywhere you have syntax like this:
 
 You can replace it with this:
 
-<pre syntax="ruby">MyObject.connection.select("select * from my_objects")</pre>
+<pre syntax="ruby">MyObject.find_as_hashes("select * from my_objects")</pre>
 
-The same data is returned, but without the overhead of creating large, complex ActiveRecord objects.  The rest of your code will continue to behave as expected, because the object-like access will now work correct with the hashes returned by connection.select.  If someone would like to contribute extensions to ActiveRecord that would create finders that automatically return hashes, e.g., "find_as_hashes(:all)", I'd be thrilled to include it as part of this plug-in.
+The same data is returned, but without the overhead of creating large, complex ActiveRecord objects.  The rest of your code will continue to behave as expected, because the object-like access will now work correctly with the hashes returned by these methods.
 
 h2. License
 
 This code is free to use under the terms of the MIT license. 
 
+h2. Credits.
+
+The initial release only provided the extension to hash that made them act more like objects.  I posed the challenge: "If someone would like to contribute extensions to ActiveRecord that would create finders that automatically return hashes, e.g., "find_as_hashes(:all)", I'd be thrilled to include it as part of this plug-in."  Elliot Laster rose to the challenge and provided the ActiveRecord extension available in the 0.0.2 release.
+
+The new call to action is to provide some unit tests!  Ideally, they should use migrations to set up dummy tables, test against them, then tear down those tables.  Anyone up for it?  :-)
+
 h2. Contact
 
 Comments are welcome. Send an email to "Dan Chak":mailto:dan@chak.org.

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: hash_extension
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors: 
 - Dan Chak
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-01-21 00:00:00 -05:00
+date: 2008-02-09 00:00:00 -05:00
 default_executable: 
 dependencies: []