wvanbergen-sql_tree 0.0.1

data/README.rdoc

@@ -0,0 +1,6 @@
+=== SQLTree
+
+SQLTree is a pure Ruby library to represent SQL queries as a tree of nodes. 
+
+The library can parse an SQL query (a string) to represent the query using
+a tree, and it can generate an SQL query from a constructed tree.

data/Rakefile

@@ -0,0 +1,3 @@
+Dir['tasks/*.rake'].each { |file| load(file) }
+ 
+task :default => [:spec]

data/lib/sql_tree.rb

@@ -0,0 +1,14 @@
+module SQLTree
+  
+end
+
+require 'sql_tree/token'
+require 'sql_tree/tokenizer'
+require 'sql_tree/parser'
+
+require 'sql_tree/node'
+require 'sql_tree/node/select_query'
+require 'sql_tree/node/expression'
+require 'sql_tree/node/leafs'
+
+require 'sql_tree/generator'

data/lib/sql_tree/generator.rb

@@ -0,0 +1,3 @@
+module SQLTree::Generator
+  
+end

data/lib/sql_tree/node.rb

@@ -0,0 +1,22 @@
+class SQLTree::Node
+
+  def inspect
+    "#{self.class.name}[#{self.to_sql}]"
+  end
+  
+  def quote_var(name)
+    "\"#{name}\""
+  end
+  
+  def quote_str(str)
+    "'#{str.gsub(/\'/, "''")}'"
+  end
+  
+  def self.[](arg)
+    case arg
+      when Symbol; Variable.new(arg.to_s)
+      else;        Value.new(arg) 
+    end
+  end
+
+end

data/lib/sql_tree/parser.rb

