gda 1.0.0

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'minitest/autorun'
+require 'gda'
+require 'sqlite3'
+
+module GDA
+  class TestCase < MiniTest::Unit::TestCase
+    @@rails_sql = nil
+
+    def self.rails_sql
+      return @@rails_sql if @@rails_sql
+
+      db_file = File.join File.dirname(__FILE__), 'sqllog.sqlite3'
+      db      = SQLite3::Database.new db_file
+      @@rails_sql = db.execute('SELECT * FROM sqllog').map(&:first)
+    end
+  end
+end

data/test/test_dot_visitor.rb

@@ -0,0 +1,43 @@
+require 'helper'
+
+module GDA
+  class TestDotVisitor < TestCase
+    attr_reader :parser
+
+    class TestViz < Visitors::Dot
+      def initialize tc
+        super()
+        @tc = tc
+      end
+
+      Visitors::Visitor.private_instance_methods.grep(/^visit_(.*)/) do |method|
+        next if superclass.private_instance_methods(false).include?(method)
+
+        klass = $1.split('_').inject(Object) { |k,c| k.const_get c }
+
+        define_method(method) do |node|
+          flunk "#{klass} (#{method}) not tested yet"
+        end
+      end
+
+      def method_missing m, *args
+        return super unless @tc.respond_to?(m)
+
+        @tc.send m, *args
+      end
+    end
+
+    def setup
+      super
+      @parser = GDA::SQL::Parser.new
+      @viz    = TestViz.new(self)
+    end
+
+    rails_sql.uniq.each do |sql|
+      define_method(:"test_#{sql}") do
+        stmt = parser.parse sql
+        @viz.accept stmt.ast
+      end
+    end
+  end
+end

data/test/test_gda.rb

@@ -0,0 +1,55 @@
+require 'helper'
+
+module GDA
+  class TestParser < TestCase
+    attr_reader :parser
+
+    def setup
+      super
+      @parser = GDA::SQL::Parser.new
+    end
+
+    def test_split
+      assert_equal ['test', '"table"'], GDA.sql_identifier_split("test.\"table\"")
+    end
+
+    def test_parses
+      assert parser.parse('SELECT * FROM FOO')
+    end
+
+    def test_providers
+      assert_kind_of Array, GDA::SQL.providers
+      assert_operator GDA::SQL.providers.length, :>, 0
+    end
+
+    def test_get_provider
+      assert GDA::SQL::Provider.find SQL.providers.first
+    end
+
+    def test_provider_name
+      name = SQL.providers.first
+      provider = SQL::Provider.find name
+      assert_equal name, provider.name
+    end
+
+    def test_pg_parser
+      provider = SQL::Provider.find "PostgreSQL"
+      assert provider.parser.parse 'INSERT INTO "accounts" ("credit_limit", "firm_id", "firm_name") VALUES ($1, $2, $3) RETURNING "id"'
+    end
+
+    def test_mysql_parser
+      provider = SQL::Provider.find "MySQL"
+      assert provider.parser.parse 'SELECT topics.* FROM topics WHERE topics.id = 147 LIMIT 1'
+
+    end
+
+    def test_id_quote
+      provider = SQL::Provider.find "MySQL"
+      assert_equal '"1foo"', provider.quote("1foo")
+    end
+
+    def test_error
+      assert_nil SQL::Provider.find "asdfasdfadsf"
+    end
+  end
+end

data/test/test_max_depth.rb

@@ -0,0 +1,19 @@
+require 'helper'
+
+module GDA
+  module Visitors
+    class TestMaxDepth < TestCase
+      attr_reader :parser
+
+      def setup
+        super
+        @parser = GDA::SQL::Parser.new
+      end
+
+      def test_depth
+        stmt = parser.parse('SELECT * FROM FOO')
+        assert_equal 5, stmt.ast.max_depth
+      end
+    end
+  end
+end

data/test/test_node_attributes.rb

