queryalize 0.0.1

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in queryalize.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,19 @@
+Copyright (C) 2011 by Peter Brindisi, frestyl
+
+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.markdown

@@ -0,0 +1,85 @@
+**Queryalize** lets you use Rails 3 to build queries just like with `ActiveRecord::QueryMethods`,
+except you can serialize the end result. This is useful for running queries that potentially
+return large result sets in the background using something like Resque or Delayed::Job.
+
+Normally, using `ActiveRecord::QueryMethods`, you build queries like this:
+
+    query = User.where(:name => "something").order("created_at DESC")
+    
+With **Queryalize**, it's only a little different:
+
+    query = Querialize.new(User).where(:name => "something").order("created_at DESC")
+
+However, now you get all of this goodness:
+
+    # NOTE the following methods DO NOT query the database,
+    # they return a representation of the query itself in one 
+    # of the following formats
+
+    json = query.to_json # => query as json data
+    yaml = query.to_yaml # => query as yaml data
+    hash = query.to_hash # => query as ruby hash
+    
+    new_query_from_json = Queryalize.from_json(json)
+    new_query_from_yaml = Queryalize.from_yaml(yaml)
+    new_query_from_hash = Queryalize.from_hash(hash)
+
+# Why?
+
+Imagine, for example, that you have a database that organizes music into several genres. 
+You have built an admin interface that allows the administrator to filter the catalog of 
+music by genre, and run updates against the result set. However, the database is large, 
+and the query for "electronica" returns 1,000,000+ results. The administrator wants to 
+re-process these entries such that the genre is "electronic" (without the annoying 'a' 
+at the end). 
+
+Unfortunately, your schema is setup in such a way that you cannot simply run a single 
+"UPDATE." Rather, you must iterate through each individual record and update its genre. 
+Ouch. There is no way you can allow this to happen during the request, or it will certainly 
+timeout. So you decide to queue the update, but how do you tell the queue workers which 
+records to update? You could try to capture just the ids from the records, but you'd still 
+need to store 1,000,000+ ids somewhere so the queue worker can reference them later, not to 
+mention that actually collecting the ids takes a healthy amount of time and memory, and 
+will probably also time out. You could build up your query and then use `to_sql` to pass 
+the raw SQL to the queue worker, but then you can't use useful methods like 'find_each' in 
+the queue task. 
+
+The solution is to serialize the query you've built, and then rebuild it in the queue task. 
+It ends up looking something like this (if you're using Delayed::Job):
+    
+    query = Queryalize.new(Music).joins("JOIN #{Genre.table_name} ON #{Genre.table_name}.music_id = #{Music.table_name}.id").where(["#{Genre.table_name}.name = ?", 'electronica'])
+    # see 1. below
+    
+    worker = GenreWorker.new({
+      :update => 'electronic',
+      :query  => query.to_json
+    })
+    
+    Delayed::Job.enqueue(worker)
+    
+    # 1.
+    # written this way to demonstrate chaining, but a slightly cleaner way would be:
+    # genres = Genre.table_name
+    # query  = Queryalize.new(Music)
+    # query  = query.joins("JOIN #{genres} ON #{genres}.music_id = #{genres}.id")
+    # query  = query.where(["#{genres}.name = ?", 'electronica'])
+    
+The `GenreWorker` class looks something like this:
+
+    class GenreWorker
+    
+        def initialize(args)
+          @update = args[:update]
+          @query  = args[:query]
+        end
+        
+        def perform
+          Queryalize.from_json(@query).find_each do |music|
+            music.genre.update_attribute(:name => @update)
+          end
+        end
+      end
+    end
+    
+Notice the query was serialized and reconstructed to its original state, so you
+can seamlessly use ActiveRecord features like `find_each`. Simple!

data/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/lib/queryalize/serializable_query.rb

@@ -0,0 +1,106 @@
+module Queryalize
+  
+  class SerializableQuery
+  
+    attr_reader :chain_methods
+
+    def self.deserialize(data, mode = :json)
+     
+      data          = parse(data, mode)
+      klass         = data[:class].constantize
+      chain_methods = data[:chain_methods]
+  
+      scope = klass
+      chain_methods.each do |method, args|
+        scope = scope.send(method, *args)
+      end
+  
+      new(klass, scope, chain_methods)
+    end
+
+    def self.from_hash(hash)
+      deserialize(hash, :hash)
+    end
+
+    def self.from_json(json)
+      deserialize(json, :json)
+    end
+
+    def self.from_yaml(yaml)
+      deserialize(yaml, :yaml)
+    end
+    
+    class << self
+      alias_method :_load, :from_json
+    end
+
+    def initialize(klass, scope = nil, chain_methods = { })
+      @klass = klass
+      if scope
+        @scope = scope
+      else
+        @scope = klass
+      end
+  
+      @chain_methods  = chain_methods
+    end
+
+    def serialize(mode = :json)
+      send("to_#{mode}")
+    end
+
+    def to_hash
+      { :class => @klass.name, :chain_methods => chain_methods }
+    end
+
+    def to_json
+      to_hash.to_json
+    end
+
+    def to_yaml(opts = { })
+      to_hash.to_yaml(opts)
+    end
+    
+    def _dump(depth)
+      to_json
+    end
+
+    def query_method?(name)
+      ActiveRecord::QueryMethods.public_instance_methods.include?(name.to_s)
+    end
+
+    def chain(name, *args)
+      self.class.new(@klass, @scope.send(name, *args), @chain_methods.merge(name => args))
+    end
+
+    def method_missing(name, *args, &block)
+      if query_method?(name)
+        chain(name, *args)
+    
+      elsif @scope.respond_to?(name)
+        @scope.send(name, *args, &block)
+    
+      else
+        super(name, *args, &block)
+      end
+    end
+    
+    def inspect
+      if @chain_methods.empty?
+        @klass.name
+      else
+        @klass.name + "." + @chain_methods.collect { |method, args| "#{method}(#{args.collect(&:inspect).join(", ")})" }.join(".")
+      end
+    end
+
+    private
+    
+    def self.parse(data, mode)
+      case mode
+        when :json then data = JSON::parse(data)
+        when :yaml then data = YAML.load(data)
+      end
+      data.symbolize_keys
+    end
+  end
+end

data/lib/queryalize/version.rb

@@ -0,0 +1,3 @@
+module Queryalize
+  VERSION = "0.0.1"
+end

data/lib/queryalize.rb

@@ -0,0 +1,19 @@
+require 'queryalize/serializable_query'
+
+module Queryalize
+  def self.new(klass)
+    SerializableQuery.new(klass)
+  end
+  
+  def self.from_hash(hash)
+    SerializableQuery.from_hash(hash)
+  end
+  
+  def self.from_json(json)
+    SerializableQuery.from_json(json)
+  end
+  
+  def self.from_yaml(yaml)
+    SerializableQuery.from_yaml(yaml)
+  end
+end

data/queryalize.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "queryalize/version"
+
+Gem::Specification.new do |s|
+  s.name        = "queryalize"
+  s.version     = Queryalize::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Peter Brindisi", "frestyl"]
+  s.email       = ['npj@frestyl.com', 'info@frestyl.com']
+  s.license     = 'MIT'
+  s.homepage    = 'http://github.com/frestyl/queryalize'
+  s.summary     = %q{Serialize chainable queries constructed with ActiveRecord::QueryMethods}
+  s.description = %q{
+    Queryalize lets you use Rails 3 to build queries just like with ActiveRecord::QueryMethods,
+    except you can serialize the end result. This is useful for running queries that potentially
+    return large result sets in the background using something like Resque or Delayed::Job.
+  }
+
+  s.rubyforge_project = "queryalize"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec}/*`.split("\n")
+  s.require_paths = ["lib"]
+  
+  s.add_dependency('activerecord', [">= 3.0.0"])
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: queryalize
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Peter Brindisi
+- frestyl
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-05-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 3
+        - 0
+        - 0
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+description: "\n    Queryalize lets you use Rails 3 to build queries just like with ActiveRecord::QueryMethods,\n    except you can serialize the end result. This is useful for running queries that potentially\n    return large result sets in the background using something like Resque or Delayed::Job.\n  "
+email: 
+- npj@frestyl.com
+- info@frestyl.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.markdown
+- Rakefile
+- lib/queryalize.rb
+- lib/queryalize/serializable_query.rb
+- lib/queryalize/version.rb
+- queryalize.gemspec
+has_rdoc: true
+homepage: http://github.com/frestyl/queryalize
+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: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: queryalize
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Serialize chainable queries constructed with ActiveRecord::QueryMethods
+test_files: []
+