@@ -0,0 +1,214 @@
+class SQLTree::Parser
+
+  def current_token
+    @current_token
+  end
+  
+  def next_token
+    @current_token = @tokens.shift
+  end 
+  
+  def consume(check)
+    error(current_token) unless check == next_token
+  end  
+  
+  def peek_token(distance = 1)
+    @tokens[distance - 1]
+  end
+  
+  def error(token)
+    raise "Unexpected token: #{token.inspect}"
+  end
+  
+  def debug
+    p @tokens.inspect
+  end
+  
+  def parse(tokens, options = {:as => :query})
+    if tokens.kind_of?(String)
+      tokenizer = SQLTree::Tokenizer.new
+      @tokens   = tokenizer.tokenize(tokens)
+    else
+      @tokens   = tokens
+    end
+    
+    send("parse_#{options[:as]}".to_sym)
+  end
+  
+  def parse_query
+    case peek_token
+    when SQLTree::Token::SELECT; parse_select_query
+    else raise "Could not parse query"
+    end
+  end
+  
+  def parse_select_query
+    select_node = SQLTree::Node::SelectQuery.new
+    consume(SQLTree::Token::SELECT)
+    
+    if peek_token == SQLTree::Token::DISTINCT
+      consume(SQLTree::Token::DISTINCT)
+      select_node.distinct = true
+    end
+    
+    select_node.select = parse_select_clause 
+    select_node.from   = parse_from_clause   if peek_token == SQLTree::Token::FROM
+    select_node.where  = parse_where_clause  if peek_token == SQLTree::Token::WHERE
+    
+    return select_node
+  end
+  
+  def parse_select_clause
+    expressions = [parse_select_expression]
+    while peek_token == SQLTree::Token::COMMA
+      consume(SQLTree::Token::COMMA)
+      expressions << parse_select_expression
+    end
+    return expressions
+  end
+  
+  def parse_select_expression
+    if peek_token == SQLTree::Token::MULTIPLY
+      consume(SQLTree::Token::MULTIPLY)
+      return SQLTree::Node::ALL_FIELDS 
+    else
+      expr = SQLTree::Node::SelectExpression.new(parse_expression)
+      if peek_token == SQLTree::Token::AS
+        consume(SQLTree::Token::AS)
+        expr.variable = parse_variable_name
+      end
+      return expr
+    end
+  end
+  
+  def parse_single_expression
+    if SQLTree::Token::LPAREN === peek_token(1)
+      consume(SQLTree::Token::LPAREN)
+      expr = parse_expression
+      consume(SQLTree::Token::RPAREN)
+      return expr
+    elsif SQLTree::Token::Variable === peek_token(1)  && peek_token(2) == SQLTree::Token::LPAREN
+      return parse_function_call
+    elsif SQLTree::Token::Variable === peek_token(1)
+      return parse_variable
+    else
+      return parse_value
+    end    
+  end
+  
+  def parse_expression
+    parse_logical_expression
+  end
+
+  def parse_secondary_arithmetic_expression
+    expr = parse_single_expression
+    while [SQLTree::Token::PLUS, SQLTree::Token::MINUS].include?(peek_token)
+      expr = SQLTree::Node::ArithmeticExpression.new(next_token.literal, expr, parse_single_expression)
+    end
+    return expr    
+  end
+
+  
+  def parse_primary_arithmetic_expression
+    expr = parse_secondary_arithmetic_expression
+    while [SQLTree::Token::PLUS, SQLTree::Token::MINUS].include?(peek_token)
+      expr = SQLTree::Node::ArithmeticExpression.new(next_token.literal, expr, parse_secondary_arithmetic_expression)
+    end
+    return expr    
+  end
+  
+  def parse_comparison_expression
+    expr = parse_primary_arithmetic_expression    
+    while [SQLTree::Token::EQ, SQLTree::Token::NE, SQLTree::Token::GT, SQLTree::Token::GTE, SQLTree::Token::LT, SQLTree::Token::LTE].include?(peek_token)
+      expr = SQLTree::Node::ComparisonExpression.new(next_token.literal, expr, parse_primary_arithmetic_expression)   
+    end
+    return expr
+  end
+  
+  def parse_logical_expression
+    expr = parse_comparison_expression
+    while [SQLTree::Token::AND, SQLTree::Token::OR].include?(peek_token)
+      expr = SQLTree::Node::LogicalExpression.new(next_token.literal, [expr, parse_comparison_expression])   
+    end 
+    return expr
+  end
+  
+  def parse_logical_not_expression  
+    
+  end
+  
+  def parse_function_call
+    
+    expr = SQLTree::Node::FunctionExpression.new(next_token.literal)
+    consume(SQLTree::Token::LPAREN)
+    until peek_token == SQLTree::Token::RPAREN
+      expr.arguments << parse_expression
+      consume(SQLTree::Token::COMMA) if peek_token == SQLTree::Token::COMMA
+    end
+    consume(SQLTree::Token::RPAREN)
+    return expr
+  end
+  
+  def parse_from_clause
+    consume(SQLTree::Token::FROM)
+    from_expressions = [parse_from_expression]
+    while peek_token == SQLTree::Token::COMMA
+      consume(SQLTree::Token::COMMA)
+      from_expressions << parse_from_expression
+    end 
+
+    return from_expressions    
+  end
+  
+  def parse_from_expression
+    from_expression = case peek_token
+      when SQLTree::Token::Variable;  parse_table_import
+      else;                           error(peek_token)
+    end
+    return from_expression
+  end
+  
+  def parse_table_import
+    table_import = SQLTree::Node::TableImport.new(next_token.literal)
+    if peek_token == SQLTree::Token::AS || SQLTree::Token::Variable === peek_token
+      consume(SQLTree::Token::AS) if peek_token == SQLTree::Token::AS
+      table_import.variable = parse_variable
+    end
+    return table_import
+  end
+  
+  def parse_field
+    lhs = next_token
+    lhs = (lhs == SQLTree::Token::MULTIPLY) ? :all : lhs.literal
+    
+    if peek_token == SQLTree::Token::DOT
+      consume(SQLTree::Token::DOT)
+      rhs = next_token
+      rhs = (rhs == SQLTree::Token::MULTIPLY) ? :all : rhs.literal      
+      SQLTree::Node::Field.new(rhs, lhs)
+    else
+      SQLTree::Node::Field.new(lhs)
+    end
+  end
+  
+  def parse_variable_name
+    return SQLTree::Node::Variable.new(next_token.literal)
+  end
+
+  def parse_variable
+    if peek_token(2) == SQLTree::Token::DOT
+      parse_field
+    else
+      parse_variable_name
+    end
+  end
+  
+  def parse_value
+    SQLTree::Node::Value.new(next_token.literal)
+  end
+
+    
+  def parse_where_clause
+  end
+  
+end

