sqltorial 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc641ec92204199a0c354f413f381b544a4fc0f1
+  data.tar.gz: c42caec90a3cefc4a6c6273f99699fae636ed492
+SHA512:
+  metadata.gz: 61f3145d3f3cbf346b9f88370bda5ab9fef7ad083340f562d4fde4ec16a2eda5cb64373f391a6162a253e8947da9bc91dd3fd173dc84ac160ba94e3364fc19cc
+  data.tar.gz: 01d990718cf2c72b49cec7ac9f308c8e0722beeb71125818e2f1f4abba06bc1d37f5f713a071bdfa8893de34209aec7e81ab0332a356a8cfae2094a3c0a69b0b

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+examples/.cache

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.2

data/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+## Unreleased
+
+### Added
+- Nothing.
+
+### Deprecated
+- Nothing.
+
+### Removed
+- Nothing.
+
+### Fixed
+- Nothing.
+
+## 0.0.1 - 2015-08-21
+
+### Added
+- The project itself
+
+### Deprecated
+- Nothing.
+
+### Removed
+- Nothing.
+
+### Fixed
+- Nothing.

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sqltorial.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Outcomes Insights, Inc.
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,71 @@
+# SQLtorial
+
+Create your own SQL Tutorials with SQLtorial.
+
+
+## Motivation
+
+SQLtorial is a gem I cooked up because I was frequently demonstrating how to write certain queries or how to explore data in certain databases.  Generally, I wanted each example SQL statement to have a bit of explanation about how it works or what I’m looking for, followed by the query itself, followed by the results that SQL statement generated.
+
+So I decided to write SQLtorial, a command that will process all files ending in \*.sql and generate a Markdown document with all the examples concatenated together.
+
+The gem will process each .sql statement in the following manner:
+- The first line is considered the title for the entire example
+- Comments placed above a SQL query will be run through a Markdown formatter and placed as formatted text before the SQL query
+- SQL queries must end with a ;
+- SQL queries are run through [pgFormatter](https://github.com/darold/pgFormatter) to create a consistent presentation for queries
+- Results from the query are shown in a table after the query.  Only the first ten results are shown.
+
+See the examples directory.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'sqltorial'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install sqltorial
+
+## Usage
+
+Create a directory for your SQL examples.  Create at least one file ending with `.sql` and add comments and example queries as you see fit.
+
+When you are ready to execute your examples against a database and compile the examples into a markdown file, create a configuration file following the instructions in the [sequelizer](https://github.com/outcomesinsights/sequelizer) README.
+
+Once your sequelizer configuration is set up, run
+
+    $ bundle exec sqltorial
+
+The `sqltorial` command will convert each `.sql` file into a markdown and concatenate the files into a single markdown file called `output.md`
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/outcomesinsights/sqltorial/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+## Thanks
+
+- [Outcomes Insights, Inc.](http://outins.com)
+    - Many thanks for allowing me to release a portion of my work as Open Source Software!
+- [knitr](http://yihui.name/knitr/)
+    - Thanks for the inspiration!
+
+## License
+Released under the MIT license, Copyright (c) 2015 Outcomes Insights, Inc.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "sqltorial"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/example_input.sql

@@ -0,0 +1,15 @@
+-- This is the title of the example
+--
+-- And here is the first query
+SELECT 1 as column_header;
+
+-- You can use [Markdown](https://daringfireball.net/projects/markdown/) to:
+--
+-- - Format your comments
+--
+-- - Highlight things in **bold**
+--
+-- - And make lists like this one, though the formatting is a bit odd.  I'm looking into it.
+--
+-- And they'll appear above your next query like this query:
+SELECT 'hey' as some_name_for_column;

data/examples/example_output.md

@@ -0,0 +1,47 @@
+## Example 1: This is the title of the example
+
+
+
+ And here is the first query
+
+**Query 1.1**
+
+```sql
+SELECT
+  1 AS column_header
+;
+```
+
+Found 1 results.
+
+| column_header |
+| ------------------: |
+| 1 |
+
+
+ You can use [Markdown](https://daringfireball.net/projects/markdown/) to:
+
+ - Format your comments
+
+ - Highlight things in **bold**
+
+ - And make lists like this one, though the formatting is a bit odd.  I'm looking into it.
+
+ And they'll appear above your next query like this query:
+
+**Query 1.2**
+
+```sql
+SELECT
+  'hey' AS some_name_for_column
+;
+```
+
+Found 1 results.
+
+| some_name_for_column |
+| :----------------------------- |
+| hey |
+
+
+

data/exe/sqltorial

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+
+require "escort"
+require "bundler/setup"
+require "sqltorial"
+
+Escort::App.create do |app|
+  app.version SQLtorial::VERSION
+  app.summary SQLtorial::SUMMARY
+  app.description SQLtorial::DESCRIPTION
+  app.options do |opts|
+    opts.opt :no_results, "Don't Include Results", short: '-n', long: '--no-results', type: :boolean, default: false
+    opts.opt :output, "Output File", short: '-o', long: '--output', type: :string, default: 'output.md'
+    opts.opt :preface, "Preface File", short: '-p', long: '--preface', type: :string, default: 'preface.md'
+  end
+  app.action do |options, arguments|
+    begin
+      SQLtorial::AssembleCommand.new(options, arguments).execute
+    rescue
+      puts $!.message
+      puts $!.backtrace.join("\n")
+      raise
+    end
+  end
+end

data/lib/sqltorial.rb

@@ -0,0 +1,8 @@
+require "sqltorial/metadata"
+require "sqltorial/assemble_command"
+require "sqltorial/directives/all_directive"
+require "sqltorial/directives/valid_column_directive"
+
+module SQLtorial
+  # Your code goes here...
+end

data/lib/sqltorial/assemble_command.rb

@@ -0,0 +1,40 @@
+require_relative 'sql_to_example'
+require 'sequelizer'
+require 'facets/pathname/chdir'
+
+module SQLtorial
+  class AssembleCommand < ::Escort::ActionCommand::Base
+    include Sequelizer
+    def execute
+      process_dir.chdir do
+        preface = Pathname.new(global_options[:preface]) if global_options[:preface]
+        File.open(global_options[:output], 'w') do |f|
+          f.puts preface.read if preface && preface.exist?
+          examples = files.map.with_index do |file, index|
+            Escort::Logger.output.puts "Examplizing #{file.to_s}"
+            SqlToExample.new(file, db, index + 1).to_str(!global_options[:no_results])
+          end
+          f.puts(examples.join("\n\n"))
+        end
+      end
+    end
+
+    def process_dir
+      @process_dir = path.directory? ? path : Pathname.pwd
+    end
+
+    def path
+      @path ||= Pathname.new(arguments.first || ".")
+    end
+
+    def files
+      path.directory? ? Pathname.glob('*.sql') : files_from_file
+    end
+
+    def files_from_file
+      path.readlines.map(&:chomp!).select { |l| l !~ /^\s*#/ && !l.empty? }.map do |file_name|
+        Pathname.new(file_name)
+      end
+    end
+  end
+end

data/lib/sqltorial/directives/all_directive.rb

@@ -0,0 +1,26 @@
+require_relative "directive"
+
+module SQLtorial
+  class AllDirective
+    REGEXP = /^ DIRECTIVE:\s*ALL/
+    class << self
+      def regexp
+        REGEXP
+      end
+    end
+
+    def initialize(line)
+    end
+
+    def alter(query_to_md)
+      query_to_md.row_limit = nil
+    end
+
+    def inspect
+      "ALL"
+    end
+  end
+  Directive.register(AllDirective)
+end
+
+

data/lib/sqltorial/directives/directive.rb

@@ -0,0 +1,22 @@
+module SQLtorial
+  class Directive
+    class << self
+      def register(directive_klass)
+        (@@directives ||= []) << directive_klass
+      end
+
+      def match(line)
+        @@directives.any? do |directive_klass|
+          directive_klass.regexp.match(line)
+        end
+      end
+
+      def from_line(line)
+        @@directives.each do |directive_klass|
+          return directive_klass.new(line) if directive_klass.regexp.match(line)
+        end
+      end
+    end
+  end
+end
+

data/lib/sqltorial/directives/valid_column_directive.rb

@@ -0,0 +1,22 @@
+module SQLtorial
+  class ValidColumnDirective
+    REGEXP = /^ DIRECTIVE:\s*(\S+)\s+(\S+)\s+(.+)/
+    attr :column, :op, :matcher
+    def initialize(line)
+      _, column, op, matcher = REGEXP.match(line).to_a
+      @column = column.to_sym
+      @op = op
+      @matcher = Regexp.new(matcher)
+    end
+
+    def validate(result)
+      md = matcher.match(result[column])
+      op == '=' ? !md.nil? : md.nil?
+    end
+
+    def inspect
+      [column, op, matcher].join(" ")
+    end
+  end
+  Directive.register(AllDirective)
+end

data/lib/sqltorial/metadata.rb

@@ -0,0 +1,6 @@
+module SQLtorial
+  VERSION = "0.0.1"
+  SUMMARY = %q{Knitr, but for SQL files, sorta}
+  DESCRIPTION = %q{Ingests a set of commented SQL statements, executes them, and dumps the comments, queries, and results into a markdown file}
+  HOMEPAGE = "http://github.com/outcomesinsights/sqltorial"
+end

data/lib/sqltorial/query_cache.rb

@@ -0,0 +1,35 @@
+module SQLtorial
+  class QueryCache
+    attr_reader :query_to_md
+
+    def initialize(query_to_md)
+      @query_to_md = query_to_md
+    end
+
+    def to_md
+      unless cache_file.exist?
+        make_cache_file
+      end
+      cache_file.read
+    end
+
+    def make_cache_file
+      cache_file.dirname.mkpath
+      cache_file.write(query_to_md.get_md)
+    end
+
+    def cache_file
+      @cache_file ||= Pathname.pwd + '.cache' + cache_file_name
+    end
+
+    def cache_file_name
+      @cache_file_name ||= Digest::SHA256.hexdigest("#{input_str}") + ".md"
+    end
+
+    def input_str
+      @input_str ||= %w(query row_limit validation_directives other_directives).inject("") do |s, meth|
+        s + query_to_md.send(meth).inspect
+      end
+    end
+  end
+end

data/lib/sqltorial/query_to_md.rb

@@ -0,0 +1,142 @@
+require_relative 'query_cache'
+
+module SQLtorial
+  class QueryToMD
+    attr :validation_directives, :other_directives
+    attr_accessor :query, :row_limit
+    def initialize(query, directives, row_limit = 10)
+      @query = query
+      @validation_directives, @other_directives = directives.partition { |d| d.respond_to?(:validate) }
+      @row_limit = row_limit
+      @other_directives.each do |directive|
+        directive.alter(self)
+      end
+    end
+
+    def row_limit
+      @row_limit ||= count
+    end
+
+    def to_md
+      cache.to_md
+    end
+
+    def get_md
+      return "**No results found.**" if all.empty?
+      output = []
+      output << "Found #{count} results."
+      if count > row_limit
+        output.last << "  Displaying first #{row_limit}."
+      end
+      output << ""
+      output << tableize(all.first.keys + additional_headers)
+      output << tableize(orientations_for(all))
+      output_rows.each do |row|
+        output << tableize(process(row.values))
+      end
+      output.join("\n") + "\n\n"
+    end
+
+    def count
+      @count ||= query.from_self.count
+    end
+
+    def all
+      @all ||= begin
+        q = query.from_self
+        q = q.limit(row_limit)
+        q.all
+      end
+    end
+
+    def additional_headers
+      validation_directives.empty? ? [] : [:valid_row]
+    end
+
+    def output_rows
+      rows = all[0...row_limit]
+      return rows if validation_directives.empty?
+
+      rows.map do |row|
+        row[:valid_row] = validation_directives.all? { |d| d.validate(row) } ? 'Y' : 'N'
+        row
+      end
+    end
+
+    def tableize(columns)
+      "| #{columns.join(" | ")} |"
+    end
+
+    def processors
+      @processors ||= make_processors
+    end
+
+    def process(columns)
+      processors.map.with_index do |processor, index|
+        value = columns[index]
+        if processor
+          processor.call(value)
+        else
+          value
+        end
+      end
+    end
+
+    def make_processors
+      output_rows.first.map do |name, column|
+        if name.to_s.end_with?('_id')
+          Proc.new do |column|
+            column.to_s.chomp
+          end
+        else
+          case column
+          when Float, BigDecimal
+            Proc.new do |column|
+              sprintf("%.02f", column)
+            end
+          when Numeric, Fixnum
+            Proc.new do |column|
+              commatize(column.to_s)
+            end
+          else
+            Proc.new do |column|
+              column.to_s.chomp
+            end
+          end
+        end
+      end
+    end
+
+    def orientations_for(dataset)
+      widths = widths_for(dataset)
+      dataset.first.map.with_index do |(_, value), index|
+        case value
+        when Numeric, Fixnum, Float
+          widths[index][-1] = ":"
+        else
+          widths[index][0] = ":"
+        end
+        widths[index]
+      end
+    end
+
+    def widths_for(dataset)
+      widths = [0] * dataset.first.length
+      dataset.each do |row|
+        widths = row.map.with_index do |value, index|
+          [value.to_s.length, widths[index]].max
+        end
+      end
+      widths.map { |width| '-' * width }
+    end
+
+    def commatize(str)
+      return str unless str =~ /^\d+$/
+      str.reverse.chars.each_slice(3).map(&:join).join(',').reverse
+    end
+
+    def cache
+      @cache ||= QueryCache.new(self)
+    end
+  end
+end

data/lib/sqltorial/regexp_directive.rb

@@ -0,0 +1,31 @@
+require_relative "directive"
+
+module SQLtorial
+  class RegexpDirective
+    REGEXP = /^ DIRECTIVE:\s*(\S+)\s+(\S+)\s+(.+)/
+    class << self
+      def regexp
+        REGEXP
+      end
+    end
+
+    attr :column, :op, :matcher
+    def initialize(line)
+      _, column, op, matcher = REGEXP.match(line).to_a
+      @column = column.to_sym
+      @op = op
+      @matcher = Regexp.new(matcher)
+    end
+
+    def validate(result)
+      md = matcher.match(result[column])
+      op == '=' ? !md.nil? : md.nil?
+    end
+
+    def inspect
+      [column, op, matcher].join(" ")
+    end
+  end
+
+  Directive.register(RegexpDirective)
+end

data/lib/sqltorial/sql_to_example.rb

@@ -0,0 +1,138 @@
+require 'sqltorial'
+require_relative 'query_to_md'
+require_relative 'formatter'
+
+module SQLtorial
+  class SqlToExample
+    attr :file, :db
+    def initialize(file, db, number)
+      @file = file
+      @db = db
+      @number = number
+    end
+
+    def formatted
+      @formatted ||= `fsqlf -i #{file}`
+      #@formatted ||= `pg_format #{file}`
+      #@formatted ||= `cat #{file} | anbt-sql-formatter`
+      #@formatted ||= `cat #{file} | py_format`
+      #@formatted ||= formatter.format(file.read)
+      #file.read
+    end
+
+    def formatter
+      @formatter ||= Formatter.new
+    end
+
+    def formatted_lines
+      if @formatted_lines.nil?
+        @title_line, @formatted_lines = get_title_and_formatted_lines
+      end
+      @formatted_lines
+    end
+
+    def queries
+      @queries ||= formatted_lines.slice_after { |l| l =~ /;$/ }
+    end
+
+    def title_line
+      if @title_line.nil?
+        @title_line, @formatted_lines = get_title_and_formatted_lines
+      end
+      @title_line
+    end
+
+    def title
+      @title ||= title_line.gsub(/^\s*-+\s*/, '')
+    end
+
+    def make_prose_directives_and_query(query)
+      lines = query.dup
+      prose_lines = []
+      lines.shift while lines.first.strip.empty?
+      prose_lines << lines.shift.sub(/^\s*-+\s*/, ' ').chomp.sub(/^ $/, "\n\n") while lines.first =~ /^\s*(-+|$)/
+      directives, prose_lines = prose_lines.partition { |line| Directive.match(line) }
+      [prose_lines.join(''), process_directives(directives), lines.join("\n")]
+    end
+
+    def number
+      @number ||= file.basename.to_s.to_i
+    end
+
+    def to_str(include_results = true)
+      hash = {}
+      queries.each_with_index do |query, index|
+        prose, directives, sql = make_prose_directives_and_query(query)
+
+        begin
+          if is_create(sql)
+            execute(sql, include_results)
+            hash[sql] = [prose, create_to_md(include_results, sql, directives)];
+            next
+          elsif is_drop(sql)
+            execute(sql, include_results)
+            hash[sql] = [prose, nil];
+            next
+          end
+          hash[sql] = [prose, query_to_md(include_results, sql, directives)]
+        rescue
+          puts sql
+          puts $!.message
+          puts $!.backtrace.join("\n")
+          $stdin.gets
+        end
+      end
+      parts = []
+      parts << "## Example #{number}: #{title}\n"
+      part_num = 0
+      parts += hash.map do |key, value|
+        arr = [value.first]
+        if key && !key.empty?
+          part_num += 1
+          arr << "**Query #{number}.#{part_num}**"
+          arr << "```sql\n#{key}\n```"
+        end
+        arr << value.last
+        arr.join("\n\n")
+      end
+      parts.join("\n") + "\n\n"
+    end
+
+    private
+    def process_directives(directives)
+      directives.map do |line|
+        Directive.from_line(line)
+      end
+    end
+
+    def get_title_and_formatted_lines
+      all_lines = formatted.split("\n")
+      title_line = all_lines.shift
+      [title_line, all_lines]
+    end
+
+    def is_create(sql)
+      sql =~ /^\s*create/i
+    end
+
+    def is_drop(sql)
+      sql =~ /^\s*drop/i
+    end
+
+    def execute(sql, include_results)
+      db.execute(sql) if include_results
+    end
+
+    def create_to_md(include_results, sql, directives)
+      return nil unless include_results
+      table_name = /create\s*(?:temp)?\s*(?:table|view)\s*(\S+)/i.match(sql)[1].gsub('.', '__')
+      QueryToMD.new(db[table_name.to_sym], directives).to_md
+    end
+
+    def query_to_md(include_results, sql, directives)
+      return nil unless include_results
+      return nil if sql.empty?
+      QueryToMD.new(db[sql.sub(';', '')], directives).to_md
+    end
+  end
+end

data/sqltorial.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'sqltorial/metadata'
+
+Gem::Specification.new do |spec|
+  spec.name          = "sqltorial"
+  spec.version       = SQLtorial::VERSION
+  spec.authors       = ["Ryan Duryea"]
+  spec.email         = ["aguynamedryan@gmail.com"]
+
+  spec.summary       = SQLtorial::SUMMARY
+  spec.description   = SQLtorial::DESCRIPTION
+  spec.homepage      = SQLtorial::HOMEPAGE
+  spec.license       = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = "https://rubygems.org"
+  else
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "sequelizer", "~> 0.0.6"
+  spec.add_dependency "anbt-sql-formatter", "~> 0.0.3"
+  spec.add_dependency "facets", "~> 3.0"
+  spec.add_dependency "escort", "~> 0.4.0"
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: sqltorial
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ryan Duryea
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-08-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: sequelizer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.6
+- !ruby/object:Gem::Dependency
+  name: anbt-sql-formatter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.0.3
+- !ruby/object:Gem::Dependency
+  name: facets
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: escort
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+description: Ingests a set of commented SQL statements, executes them, and dumps the
+  comments, queries, and results into a markdown file
+email:
+- aguynamedryan@gmail.com
+executables:
+- sqltorial
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/example_input.sql
+- examples/example_output.md
+- exe/sqltorial
+- lib/sqltorial.rb
+- lib/sqltorial/assemble_command.rb
+- lib/sqltorial/directives/all_directive.rb
+- lib/sqltorial/directives/directive.rb
+- lib/sqltorial/directives/valid_column_directive.rb
+- lib/sqltorial/metadata.rb
+- lib/sqltorial/query_cache.rb
+- lib/sqltorial/query_to_md.rb
+- lib/sqltorial/regexp_directive.rb
+- lib/sqltorial/sql_to_example.rb
+- sqltorial.gemspec
+homepage: http://github.com/outcomesinsights/sqltorial
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+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: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Knitr, but for SQL files, sorta
+test_files: []
+has_rdoc: