sql_tagger 0.0.3 → 0.0.4

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9b7df0d78b3a94e79c9a8dbe4004b6b42a6b2ca2
+  data.tar.gz: 96f28433e8752ffd4c3ffd413ffdc8aa7078967b
+SHA512:
+  metadata.gz: b1505eab9c0b0f24dc4fc324b9d360d1e52810e957252c2eef814ba6996c384ce72b78fe173057a62a5d3d15603c08a3c43884979378e6d0f6d81df9f2673e93
+  data.tar.gz: b0d48bd55f0f659f5d71e494808dff705079b1726495a3f8ad22914c90e69197e880a2aa92d245f53a9d8875fbc7b680741989bc367d4c382af31d6e514b8717

data/README.md

@@ -0,0 +1,19 @@
+# sql\_tagger
+
+[![Build Status](https://travis-ci.org/SlideShareInc/sql_tagger.svg?branch=master)](https://travis-ci.org/SlideShareInc/sql_tagger)
+
+sql\_tagger is a gem that inserts comments into SQL queries. These comments
+include a string from `Kernel#caller` that (hopefully) reveals what Ruby code
+was responsible for performing the query.
+
+To use this, just require the appropriate file. For example, to use this with
+the `mysql` gem, write `require 'sql_tagger/mysql'` instead of `require
+'mysql'`.
+
+Before:
+
+    SELECT 1
+
+After:
+
+    /* program.rb:25:in `some_method' */ SELECT 1

data/VERSION

@@ -1 +1 @@
-0.0.3
+0.0.4

data/lib/sql_tagger.rb

@@ -2,6 +2,7 @@ require 'set'
 
 # Instances of this class insert stack trace comments into SQL queries.
 class SqlTagger
+  # Version string
   VERSION = IO.read(
     File.join(File.dirname(__FILE__), '..', 'VERSION')
   ).chomp.freeze
@@ -16,7 +17,7 @@ class SqlTagger
   attr_reader :exclusion_cache
 
   def initialize
-    @exclusion_pattern = /^#{RbConfig::CONFIG['prefix']}|\/bundle\/|\/vendor\//
+    @exclusion_pattern = %r{\A#{RbConfig::CONFIG['prefix']}|/gems/}
     @exclusion_cache = Set.new
   end
 
@@ -26,7 +27,7 @@ class SqlTagger
   # For example, given "SELECT 1", this will return something like
   # "/* program.rb:25:in `some_method' */ SELECT 1".
   #
-  # @param [String] sql SQL query string
+  # @param sql [String] SQL query string
   # @return [String] query string with a comment at the beginning
   def tag(sql)
     caller(2).each do |string|
@@ -44,7 +45,7 @@ class SqlTagger
 
   # Sets +@exclusion_pattern+.
   #
-  # @param [Regexp] regexp regular expression to be used to skip stack strings
+  # @param regexp [Regexp] regular expression to be used to skip stack strings
   def exclusion_pattern=(regexp)
     @exclusion_pattern = regexp
     @exclusion_cache.clear
@@ -57,9 +58,12 @@ class SqlTagger
     attr_accessor :default
   end
 
-  # Mixin that monkey patches the receiver's +initialize+ method to set
-  # +@sql_tagger+.
+  # @see .included
   module Initializer
+    # Callback that monkey patches the receiver's +initialize+ method to set
+    # +@sql_tagger+.
+    #
+    # @param base [Module]
     def self.included(base)
       base.send(:alias_method, :initialize_without_sql_tagger, :initialize)
       base.send(:alias_method, :initialize, :initialize_with_sql_tagger)
@@ -74,22 +78,26 @@ class SqlTagger
     # @return [SqlTagger] the SqlTagger used to tag queries for this instance
     attr_accessor :sql_tagger
 
+    # Sets +@sql_tagger+ before initializing
     def initialize_with_sql_tagger(*args, &block)
       @sql_tagger = SqlTagger.default
       initialize_without_sql_tagger(*args, &block)
     end
   end
 
+  # Extend this module in your adapter module
   module ModuleMethods
     # Callback that includes SqlTagger::Initializer and does method aliasing.
     #
-    # @param [Module] base
+    # @param base [Module]
     def included(base)
       base.send(:include, SqlTagger::Initializer)
       self.instance_methods.map(&:to_s).grep(/_with_sql_tagger$/).each do |with_method|
         target = with_method.sub(/_with_sql_tagger$/, '')
-        base.send(:alias_method, "#{target}_without_sql_tagger", target)
-        base.send(:alias_method, target, with_method)
+        if base.method_defined?(target)
+          base.send(:alias_method, "#{target}_without_sql_tagger", target)
+          base.send(:alias_method, target, with_method)
+        end
       end
     end
   end

data/lib/sql_tagger/mysql.rb

@@ -1,6 +1,7 @@
 require 'sql_tagger'
 require 'mysql'
 
+# Adapter for +Mysql+ from the mysql gem
 module SqlTagger::Mysql
   extend SqlTagger::ModuleMethods
 

data/lib/sql_tagger/mysql2.rb

@@ -1,13 +1,19 @@
 require 'sql_tagger'
 require 'mysql2'
 
+# Adapter for +Mysql2::Client+ from the mysql2 gem
 module SqlTagger::Mysql2
   extend SqlTagger::ModuleMethods
 
   # @see Mysql2::Client#query
-  def query_with_sql_tagger(sql, opts ={})
+  def query_with_sql_tagger(sql, opts = {})
     query_without_sql_tagger(@sql_tagger.tag(sql), opts)
   end
+
+  # @see Mysql2::Client#prepare
+  def prepare_with_sql_tagger(sql)
+    prepare_without_sql_tagger(@sql_tagger.tag(sql))
+  end
 end
 
 Mysql2::Client.send(:include, SqlTagger::Mysql2)

data/lib/sql_tagger/pg.rb

@@ -0,0 +1,32 @@
+require 'sql_tagger'
+require 'pg'
+
+# Adapter for +PG::Connection+ from the pg gem
+module SqlTagger::PG
+  extend SqlTagger::ModuleMethods
+
+  # I wouldn't be surprised if I missed a method (checked against pg 0.18.4)
+
+  [
+    :async_exec,
+    :async_query,
+    :exec,
+    :exec_params,
+    :query,
+    :send_query,
+  ].each do |method|
+    define_method("#{method}_with_sql_tagger") do |*args, &blk|
+      sql = @sql_tagger.tag(args[0])
+      __send__("#{method}_without_sql_tagger", sql, *args[1..-1], &blk)
+    end
+  end
+
+  [:prepare, :send_prepare].each do |method|
+    define_method("#{method}_with_sql_tagger") do |*args, &blk|
+      sql = @sql_tagger.tag(args[1])
+      __send__("#{method}_without_sql_tagger", args[0], sql, *args[2..-1], &blk)
+    end
+  end
+end
+
+PG::Connection.send(:include, SqlTagger::PG)

data/spec/spec_helper.rb

@@ -1,5 +1,5 @@
 shared_examples_for 'connections with sql_tagger' do
   it 'assigns SqlTagger.default to @sql_tagger' do
-    @db.sql_tagger.should == SqlTagger.default
+    expect(@db.sql_tagger).to eq(SqlTagger.default)
   end
 end

data/spec/sql_tagger/mysql2_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 require 'sql_tagger/mysql2'
 
-describe Mysql2::Client do
+RSpec.describe Mysql2::Client do
   before :all do
     @db = Mysql2::Client.new
   end
@@ -15,12 +15,35 @@ describe Mysql2::Client do
   describe '#query' do
     it 'works' do
       results = @db.query('SELECT 1 AS one', :symbolize_keys => true)
-      results.to_a.should == [{:one => 1}]
+      expect(results.to_a).to eq([{:one => 1}])
     end
 
-    it 'calls SqlTagger#tag' do
-      @db.sql_tagger.should_receive(:tag).and_return('/* something.rb */ SELECT 1')
-      @db.query('SELECT 1')
+    it 'passes a tagged query to the original method' do
+      query = 'SELECT 1'
+      allow(@db.sql_tagger).to receive(:tag).with(query).
+        and_return("/* something.rb */ #{query}")
+      expect(@db).to receive(:query_without_sql_tagger).
+        with("/* something.rb */ #{query}", {})
+      @db.query(query)
+    end
+  end
+
+  describe '#prepare' do
+    let(:query) { 'SELECT ? AS num' }
+
+    it 'works' do
+      stmt = @db.prepare(query)
+      result = stmt.execute(7)
+      expect(result.to_a).to eq([{'num' => 7}])
+      stmt.close
+    end
+
+    it 'passes a tagged query to the original method' do
+      allow(@db.sql_tagger).to receive(:tag).with(query).
+        and_return("/* something.rb */ #{query}")
+      expect(@db).to receive(:prepare_without_sql_tagger).
+        with("/* something.rb */ #{query}")
+      @db.prepare(query)
     end
   end
 end

data/spec/sql_tagger/mysql_spec.rb

@@ -1,7 +1,9 @@
 require 'spec_helper'
 require 'sql_tagger/mysql'
 
-describe Mysql do
+RSpec.describe Mysql do
+  let(:query) { 'SELECT 1' }
+
   before :all do
     @db = Mysql.new
   end
@@ -15,19 +17,22 @@ describe Mysql do
   describe '#query' do
     it 'works' do
       result = @db.query('SELECT 2')
-      result.fetch_row.should == ['2']
+      expect(result.fetch_row).to eq(['2'])
       result.free
     end
 
     it 'works when given a block' do
       @db.query('SELECT 5') do |result|
-        result.fetch_row.should == ['5']
+        expect(result.fetch_row).to eq(['5'])
       end
     end
 
-    it 'calls SqlTagger#tag' do
-      @db.sql_tagger.should_receive(:tag).and_return('/* something.rb */ SELECT 1')
-      @db.query('SELECT 1').free
+    it 'passes a tagged query to the original method' do
+      allow(@db.sql_tagger).to receive(:tag).with(query).
+        and_return("/* something.rb */ #{query}")
+      expect(@db).to receive(:query_without_sql_tagger).
+        with("/* something.rb */ #{query}")
+      @db.query(query)
     end
   end
 
@@ -35,14 +40,17 @@ describe Mysql do
     it 'works' do
       stmt = @db.prepare('SELECT ?')
       stmt.execute(9)
-      stmt.fetch.should == ['9']
+      expect(stmt.fetch).to eq(['9'])
       stmt.free_result
       stmt.close
     end
 
-    it 'calls SqlTagger#tag' do
-      @db.sql_tagger.should_receive(:tag).and_return('/* something.rb */ SELECT 1')
-      @db.prepare('SELECT 1').close
+    it 'passes a tagged query to the original method' do
+      allow(@db.sql_tagger).to receive(:tag).with(query).
+        and_return("/* something.rb */ #{query}")
+      expect(@db).to receive(:prepare_without_sql_tagger).
+        with("/* something.rb */ #{query}")
+      @db.prepare(query)
     end
   end
 end

data/spec/sql_tagger/pg_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+require 'sql_tagger/pg'
+
+RSpec.describe PG::Connection do
+  let(:query) { 'SELECT 1 AS num' }
+
+  before :context do
+    @db = PG.connect(dbname: 'postgres')
+  end
+
+  after :context do
+    @db.finish
+  end
+
+  it_should_behave_like 'connections with sql_tagger'
+
+  [
+    :async_exec,
+    :async_query,
+    :exec,
+    :exec_params,
+    :query,
+    :send_query,
+  ].each do |method|
+    describe "##{method}" do
+      it 'works' do
+        result = @db.__send__(method, query)
+        if method == :send_query
+          result = @db.get_last_result
+        end
+        expect(result.to_a).to eq([{'num' => '1'}])
+      end
+
+      it 'passes a tagged query to the original method' do
+        allow(@db.sql_tagger).to receive(:tag).with(query).
+          and_return("/* something.rb */ #{query}")
+        expect(@db).to receive("#{method}_without_sql_tagger").
+          with("/* something.rb */ #{query}")
+        @db.__send__(method, query)
+      end
+    end
+  end
+
+  [:prepare, :send_prepare].each do |method|
+    describe "##{method}" do
+      it 'works' do
+        statement_name = "#{method}_test_works"
+        @db.__send__(method, statement_name, query)
+        result = @db.exec_prepared(statement_name)
+        expect(result.to_a).to eq([{'num' => '1'}])
+      end
+
+      it 'passes a tagged query to the original method' do
+        statement_name = "#{method}_test_calls"
+        allow(@db.sql_tagger).to receive(:tag).with(query).
+          and_return("/* something.rb */ #{query}")
+        expect(@db).to receive("#{method}_without_sql_tagger").
+          with(statement_name, "/* something.rb */ #{query}")
+        @db.__send__(method, statement_name, query)
+      end
+    end
+  end
+end

data/spec/sql_tagger_spec.rb

@@ -1,74 +1,99 @@
 require 'sql_tagger'
 
-describe SqlTagger do
-  before :each do
-    @sql_tagger = SqlTagger.new
-  end
+RSpec.describe SqlTagger do
+  subject(:sql_tagger) { SqlTagger.new }
 
   describe '#tag' do
-    before :each do
-      prefix = '/usr'
-      @sql_tagger.exclusion_pattern = /^#{prefix}/
-
-      @stack_strings_to_skip = [
-        "#{prefix}/lib//gems/activerecord-2.3.5/lib/active_record/base.rb:500",
-        "#{prefix}//gems/actionpack-2.3.5/lib/something.rb:20",
+    let(:prefix) { '/usr' }
+    let(:stack_strings_to_skip) do
+      [
+        "#{prefix}/lib/gems/activerecord-2.3.5/lib/active_record/base.rb:500",
+        "#{prefix}/gems/actionpack-2.3.5/lib/something.rb:20",
       ]
-      @valid_stack_string = '/home/app/myapp/lib/user.rb:150'
-      @caller_result = @stack_strings_to_skip + [@valid_stack_string]
-      @sql_tagger.stub!(:caller => @caller_result)
+    end
+    let(:valid_stack_string) { '/home/app/myapp/lib/user.rb:150' }
+    let(:caller_result) { stack_strings_to_skip + [valid_stack_string] }
+    let(:sql) { 'SELECT 1' }
 
-      @sql = 'SELECT 1'
+    before :each do
+      sql_tagger.exclusion_pattern = /^#{prefix}/
+      allow(sql_tagger).to receive(:caller).and_return(caller_result)
     end
 
     it 'skips stack strings that match @exclusion_pattern' do
-      @sql_tagger.tag(@sql).should == "/* #{@valid_stack_string} */ #{@sql}"
+      expect(sql_tagger.tag(sql)).to eq("/* #{valid_stack_string} */ #{sql}")
     end
 
     it 'returns the 1st stack string that does not match @exclusion_pattern' do
-      @caller_result.push(
+      caller_result.push(
         '/home/app/myapp/lib/document.rb:788',
         '/home/app/myapp/runner.rb:29'
       )
-      @sql_tagger.tag(@sql).should == "/* #{@valid_stack_string} */ #{@sql}"
+      expect(sql_tagger.tag(sql)).to eq("/* #{valid_stack_string} */ #{sql}")
     end
 
     it 'adds skipped stack strings into @exclusion_cache' do
-      @sql_tagger.exclusion_cache.should be_empty
-      @sql_tagger.tag(@sql)
-      @stack_strings_to_skip.each do |string|
-        @sql_tagger.exclusion_cache.should include(string)
+      expect(sql_tagger.exclusion_cache).to be_empty
+      sql_tagger.tag(sql)
+      stack_strings_to_skip.each do |string|
+        expect(sql_tagger.exclusion_cache).to include(string)
       end
-      @sql_tagger.exclusion_cache.size.should == @stack_strings_to_skip.length
+      expect(sql_tagger.exclusion_cache.size).to eq(stack_strings_to_skip.length)
     end
 
     it 'skips strings in @exclusion_cache' do
       correct_string = '/home/myapp/i.rb:2890'
-      @caller_result.push(correct_string)
-      @sql_tagger.exclusion_cache.add(@valid_stack_string)
-      @sql_tagger.tag(@sql).should == "/* #{correct_string} */ #{@sql}"
+      caller_result.push(correct_string)
+      sql_tagger.exclusion_cache.add(valid_stack_string)
+      expect(sql_tagger.tag(sql)).to eq("/* #{correct_string} */ #{sql}")
     end
   end
 
   describe '#exclusion_pattern=' do
     it 'sets @exclusion_pattern' do
-      @sql_tagger.exclusion_pattern = /regexp/
-      @sql_tagger.exclusion_pattern.should == /regexp/
+      sql_tagger.exclusion_pattern = /regexp/
+      expect(sql_tagger.exclusion_pattern).to eq(/regexp/)
     end
 
     it 'clears @exclusion_cache' do
-      @sql_tagger.exclusion_cache.merge(['/usr', '/opt'])
-      @sql_tagger.exclusion_pattern = /regexp/
-      @sql_tagger.exclusion_cache.should be_empty
+      sql_tagger.exclusion_cache.merge(['/usr', '/opt'])
+      sql_tagger.exclusion_pattern = /regexp/
+      expect(sql_tagger.exclusion_cache).to be_empty
     end
   end
 
   describe '.default' do
     it 'returns a functional SqlTagger' do
-      SqlTagger.default.should be_a(SqlTagger)
+      expect(SqlTagger.default).to be_a(SqlTagger)
       # The following is to ensure that SqlTagger.default is set after
       # #initialize is defined.
-      SqlTagger.default.exclusion_pattern.should be_a(Regexp)
+      expect(SqlTagger.default.exclusion_pattern).to be_a(Regexp)
+    end
+  end
+
+  describe SqlTagger::ModuleMethods do
+    describe '#included' do
+      let(:adapter_class) do
+        Module.new do
+          extend SqlTagger::ModuleMethods
+
+          def foo_with_sql_tagger; end
+
+          def bar_with_sql_tagger; end
+        end
+      end
+
+      let(:receiver_class) do
+        Class.new do
+          def foo; end
+        end
+      end
+
+      it 'does not fail for methods that do not exist on the receiver' do
+        expect {
+          receiver_class.send(:include, adapter_class)
+        }.not_to raise_error
+      end
     end
   end
 end

data/sql_tagger.gemspec

@@ -5,12 +5,16 @@ Gem::Specification.new do |s|
   s.homepage = 'https://github.com/SlideShareInc/sql_tagger'
   s.summary = 'Stack trace comments for SQL queries'
   s.description = 'sql_tagger inserts stack trace comments into SQL queries.'
+  s.license = 'MIT'
 
-  s.add_development_dependency('rspec')
+  s.add_development_dependency('rspec', '~> 3.4')
+
+  s.add_development_dependency('appraisal', '~> 2.1.0')
   s.add_development_dependency('mysql')
   s.add_development_dependency('mysql2')
+  s.add_development_dependency('pg')
 
-  s.files = ['MIT-LICENSE', 'README.rdoc', 'VERSION', 'sql_tagger.gemspec'] +
+  s.files = ['MIT-LICENSE', 'README.md', 'VERSION', 'sql_tagger.gemspec'] +
     Dir.glob('lib/**/*')
 
   s.test_files = Dir.glob('spec/**/*')

metadata

@@ -1,121 +1,132 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: sql_tagger
-version: !ruby/object:Gem::Version 
-  hash: 25
-  prerelease: false
-  segments: 
-  - 0
-  - 0
-  - 3
-  version: 0.0.3
+version: !ruby/object:Gem::Version
+  version: 0.0.4
 platform: ruby
-authors: 
+authors:
 - Toby Hsieh
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2013-07-11 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2016-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
   prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: appraisal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
   type: :development
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: mysql
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: mysql
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
   name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 description: sql_tagger inserts stack trace comments into SQL queries.
 email: 
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - MIT-LICENSE
-- README.rdoc
+- README.md
 - VERSION
 - sql_tagger.gemspec
 - lib/sql_tagger/mysql.rb
 - lib/sql_tagger/mysql2.rb
+- lib/sql_tagger/pg.rb
 - lib/sql_tagger.rb
 - spec/spec_helper.rb
 - spec/sql_tagger/mysql2_spec.rb
 - spec/sql_tagger/mysql_spec.rb
+- spec/sql_tagger/pg_spec.rb
 - spec/sql_tagger_spec.rb
-has_rdoc: true
 homepage: https://github.com/SlideShareInc/sql_tagger
-licenses: []
-
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.3.7
+rubygems_version: 2.0.14.1
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Stack trace comments for SQL queries
-test_files: 
+test_files:
 - spec/spec_helper.rb
 - spec/sql_tagger/mysql2_spec.rb
 - spec/sql_tagger/mysql_spec.rb
+- spec/sql_tagger/pg_spec.rb
 - spec/sql_tagger_spec.rb
+has_rdoc: 

data/README.rdoc

@@ -1,14 +0,0 @@
-= sql_tagger
-
-+sql_tagger+ is a gem that inserts comments into SQL queries. These comments
-include a string from <tt>Kernel#caller</tt> that (hopefully) reveals what Ruby
-code was responsible for performing the query.
-
-To use this, just require the appropriate file. For example, to use this with
-the +mysql+ gem, perform <tt>require 'sql_tagger/mysql'</tt> instead of
-<tt>require 'mysql'</tt>.
-
-Before:
-    SELECT 1
-After:
-    /* program.rb:25:in `some_method' */ SELECT 1