gda 1.1.0 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 09209a9fa57de499346a00205d6192c1fdc814b2
-  data.tar.gz: e5f046ad0e79ad6cbd379348140455837fe458c9
+SHA256:
+  metadata.gz: 249c2a0b4052ce8966703bb9e64523efdcc6efb8fa811e2ec615673d95e40c28
+  data.tar.gz: 19e8a69b6aeda5bceac5b682329ada312d25133fcb9ac42ab98396239420768c
 SHA512:
-  metadata.gz: 05f0726618f23cf50ce0e78215401bdfc4729ebb6ee4058e558947ad984b31a6c9fa52717965453c797fdfd2b08a89b3e90244e57a0dd401bb61da4a194d39f5
-  data.tar.gz: 97f55889fb6c30db52176f9ed61d7b8678702f2627f1c87be1f67dee193eb8df4c78813ac0d3ea8d5ad5912a15ce033dcd54a4aeb2f6639ee0d0d1816c30a45b
+  metadata.gz: 42f1ec2a4b005c76434ac414cdc3845d7fa0133490fc0bd13d092f258b67c55cecf4d00279f3f16207383f1d62f4971a6f7b05fe1c59ba32b4df10ca327db548
+  data.tar.gz: 4ea782a5e30f0996617387dc2d706cf8cb77154162055f6bad58a4bc93c2e77d0176a018c0e8155a9163e5d1caf11f975c9bfbd9d7e29192c87757657397532c

data/ext/gda/extconf.rb

@@ -2,7 +2,7 @@ require 'mkmf'
 
 # :stopdoc:
 
-ENV['PKG_CONFIG_PATH'] ||= '/usr/local/Library/ENV/pkgconfig/10.8'
+ENV['PKG_CONFIG_PATH'] ||= '/usr/local/lib/pkgconfig'
 
 dir_config 'libgda'
 

data/ext/gda/gda_nodes.c

@@ -419,6 +419,7 @@ void Init_gda_nodes()
     mNodes = rb_define_module_under(mGDA, "Nodes");
 
     cNode = rb_define_class_under(mNodes, "Node", rb_cObject);
+    rb_undef_alloc_func(cNode);
 
     cSelect = rb_define_class_under(mNodes, "Select", cNode);
     rb_define_method(cSelect, "distinct?", distinct_p, 0);

data/ext/gda/gda_provider.c

@@ -7,7 +7,7 @@ static VALUE name(VALUE self)
     GdaServerProvider * pr;
     Data_Get_Struct(self, GdaServerProvider, pr);
 
-    return rb_tainted_str_new2(gda_server_provider_get_name(pr));
+    return rb_str_new2(gda_server_provider_get_name(pr));
 }
 
 static VALUE find(VALUE klass, VALUE string)
