pendulum 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 39768125e6cbdf710a729beac0133f6c3e53d7b9
+  data.tar.gz: ef90d7cedb538420b6cdae2dcea602a2b5bafb5b
+SHA512:
+  metadata.gz: b9e1c70253542545c488fd040d7640f907343920783feae932def202a27f274f23781251f060fb3deeeff382b49910eb2b723a681f47a3750c9df53cd3535556
+  data.tar.gz: da9651c21dc64f7b674b94b2f66edd0f88c869744191c149493bf2a3918f2b42faad57ac958ca842e549a6c02ee4075e86313e73d42631dd3f300a103e993f98

data/.gitignore

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

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 monochromegane
+
+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,92 @@
+# Pendulum
+
+Pendulum is a tool to manage Treasure Data scheduled jobs.
+
+It defines the state of Treasure Data scheduled jobs using DSL, and updates the jobs according as DSL.
+
+## Usage
+
+```sh
+# Export from Treasure Data
+$ pendulum --apikey='...' -e -o Schedfile
+
+# Update Schedfile
+$ vi Schedfile
+
+# Apply scheduled jobs
+$ pendulum --apikey='...' -a --dry-run
+$ pendulum --apikey='...' -a
+```
+
+## Schedfile
+
+```rb
+schedule 'test-scheduled-job' do
+  database   'db_name'
+  query      'select time from access;'
+  retry_limit 0
+  priority    :normal
+  cron        '30 0 * * *'
+  timezone    'Asia/Tokyo'
+  delay       0
+  result_url  'td://@/db_name/table_name'
+end
+```
+
+#### query_file
+
+If your query is long, you can specify `query_file`.
+
+```rb
+query_file 'queries/test-scheduled-job.hql'
+```
+
+#### result
+
+You can use `result` DSL instead of `result_url`.
+
+```rb
+schedule 'test-scheduled-job' do
+  database   'db_name'
+  ...
+  result :td do
+    database 'db_name'
+    table    'table_name'
+  end
+end
+```
+
+Now, Pendulum supports `td` and `postgresql` result export.
+If you want to use other result export, please send pull request :smile:
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'pendulum'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pendulum
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also 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`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/monochromegane/pendulum.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task :default => :spec

data/bin/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "pendulum"
+
+# 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.
+
+require "pry"
+Pry.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/pendulum

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+$: << File.expand_path("#{File.dirname __FILE__}/../lib")
+require 'rubygems'
+require 'pendulum'
+
+exit_code = Pendulum::Runner.new.run ARGV
+exit exit_code

data/lib/pendulum.rb

@@ -0,0 +1,19 @@
+require "pendulum/version"
+require "pendulum/client"
+require "pendulum/settings"
+require "pendulum/configuration"
+require "pendulum/dsl/helper"
+require "pendulum/dsl/schedule"
+require "pendulum/dsl/result"
+require "pendulum/dsl/output/base"
+require "pendulum/dsl/output/treasure_data"
+require "pendulum/dsl/output/postgresql"
+require "pendulum/dsl/output/result"
+require "pendulum/dsl/converter"
+require "pendulum/command/apply"
+require "pendulum/command/apply/result_url"
+require "pendulum/command/apply/schedule"
+require "pendulum/runner"
+
+module Pendulum
+end

data/lib/pendulum/client.rb

@@ -0,0 +1,50 @@
+require 'td'
+require 'td-client'
+require 'fileutils'
+
+module Pendulum
+  class Client
+    def initialize(api_key='', options={}, &block)
+      @api_key = api_key
+      @config = Configuration.new(options)
+      @config.instance_eval(&block) if block_given?
+    end
+
+    def apply(dry_run: false, force: false, color: false)
+      Pendulum::Command::Apply.new(
+        td_client,
+        current_schedules,
+        @config.schedules,
+        dry_run,
+        force,
+        color,
+      ).execute
+    end
+
+    def export(output)
+      result = DSL::Converter.new(td_client.schedules).convert
+      # schedule
+      File.write(output, result[:schedule])
+      # queries
+      query_dir = File.join(File.dirname(output), 'queries')
+      make_dir(query_dir)
+      result[:queries].each do |query|
+        File.write(File.join(query_dir, query[:name]), query[:query])
+      end
+    end
+
+    private
+
+    def current_schedules
+      td_client.schedules
+    end
+
+    def td_client
+      @td_client ||= TreasureData::Client.new(@api_key, {ssl: true})
+    end
+
+    def make_dir(dir)
+      FileUtils.mkdir(dir) unless File.exist?(dir)
+    end
+  end
+end

data/lib/pendulum/command/apply.rb

@@ -0,0 +1,35 @@
+module Pendulum::Command
+  class Apply
+    attr_accessor :client, :dry_run, :force
+
+    def initialize(client, from, to, dry_run=false, force=false, color=false)
+      @schedules = matched_schedules(client, from, to, dry_run, force, color)
+    end
+
+    def execute
+      @schedules.each{|s| s.apply }
+    end
+
+    private
+
+    def matched_schedules(client, from, to, dry_run, force, color)
+      # create or update
+      schedules = to.map do |schedule|
+        Schedule.new(
+          client,
+          from.find{|f| f.name == schedule.name},
+          schedule,
+          dry_run,
+          force,
+          color
+        )
+      end
+
+      # delete
+      from.reject{|f| to.any?{|t| t.name == f.name}}.each do |schedule|
+        schedules << Schedule.new(client, schedule, nil, dry_run, force, color)
+      end
+      schedules
+    end
+  end
+end

data/lib/pendulum/command/apply/result_url.rb

@@ -0,0 +1,57 @@
+module Pendulum::Command
+  class Apply
+    class ResultURL
+      attr_accessor :client, :from, :to
+      def initialize(client, from, to)
+        self.client = client
+        self.from   = from
+        self.to     = to
+      end
+
+      def changed?
+        from_uri = to_uri(from)
+        to_uri   = mask(to_uri(to))
+
+        uri_without_query(from_uri) != uri_without_query(to_uri) ||
+          query_hash(from_uri) != query_hash(to_uri)
+      end
+
+      def mask(uri)
+        uri.password = '***' if uri.user
+        uri
+      end
+
+      private
+
+      def uri_without_query(uri)
+        uri.to_s.split('?').first
+      end
+
+      def query_hash(uri)
+        Hash[URI::decode_www_form(uri.query || '')]
+      end
+
+      def to_uri(url)
+        return URI.parse(url) if url.include?('://')
+
+        # use result
+        name, table = url.split(':', 2)
+
+        result = result_by(name)
+        return URI.parse(url) unless result
+
+        uri = URI.parse(result.url)
+        uri.path += "/#{table}"
+        uri
+      end
+
+      def results
+        @results ||= client.results
+      end
+
+      def result_by(name)
+        results.find{|r| name == r.name}
+      end
+    end
+  end
+end

data/lib/pendulum/command/apply/schedule.rb

@@ -0,0 +1,165 @@
+require 'highline'
+
+module Pendulum::Command
+  class Apply
+    class Schedule
+      attr_accessor :client, :from, :to, :dry_run, :force, :color
+      def initialize(client, from, to, dry_run=false, force=false, color=false)
+        self.client  = client
+        self.from    = from
+        self.to      = to
+        self.dry_run = dry_run
+        self.force   = force
+        self.color   = color
+      end
+
+      def apply
+        case
+        when will_create? then create
+        when will_update? then update
+        when will_delete? then delete
+        end
+      end
+
+      def create
+        puts message_for_create
+        client.create_schedule(to.name, to.to_params) unless dry_run?
+      end
+
+      def update
+        puts message_for_update
+        puts message_for_diff if has_diff?
+        if force? || has_diff?
+          client.update_schedule(to.name, to.to_params) unless dry_run?
+        end
+      end
+
+      def delete
+        puts message_for_delete
+        client.delete_schedule(from.name) if force? && !dry_run?
+      end
+
+      private
+
+      def will_create?
+        !from && to
+      end
+
+      def will_update?
+        from && to
+      end
+
+      def will_delete?
+        from && !to
+      end
+
+      def has_diff?
+        !diff.empty?
+      end
+
+      def diff
+        return {} unless will_update?
+
+        @diff ||= begin
+                    default_params.merge(to.to_params).select do |k, v|
+                      if k == :result
+                        result_url_changed?(from.result_url, v)
+                      else
+                        v != from.send(k)
+                      end
+                    end
+                  end
+      end
+
+      def masked_diff
+        return diff unless diff.key?(:result)
+
+        masked = diff.dup
+        uri = URI.parse(masked[:result])
+        uri.password = '***' if uri.user
+        masked[:result] = uri.to_s
+
+        masked
+      end
+
+      def message_for_create
+        colorize message_for(:create), :cyan
+      end
+
+      def message_for_update
+        if force? || has_diff?
+          colorize message_for(:update), :green
+        else
+          colorize message_with_dry_run("No change schedule: #{name}"), :blue
+        end
+      end
+
+      def message_for_delete
+        if force?
+          colorize message_for(:delete), :red
+        else
+          colorize message_with_dry_run("Undefined schedule (pass `--force` if you want to remove): #{name}"), :yellow
+        end
+      end
+
+      def message_with_dry_run(message)
+        message += ' (dry-run)' if dry_run?
+        message
+      end
+
+      def message_for(action)
+        message_with_dry_run "#{action.to_s.capitalize} schedule: #{name}"
+      end
+
+      def message_for_diff
+        message = masked_diff.map do |name, value|
+          "  set #{name}=#{value}"
+        end.join("\n")
+        colorize message, :green
+      end
+
+      def name
+        (from && from.name) || (to && to.name)
+      end
+
+      def dry_run?
+        dry_run
+      end
+
+      def force?
+        force
+      end
+
+      def color?
+        color
+      end
+
+      def default_params
+        {
+          database:    '',
+          query:       nil,
+          retry_limit: 0,
+          priority:    0,
+          cron:        nil,
+          timezone:    'Asia/Tokyo', # TODO: require timezone.
+          delay:       0,
+          result:      ''
+        }
+      end
+
+      def result_url_changed?(from_url, to_url)
+        Apply::ResultURL.new(client, from_url, to_url).changed?
+      end
+
+      def colorize(message, color)
+        return message unless color?
+        h.color message, color
+      end
+
+      def h
+        @h ||= HighLine.new
+      end
+    end
+  end
+end
+

data/lib/pendulum/configuration.rb

@@ -0,0 +1,18 @@
+module Pendulum
+  class Configuration
+    def initialize(options={})
+      settings = Pendulum::Settings.load(options[:env])
+      if file = options[:file]
+        self.instance_eval(File.read(file), file)
+      end
+    end
+
+    def schedule(name, &block)
+      schedules << DSL::Schedule.new(name, &block)
+    end
+
+    def schedules
+      @schedules ||= []
+    end
+  end
+end

data/lib/pendulum/dsl/converter.rb

@@ -0,0 +1,51 @@
+require 'erb'
+
+module Pendulum::DSL
+  class Converter
+    def initialize(schedules)
+      @schedules = schedules
+    end
+
+    def convert
+      result = {}
+      result[:schedule] = @schedules.map do |schedule|
+        to_dsl(schedule)
+      end.join("\n")
+
+      result[:queries] = @schedules.map do |schedule|
+        to_query(schedule)
+      end.compact
+
+      result
+    end
+
+    private
+
+    def to_dsl(schedule)
+      ERB.new(<<-EOS, nil, '-').result(binding)
+schedule '<%= schedule.name %>' do
+  database    '<%= schedule.database %>'
+<% if schedule.query -%>
+  query_file 'queries/<%= schedule.name %>.hql'
+  # type     :hive # FIXME: Treasure Data schedule api dosen't contain type result.
+  retry_limit <%= schedule.retry_limit %>
+  priority    <%= schedule.priority %>
+<% end -%>
+<% if schedule.cron -%>
+  cron        '<%= schedule.cron %>'
+  timezone    '<%= schedule.timezone %>'
+  delay       <%= schedule.delay %>
+<% end -%>
+<% if schedule.result_url != '' -%>
+  result_url  '<%= schedule.result_url %>'
+<% end -%>
+end
+      EOS
+    end
+
+    def to_query(schedule)
+      return nil unless schedule.query
+      {name: "#{schedule.name}.hql", query: schedule.query}
+    end
+  end
+end

data/lib/pendulum/dsl/helper.rb

@@ -0,0 +1,17 @@
+module Pendulum::DSL
+  module Helper
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def define_setter(*names)
+        names.each do |name|
+          define_method(name) do |value|
+            instance_variable_set("@#{name}", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pendulum/dsl/output/base.rb

@@ -0,0 +1,46 @@
+module Pendulum::DSL::Output
+  class Base
+    include Pendulum::DSL::Helper
+
+    def initialize(&block)
+      self.instance_eval(&block) if block_given?
+    end
+
+    def to_url
+      raise NotImplementedError, "You must implement #{self.class}##{__method__}"
+    end
+
+    private
+
+    def with_options(url, *options)
+      params = (options || []).select do |option|
+        instance_variable_defined?("@#{option}")
+      end.map do |option|
+        "#{option}=#{instance_variable_get("@#{option}")}"
+      end.join('&')
+      url + (params.empty? ? '' : "?#{params}")
+    end
+
+    def username_and_password
+      case
+      when @username && @password
+        "#{@username}:#{@password}"
+      when @username
+        @username
+      when @password
+        ":#{@password}"
+      end
+    end
+
+    def hostname_and_port
+      case
+      when @hostname && @port
+        "#{@hostname}:#{@port}"
+      when @hostname
+        @hostname
+      when @port
+        ":#{@port}"
+      end
+    end
+  end
+end

data/lib/pendulum/dsl/output/postgresql.rb

@@ -0,0 +1,11 @@
+module Pendulum::DSL::Output
+  class Postgresql < Base
+    define_setter :username, :password, :hostname, :port,
+                  :database, :table, :ssl, :schema, :mode, :method
+
+    def to_url
+      url = "postgresql://#{username_and_password}@#{hostname_and_port}/#{@database}/#{@table}"
+      with_options(url, :ssl, :schema, :mode, :method)
+    end
+  end
+end

data/lib/pendulum/dsl/output/result.rb

@@ -0,0 +1,14 @@
+module Pendulum::DSL::Output
+  class Result < Base
+    define_setter :table
+
+    def initialize(name)
+      @name = name
+      super()
+    end
+
+    def to_url
+      "#{@name}:#{@table}"
+    end
+  end
+end

data/lib/pendulum/dsl/output/treasure_data.rb

@@ -0,0 +1,9 @@
+module Pendulum::DSL::Output
+  class TreasureData < Base
+    define_setter :database, :table, :mode
+
+    def to_url
+      with_options("td://@/#{@database}/#{@table}", :mode)
+    end
+  end
+end

data/lib/pendulum/dsl/result.rb

@@ -0,0 +1,28 @@
+module Pendulum::DSL
+  class Result
+    attr_accessor :type, :output
+
+    def initialize(type, &block)
+      self.type = type
+      self.output = output_by(type)
+      self.output.instance_eval(&block) if block_given?
+    end
+
+    def to_url
+      output.to_url
+    end
+
+    private
+
+    def output_by(type)
+      case type.to_sym
+      when :treasure_data, :td
+        Output::TreasureData.new
+      when :postgresql
+        Output::Postgresql.new
+      else
+        Output::Result.new(type)
+      end
+    end
+  end
+end

data/lib/pendulum/dsl/schedule.rb

@@ -0,0 +1,56 @@
+module Pendulum::DSL
+  class Schedule
+    include Helper
+
+    attr_accessor :name
+
+    def initialize(name, &block)
+      self.name = name
+      self.instance_eval(&block) if block_given?
+    end
+
+    define_setter :database, :query, :timezone,
+                  :delay, :retry_limit, :type
+
+    def query_file(path)
+      query(File.read(path))
+    end
+
+    def cron(cron)
+      @cron = %i(hourly daily monthly).include?(cron) ? "@#{cron}" : cron
+    end
+
+    def priority(priority)
+      @priority = priority.is_a?(Integer) ? priority : priority_id_of(priority)
+    end
+
+    def result_url(url)
+      @result = url
+    end
+
+    def result(type, &block)
+      result = Result.new(type, &block)
+      @result = result.to_url
+    end
+
+    def to_params
+      instance_variables.inject({}) do |params, v|
+        params[v.to_s.delete('@').to_sym] = instance_variable_get(v)
+        params
+      end
+    end
+
+    private
+
+    def priority_id_of(name)
+      case name.to_sym
+      when :very_low  then -2
+      when :low       then -1
+      when :normal    then  0
+      when :high      then  1
+      when :very_high then  2
+      else                  0
+      end
+    end
+  end
+end

data/lib/pendulum/runner.rb

@@ -0,0 +1,67 @@
+require 'optparse'
+
+
+module Pendulum
+  DEFAULT_SCHEDFILE = 'Schedfile'
+  class Runner
+    def run(argv=ARGV)
+      api_key = nil
+      mode    = nil
+      dry_run = false
+      force   = false
+      color   = true
+      options = {
+        file:    DEFAULT_SCHEDFILE,
+        env:     :development,
+      }
+      output  = DEFAULT_SCHEDFILE
+
+      opt.on('-k', '--apikey=KEY') {|v| api_key = v }
+
+      # apply
+      opt.on('-a', '--apply')           {    mode   = :apply    }
+      opt.on('-E', '--environment=ENV') {|v| options[:env]  = v }
+      opt.on('-f', '--file=FILE')       {|v| options[:file] = v }
+      opt.on('',   '--dry-run')         {    dry_run = true     }
+      opt.on('',   '--force')           {    force   = true     }
+      opt.on('',   '--no-color')        {    color   = false    }
+
+      # export
+      opt.on('-e', '--export') do
+        mode = :export
+        options.delete(:file)
+      end
+      opt.on('-o', '--output=FILE') {|v| output = v }
+
+      opt.parse!(argv) rescue return usage $!
+      return usage if (api_key.nil? || mode.nil?)
+
+      begin
+        client = Client.new(api_key, options)
+        case mode
+        when :apply
+          client.apply(dry_run: dry_run, force: force, color: color)
+        when :export
+          client.export(output)
+        end
+      rescue
+        $stderr.puts $!
+        return 1
+      end
+
+      return 0
+    end
+
+    private
+
+    def usage(err=nil)
+      puts err if err
+      puts opt.help
+      err ? 1 : 0
+    end
+
+    def opt
+      @opt ||= OptionParser.new
+    end
+  end
+end

data/lib/pendulum/settings.rb

@@ -0,0 +1,23 @@
+require 'hashie'
+
+module Pendulum
+  class Settings
+    class << self
+      def load(env)
+        merge(load_from(:default), load_from(env))
+      end
+
+      private
+
+      def load_from(env)
+        path = File.join('environments', "#{env}.yml")
+        return Hashie::Mash.new unless File.file?(path)
+        Hashie::Mash.load(path)
+      end
+
+      def merge(org, new)
+        org.deep_merge(new)
+      end
+    end
+  end
+end

data/lib/pendulum/version.rb

@@ -0,0 +1,3 @@
+module Pendulum
+  VERSION = "0.1.0"
+end

data/pendulum.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pendulum/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "pendulum"
+  spec.version       = Pendulum::VERSION
+  spec.authors       = ["monochromegane"]
+  spec.email         = ["dev.kuro.obi@gmail.com"]
+
+  spec.summary       = %q{Pendulum is a tool to manage Treasure Data scheduled jobs.}
+  spec.description   = %q{Pendulum is a tool to manage Treasure Data scheduled jobs.}
+  spec.homepage      = "https://github.com/monochromegane/pendulum"
+  spec.license       = "MIT"
+
+  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_dependency "td"
+  spec.add_dependency "td-client"
+  spec.add_dependency "hashie"
+  spec.add_dependency "highline"
+
+  spec.add_development_dependency "bundler", "~> 1.11"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.0"
+  spec.add_development_dependency "pry"
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: pendulum
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- monochromegane
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: td
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: td-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: highline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  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'
+description: Pendulum is a tool to manage Treasure Data scheduled jobs.
+email:
+- dev.kuro.obi@gmail.com
+executables:
+- pendulum
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- exe/pendulum
+- lib/pendulum.rb
+- lib/pendulum/client.rb
+- lib/pendulum/command/apply.rb
+- lib/pendulum/command/apply/result_url.rb
+- lib/pendulum/command/apply/schedule.rb
+- lib/pendulum/configuration.rb
+- lib/pendulum/dsl/converter.rb
+- lib/pendulum/dsl/helper.rb
+- lib/pendulum/dsl/output/base.rb
+- lib/pendulum/dsl/output/postgresql.rb
+- lib/pendulum/dsl/output/result.rb
+- lib/pendulum/dsl/output/treasure_data.rb
+- lib/pendulum/dsl/result.rb
+- lib/pendulum/dsl/schedule.rb
+- lib/pendulum/runner.rb
+- lib/pendulum/settings.rb
+- lib/pendulum/version.rb
+- pendulum.gemspec
+homepage: https://github.com/monochromegane/pendulum
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Pendulum is a tool to manage Treasure Data scheduled jobs.
+test_files: []