data/lib/sql_tree/token.rb

@@ -0,0 +1,63 @@
+class SQLTree::Token
+
+  attr_accessor :literal
+
+  def initialize(literal)
+    @literal = literal
+  end
+  
+  def ==(other)
+    other.class == self.class && @literal == other.literal
+  end
+  
+  alias :eql? :==
+  
+  def inspect
+    literal
+  end
+  
+  # Token types
+  
+  class Value < SQLTree::Token
+  end
+  
+  class Variable < SQLTree::Token::Value
+  end
+  
+  class String < SQLTree::Token::Value
+  end
+  
+  class Number < SQLTree::Token::Value
+  end  
+  
+  class Keyword < SQLTree::Token
+    def inspect
+      ":#{literal.downcase}"
+    end    
+  end
+
+  class Operator < SQLTree::Token
+    def inspect
+      OPERATORS[literal].inspect
+    end
+  end
+
+  LPAREN = Class.new(SQLTree::Token).new('(')
+  RPAREN = Class.new(SQLTree::Token).new(')')
+  DOT    = Class.new(SQLTree::Token).new('.')  
+  COMMA  = Class.new(SQLTree::Token).new(',')    
+  
+  KEYWORDS = %w{select from where group having order distinct left right inner outer join and or not as}
+  KEYWORDS.each do |kw|
+    self.const_set(kw.upcase, Class.new(SQLTree::Token::Keyword).new(kw.upcase))
+  end
+  
+  ARITHMETHIC_OPERATORS = { '+' => :plus, '-' => :minus, '*' => :multiply, '/' => :divide, '%' => :modulo }
+  LOGICAL_OPERATORS     = { '=' => :eq, '!=' => :ne, '<>' => :ne, '>' => :gt, '<' => :lt, '>=' => :gte, '<=' => :lte }
+
+  OPERATORS = ARITHMETHIC_OPERATORS.merge(LOGICAL_OPERATORS)
+  OPERATORS.each do |literal, symbol|
+    self.const_set(symbol.to_s.upcase, Class.new(SQLTree::Token::Operator).new(literal)) unless self.const_defined?(symbol.to_s.upcase)
+  end
+
+end

data/lib/sql_tree/tokenizer.rb

@@ -0,0 +1,99 @@
+class SQLTree::Tokenizer
+  
+  include Enumerable
+  
+  def tokenize(string)
+    @string = string
+    @current_char_pos = -1    
+    to_a
+  end
+  
+  def current_char
+    @current_char
+  end
+
+  def peek_char(amount = 1)
+    @string[@current_char_pos + amount, 1]
+  end
+
+  def next_char
+    @current_char_pos += 1
+    @current_char = @string[@current_char_pos, 1]
+  end
+
+  OPERATOR_CHARS = /\=|<|>|!|\-|\+|\/|\*|\%/
+
+  def each_token(&block)
+    while next_char
+      case current_char
+      when /^\s?$/;        # whitespace, go to next token
+      when '(';            yield(SQLTree::Token::LPAREN)
+      when ')';            yield(SQLTree::Token::RPAREN)
+      when '.';            yield(SQLTree::Token::DOT)
+      when '.';            yield(SQLTree::Token::COMMA)        
+      when /\d/;           tokenize_number(&block)
+      when "'";            tokenize_quoted_string(&block)
+      when OPERATOR_CHARS; tokenize_operator(&block)
+      when /\w/;           tokenize_literal(&block)
+      when '"';            tokenize_quoted_literal(&block)     # TODO: allow MySQL quoting mode   
+      end      
+    end
+  end
+  
+  alias :each :each_token  
+  
+  def tokenize_literal(&block)
+    literal = current_char
+    literal << next_char while /[\w]/ =~ peek_char    
+      
+    if SQLTree::Token::KEYWORDS.include?(literal.downcase)
+      yield(SQLTree::Token.const_get(literal.upcase))
+    else
+      yield(SQLTree::Token::Variable.new(literal))
+    end
+  end
+
+  def tokenize_number(&block)
+    number = current_char
+    dot_encountered = false
+    while /\d/ =~ peek_char || (peek_char == '.' && !dot_encountered)
+      dot_encountered = true if peek_char == '.'
+      number << next_char
+    end
+    
+    if dot_encountered
+      yield(SQLTree::Token::Number.new(number.to_f))
+    else
+      yield(SQLTree::Token::Number.new(number.to_i))
+    end
+  end
+
+  def tokenize_quoted_string(&block)
+    string = ''
+    until next_char.nil? || current_char == "'"
+      string << (current_char == "\\" ? next_char : current_char)
+    end
+    yield(SQLTree::Token::String.new(string))
+  end  
+  
+  def tokenize_quoted_literal(&block)
+    literal = ''
+    until next_char.nil? || current_char == '"' # TODO: allow MySQL quoting mode
+      literal << (current_char == "\\" ? next_char : current_char)
+    end
+    yield(SQLTree::Token::Variable.new(literal))     
+  end  
+  
+  
+  def tokenize_operator(&block)
+    operator = current_char
+    if operator == '-' && /[\d\.]/ =~ peek_char 
+      tokenize_number(&block)
+    else
+      operator << next_char if SQLTree::Token::OPERATORS.has_key?(operator + peek_char)
+      yield(SQLTree::Token.const_get(SQLTree::Token::OPERATORS[operator].to_s.upcase))
+    end
+  end
+  
+  
+end

data/spec/integration/api_spec.rb

@@ -0,0 +1,5 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe SQLTree, :API do
+  
+end

data/spec/lib/matchers.rb

@@ -0,0 +1,80 @@
+class ParseAs
+  
+  def initialize(expected_tree)
+    @expected_tree = expected_tree
+  end 
+  
+  def matches?(found_tree)
+    @found_tree = found_tree.to_tree
+    return @found_tree.eql?(@expected_tree)
+  end
+  
+  def description
+    "expected to parse to #{@expected_tree.inspect}"
+  end
+  
+  def failure_message
+    " #{@expected_tree.inspect} expected, but found #{@found_tree.inspect}"
+  end
+  
+  def negative_failure_message
+    " expected not to be tokenized to #{@expected_tree.inspect}"
+  end  
+end
+
+def parse_as(tree)
+  ParseAs.new(tree)
+end
+
+class TokenizeTo
+  
+  def initialize(expected_tokens)
+    @expected_tokens = expected_tokens.map do |t|
+      case t
+        when SQLTree::Token; t
+        when String;  SQLTree::Token::String.new(t)
+        when Integer; SQLTree::Token::Number.new(t)
+        when Float;   SQLTree::Token::Number.new(t)          
+        when Symbol;  SQLTree::Token.const_get(t.to_s.upcase)
+      end
+    end
+  end
+  
+  def matches?(found_tokens)
+    @found_tokens = found_tokens
+    return @found_tokens.eql?(@expected_tokens)
+  end
+  
+  def description
+    "expected to tokenized to #{@expected_tokens.inspect}"
+  end
+  
+  def failure_message
+    " #{@expected_tokens.inspect} expected, but found #{@found_tokens.inspect}"
+  end
+  
+  def negative_failure_message
+    " expected not to be tokenized to #{@expected_tokens.inspect}"
+  end  
+  
+end
+
+def tokenize_to(*expected_tokens)
+  TokenizeTo.new(expected_tokens)
+end
+
+def sql_var(name)
+  SQLTree::Token::Variable.new(name.to_s)
+end
+
+def dot
+  SQLTree::Token::DOT
+end
+
+def lparen
+  SQLTree::Token::LPAREN
+end
+
+def rparen
+  SQLTree::Token::RPAREN
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+$:.reject! { |e| e.include? 'TextMate' }
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'sql_tree'
+
+module SQLTree::Spec
+end
+
+require "#{File.dirname(__FILE__)}/lib/matchers"

data/spec/unit/parser_spec.rb

