each_sql 0.2.4 → 0.2.5

data/{CHANGELOG.rdoc → CHANGELOG.markdown}

@@ -1,19 +1,27 @@
-=== 0.2.4 / 2011/08/04
+### 0.2.5 / 2011/09/01
+* Can pass block directly to EachSQL(script)
+```ruby
+EachSQL(script) do |sql|
+  # ...
+end
+```
+
+### 0.2.4 / 2011/08/04
 * Bug fix: Strip semicolons at both ends
 
-=== 0.2.3 / 2011/07/08
+### 0.2.3 / 2011/07/08
 * Bug fix: Two Oracle PL/SQL parsing errors fixed
 
-=== 0.2.2 / 2011/06/21
+### 0.2.2 / 2011/06/21
 * Bug fix: Error on nil/empty input
 
-=== 0.2.1 / 2011/06/20
+### 0.2.1 / 2011/06/20
 * Fixed invalid gem packaging
 
-=== 0.2.0 / 2011/06/17
+### 0.2.0 / 2011/06/17
 * Second release. Handles more cases.
 * Ruby 1.8 compatible
 
-=== 0.1.0 / 2011/06/15
+### 0.1.0 / 2011/06/15
 * Initial release. Turned out to be very flawed :p
 

data/Gemfile.lock

@@ -2,13 +2,13 @@ GEM
   remote: http://rubygems.org/
   specs:
     git (1.2.5)
-    jeweler (1.6.2)
+    jeweler (1.6.4)
       bundler (~> 1.0)
       git (>= 1.2.5)
       rake
-    rake (0.8.7)
-    rcov (0.9.9)
-    rcov (0.9.9-java)
+    rake (0.9.2)
+    rcov (0.9.10)
+    rcov (0.9.10-java)
 
 PLATFORMS
   java

data/{README.rdoc → README.markdown}

@@ -1,39 +1,50 @@
-= each_sql
+# each_sql
 
 Enumerate each SQL statement in the given SQL script.
 
-== Installation
- gem install 'each_sql'
-
-== Example
-=== Basic
-  require 'each_sql'
- 
-  EachSQL(sql_script).each do |sql|
-    puts sql
-  end
- 
-  sqls = EachSQL(sql_script).to_a
-
-=== For scripts containing vendor-specific syntax
-  # For MySQL script
-  EachSQL(mysql_script, :mysql).each do |sql|
-    # ...
-  end
-
-  # For Oracle PL/SQL scripts
-  EachSQL(plsql_script, :oracle).each do |sql|
-    # ...
-  end
-
-== TODO
+## Installation
+```
+gem install 'each_sql'
+```
+
+## Example
+### Basic
+```ruby
+require 'each_sql'
+
+EachSQL(sql_script).each do |sql|
+  puts sql
+end
+
+# .each can be omitted
+EachSQL(sql_script) do |sql|
+  puts sql
+end
+
+sqls = EachSQL(sql_script).to_a
+```
+
+### For scripts containing vendor-specific syntax
+```ruby
+# For MySQL script
+EachSQL(mysql_script, :mysql).each do |sql|
+  # ...
+end
+
+# For Oracle PL/SQL scripts
+EachSQL(plsql_script, :oracle).each do |sql|
+  # ...
+end
+```
+
+## TODO
 - More/better tests.
 - pgplsql support.
 
-== Warning
+## Warning
 Stored procedure handling is at best incomplete. Use it at your own risk.
 
-== Contributing to each_sql
+## Contributing to each_sql
  
 * Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
 * Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
@@ -43,7 +54,7 @@ Stored procedure handling is at best incomplete. Use it at your own risk.
 * Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
 * Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
 
-== Copyright
+## Copyright
 
 Copyright (c) 2011 Junegunn Choi. See LICENSE.txt for
 further details.

data/VERSION

@@ -1 +1 @@
-0.2.4
+0.2.5

data/lib/each_sql/each_sql.rb

@@ -3,171 +3,171 @@
 
 # Enumerable EachSQL object.
 class EachSQL
