ath 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 134345334c460d1e50d1bea0a32bc3ec41fe122b
+  data.tar.gz: b2745a235f660622e72bb026a0adc8a88c124e9a
+SHA512:
+  metadata.gz: 391cf7167a4ed37c9bf2ce9f60cea79c3ecadec7053956245c92f66d59fe9a7993e7f3dd3ea72bbf45773b1bbf48eb0f0caa4ca86b895c8b1985c49bb4d5ab7f
+  data.tar.gz: 31ac7b442fc2f96686d676277d227ff560a46e481be39ff6285f4ac329c608d6e289299eea6da7731c8067a6804992ca7f0ff121fb4fd3bb4c9697baa3849ecf

data/.gitignore

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

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.3.3
+before_install: gem install bundler -v 1.13.6

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 winebarrel
+
+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,100 @@
+# ath
+
+ath is a interactive [Amazon Athena](https://aws.amazon.com/athena/) shell.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ath'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ath
+
+## Getting Started
+
+```
+$ export ATH_OUTPUT_LOCATION=s3://my-bucket
+
+$ ath
+
+default> show databases;
+default
+sampledb
+
+default> /use sampledb
+sampledb> show tables;
+elb_logs
+
+sampledb> select * from elb_logs limit 3;
+"request_timestamp","elb_name","request_ip","request_port","backend_ip","backend_port","request_processing_time","backend_processing_time","client_response_time","elb_response_code","backend_response_code","received_bytes","sent_bytes","request_verb","url","protocol","user_agent","ssl_cipher","ssl_protocol"
+"2015-01-01T08:00:00.516940Z","elb_demo_009","240.136.98.149","25858","172.51.67.62","8888","9.99E-4","8.11E-4","0.001561","200","200","0","428","GET","https://www.example.com/articles/746","HTTP/1.1","""Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/602.1.50 (KHTML, like Gecko) Version/10.0 Safari/602.1.50""","DHE-RSA-AES128-SHA","TLSv1.2"
+"2015-01-01T08:00:00.902953Z","elb_demo_008","244.46.184.108","27758","172.31.168.31","443","6.39E-4","0.001471","3.73E-4","200","200","0","4231","GET","https://www.example.com/jobs/688","HTTP/1.1","""Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1""","DHE-RSA-AES128-SHA","TLSv1.2"
+"2015-01-01T08:00:01.206255Z","elb_demo_008","240.120.203.212","26378","172.37.170.107","8888","0.001174","4.97E-4","4.89E-4","200","200","0","2075","GET","http://www.example.com/articles/290","HTTP/1.1","""Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.246""","-","-"
+
+sampledb> select * from elb_logs limit 3 &
+QueryExecution 2335c77b-d138-4c5d-89df-12f2781c311b
+
+sampledb> /desc 2335c77b-d138-4c5d-89df-12f2781c311b
+{
+  "query_execution_id": "2335c77b-d138-4c5d-89df-12f2781c311b",
+  "query": "select * from elb_logs limit 3",
+  "result_configuration": {
+    "output_location": "s3://sugawara-test/2335c77b-d138-4c5d-89df-12f2781c311b.csv"
+  },
+  "query_execution_context": {
+    "database": "sampledb"
+  },
+  "status": {
+    "state": "SUCCEEDED",
+    "submission_date_time": "2017-07-02 16:29:57 +0900",
+    "completion_date_time": "2017-07-02 16:29:58 +0900"
+  },
+  "statistics": {
+    "engine_execution_time_in_millis": 719,
+    "data_scanned_in_bytes": 422696
+  }
+}
+
+sampledb> /result 2335c77b-d138-4c5d-89df-12f2781c311b
+"request_timestamp","elb_name","request_ip","request_port","backend_ip","backend_port","request_processing_time","backend_processing_time","client_response_time","elb_response_code","backend_response_code","received_bytes","sent_bytes","request_verb","url","protocol","user_agent","ssl_cipher","ssl_protocol"
+"2015-01-01T16:00:00.516940Z","elb_demo_009","242.76.140.141","18201","172.42.159.57","80","0.001448","8.46E-4","9.97E-4","302","302","0","2911","GET","https://www.example.com/articles/817","HTTP/1.1","""Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:15.0) Gecko/20100101 Firefox/15.0.1""","DHE-RSA-AES128-SHA","TLSv1.2"
+"2015-01-01T16:00:00.902953Z","elb_demo_005","246.233.91.115","1950","172.42.232.155","8888","9.59E-4","0.001703","8.93E-4","200","200","0","3027","GET","http://www.example.com/jobs/509","HTTP/1.1","""Mozilla/5.0 (Macintosh; Intel Mac OS X 10_11_6) AppleWebKit/602.1.50 (KHTML, like Gecko) Version/10.0 Safari/602.1.50""","-","-"
+"2015-01-01T16:00:01.206255Z","elb_demo_002","250.96.73.238","12800","172.34.87.144","80","0.001549","9.68E-4","0.001908","200","200","0","888","GET","http://www.example.com/articles/729","HTTP/1.1","""Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/42.0.2311.135 Safari/537.36 Edge/12.246""","-","-"
+```
+
+## Usage
+
+```
+$ ath -h
+Usage: ath [options]
+    -p, --profile PROFILE_NAME
+        --credentials-path PATH
+    -k, --access-key ACCESS_KEY
+    -s, --secret-key SECRET_KEY
+    -r, --region REGION
+        --output-location S3URI
+    -d, --database DATABASE
+    -e, --execute QUERY
+    -f, --file QUERY_FILR
+        --debug
+```
+
+```
+default> /help
+/debug true|false
+/desc QUERY_EXECUTION_ID
+/help
+/list [NUM]
+/pager PAGER
+/result QUERY_EXECUTION_ID
+/stop QUERY_EXECUTION_ID
+/use DATABASE
+```

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/ath.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ath/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ath'
+  spec.version       = Ath::VERSION
+  spec.authors       = ['winebarrel']
+  spec.email         = ['sgwr_dts@yahoo.co.jp']
+
+  spec.summary       = %q{ath is a interactive Amazon Athena shell.}
+  spec.description   = %q{ath is a interactive Amazon Athena shell.}
+  spec.homepage      = 'https://github.com/winebarrel/ath'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'aws-sdk', '>= 2.9.21', '< 3'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'ath'
+
+# 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,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/ath

@@ -0,0 +1,90 @@
+#!/usr/bin/env ruby
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'logger'
+require 'optparse'
+require 'ath'
+
+Version = Ath::VERSION
+
+options = {
+  database: 'default',
+  output_location: ENV['ATH_OUTPUT_LOCATION'],
+  debug: false,
+}
+
+query = nil
+query_file = nil
+
+ARGV.options do |opt|
+  aws_opts = {}
+  creds_opts = {}
+
+  begin
+    opt.on('-p', '--profile PROFILE_NAME')  {|v| creds_opts[:profile_name]    = v    }
+    opt.on(''  , '--credentials-path PATH') {|v| creds_opts[:path]            = v    }
+    opt.on('-k', '--access-key ACCESS_KEY') {|v| aws_opts[:access_key]        = v    }
+    opt.on('-s', '--secret-key SECRET_KEY') {|v| aws_opts[:secret_access_key] = v    }
+    opt.on('-r', '--region REGION')         {|v| aws_opts[:region]            = v    }
+    opt.on(''  , '--output-location S3URI') {|v| options[:output_location]    = v    }
+    opt.on('-d', '--database DATABASE')     {|v| options[:database]           = v    }
+    opt.on('-e', '--execute QUERY')         {|v| query                        = v    }
+    opt.on('-f', '--file QUERY_FILR')       {|v| query_file                   = v    }
+    opt.on(''  , '--debug')                 {    options[:debug]              = true }
+    opt.parse!
+
+    unless options[:output_location]
+      raise Ath::Error, '"--output-location" or ATH_OUTPUT_LOCATION is required'
+    end
+
+    if not creds_opts.empty?
+      creds = Aws::SharedCredentials.new(credentials_opts)
+      aws_opts[:credentials] = creds
+    end
+
+    Aws.config.update(aws_opts)
+  rescue Ath::Error, OptionParser::ParseError => e
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  rescue => e
+    $stderr.puts("[ERROR] #{e.message}")
+    puts "\t" + e.backtrace.join("\n\t")
+    exit 1
+  end
+end
+
+if options[:debug]
+  Aws.config.update(
+    http_wire_trace: true,
+    logger: Logger.new($stdout).tap {|l| l.level = Logger::DEBUG },
+  )
+end
+
+begin
+  shell = Ath::Shell.new(database: options.delete(:database), options: options)
+
+  if query_file
+    if query_file == '-'
+      query = $stdin.read
+    else
+      query = File.read(query_file)
+    end
+  end
+
+  if query
+    query.strip!
+    query << ';' if query !~ /[;&]\z/
+    shell.oneshot(query)
+  else
+    shell.start
+  end
+rescue Interrupt
+  # nothing to do
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{[e.message, e.backtrace.first].join("\n\t")}")
+    exit 1
+  end
+end

data/lib/ath/command.rb

@@ -0,0 +1,100 @@
+class Ath::Command
+  MAX_LIST_QUERY = 20
+
+  def initialize(shell:, command:, arg: nil)
+    @shell = shell
+    @command = command
+    @arg = arg
+  end
+
+  def run
+    out = nil
+
+    case @command
+    when 'debug'
+      if @arg == 'true' or @arg == 'false'
+        @shell.options[:debug] = (@arg =~ /true/)
+      else
+        out = "Usage: /debug true|false"
+      end
+    when 'desc'
+      if @arg
+        query_execution = @shell.driver.get_query_execution(query_execution_id: @arg)
+        out = JSON.pretty_generate(query_execution.to_h)
+      else
+        out = "Usage: /desc QUERY_EXECUTION_ID"
+      end
+    when 'help'
+      out = usage
+    when 'list'
+      query_executions = @shell.driver.list_query_executions
+      query_executions.sort_by! {|qe| qe.status.submission_date_time }.reverse!
+
+      lines = query_executions.map do |qe|
+        line = [
+          qe.status.submission_date_time,
+          qe.query_execution_id,
+          qe.status.state,
+        ]
+
+        if qe.query.length > MAX_LIST_QUERY
+          line << qe.query.slice(0, MAX_LIST_QUERY) + '..'
+        else
+          line << qe.query
+        end
+
+        line.join("\s")
+      end
+
+      if @arg
+        lines = lines.slice(0, @arg.to_i)
+      end
+
+      out = lines.join("\n")
+    when 'pager'
+      if @arg
+        @shell.pager = @arg
+      else
+        @shell.pager = nil
+        out = "Using stdout"
+      end
+    when 'result'
+      if @arg
+        out = @shell.driver.get_query_execution_result(query_execution_id: @arg)
+      else
+        out = "Usage: /result QUERY_EXECUTION_ID"
+      end
+    when 'stop'
+      if @arg
+        @shell.driver.stop_query_execution(query_execution_id: @arg)
+      else
+        out = "Usage: /stop QUERY_EXECUTION_ID"
+      end
+    when 'use'
+      if @arg
+        @shell.database = @arg
+      else
+        out = "Usage: /use DATABASE"
+      end
+    else
+      raise Ath::Error, "Unknown command: #{@command}"
+    end
+
+    out
+  end
+
+  private
+
+  def usage
+    <<-EOS
+/debug true|false
+/desc QUERY_EXECUTION_ID
+/help
+/list [NUM]
+/pager PAGER
+/result QUERY_EXECUTION_ID
+/stop QUERY_EXECUTION_ID
+/use DATABASE
+    EOS
+  end
+end

data/lib/ath/driver.rb

@@ -0,0 +1,42 @@
+class Ath::Driver
+  def initialize(athena:, s3:)
+    @athena = athena
+    @s3 = s3
+  end
+
+  def get_query_execution(query_execution_id:)
+
+    @athena.get_query_execution(query_execution_id: query_execution_id).query_execution
+  end
+
+  def list_query_executions
+    query_execution_ids = @athena.list_query_executions.each_page.flat_map(&:query_execution_ids)
+    @athena.batch_get_query_execution(query_execution_ids: query_execution_ids.slice(0, 50)).query_executions
+  end
+
+  def get_query_execution_result(query_execution_id:)
+    query_execution = @athena.get_query_execution(query_execution_id: query_execution_id).query_execution
+    output_location = query_execution.result_configuration.output_location
+    bucket, key = output_location.sub(%r{\As3://}, '').split('/', 2)
+    tmp = Tempfile.create('ath')
+
+    @s3.get_object(bucket: bucket, key: key) do |chunk|
+      tmp.write(chunk)
+    end
+
+    tmp.flush
+    tmp
+  end
+
+  def start_query_execution(query_string:, database:, output_location:)
+    @athena.start_query_execution(
+      query_string: query_string,
+      query_execution_context: {database: database},
+      result_configuration: { output_location: output_location}
+    )
+  end
+
+  def stop_query_execution(query_execution_id:)
+    @athena.stop_query_execution(query_execution_id: query_execution_id)
+  end
+end

data/lib/ath/error.rb

@@ -0,0 +1,2 @@
+class Ath::Error < StandardError
+end

data/lib/ath/query.rb

@@ -0,0 +1,47 @@
+class Ath::Query
+  def initialize(shell:, query:, detach: false)
+    @shell = shell
+    @query = query
+    @detach = detach
+  end
+
+  def run
+    query_execution_id = @shell.driver.start_query_execution(
+      query_string: @query,
+      database: @shell.database,
+      output_location: @shell.options.fetch(:output_location)
+    ).query_execution_id
+
+    if @detach
+      return "QueryExecution #{query_execution_id}"
+    end
+
+    abort_waiting = false
+    orig_handler = trap(:INT, proc { abort_waiting = true })
+    query_execution = nil
+
+    begin
+      until abort_waiting
+        query_execution = @shell.driver.get_query_execution(query_execution_id: query_execution_id)
+
+        if query_execution.status.completion_date_time
+          break
+        end
+
+        sleep 1
+      end
+    ensure
+      trap(:INT, orig_handler)
+    end
+
+    if abort_waiting
+      return "QueryExecution #{query_execution_id}: Detach query"
+    end
+
+    if query_execution.status.state == 'SUCCEEDED'
+      @shell.driver.get_query_execution_result(query_execution_id: query_execution_id)
+    else
+      "QueryExecution #{query_execution_id}: #{query_execution.status.state_change_reason}"
+    end
+  end
+end

data/lib/ath/scanner.rb

@@ -0,0 +1,42 @@
+class Ath::Scanner
+  def initialize(shell:)
+    @shell = shell
+    @buf = ''
+  end
+
+  def scan(line)
+    ss = StringScanner.new(line)
+
+    if self.empty? and (tok = ss.scan %r{/\w+(?:\s+.*)?\z})
+      cmd, arg = tok.split(/\s+/, 2)
+      cmd.slice!(0)
+      arg.strip! if arg
+      yield(Ath::Command.new(shell: @shell, command: cmd, arg: arg))
+    end
+
+    until ss.eos?
+      @buf << ' '
+
+      if (tok = ss.scan %r{[^'";&]+})
+        @buf << tok
+      elsif (tok = ss.scan /'(?:''|[^'])*'/)
+        @buf << tok
+      elsif (tok = ss.scan /"(?:""|[^"])*"/)
+        @buf << tok
+      elsif (tok = ss.scan /(?:[;&])/)
+        query = @buf.strip
+        @buf.clear
+        raise Ath::Error, 'No query specified' if query.empty?
+        yield(Ath::Query.new(shell: @shell, query: query, detach: (tok == '&')))
+      else
+        raise Ath::Error, 'You have an error in your HiveQL syntax'
+      end
+    end
+
+    @buf.strip!
+  end
+
+  def empty?
+    @buf.empty?
+  end
+end

data/lib/ath/shell.rb

@@ -0,0 +1,130 @@
+class Ath::Shell
+  HISTORY_FILE = File.join(ENV.fetch('HOME', '.'), '.ath_history')
+  HISTSIZE = 1000
+
+  attr_reader :driver
+  attr_reader :options
+  attr_accessor :database
+  attr_accessor :pager
+
+  def initialize(athena: Aws::Athena::Client.new, s3: Aws::S3::Client.new, database: nil, options: {})
+    @driver = Ath::Driver.new(athena: athena, s3: s3)
+    @options = options
+    @database = database
+    @scanner = Ath::Scanner.new(shell: self)
+  end
+
+  def start
+    load_history
+
+    while line = Readline.readline(prompt, true)
+      execute_query(line)
+    end
+
+    save_history
+  end
+
+  def oneshot(query)
+    execute_query(query)
+  end
+
+  private
+
+  def execute_query(line)
+    begin
+      execute_query0(line)
+    rescue => e
+      puts e.message
+
+      if @options[:debug]
+        puts e.backtrace.join("\n\t")
+      end
+    end
+  end
+
+  def execute_query0(line)
+    @scanner.scan(line) do |cmd_or_query|
+      out = nil
+
+      case cmd_or_query
+      when Ath::Command
+        out = cmd_or_query.run
+      when Ath::Query
+        out = cmd_or_query.run
+      else
+        raise 'must not happen'
+      end
+
+      print_result(out)
+    end
+  end
+
+  def prompt
+    database = @database || '(none)'
+
+    if @scanner.empty?
+      "#{database}> "
+    else
+      indent = "\s" * (database.length - 1)
+      "#{indent}-> "
+    end
+  end
+
+  def print_result(out)
+    return unless out
+
+    if out.kind_of?(File)
+      begin
+        cmd = "cat #{out.path}"
+        cmd << " | #{@pager}" if @pager
+        system(cmd)
+
+        begin
+          out.seek(-1, IO::SEEK_END)
+          puts if out.gets !~ /\n\z/
+        rescue Errno::EINVAL
+          puts
+        end
+      ensure
+        out.close
+      end
+    else
+      if @pager
+        Tempfile.create('ath') do |f|
+          f.puts out
+          f.flush
+          system("cat #{f.path} | #{@pager}")
+        end
+      else
+        puts out
+      end
+    end
+  end
+
+  def load_history
+    return unless File.exist?(HISTORY_FILE)
+
+    open(HISTORY_FILE) do |f|
+      f.each_line.map(&:strip).reject(&:empty?).each do |line|
+        Readline::HISTORY.push(line)
+      end
+    end
+  end
+
+  def save_history
+    if Readline::HISTORY.length < HISTSIZE
+      offset = Readline::HISTORY.length
+    else
+      offset = HISTORY
+    end
+
+    history = Readline::HISTORY.map(&:strip).reject(&:empty?).uniq
+    history = history.slice(-offset..-1) || []
+
+    return if history.empty?
+
+    open(HISTORY_FILE, 'wb') do |f|
+      history.each {|l| f.puts l }
+    end
+  end
+end

data/lib/ath/version.rb

@@ -0,0 +1,3 @@
+module Ath
+  VERSION = '0.1.0'
+end

data/lib/ath.rb

@@ -0,0 +1,13 @@
+require 'readline'
+require 'strscan'
+require 'tempfile'
+
+require 'aws-sdk'
+
+require 'ath/version'
+require 'ath/command'
+require 'ath/driver'
+require 'ath/error'
+require 'ath/query'
+require 'ath/shell'
+require 'ath/scanner'

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: ath
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- winebarrel
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.21
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.9.21
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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: rake
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: ath is a interactive Amazon Athena shell.
+email:
+- sgwr_dts@yahoo.co.jp
+executables:
+- ath
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ath.gemspec
+- bin/console
+- bin/setup
+- exe/ath
+- lib/ath.rb
+- lib/ath/command.rb
+- lib/ath/driver.rb
+- lib/ath/error.rb
+- lib/ath/query.rb
+- lib/ath/scanner.rb
+- lib/ath/shell.rb
+- lib/ath/version.rb
+homepage: https://github.com/winebarrel/ath
+licenses:
+- MIT
+metadata: {}
+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.5.2
+signing_key: 
+specification_version: 4
+summary: ath is a interactive Amazon Athena shell.
+test_files: []