@@ -0,0 +1,81 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe SQLTree::Parser do
+  
+  before(:all) do
+    @parser = SQLTree::Parser.new
+  end
+  
+  context :expressions do
+  
+    it "should parse a variable" do
+      @parser.parse("field", :as => :expression).should eql(SQLTree::Node[:field])
+    end
+
+    it "should parse a table field" do
+      @parser.parse('tbl.field', :as => :expression).should eql(SQLTree::Node::Field[:tbl, :field])
+    end
+
+  
+    it "should parse a number" do
+      @parser.parse("1.0", :as => :expression).should eql(SQLTree::Node[1.0])
+    end
+
+    it "should parse a string" do
+      @parser.parse("'str'", :as => :expression).should eql(SQLTree::Node['str'])
+    end
+
+    it "should parse a function call without arguments" do
+      @parser.parse("NOW()", :as => :expression).should parse_as([:NOW])
+    end
+
+    it "should parse a function call with a single numeric argument" do
+      @parser.parse("MD5('abc')", :as => :expression).should parse_as([:MD5, 'abc'])
+    end
+
+    it "should parse a function call with multiple arguments" do
+      @parser.parse("CONCAT('Mr. ', last_name)", :as => :expression).should parse_as([:CONCAT, 'Mr. ', :last_name])
+    end
+
+    it "should parse a simple arithmetic operator" do
+      @parser.parse("1 + 2", :as => :expression).should parse_as([:plus, 1, 2])
+    end
+    
+    it "should parse a simple comparison" do
+      @parser.parse("1 < 2", :as => :expression).should parse_as([:lt, 1, 2])
+    end
+
+    it "should parse a simple subexpressions with parenthesis on the start" do
+      @parser.parse("(1 + 1) = 2", :as => :expression).should parse_as([:eq, [:plus, 1, 1], 2])
+    end
+
+    it "should parse a simple subexpressions with parenthesis on the end" do
+      @parser.parse("1 + (1 = 2)", :as => :expression).should parse_as([:plus, 1, [:eq, 1, 2]])
+    end
+
+    it "should parse arithmetic operations before comparisons" do
+      @parser.parse("1 + 1 = 2", :as => :expression).should parse_as([:eq, [:plus, 1, 1], 2])
+    end
+    
+    it "should parse arithmetic operations before comparisons" do
+      @parser.parse("1 + 2 - 3", :as => :expression).should parse_as([:minus, [:plus, 1, 2], 3])
+    end
+    
+
+    it "should parse arithmetic operations before comparisons" do
+      @parser.parse("a and b", :as => :expression).should parse_as([:and, :a, :b])
+    end
+
+    it "should parse arithmetic operations before comparisons" do
+      @parser.parse("a and b and c", :as => :expression).should parse_as([:and, [:and, :a, :b], :c])
+    end
+
+    it "should parse arithmetic operations before comparisons" do
+      @parser.parse("a and b or c", :as => :expression).should parse_as([:or, [:and, :a, :b], :c])
+    end
+
+    
+  end
+
+
+end

data/spec/unit/tokenizer_spec.rb

@@ -0,0 +1,76 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe SQLTree::Tokenizer do
+  
+  before(:all) do
+    @tokenizer = SQLTree::Tokenizer.new
+  end
+  
+  context "recognizing single tokens" do
+    it "should tokenize SQL query keywords" do
+      @tokenizer.tokenize('WHERE').should tokenize_to(:where)
+    end
+
+    it "should tokenize expression keywords" do
+      @tokenizer.tokenize('and').should tokenize_to(:and)
+    end
+    
+    it "should tokenize muliple keywords" do
+      @tokenizer.tokenize('SELECT DISTINCT').should tokenize_to(:select, :distinct)
+    end
+
+    it "should ignore excessive whitespace" do
+      @tokenizer.tokenize("\tSELECT      DISTINCT \r\r").should tokenize_to(:select, :distinct)
+    end
+
+    it "should tokenize variables" do
+      @tokenizer.tokenize("var").should tokenize_to(sql_var('var'))
+    end
+
+    it "should tokenize quoted variables" do
+      @tokenizer.tokenize('"var"').should tokenize_to(sql_var('var'))
+    end
+
+    it "should tokenize strings" do
+      @tokenizer.tokenize("'hello' '  world  '").should tokenize_to('hello', '  world  ')
+    end
+  
+    it "should tokenize numbers" do
+      @tokenizer.tokenize("1 -2 3.14 -4.0").should tokenize_to(1, -2, 3.14, -4.0)
+    end  
+
+    it "should tokenize logical operators" do
+      @tokenizer.tokenize("< = <> >=").should tokenize_to(:lt, :eq, :ne, :gte)
+    end
+    
+    it "should tokenize arithmetic operators" do
+      @tokenizer.tokenize("+ - / * %").should tokenize_to(:plus, :minus, :divide, :multiply, :modulo)
+    end    
+    
+    it "should tokenize parentheses" do
+      @tokenizer.tokenize("(a)").should tokenize_to(lparen, sql_var('a'), rparen)
+    end  
+    
+    it "should tokenize dots" do
+      @tokenizer.tokenize('a."b"').should tokenize_to(sql_var('a'), dot, sql_var('b'))
+    end  
+    
+    it "should tokenize commas" do
+      @tokenizer.tokenize('a,"b"').should tokenize_to(sql_var('a'), comma, sql_var('b'))
+    end  
+    
+    
+  end
+  
+  context "combined tokens"  do
+    it "should tokenize a full sql_query" do
+      @tokenizer.tokenize("SELECT a.* FROM a_table AS a WHERE a.id > 1").should tokenize_to(
+        :select,  sql_var('a'), dot, :multiply, :from, sql_var('a_table'), :as, sql_var('a'), :where, sql_var('a'), dot, sql_var('id'), :gt, 1)
+    end
+    
+    it "should tokenize a function call" do
+      @tokenizer.tokenize("MD5('test')").should tokenize_to(sql_var('MD5'), lparen, 'test', rparen)
+    end
+  end
+  
+end

data/tasks/github-gem.rake