@@ -52,6 +52,7 @@ static VALUE quote_str(VALUE self, VALUE str)
 void Init_gda_provider()
 {
     cProvider = rb_define_class_under(mSQL, "Provider", rb_cObject);
+    rb_undef_alloc_func(cProvider);
     rb_define_singleton_method(cProvider, "find", find, 1);
     rb_define_method(cProvider, "name", name, 0);
     rb_define_method(cProvider, "parser", parser, 0);

data/ext/gda/gda_statement.c

@@ -49,6 +49,9 @@ void Init_gda_statement()
     cStatement = rb_define_class_under(mSQL, "Statement", rb_cObject);
     cStructure = rb_define_class_under(mSQL, "Structure", rb_cObject);
 
+    rb_undef_alloc_func(cStatement);
+    rb_undef_alloc_func(cStructure);
+
     rb_define_method(cStatement, "serialize", serialize, 0);
     rb_define_method(cStatement, "structure", structure, 0);
     rb_define_method(cStructure, "ast", ast, 0);

data/lib/gda/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module GDA
+  VERSION = '1.1.3'
+end

data/lib/gda.rb

@@ -4,8 +4,6 @@ require 'gda/visitors/dot'
 require 'gda/visitors/max_depth'
 
 module GDA
-  VERSION = '1.1.0'
-
   module SQL
     class Statement
       def ast

metadata

@@ -1,71 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: gda
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.3
 platform: ruby
 authors:
 - Aaron Patterson
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2016-01-29 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: rdoc
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '4.0'
-- !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.14'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.14'
+date: 2019-03-20 00:00:00.000000000 Z
+dependencies: []
 description: |-
   An SQL parser. Wraps libgda in a loving embrace to give you a ruby level SQL
   parser.
@@ -77,13 +21,10 @@ extensions:
 extra_rdoc_files:
 - CHANGELOG.rdoc
 - Manifest.txt
-- README.rdoc
 files:
-- ".autotest"
 - CHANGELOG.rdoc
 - Manifest.txt
-- README.rdoc
-- Rakefile
+- README.md
 - ext/gda/extconf.rb
 - ext/gda/gda.c
 - ext/gda/gda.h
@@ -94,23 +35,16 @@ files:
 - ext/gda/gda_statement.c
 - ext/gda/gda_statement.h
 - lib/gda.rb
+- lib/gda/version.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
 homepage: http://github.com/tenderlove/gda
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -120,16 +54,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.3
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.5.0
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.5
-signing_key: 
+rubygems_version: 3.4.0.dev
+signing_key:
 specification_version: 4
 summary: An SQL parser
 test_files: []

data/.autotest

@@ -1,12 +0,0 @@
-require "autotest/restart"
-require 'rbconfig'
-
-Autotest.add_hook :initialize do |at|
-  at.find_directories = ARGV unless ARGV.empty?
-  at.testlib = "minitest/autorun"
-end
-
-Autotest.add_hook :run_command do |at|
-  at.unit_diff = 'cat'
-  system "ruby -S rake compile"
-end

data/Rakefile

@@ -1,34 +0,0 @@
-# -*- ruby -*-
-
-require 'rubygems'
-require 'hoe'
-
-Hoe.plugins.delete :rubyforge
-Hoe.plugin :minitest
-Hoe.plugin :gemspec # `gem install hoe-gemspec`
-Hoe.plugin :git     # `gem install hoe-git`
-
-Hoe.spec 'gda' do
-  developer('Aaron Patterson', 'tenderlove@ruby-lang.org')
-  self.readme_file   = 'README.rdoc'
-  self.history_file  = 'CHANGELOG.rdoc'
-  self.extra_rdoc_files  = FileList['*.rdoc']
-
-  extra_dev_deps << ['rake-compiler', '>= 0.4.1']
-  extra_dev_deps << ['sqlite3']
-
-  self.spec_extras = {
-    :extensions            => ["ext/gda/extconf.rb"],
-    :required_ruby_version => '>= 1.9.3'
-  }
-
-  require "rake/extensiontask"
-
-  Rake::ExtensionTask.new "gda", spec do |ext|
-    ext.lib_dir = File.join(*['lib', ENV['FAT_DIR']].compact)
-  end
-end
-
-task :test => :compile
-
-# vim: syntax=ruby

data/test/helper.rb

@@ -1,17 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,159 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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
-
-    def test_not_equal_operator
-      stmt = parser.parse 'SELECT id FROM comments WHERE issue_id = 1 AND type <> 3'
-      assert stmt.ast.is_a?(GDA::Nodes::Select)
-    end
-  end
-end

data/test/test_statement.rb

@@ -1,112 +0,0 @@
-require 'helper'
-
-module GDA
-  module SQL
-    class TestUnion < TestCase
-      attr_reader :parser, :stmt
-
-      def setup
-        @parser = GDA::SQL::Parser.new
-        sql = <<-SQL.gsub(/^ */, "")
-            SELECT id FROM posts WHERE actor_id = 1 AND actor_type = 1
-            UNION
-            SELECT id FROM posts WHERE actor_id = 1 AND actor_type = 3
-          SQL
-
-        @stmt = parser.parse(sql)
-      end
-
-      def test_union_query
-        assert_equal 2, stmt.ast.stmt_list.count
-        assert_equal 0, stmt.ast.compound_type, "should be an UNION type"
-      end
-
-      def test_union_query_visitor
-        visitor = Class.new(Visitors::Visitor) do
-          attr_reader :selects_count
-          def visit_GDA_Nodes_Select(*)
-            @selects_count ||= 0
-            @selects_count += 1
-          end
-        end.new
-
-        visitor.accept stmt.ast
-        assert_equal 2, visitor.selects_count
-      end
-    end
-
-    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