@@ -0,0 +1,159 @@
+require 'helper'
+
+module GDA
+  class TestNodeAttributes < TestCase
+    attr_reader :parser
+
+    class AttributeTest < Visitors::Visitor
+      def initialize tc
+        @tc = tc
+      end
+
+      private
+
+      def visit_Array node
+        node.each { |n| accept n }
+      end
+
+      def visit_GDA_Nodes_Select node
+        assert_respond_to node, :distinct?
+        super
+      end
+
+      def visit_GDA_Nodes_Unknown node
+        super
+      end
+
+      def visit_GDA_Nodes_Insert node
+        assert_string node, :on_conflict
+        super
+      end
+
+      def visit_GDA_Nodes_SelectField node
+        [:field_name, :table_name, :as].each do |m|
+          assert_string node, m
+        end
+        super
+      end
+
+      def visit_GDA_Nodes_Expr node
+        assert_string node, :value
+        assert_string node, :cast_as
+        super
+      end
+
+      def visit_GDA_Nodes_Function node
+        assert_string node, :function_name
+        super
+      end
+
+      def visit_GDA_Nodes_From node
+        super
+      end
+
+      def visit_GDA_Nodes_Table node
+        assert_string node, :table_name
+        super
+      end
+
+      def visit_GDA_Nodes_Update node
+        assert_string node, :on_conflict
+        super
+      end
+
+      def visit_GDA_Nodes_Operation node
+        assert_string node, :operator
+        super
+      end
+
+      def visit_GDA_Nodes_Delete node
+        super
+      end
+
+      def visit_GDA_Nodes_Order node
+        assert_boolean node, :asc
+        assert_string node, :collation_name
+        super
+      end
+
+      def visit_GDA_Nodes_RollbackSavepoint node
+        assert_string node, :__type__
+        assert_string node, :isolation_level
+        assert_string node, :trans_mode
+        assert_string node, :trans_name
+        super
+      end
+
+      alias :visit_GDA_Nodes_Begin           :visit_GDA_Nodes_RollbackSavepoint
+      alias :visit_GDA_Nodes_Savepoint       :visit_GDA_Nodes_RollbackSavepoint
+      alias :visit_GDA_Nodes_DeleteSavepoint :visit_GDA_Nodes_RollbackSavepoint
+      alias :visit_GDA_Nodes_Commit          :visit_GDA_Nodes_RollbackSavepoint
+      alias :visit_GDA_Nodes_Rollback        :visit_GDA_Nodes_RollbackSavepoint
+
+      def visit_GDA_Nodes_Field node
+        assert_string node, :field_name
+        super
+      end
+
+      def visit_GDA_Nodes_Join node
+        assert_string node, :join_type
+        assert_int node, :position
+        super
+      end
+
+      def visit_GDA_Nodes_Target node
+        assert_string node, :table_name
+        assert_string node, :as
+        super
+      end
+
+      def assert_boolean node, m
+        assert_respond_to node, m
+        if node.send(m)
+          assert_equal(true, node.send(m))
+        else
+          assert_equal(false, node.send(m))
+        end
+      end
+
+      def assert_string node, m
+        assert_respond_to node, m
+        assert_kind_of(String, node.send(m)) if node.send(m)
+      end
+
+      def assert_int node, m
+        assert_respond_to node, m
+        assert_kind_of(Numeric, node.send(m)) if node.send(m)
+      end
+
+      Visitors::Visitor.private_instance_methods.grep(/^visit_(.*)/) do |method|
+        next if private_instance_methods(false).include?(method)
+
+        klass = $1.split('_').inject(Object) { |k,c| k.const_get c }
+
+        define_method(method) do |node|
+          flunk "#{klass} (#{method}) not tested yet"
+        end
+      end
+
+      def method_missing m, *args
+        return super unless @tc.respond_to?(m)
+
+        @tc.send m, *args
+      end
+    end
+
+    def setup
+      super
+      @parser      = GDA::SQL::Parser.new
+      @attr_tester = AttributeTest.new(self)
+    end
+
+    rails_sql.uniq.each do |sql|
+      define_method(:"test_#{sql}") do
+        stmt = parser.parse sql
+        @attr_tester.accept stmt.ast
+      end
+    end
+  end
+end

data/test/test_nodes.rb

@@ -0,0 +1,26 @@
+require 'helper'
+
+module GDA
+  class TestNodes < TestCase
+    attr_reader :parser
+
+    def setup
+      super
+      @parser = GDA::SQL::Parser.new
+    end
+
+    rails_sql.uniq.each do |sql|
+      define_method(:"test_#{sql}") do
+        stmt = parser.parse sql
+        stmt.ast.each do |node|
+          assert node
+        end
+      end
+    end
+
+    def test_depth
+      stmt = parser.parse 'SELECT * FROM OMG WHERE 1 = 10'
+      assert_operator stmt.ast.to_a.length, :>, 1
+    end
+  end
+end

data/test/test_statement.rb

@@ -0,0 +1,79 @@
+require 'helper'
+
+module GDA
+  module SQL
+    class TestStatement < TestCase
+      attr_reader :parser, :stmt
+
+      def setup
+        super
+        @parser = GDA::SQL::Parser.new
+        @stmt = parser.parse 'SELECT * FROM FOO WHERE 1 = 1 GROUP BY omg HAVING omg(id) < 2 ORDER BY foo, bar LIMIT 50 OFFSET 2'
+      end
+
+      def test_serialize
+        assert stmt.serialize
+      end
+
+      def test_from
+        assert stmt.ast
+        assert stmt.ast.from
+      end
+
+      def test_distinct_expr
+        assert_nil stmt.ast.distinct_expr
+      end
+
+      def test_expr_list
+        assert_equal 1, stmt.ast.expr_list.length
+
+        stmt.ast.expr_list.each do |node|
+          assert node
+        end
+      end
+
+      def test_where_cond
+        assert stmt.ast.where_cond
+      end
+
+      def test_group_by
+        assert stmt.ast.group_by
+        stmt.ast.group_by.each do |node|
+          assert node
+        end
+      end
+
+      def test_having_cond
+        assert stmt.ast.having_cond
+      end
+
+      def test_order_by
+        assert_equal 2, stmt.ast.order_by.length
+        stmt.ast.order_by.each do |node|
+          assert node
+        end
+      end
+
+      def test_limit_count
+        assert stmt.ast.limit_count
+      end
+
+      def test_limit_offset
+        assert stmt.ast.limit_offset
+      end
+
+      def test_distinct?
+        refute stmt.ast.distinct?
+      end
+
+      def test_each
+        yielded = false
+        stmt.ast.each do |node|
+          yielded = true
+          assert node
+        end
+        assert yielded
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: gda
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Aaron Patterson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-07 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '4.6'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.4.1
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: |-
+  An SQL parser. Wraps libgda in a loving embrace to give you a ruby level SQL
+  parser.
+email:
+- tenderlove@ruby-lang.org
+executables: []
+extensions:
+- ext/gda/extconf.rb
+extra_rdoc_files:
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+files:
+- .autotest
+- CHANGELOG.rdoc
+- Manifest.txt
+- README.rdoc
+- Rakefile
+- ext/gda/extconf.rb
+- ext/gda/gda.c
+- ext/gda/gda.h
+- ext/gda/gda_nodes.c
+- ext/gda/gda_nodes.h
+- ext/gda/gda_provider.c
+- ext/gda/gda_provider.h
+- ext/gda/gda_statement.c
+- ext/gda/gda_statement.h
+- lib/gda.rb
+- lib/gda/visitors/dot.rb
+- lib/gda/visitors/each.rb
+- lib/gda/visitors/max_depth.rb
+- lib/gda/visitors/visitor.rb
+- test/helper.rb
+- test/sqllog.sqlite3
+- test/test_dot_visitor.rb
+- test/test_gda.rb
+- test/test_max_depth.rb
+- test/test_node_attributes.rb
+- test/test_nodes.rb
+- test/test_statement.rb
+- .gemtest
+homepage: http://github.com/tenderlove/gda
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options:
+- --main
+- README.rdoc
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: 1.9.3
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: gda
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: An SQL parser
+test_files:
+- test/test_dot_visitor.rb
+- test/test_gda.rb
+- test/test_max_depth.rb
+- test/test_node_attributes.rb
+- test/test_nodes.rb
+- test/test_statement.rb