@@ -0,0 +1,250 @@
+require 'rubygems'
+require 'rubyforge'
+require 'rake'
+require 'rake/tasklib'
+require 'date'
+
+module Rake 
+  
+  class GithubGem < TaskLib
+    
+    attr_accessor :name
+    attr_accessor :specification
+   
+    def self.define_tasks!
+      gem_task_builder = Rake::GithubGem.new      
+      gem_task_builder.register_all_tasks!
+    end
+    
+
+    def initialize
+      reload_gemspec!
+    end
+
+    def register_all_tasks!
+      namespace(:gem) do
+        desc "Updates the file lists for this gem"
+        task(:manifest) { manifest_task }
+
+        desc "Releases a new version of #{@name}"
+        task(:build => [:manifest]) { build_task } 
+        
+        
+        release_dependencies = [:check_clean_master_branch, :version, :build, :create_tag]
+        release_dependencies.push 'doc:publish' if has_rdoc?
+        release_dependencies.unshift 'test' if has_tests?
+        release_dependencies.unshift 'spec' if has_specs?
+                
+        desc "Releases a new version of #{@name}"
+        task(:release => release_dependencies) { release_task } 
+        
+        # helper task for releasing
+        task(:check_clean_master_branch) { verify_clean_status('master') }
+        task(:check_version) { verify_version(ENV['VERSION'] || @specification.version) }
+        task(:version => [:check_version]) { set_gem_version! }
+        task(:create_tag) { create_version_tag! }
+      end
+      
+      # Register RDoc tasks
+      if has_rdoc?
+        require 'rake/rdoctask'
+        
+        namespace(:doc) do 
+          desc 'Generate documentation for request-log-analyzer'
+          Rake::RDocTask.new(:compile) do |rdoc|
+            rdoc.rdoc_dir = 'doc'
+            rdoc.title    = @name
+            rdoc.options += @specification.rdoc_options
+            rdoc.rdoc_files.include(@specification.extra_rdoc_files)
+            rdoc.rdoc_files.include('lib/**/*.rb')
+          end
+          
+          desc "Publish RDoc files for #{@name} to Github"
+          task(:publish => :compile) do
+            sh 'git checkout gh-pages'
+            sh 'git pull origin gh-pages'
+            sh 'cp -rf doc/* .'
+            sh "git commit -am \"Publishing newest RDoc documentation for #{@name}\""
+            sh "git push origin gh-pages"
+            sh "git checkout master"
+          end
+        end
+      end
+    
+      # Setup :spec task if RSpec files exist
+      if has_specs?
+        require 'spec/rake/spectask'
+
+        desc "Run all specs for #{@name}"
+        Spec::Rake::SpecTask.new(:spec) do |t|
+          t.spec_files = FileList['spec/**/*_spec.rb']
+        end
+      end
+      
+      # Setup :test task if unit test files exist
+      if has_tests?
+        require 'rake/testtask'
+
+        desc "Run all unit tests for #{@name}"
+        Rake::TestTask.new(:test) do |t|
+          t.pattern = 'test/**/*_test.rb'
+          t.verbose = true
+          t.libs << 'test'
+        end
+      end      
+    end
+    
+    protected 
+
+    def has_rdoc?
+      @specification.has_rdoc
+    end
+
+    def has_specs?
+      Dir['spec/**/*_spec.rb'].any?
+    end
+    
+    def has_tests?
+      Dir['test/**/*_test.rb'].any?
+    end
+
+    def reload_gemspec!
+      raise "No gemspec file found!" if gemspec_file.nil?      
+      spec = File.read(gemspec_file)
+      @specification = eval(spec)
+      @name = specification.name  
+    end
+
+    def run_command(command)
+      lines = []
+      IO.popen(command) { |f| lines = f.readlines }
+      return lines
+    end
+    
+    def git_modified?(file)
+      return !run_command('git status').detect { |line| Regexp.new(Regexp.quote(file)) =~ line }.nil?
+    end
+    
+    def git_commit_file(file, message, branch = nil)
+      verify_current_branch(branch) unless branch.nil?
+      if git_modified?(file)
+        sh "git add #{file}"
+        sh "git commit -m \"#{message}\""
+      else
+        raise "#{file} is not modified and cannot be committed!"
+      end
+    end
+    
+    def git_create_tag(tag_name, message)
+      sh "git tag -a \"#{tag_name}\" -m \"#{message}\""
+    end
+    
+    def git_push(remote = 'origin', branch = 'master', options = [])
+      verify_clean_status(branch)
+      options_str = options.map { |o| "--#{o}"}.join(' ')
+      sh "git push #{options_str} #{remote} #{branch}"
+    end
+    
+    def gemspec_version=(new_version)
+      spec = File.read(gemspec_file)
+      spec.gsub!(/^(\s*s\.version\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{new_version}'#{$5}" }
+      spec.gsub!(/^(\s*s\.date\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{Date.today.strftime('%Y-%m-%d')}'#{$5}" }    
+      File.open(gemspec_file, 'w') { |f| f << spec }
+      reload_gemspec!      
+    end
+    
+    def gemspec_date=(new_date)
+      spec = File.read(gemspec_file)
+      spec.gsub!(/^(\s*s\.date\s*=\s*)('|")(.+)('|")(\s*)$/) { "#{$1}'#{new_date.strftime('%Y-%m-%d')}'#{$5}" }    
+      File.open(gemspec_file, 'w') { |f| f << spec }
+      reload_gemspec!       
+    end
+    
+    def gemspec_file 
+      @gemspec_file ||= Dir['*.gemspec'].first
+    end
+    
+    def verify_current_branch(branch)
+      run_command('git branch').detect { |line| /^\* (.+)/ =~ line }
+      raise "You are currently not working in the master branch!" unless branch == $1
+    end
+    
+    def verify_clean_status(on_branch = nil)
+      sh "git fetch"
+      lines = run_command('git status')
+      raise "You don't have the most recent version available. Run git pull first." if /^\# Your branch is behind/ =~ lines[1]
+      raise "You are currently not working in the #{on_branch} branch!" unless on_branch.nil? || (/^\# On branch (.+)/ =~ lines.first && $1 == on_branch)
+      raise "Your master branch contains modifications!" unless /^nothing to commit \(working directory clean\)/ =~ lines.last
+    end
+    
+    def verify_version(new_version)
+      newest_version = run_command('git tag').map { |tag| tag.split(name + '-').last }.compact.map { |v| Gem::Version.new(v) }.max
+      raise "This version number (#{new_version}) is not higher than the highest tagged version (#{newest_version})" if !newest_version.nil? && newest_version >= Gem::Version.new(new_version.to_s)
+    end
+    
+    def set_gem_version!
+      # update gemspec file
+      self.gemspec_version = ENV['VERSION'] if Gem::Version.correct?(ENV['VERSION'])
+      self.gemspec_date    = Date.today
+    end
+
+    def manifest_task
+      verify_current_branch('master')
+      
+      list = Dir['**/*'].sort
+      list -= [gemspec_file]
+
+      if File.exist?('.gitignore')
+        File.read('.gitignore').each_line do |glob|
+          glob = glob.chomp.sub(/^\//, '')
+          list -= Dir[glob]
+          list -= Dir["#{glob}/**/*"] if File.directory?(glob) and !File.symlink?(glob)
+        end
+      end
+      
+      # update the spec file
+      spec = File.read(gemspec_file)
+      spec.gsub! /^(\s* s.(test_)?files \s* = \s* )( \[ [^\]]* \] | %w\( [^)]* \) )/mx do
+        assignment = $1
+        bunch = $2 ? list.grep(/^(test.*_test\.rb|spec.*_spec.rb)$/) : list
+        '%s%%w(%s)' % [assignment, bunch.join(' ')]
+      end
+
+      File.open(gemspec_file, 'w') { |f| f << spec }
+      reload_gemspec!
+    end
+    
+    def build_task
+      sh "gem build #{gemspec_file}"
+      Dir.mkdir('pkg') unless File.exist?('pkg')
+      sh "mv #{name}-#{specification.version}.gem pkg/#{name}-#{specification.version}.gem" 
+    end
+    
+    def install_task
+      raise "#{name} .gem file not found" unless File.exist?("pkg/#{name}-#{specification.version}.gem")
+      sh "gem install pkg/#{name}-#{specification.version}.gem"
+    end
+    
+    def uninstall_task
+      raise "#{name} .gem file not found" unless File.exist?("pkg/#{name}-#{specification.version}.gem")
+      sh "gem uninstall #{name}"
+    end    
+    
+    def create_version_tag!
+      # commit the gemspec file
+      git_commit_file(gemspec_file, "Updated #{gemspec_file} for release of version #{@specification.version}") if git_modified?(gemspec_file)
+
+      # create tag and push changes
+      git_create_tag("#{@name}-#{@specification.version}", "Tagged version #{@specification.version}")
+      git_push('origin', 'master', [:tags])     
+    end
+    
+    def release_task
+      puts
+      puts '------------------------------------------------------------'
+      puts "Released #{@name} - version #{@specification.version}"
+    end
+  end
+end
+
+Rake::GithubGem.define_tasks!

metadata

@@ -0,0 +1,82 @@
+--- !ruby/object:Gem::Specification 
+name: wvanbergen-sql_tree
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Willem van Bergen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-08-02 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: To make it easier to build and manipulate SQL queries, sql_tree can parse an SQL query to represent it as a tree of nodes and can generate an SQL query given a tree as input
+email: willem@vanbergen.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- Rakefile
+- lib
+- lib/sql_tree
+- lib/sql_tree.rb
+- lib/sql_tree/generator.rb
+- lib/sql_tree/node
+- lib/sql_tree/node.rb
+- lib/sql_tree/parser.rb
+- lib/sql_tree/token.rb
+- lib/sql_tree/tokenizer.rb
+- spec
+- spec/integration
+- spec/integration/api_spec.rb
+- spec/lib
+- spec/lib/matchers.rb
+- spec/spec_helper.rb
+- spec/unit
+- spec/unit/parser_spec.rb
+- spec/unit/tokenizer_spec.rb
+- tasks
+- tasks/github-gem.rake
+has_rdoc: true
+homepage: http://wiki.github.com/wvanbergen/sql_tree
+licenses: 
+post_install_message: 
+rdoc_options: 
+- --title
+- sql_tree
+- --main
+- README.rdoc
+- --line-numbers
+- --inline-source
+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.3.5
+signing_key: 
+specification_version: 2
+summary: A pure Ruby library to represent SQL queries as trees of nodes.
+test_files: 
+- spec/integration/api_spec.rb
+- spec/unit/parser_spec.rb
+- spec/unit/tokenizer_spec.rb