-	include Enumerable
-
-	def initialize input, options
-		raise NotImplementedError.new if options.nil?
-		# immutables
-		@org_input = input && input.sub(/\A#{[65279].pack('U*')}/, '') # BOM
-		@options = options
-		@blocks = @options[:blocks]
-		@nblocks = @options[:nesting_blocks]
-		@all_blocks = @blocks.merge @nblocks
-	end
-
-	def each
-		return nil if @org_input.nil? || @org_input.empty?
-		@input = @org_input.dup
-
-		# Zero out comments and string literals to simplify subsequent parsing
-		@input_c = zero_out @org_input
-
-		@delimiter = @options[:delimiter]
-		while @input && @input.length > 0
-			# Extract a statement
-			statement = next_statement
-
-			# When a non-empty statement is found
-			statement = @options[:strip_delimiter].call self, statement if @options[:strip_delimiter]
-			if statement.length > 0
-				# Apply replacements
-				@options[:replace].each do |k, v|
-					statement.gsub!(k, v)
-				end
-				statement.strip!
-
-				# Process callbacks
-				@options[:callbacks].each do |pattern, callback|
-					#md = statement.match pattern
-					md = zero_out(statement).strip.match pattern
-					callback.call self, statement, md if md
-				end
-
-				# Ignore
-				if (@options[:ignore] || []).all? { |ipat| statement !~ ipat } && statement.empty? == false
-					yield statement
-					@prev_statement = statement
-				end
-			end
-		end
-		nil
-	end
-
-	# To change delimiter while parsing the input
-	attr_accessor :delimiter, :delimiter_string
-
-private
-	def zero_out input
-		output = input.dup
-		idx = 0
-		# Look for the closest block
-		while true
-			block_start, opener_length, opener, closer = @blocks.map { |opener, closer|
-				md = match output, opener, idx
-				[md && md[:begin], md && md[:length], opener, closer]
-			}.reject { |e| e.first.nil? }.min_by(&:first)
-			break if block_start.nil?
-
-			md = match output, closer, block_start + opener_length
-			idx = block_end = md ? md[:end] : (output.length-1)
-
-			output[block_start...block_end] = ' ' * (block_end - block_start)
-		end
-		output
-	end
-
-	def next_statement
-		@cur = 0
-
-		while process_next_block != :done
-		end
-
-		ret = @input[0...@cur].strip
-		@input   =   @input[@cur..-1]
-		@input_c = @input_c[@cur..-1]
-		return ret
-	end
-
-	def process_next_block expect = nil
-		# Look for the closest delimiter
-		md = match @input_c, @delimiter, @cur
-		delim_start = md ? md[:begin] : @input.length
-		delim_end   = md ? md[:end]   : @input.length
-
-		# Look for the closest block depending on the current context
-		target_blocks = 
-			if @options[:nesting_context].any? {|pat| @input_c.match pat }
-				@all_blocks
-			else
-				@blocks
-			end
-
-		block_start, body_start, opener, closer = target_blocks.map { |opener, closer|
-			closer = closer[:closer] if closer.is_a? Hash
-			md = match @input_c, opener, @cur
-			[md && md[:begin], md && md[:end], opener, closer]
-		}.reject { |e| e.first.nil? }.min_by(&:first)
-
-		# If we're nested, look for the parent's closer as well
-		if expect && (md = match @input_c, expect, @cur) &&
-				(block_start.nil? || md[:begin] < block_start)
-
-			@cur = md[:end]
-			return :nest_closer
-		end
-	
-		# No block until the next delimiter
-		if block_start.nil? || block_start > delim_start
-			@cur = delim_end
-			return :done
-		end
-
-		# We found a block. Look for the end of it
-		@cur = body_start
-
-		# If nesting block, we go deeper
-		if @nblocks.keys.include? opener
-			while true
-				ret = process_next_block(closer)
-				break if ret == :nest_closer
-				throw_exception(closer) if @cur >= @input.length - 1
-			end
-			return :done if @nblocks[opener].is_a?(Hash) && @nblocks[opener][:pop]
-
-		# If non-nesting block, just skip through it
-		else
-			skip_through_block closer
-		end
-
-		return :continue
-	end
-
-	# For Ruby 1.8 compatibility
-	def match str, pat, idx
-		md = str[idx..-1].match(pat)
-		return nil if md.nil?
-
-		result = {
-			:begin => md && (md.begin(0) + idx),
-			:length => md && md[0].length,
-			:end => md && (md.end(0) + idx)
-		}
-		result
-	end
-
-	def skip_through_block closer
-		md = match @input_c, closer, @cur
-		throw_exception(closer) if md.nil?
-
-		@cur = md[:end]
-	end
-
-	def throw_exception closer
-		raise ArgumentError.new(
-				"Unclosed block: was expecting #{closer.inspect} " +
-				"while processing #{(@input[0, 60] + ' ... ').inspect}" + 
-				(@prev_statement ?
-					" after #{@prev_statement.inspect}" : ""))
-	end
+  include Enumerable
+
+  def initialize input, options
+    raise NotImplementedError.new if options.nil?
+    # immutables
+    @org_input = input && input.sub(/\A#{[65279].pack('U*')}/, '') # BOM
+    @options = options
+    @blocks = @options[:blocks]
+    @nblocks = @options[:nesting_blocks]
+    @all_blocks = @blocks.merge @nblocks
+  end
+
+  def each
+    return nil if @org_input.nil? || @org_input.empty?
+    @input = @org_input.dup
+
+    # Zero out comments and string literals to simplify subsequent parsing
+    @input_c = zero_out @org_input
+
+    @delimiter = @options[:delimiter]
+    while @input && @input.length > 0
+      # Extract a statement
+      statement = next_statement
+
+      # When a non-empty statement is found
+      statement = @options[:strip_delimiter].call self, statement if @options[:strip_delimiter]
+      if statement.length > 0
+        # Apply replacements
+        @options[:replace].each do |k, v|
+          statement.gsub!(k, v)
+        end
+        statement.strip!
+
+        # Process callbacks
+        @options[:callbacks].each do |pattern, callback|
+          #md = statement.match pattern
+          md = zero_out(statement).strip.match pattern
+          callback.call self, statement, md if md
+        end
+
+        # Ignore
+        if (@options[:ignore] || []).all? { |ipat| statement !~ ipat } && statement.empty? == false
+          yield statement
+          @prev_statement = statement
+        end
+      end
+    end
+    nil
+  end
+
+  # To change delimiter while parsing the input
+  attr_accessor :delimiter, :delimiter_string
+
+  private
+  def zero_out input
+    output = input.dup
+    idx = 0
+    # Look for the closest block
+    while true
+      block_start, opener_length, opener, closer = @blocks.map { |opener, closer|
+        md = match output, opener, idx
+        [md && md[:begin], md && md[:length], opener, closer]
+      }.reject { |e| e.first.nil? }.min_by(&:first)
+      break if block_start.nil?
+
+      md = match output, closer, block_start + opener_length
+      idx = block_end = md ? md[:end] : (output.length-1)
+
+      output[block_start...block_end] = ' ' * (block_end - block_start)
+    end
+    output
+  end
+
+  def next_statement
+    @cur = 0
+
+    while process_next_block != :done
+    end
+
+    ret = @input[0...@cur].strip
+    @input   =   @input[@cur..-1]
+    @input_c = @input_c[@cur..-1]
+    return ret
+  end
+
+  def process_next_block expect = nil
+    # Look for the closest delimiter
+    md = match @input_c, @delimiter, @cur
+    delim_start = md ? md[:begin] : @input.length
+    delim_end   = md ? md[:end]   : @input.length
+
+    # Look for the closest block depending on the current context
+    target_blocks = 
+      if @options[:nesting_context].any? {|pat| @input_c.match pat }
+        @all_blocks
+      else
+        @blocks
+      end
+
+    block_start, body_start, opener, closer = target_blocks.map { |opener, closer|
+      closer = closer[:closer] if closer.is_a? Hash
+      md = match @input_c, opener, @cur
+      [md && md[:begin], md && md[:end], opener, closer]
+    }.reject { |e| e.first.nil? }.min_by(&:first)
+
+    # If we're nested, look for the parent's closer as well
+    if expect && (md = match @input_c, expect, @cur) &&
+      (block_start.nil? || md[:begin] < block_start)
+
+      @cur = md[:end]
+      return :nest_closer
+    end
+
+    # No block until the next delimiter
+    if block_start.nil? || block_start > delim_start
+      @cur = delim_end
+      return :done
+    end
+
+    # We found a block. Look for the end of it
+    @cur = body_start
+
+    # If nesting block, we go deeper
+    if @nblocks.keys.include? opener
+      while true
+        ret = process_next_block(closer)
+        break if ret == :nest_closer
+        throw_exception(closer) if @cur >= @input.length - 1
+      end
+      return :done if @nblocks[opener].is_a?(Hash) && @nblocks[opener][:pop]
+
+      # If non-nesting block, just skip through it
+    else
+      skip_through_block closer
+    end
+
+    return :continue
+  end
+
+  # For Ruby 1.8 compatibility
+  def match str, pat, idx
+    md = str[idx..-1].match(pat)
+    return nil if md.nil?
+
+    result = {
+      :begin => md && (md.begin(0) + idx),
+      :length => md && md[0].length,
+      :end => md && (md.end(0) + idx)
+    }
+    result
+  end
+
+  def skip_through_block closer
+    md = match @input_c, closer, @cur
+    throw_exception(closer) if md.nil?
+
+    @cur = md[:end]
+  end
+
+  def throw_exception closer
+    raise ArgumentError.new(
+      "Unclosed block: was expecting #{closer.inspect} " +
+      "while processing #{(@input[0, 60] + ' ... ').inspect}" + 
+      (@prev_statement ?
+       " after #{@prev_statement.inspect}" : ""))
+  end
 end#EachSQL
 

data/lib/each_sql.rb

@@ -8,111 +8,119 @@ require 'each_sql/each_sql'
 # @param[Symbol] The type of the input SQL script. :default, :mysql, and :oracle (or :plsql)
 # @return[EachSQL] Enumerable 
 def EachSQL input, type = :default
-	EachSQL.new(input, EachSQL::Defaults[type])
+  esql = EachSQL.new(input, EachSQL::Defaults[type])
+
+  if block_given?
+    esql.each do |sql|
+      yield sql
+    end
+  else
+    esql
+  end
 end
 
 class EachSQL
-	# EachSQL::Default Hash is a set of pre-defined parsing rules
-	# - :default: Default parsing rules for vendor-independent SQL scripts
-	# - :mysql:   Parsing rules for MySQL scripts. Understands `delimiter' statements.
-	# - :oracle:  Parsing rules for Oracle scripts. Removes trailing slashes after begin-end blocks.
-	Defaults = {
-		:default => {
-			:delimiter => /;+/,
-			:blocks => {
-				/`/          => /`/,
-				/"/          => /"/,
-				/'/          => /'/,
-				/\/\*[^+]/   => /\*\//,
-				/--+/        => $/,
-			},
-			:nesting_blocks => {
-				/\bdeclare.*?;\s*?begin\b/im => /;\s*?end\b/i,
-				/\bbegin\b/i => /;\s*?end\b/i,
-			},
-			:nesting_context => [
-				/\A\s*(begin|declare|create\b[^;]+?\b(procedure|function|trigger|package))\b/im
-			],
-			:callbacks => {},
-			:ignore    => [],
-			:replace   => {},
-			# Let's assume we don't change delimiters within usual sql scripts
-			:strip_delimiter => lambda { |obj, stmt| stmt.sub(/\A;+/, '').sub(/;+\Z/, '') }
-		},
+  # EachSQL::Default Hash is a set of pre-defined parsing rules
+  # - :default: Default parsing rules for vendor-independent SQL scripts
+  # - :mysql:   Parsing rules for MySQL scripts. Understands `delimiter' statements.
+  # - :oracle:  Parsing rules for Oracle scripts. Removes trailing slashes after begin-end blocks.
+  Defaults = {
+    :default => {
+    :delimiter => /;+/,
+    :blocks => {
+      /`/          => /`/,
+      /"/          => /"/,
+      /'/          => /'/,
+      /\/\*[^+]/   => /\*\//,
+      /--+/        => $/,
+    },
+    :nesting_blocks => {
+      /\bdeclare.*?;\s*?begin\b/im => /;\s*?end\b/i,
+      /\bbegin\b/i => /;\s*?end\b/i,
+    },
+    :nesting_context => [
+      /\A\s*(begin|declare|create\b[^;]+?\b(procedure|function|trigger|package))\b/im
+    ],
+      :callbacks => {},
+      :ignore    => [],
+      :replace   => {},
+      # Let's assume we don't change delimiters within usual sql scripts
+      :strip_delimiter => lambda { |obj, stmt| stmt.sub(/\A;+/, '').sub(/;+\Z/, '') }
+    },
 
-		:mysql => {
-			:delimiter => /;+|delimiter\s+\S+/i,
-			:blocks => {
-				/`/          => /`/,
-				/"/          => /"/,
-				/'/          => /'/,
-				/\/\*[^+]/   => /\*\//,
-				/--+/        => $/,
-			},
-			:nesting_blocks => {
-				/\bbegin\b/i => /\bend\b/i
-			},
-			:nesting_context => [
-				/\A\s*(begin|create\b[^;]+?\b(procedure|function|trigger))\b/im
-			],
-			# We need to change delimiter on `delimiter' command
-			:callbacks => {
-				/^\s*delimiter\s+(\S+)/i => lambda { |obj, stmt, md|
-					new_delimiter = Regexp.new(Regexp.escape md[1])
-					obj.delimiter = /(#{new_delimiter})+|delimiter\s+\S+/i
-					obj.delimiter_string = md[1]
-				}
-			},
-			:ignore => [
-				/^delimiter\s+\S+$/i
-			],
-			:replace => {},
-			:strip_delimiter => lambda { |obj, stmt|
-				stmt.gsub(/(#{Regexp.escape(obj.delimiter_string || ';')})+\Z/, '')
-			}
-		},
+    :mysql => {
+      :delimiter => /;+|delimiter\s+\S+/i,
+      :blocks => {
+        /`/          => /`/,
+        /"/          => /"/,
+        /'/          => /'/,
+        /\/\*[^+]/   => /\*\//,
+        /--+/        => $/,
+      },
+      :nesting_blocks => {
+        /\bbegin\b/i => /\bend\b/i
+      },
+      :nesting_context => [
+          /\A\s*(begin|create\b[^;]+?\b(procedure|function|trigger))\b/im
+      ],
+      # We need to change delimiter on `delimiter' command
+      :callbacks => {
+        /^\s*delimiter\s+(\S+)/i => lambda { |obj, stmt, md|
+          new_delimiter = Regexp.new(Regexp.escape md[1])
+          obj.delimiter = /(#{new_delimiter})+|delimiter\s+\S+/i
+          obj.delimiter_string = md[1]
+        }
+      },
+      :ignore => [
+        /^delimiter\s+\S+$/i
+      ],
+        :replace => {},
+        :strip_delimiter => lambda { |obj, stmt|
+        stmt.gsub(/(#{Regexp.escape(obj.delimiter_string || ';')})+\Z/, '')
+      }
+    },
 
-		:oracle => {
-			:delimiter => /;+/,
-			:blocks => {
-				/`/          => /`/,
-				/"/          => /"/,
-				/'/          => /'/,
-				/\/\*[^+]/   => /\*\//,
-				/--+/        => $/,
-			},
-			:nesting_blocks => {
-				/\bbegin\b/i => /\bend\b/i,
-				/\bdeclare.*?;\s*?begin\b/im => {
-					:closer => %r{;\s*/}m,
-					# Stops immediately
-					:pop => true
-				},
-				/\bcreate[^;]+?\b(procedure|function|trigger|package)\b/im => {
-					:closer => %r{;\s*/}m,
-					# Stops immediately
-					:pop => true
-				}
-			},
-			:nesting_context => [
-				/\A\s*(\/\s*)*(begin|declare|create\b[^;]+?\b(procedure|function|trigger|package))\b/im
-			],
-			:callbacks => {
-				/\Abegin\b/ => lambda { |obj, stmt, md|
-					# Oracle needs this
-					stmt << ';' if stmt !~ /;\Z/
-				}
-			},
-			:ignore => [],
-			:replace => { %r[\A/] => '' },
-			:strip_delimiter => lambda { |obj, stmt|
-				stmt.gsub(/(#{stmt =~ /;\s*\// ? '/' : ';'})+\Z/, '')
-			}
-		}
-	}
-	Defaults[:plsql] = Defaults[:oracle] # alias
+    :oracle => {
+      :delimiter => /;+/,
+      :blocks => {
+        /`/          => /`/,
+        /"/          => /"/,
+        /'/          => /'/,
+        /\/\*[^+]/   => /\*\//,
+        /--+/        => $/,
+      },
+      :nesting_blocks => {
+        /\bbegin\b/i => /\bend\b/i,
+        /\bdeclare.*?;\s*?begin\b/im => {
+        :closer => %r{;\s*/}m,
+        # Stops immediately
+        :pop => true
+        },
+        /\bcreate[^;]+?\b(procedure|function|trigger|package)\b/im => {
+          :closer => %r{;\s*/}m,
+          # Stops immediately
+          :pop => true
+        }
+      },
+      :nesting_context => [
+        /\A\s*(\/\s*)*(begin|declare|create\b[^;]+?\b(procedure|function|trigger|package))\b/im
+      ],
+        :callbacks => {
+        /\Abegin\b/ => lambda { |obj, stmt, md|
+         # Oracle needs this
+         stmt << ';' if stmt !~ /;\Z/
+        }
+      },
+      :ignore => [],
+      :replace => { %r[\A/] => '' },
+      :strip_delimiter => lambda { |obj, stmt|
+        stmt.gsub(/(#{stmt =~ /;\s*\// ? '/' : ';'})+\Z/, '')
+      }
+    }
+  }
+  Defaults[:plsql] = Defaults[:oracle] # alias
 
-	# Freeze the Hash
-	Defaults.freeze
+  # Freeze the Hash
+  Defaults.freeze
 end
 

data/test/test_each_sql.rb

@@ -251,6 +251,15 @@ select
 			EachSQL(input).each do |sql|
 				assert false, 'Should not enumerate'
 			end
+
+			EachSQL(input) do |sql|
+				assert false, 'Should not enumerate'
+			end
+
+      # Directly pass block
+			EachSQL(input) do |sql|
+				assert false, 'Should not enumerate'
+			end
 			assert true, 'No error expected'
 		end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: each_sql
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-08-04 00:00:00.000000000Z
+date: 2011-09-01 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &2154603460 !ruby/object:Gem::Requirement
+  requirement: &2158654040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *2154603460
+  version_requirements: *2158654040
 - !ruby/object:Gem::Dependency
   name: jeweler
-  requirement: &2154602960 !ruby/object:Gem::Requirement
+  requirement: &2158648740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 1.6.2
   type: :development
   prerelease: false
-  version_requirements: *2154602960
+  version_requirements: *2158648740
 - !ruby/object:Gem::Dependency
   name: rcov
-  requirement: &2154602480 !ruby/object:Gem::Requirement
+  requirement: &2158647840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,21 +43,21 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2154602480
+  version_requirements: *2158647840
 description: Enumerate each SQL statement in SQL scripts.
 email: junegunn.c@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files:
 - LICENSE.txt
-- README.rdoc
+- README.markdown
 files:
 - .document
-- CHANGELOG.rdoc
+- CHANGELOG.markdown
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.markdown
 - Rakefile
 - VERSION
 - each_sql.gemspec
@@ -81,7 +81,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -2701967104175695105
+      hash: -794086544638494383
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -90,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.5
+rubygems_version: 1.8.6
 signing_key: 
 specification_version: 3
 summary: Enumerate each SQL statement in SQL scripts.