yql-query 1.0.0

data/.gitignore

@@ -0,0 +1,5 @@
+pkg/*
+Gemfile.lock
+coverage/*
+.yardoc
+doc/*

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=nested
+--backtrace

data/Gemfile

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

data/License.md

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Steve Agalloco
+
+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,21 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+task :test => :spec
+
+namespace :doc do
+  require 'yard'
+  YARD::Rake::YardocTask.new do |task|
+    task.files   = ['lib/**/*.rb']
+    task.options = [
+      '--protected',
+      '--output-dir', 'doc/yard',
+      '--markup', 'markdown',
+      '--readme', 'Readme.md'
+    ]
+  end
+end

data/Readme.md

@@ -0,0 +1,94 @@
+YqlQuery
+========
+
+A simple [YQL query](http://developer.yahoo.com/yql/guide/index.html) generation library written in ruby, providing a chainable query builder capable of generating the most complex query conditions you can throw at it.
+
+Installation
+------------
+
+    (sudo) gem install yql-query
+
+Documentation
+-------------
+
+[http://rdoc.info/gems/yql-query](http://rdoc.info/gems/yql-query)
+
+Usage
+-----
+
+yql-query's primary interface is the Builder class.  Once you've instantiated a builder, you can pretty much generate whatever query you'd like using it.
+
+    builder = YqlQuery::Builder.new
+    builder.table('music.artists')
+
+to generate a query, the Builder class provides a number of methods to construct it's arguments:
+
+    builder.table('music.artists')
+    builder.select('name, genre')
+    builder.conditions("bands = 'false'")
+    builder.sort('age')
+
+conditions are also aliased as 'where':
+
+    #using 'where'
+    builder.where("bands = 'true'")
+
+    # is the same thing as
+    builder.conditions("bands = 'true'")
+
+conditions can be passed as either a string, an array or
+
+    builder.conditions(["name = 'Erykah Badu'", "release_year > '2005'"])
+
+methods can be chained together:
+
+    builder.table('music.artists').select('name').where("genre = 'jazz'")
+
+to generate the query, just call to_s or to_query:
+
+    builder.to_s
+    # => 'select * from tablename...'
+
+    builder.to_query
+    # => 'select * from tablename...'
+
+passing a hash with a Builder instance to creates sub-select:
+
+    guid_query = Builder.new.table('users').select('guid').where("role = 'admin'")
+
+    builder = Builder.new.table('actions).where(:guid => guid_query)
+    builder.to_s
+    # => "select * from actions where guid in (select guid from users where role = 'admin')"
+
+The full list of methods available:
+
+    table('music.albums')
+    use('http://somedomain.com/table.xml', 'othersource')
+    select('name')
+    conditions("genre = 'jazz'")
+    sort('albumName')
+    sort_descending('albumName')
+    limit(5)
+    offset(10)
+    tail(5)
+    truncate(10)
+    unique('format')
+    sanitize('description')
+
+Refer to the [documentation](http://rdoc.info/gems/yql-query) for complete usage and more examples.
+
+Note on Patches/Pull Requests
+-----------------------------
+
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+Copyright
+---------
+
+Copyright (c) 2011 Steve Agalloco. See LICENSE for details.

data/lib/yql-query.rb

@@ -0,0 +1 @@
+require 'yql_query'

data/lib/yql_query.rb

@@ -0,0 +1,4 @@
+require 'hashie/mash'
+require 'yql_query/source'
+require 'yql_query/query'
+require 'yql_query/builder'

data/lib/yql_query/builder.rb

@@ -0,0 +1,244 @@
+module YqlQuery
+
+  # The primary query builder class, wraps a {Query} object and provides methods to assign query arguments.
+  class Builder
+
+    attr_accessor :query
+
+    # Instantiates a new Builder instance.
+    # @param
+    def initialize(options={})
+      self.query = Query.new
+      self.query.table      = options.delete(:table)
+      self.query.limit      = options.delete(:limit)
+      self.query.offset     = options.delete(:offset)
+      self.query.select     = options.delete(:select)
+      self.query.conditions = options.delete(:conditions) || []
+      self.query.uses       = options.delete(:uses) || []
+      self.query.tail       = options.delete(:tail)
+      self.query.truncate   = options.delete(:truncate)
+      self.query.reverse    = options.delete(:reverse)
+      self.query.unique     = options.delete(:unique)
+      self.query.sanitize   = options.delete(:sanitize)
+    end
+
+    # Assigns the table for the query being constructed
+    #
+    # @param [String] table The name of the table.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the table assigned.
+    def table(table)
+      self.query.table = table
+      self
+    end
+
+    # Assigns the limit for the query being constructed
+    #
+    # @param [Object] limit The limit for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the limit assigned.
+    #
+    # @example The limit may be passed as either a string or fixnum:
+    #   base = Builder.new.limit(5)
+    #   base = Builder.new.limit('5')
+    def limit(limit)
+      self.query.limit = limit
+      self
+    end
+
+    # Assigns the offset for the query being constructed
+    #
+    # @param [Object] offset The offset for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the offset assigned.
+    #
+    # @example The offset may be passed as either a string or fixnum:
+    #   base = Builder.new.offset(5)
+    #   base = Builder.new.offset('5')
+    def offset(offset)
+      self.query.offset = offset
+      self
+    end
+
+    # Assigns the columns to select for the query being constructed
+    #
+    # @param [Object] select The select arguments for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the select arguments assigned.
+    #
+    # @example The select may be passed as either a string or an array:
+    #   base = Builder.new.select('name')
+    #   base = Builder.new.select('name, age')
+    #   base = Builder.new.select(['name', 'age'])
+    def select(select)
+      self.query.select = select
+      self
+    end
+
+    # Assigns additional datatable sources for use with the query being constructed
+    #
+    # @param [String] source The url of the data source.
+    # @param [String] as The name the data source will be referenced as in queries.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the data source arguments assigned.
+    #
+    # @example The select may be passed as either a string or an array:
+    #   base = Builder.new.use('http://anothersource/sometable.xml', 'sometable')
+    #   base.to_s
+    #   # => "use http://anothersource/sometable.xml as sometable; select * from tablename"
+    def use(source, as)
+      self.query.uses << Source.new(source, as)
+      self
+    end
+
+    # Assigns additional datatable sources for use with the query being constructed.
+    # Conditions are combined.  Hashes assume equivalency when generating queries, except when passed a
+    # {Builder} instance in which case a sub-select is assumed using an 'in'.
+    #
+    # @param [Objct] conditions The conditions of the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the data conditions assigned.
+    #
+    # @example The conditions may be passed as either a string, array or a hash:
+    #   base = Builder.new.conditions("sub_genre = 'bebop'")
+    #   base.to_s
+    #   # => "select * from tablename where sub_genre = 'bebop'"
+    #
+    #   base.conditions("genre = 'jazz'").conditions("sub_genre = 'bebop'")
+    #   base.to_s
+    #   # => "select * from tablename where genre = 'jazz' and sub_genre = 'bebop'"
+    #
+    #   base.conditions(["genre = 'jazz'", "sub_genre = 'bebop'"])
+    #   # => "select * from tablename where genre = 'jazz' and sub_genre = 'bebop'"
+    #
+    #   # conditions are also aliased as 'where'
+    #   base.where("genre = 'jazz'")
+    #
+    #   guid_query = Builder.new.table('users').select('guid').where("role = 'admin'")
+    #   base = Builder.new.table('actions).where(:guid => guid_query)
+    #   base.to_s
+    #   => "select * from actions where guid in (select guid from users where role = 'admin')"
+    def conditions(conditions)
+      if conditions.kind_of?(String)
+        self.query.conditions << conditions
+      elsif conditions.kind_of?(Array)
+        self.query.conditions += conditions
+      elsif conditions.kind_of?(Hash)
+        conditions.each do |key, value|
+          if value.kind_of?(YqlQuery::Builder)
+            self.query.conditions << "#{key} in (#{value})"
+          else
+            self.query.conditions << "#{key} = '#{value}'"
+          end
+        end
+      end
+      self
+    end
+    alias :where :conditions
+
+    # Assigns the field to be sorted for the query being constructed
+    #
+    # @param [Object] sort The column to sort for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the sort assigned.
+    #
+    # @example
+    #   base = Builder.new.sort('name)
+    def sort(sort)
+      self.query.sort = sort
+      self.query.sort_descending = false
+      self
+    end
+
+    # Assigns the field to be sorted for the query being constructed
+    #
+    # @param [Object] sort The column to sort descending for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the sort assigned.
+    #
+    # @example
+    #   base = Builder.new.sort('name)
+    def sort_descending(sort)
+      self.query.sort = sort
+      self.query.sort_descending = true
+      self
+    end
+
+    # Assigns the tail argument for the query being constructed
+    #
+    # @param [Object] tail The tail argument for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the tail filter assigned.
+    #
+    # @example The tail argument may be passed as either a string or fixnum:
+    #   base = Builder.new.tail(5)
+    #   base = Builder.new.tail('5')
+    def tail(tail)
+      self.query.tail = tail
+      self
+    end
+
+    # Assigns the truncate argument for the query being constructed
+    #
+    # @param [Object] truncate The truncate argument for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the truncate filter assigned.
+    #
+    # @example The truncate argument may be passed as either a string or fixnum:
+    #   base = Builder.new.truncate(5)
+    #   base = Builder.new.truncate('5')
+    #   base.to_s
+    #   # => "select * from tablename | truncate(5)"
+    def truncate(truncate)
+      self.query.truncate = truncate
+      self
+    end
+
+    # Adds the reverse filter to the query being constructed
+    #
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the offset assigned.
+    #
+    # @example
+    #   base = Builder.new.reverse
+    #   base.to_s
+    #   # => "select * from tablename | reverse"
+    def reverse
+      self.query.reverse = true
+      self
+    end
+
+    # Assigns the unique argument for the query being constructed
+    #
+    # @param [Object] truncate The unique argument for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the unique filter assigned.
+    #
+    # @example
+    #   base = Builder.new.unique('genre')
+    #   base.to_s
+    #   # => "select * from tablename | unique(field='genre')"
+    def unique(unique)
+      self.query.unique = unique
+      self
+    end
+
+    # Assigns the sanitize argument for the query being constructed
+    #
+    # @param [Object] sanitize The sanitize argument for the query.
+    # @return [YqlQuery::Builder] YqlQuery::Builder instance reflecting the sanitize filter assigned.
+    #
+    # @example Sanitize accepts either a string representing the column name or a boolean 'true' to sanitize all
+    #   base = Builder.new.sanitize('genre')
+    #   base.to_s
+    #   # => "select * from tablename | sanitize(field='genre')"
+    #
+    #   base = Builder.new.sanitize(true)
+    #   base.to_s
+    #   # => "select * from tablename | sanitize()"
+    def sanitize(sanitize=true)
+      self.query.sanitize = sanitize
+      self
+    end
+
+    # Returns the generated YQL query based on the arguments provided
+    def to_s
+      self.query.to_s
+    end
+    alias :to_query :to_s
+
+    # Resets all arguments to the query
+    def reset
+      self.query = Query.new
+    end
+
+  end
+end

data/lib/yql_query/query.rb

@@ -0,0 +1,70 @@
+module YqlQuery
+
+  # The object underlying {Builder} which stores and generates the query.
+  class Query
+    attr_accessor :table, :limit, :offset, :select, :uses, :conditions
+    attr_accessor :sort, :tail, :truncate, :reverse, :unique, :sanitize
+    attr_accessor :sort_descending
+
+    def initialize
+      self.conditions = []
+      self.uses = []
+    end
+
+    # generates a query based on it's attributes
+    def to_s
+      [use_statement, select_statement, conditions_statement, limit_offset_statement, filter_statement].join(' ').squeeze(' ').strip
+    end
+
+    private
+      def use_statement
+        @uses.map { |use| "use #{use.source} as #{use.as};" }.join(' ')
+      end
+
+      def select_statement
+        stmt = 'select '
+        stmt << case @select
+          when String
+            @select
+          when Array
+            @select.join(', ')
+          else
+            '*'
+        end
+        stmt << " from "
+        stmt << @table if @table
+        stmt
+      end
+
+      def conditions_statement
+        @conditions.uniq.any? ? "where #{@conditions.uniq.join(' and ')}" : ""
+      end
+
+      def limit_offset_statement
+        stmt = ''
+        stmt << "limit #{@limit}" if @limit
+        stmt << "offset #{@offset}" if @offset
+        stmt
+      end
+
+      def filter_statement
+        statements = []
+        if @sort && @sort_descending
+          statements << "sort(field='#{@sort}', descending='true')"
+        elsif @sort
+          statements << "sort(field='#{@sort}')"
+        end
+
+        statements << "tail(count=#{@tail})" if @tail
+        statements << "truncate(count=#{@truncate})" if @truncate
+        statements << "reverse()" if @reverse
+        statements << "unique(field='#{@unique}')" if @unique
+        if @sanitize && @sanitize == true
+          statements << "sanitize()"
+        elsif @sanitize
+          statements << "sanitize(field='#{@sanitize}')"
+        end
+        statements.any? ? "| #{statements.join(' | ')}" : ''
+      end
+  end
+end

data/lib/yql_query/source.rb

@@ -0,0 +1,17 @@
+module YqlQuery
+
+  # A class used by {Builder} to store additional data sources.
+  class Source
+    attr_accessor :source, :as
+
+    def initialize(source, as)
+      @source = source
+      @as = as
+    end
+
+    # Sources are equal if both their 'source' and 'as' attributes are equivalent.
+    def ==(b)
+      self.source == b.source && self.as == b.as
+    end
+  end
+end

data/lib/yql_query/version.rb

@@ -0,0 +1,4 @@
+module YqlQuery
+  # The version of the gem
+  VERSION = "1.0.0"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'simplecov'
+SimpleCov.start do
+  add_group 'YQL Query', 'lib/yql_query'
+  add_group 'Specs', 'spec'
+end
+
+require File.expand_path('../../lib/yql_query', __FILE__)
+
+require 'rspec'

data/spec/yql_query_builder_spec.rb

@@ -0,0 +1,330 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe YqlQuery::Builder do
+  before(:each) do
+    @builder = YqlQuery::Builder.new
+  end
+
+  describe "#table()" do
+    it "should set the table" do
+      @builder.table('music.artists')
+      @builder.query.table.should == 'music.artists'
+    end
+
+    it "should return the builder" do
+      @builder.table('music.artists').should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#limit()" do
+    it "should set the limit" do
+      @builder.limit(5)
+      @builder.query.limit.should == 5
+    end
+
+    it "should return the builder" do
+      @builder.limit(5).should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#offset()" do
+    it "should set the offset" do
+      @builder.offset(10)
+      @builder.query.offset.should == 10
+    end
+
+    it "should return the builder" do
+      @builder.offset(10).should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#select()" do
+    it "should set the select" do
+      @builder.select('name')
+      @builder.query.select.should == 'name'
+    end
+
+    it "should accept select as an array" do
+      @builder.select(['age', 'sex', 'language', 'other'])
+      @builder.query.select.should == ['age', 'sex', 'language', 'other']
+    end
+
+    it "should return the builder" do
+      @builder.select('name').should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#use()" do
+    it "should set the use" do
+      @builder.use('http://namedata.com', 'names')
+      @builder.query.uses.include?(YqlQuery::Source.new('http://namedata.com', 'names')).should be_true
+    end
+
+    it "should return the builder" do
+      @builder.use('http://namedata.com', 'names').should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#conditions()" do
+    it "should set the conditions" do
+      @builder.conditions("name = 'fred'")
+      @builder.query.conditions.include?("name = 'fred'").should be_true
+    end
+
+    it "should return the builder" do
+      @builder.conditions("name = 'fred'").should be_kind_of(YqlQuery::Builder)
+    end
+
+    it "should be aliased as #where()" do
+      @builder.where("name = 'jeff'")
+      @builder.query.conditions.include?("name = 'jeff'").should be_true
+    end
+
+    it "should store all conditions" do
+      @builder.conditions("name = 'fred'")
+      @builder.conditions("age = 22")
+      @builder.query.conditions.include?("name = 'fred'").should be_true
+      @builder.query.conditions.include?("age = 22").should be_true
+    end
+
+    it "should accept conditions as an array" do
+      @builder.conditions(["name = 'greg'", "age = 34"])
+      @builder.query.conditions.include?("name = 'greg'").should be_true
+      @builder.query.conditions.include?("age = 34").should be_true
+    end
+
+    it "should accept conditions as a hash" do
+      @builder.conditions({ :genre => 'jazz', :type => 'bebop'})
+      @builder.query.conditions.include?("genre = 'jazz'").should be_true
+      @builder.query.conditions.include?("type = 'bebop'").should be_true
+    end
+
+    it "should accept conditions as a hash when passed another query" do
+      @builder.conditions({ :artist_id => YqlQuery::Builder.new.table('music.amg.artists').select('artist_id')})
+      @builder.query.conditions.include?("artist_id in (select artist_id from music.amg.artists)").should be_true
+    end
+  end
+
+  describe "#sort()" do
+    it "should set the sort" do
+      @builder.sort('nickname')
+      @builder.query.sort.should == 'nickname'
+    end
+
+    it "should return the builder" do
+      @builder.sort('nickname').should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#sort_descending()" do
+    it "should set the sort" do
+      @builder.sort_descending('nickname')
+      @builder.query.sort.should == 'nickname'
+    end
+
+    it "should return the builder" do
+      @builder.sort('nickname').should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#tail()" do
+    it "should set the tail" do
+      @builder.tail(3)
+      @builder.query.tail.should == 3
+    end
+
+    it "should return the builder" do
+      @builder.tail(3).should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#truncate()" do
+    it "should set the truncate option" do
+      @builder.truncate(3)
+      @builder.query.truncate.should == 3
+    end
+
+    it "should return the builder" do
+      @builder.truncate(3).should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#reverse" do
+    it "should set the reverse option" do
+      @builder.reverse
+      @builder.query.reverse.should be_true
+    end
+
+    it "should return the builder" do
+      @builder.reverse.should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#unique()" do
+    it "should set the unique option" do
+      @builder.unique("Rating.AverageRating")
+      @builder.query.unique.should == "Rating.AverageRating"
+    end
+
+    it "should return the builder" do
+      @builder.unique("Rating.AverageRating").should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  describe "#sanitize()" do
+    it "should set the unique option" do
+      @builder.sanitize("Rating.Description")
+      @builder.query.sanitize.should == "Rating.Description"
+    end
+
+    it "should default sanitize to true" do
+      @builder.sanitize
+      @builder.query.sanitize.should be_true
+    end
+
+    it "should return the builder" do
+      @builder.sanitize("Rating.Description").should be_kind_of(YqlQuery::Builder)
+    end
+  end
+
+  context "chaining" do
+    it "should combine query options" do
+      @builder.table('music.artists').limit(5).conditions("name = 'Jose James'")
+      @builder.query.limit.should == 5
+      @builder.query.table.should == 'music.artists'
+      @builder.query.conditions.include?("name = 'Jose James'").should be_true
+    end
+  end
+
+  describe "#to_s" do
+    it "should return the generated query" do
+      @builder.table('music.artists').limit(5).conditions("name = 'Jose James'")
+      @builder.to_s.should == "select * from music.artists where name = 'Jose James' limit 5"
+    end
+
+    it "should be aliased as to_query" do
+      @builder.table('music.artists').limit(5).conditions("name = 'Jose James'")
+      @builder.to_s.should == @builder.to_query
+    end
+  end
+
+  describe "#reset" do
+    it "should reset all query conditions" do
+      @builder.table('Rating')
+      @builder.limit(5)
+      @builder.offset(5)
+      @builder.select('Rating.Description, Rating.SomethingElse')
+      @builder.use('http://namedata.com', 'names')
+      @builder.conditions("name = 'fred'")
+      @builder.sort('nickname')
+      @builder.tail(5)
+      @builder.truncate(3)
+      @builder.reverse
+      @builder.unique("Rating.AverageRating")
+      @builder.sanitize("Rating.Description")
+
+      @builder.reset
+
+      @builder.query.table.should be_nil
+      @builder.query.limit.should be_nil
+      @builder.query.offset.should be_nil
+      @builder.query.select.should be_nil
+      @builder.query.limit.should be_nil
+      @builder.query.uses.should be_empty
+      @builder.query.conditions.should be_empty
+      @builder.query.sort.should be_nil
+      @builder.query.tail.should be_nil
+      @builder.query.truncate.should be_nil
+      @builder.query.reverse.should be_nil
+      @builder.query.unique.should be_nil
+      @builder.query.sanitize.should be_nil
+    end
+  end
+
+  context "generating queries" do
+    before(:each) do
+      @builder.table('music.artists')
+    end
+
+    it "should generate ther right query when given a different data source to use" do
+      @builder.conditions("name = 'Jose James'").use('http://musicbrainz.org/data.xml', 'musicBrainzArtists').table('musicBrainzArtists')
+      @builder.to_s.should == "use http://musicbrainz.org/data.xml as musicBrainzArtists; select * from musicBrainzArtists where name = 'Jose James'"
+    end
+
+    it "should generate ther right query when given multiple data sources to use" do
+      @builder.conditions("name = 'Jose James'").use('http://musicbrainz.org/data.xml', 'musicBrainzArtists').use('http://musicbrainz.org/albums.xml', 'musicBrainzAlbums').table('musicBrainzArtists')
+      @builder.to_s.should == "use http://musicbrainz.org/data.xml as musicBrainzArtists; use http://musicbrainz.org/albums.xml as musicBrainzAlbums; select * from musicBrainzArtists where name = 'Jose James'"
+    end
+
+    it "should generate the right query when given a single condition" do
+      @builder.conditions("name = 'Jose James'")
+      @builder.to_s.should == "select * from music.artists where name = 'Jose James'"
+    end
+
+    it "should generate the right query when given multiple conditions" do
+      @builder.conditions("name = 'Jose James'").conditions("genre = 'Jazz'")
+      @builder.to_s.should == "select * from music.artists where name = 'Jose James' and genre = 'Jazz'"
+    end
+
+    it "should generate the right query when given a limit" do
+      @builder.conditions("name = 'John'").limit(5)
+      @builder.to_s.should == "select * from music.artists where name = 'John' limit 5"
+    end
+
+    it "should generate the right query when given an offset" do
+      @builder.conditions("name = 'John'").offset(15)
+      @builder.to_s.should == "select * from music.artists where name = 'John' offset 15"
+    end
+
+    it "should generate the right query when given a select" do
+      @builder.conditions("name = 'John'").select('Title, First Name, Email')
+      @builder.to_s.should == "select Title, First Name, Email from music.artists where name = 'John'"
+    end
+
+    it "should generate the right query when given a select as an array" do
+      @builder.conditions("name = 'John'").select(['age', 'sex', 'language', 'other'])
+      @builder.to_s.should == "select age, sex, language, other from music.artists where name = 'John'"
+    end
+
+    it "should generate the right query when given a sort" do
+      @builder.sort('popularity')
+      @builder.to_s.should == "select * from music.artists | sort(field='popularity')"
+    end
+
+    it "should generate the right query when given a sort descending" do
+      @builder.sort_descending('popularity')
+      @builder.to_s.should == "select * from music.artists | sort(field='popularity', descending='true')"
+    end
+
+    it "should generate the right query when given a tail" do
+      @builder.tail(5)
+      @builder.to_s.should == "select * from music.artists | tail(count=5)"
+    end
+
+    it "should generate the right query when given a truncate" do
+      @builder.truncate(5)
+      @builder.to_s.should == "select * from music.artists | truncate(count=5)"
+    end
+
+    it "should generate the right query when given a reverse" do
+      @builder.reverse
+      @builder.to_s.should == "select * from music.artists | reverse()"
+    end
+
+    it "should generate the right query when given a unique" do
+      @builder.unique('art')
+      @builder.to_s.should == "select * from music.artists | unique(field='art')"
+    end
+
+    it "should generate the right query when given a sanitize" do
+      @builder.sanitize('art')
+      @builder.to_s.should == "select * from music.artists | sanitize(field='art')"
+    end
+
+    it "should generate the right query when given a sanitize all fields" do
+      @builder.sanitize
+      @builder.to_s.should == "select * from music.artists | sanitize()"
+    end
+  end
+
+end

data/spec/yql_query_source_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe YqlQuery::Source do
+  before(:each) do
+    @use_case = YqlQuery::Source.new('http://geodata.org/table.xml', 'geodata')
+  end
+
+  it "should be equivalent if both the source and as are equal" do
+    @use_case.should == YqlQuery::Source.new('http://geodata.org/table.xml', 'geodata')
+  end
+end

data/yql-query.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "yql_query/version"
+
+Gem::Specification.new do |s|
+  s.name        = "yql-query"
+  s.version     = YqlQuery::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Steve Agalloco"]
+  s.email       = ["steve.agalloco@gmail.com"]
+  s.homepage    = "https://github.com/spagalloco/yql-query"
+  s.summary     = %q{A YQL Query generator}
+  s.description = %q{A YQL Query generator}
+
+  s.rubyforge_project = "yql-query"
+
+  s.add_runtime_dependency('hashie', '~> 1.0.0')
+
+  s.add_development_dependency('bundler', '~> 1.0')
+  s.add_development_dependency('rake', '~> 0.8')
+  s.add_development_dependency('rspec', '~> 2.5.0')
+  s.add_development_dependency('yard', '~> 0.6')
+  s.add_development_dependency('maruku', '~> 0.6')
+  s.add_development_dependency('simplecov', '~> 0.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,150 @@
+--- !ruby/object:Gem::Specification 
+name: yql-query
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Steve Agalloco
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-22 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hashie
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.8"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: yard
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: maruku
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.6"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: simplecov
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "0.3"
+  type: :development
+  version_requirements: *id007
+description: A YQL Query generator
+email: 
+- steve.agalloco@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .rspec
+- Gemfile
+- License.md
+- Rakefile
+- Readme.md
+- lib/yql-query.rb
+- lib/yql_query.rb
+- lib/yql_query/builder.rb
+- lib/yql_query/query.rb
+- lib/yql_query/source.rb
+- lib/yql_query/version.rb
+- spec/spec_helper.rb
+- spec/yql_query_builder_spec.rb
+- spec/yql_query_source_spec.rb
+- yql-query.gemspec
+has_rdoc: true
+homepage: https://github.com/spagalloco/yql-query
+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: yql-query
+rubygems_version: 1.5.0
+signing_key: 
+specification_version: 3
+summary: A YQL Query generator
+test_files: 
+- spec/spec_helper.rb
+- spec/yql_query_builder_spec.rb
+- spec/yql_query_source_spec.rb