ridgepole 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7a10d9b0607e25c59ff80c62aad7a6994d3b84d
+  data.tar.gz: 56933fbf7941579d0e83d56a10a8703a555baff6
+SHA512:
+  metadata.gz: f353e4f59e6188b7851eb14a90ee7ece7484f994f6a80258c1453e1ef0aeb74edf11d5257a71d4330aa8cebc98c5cf946f5238f3b803010deedefcdf44f76ffd
+  data.tar.gz: 70a90fa4e5a3acb0b23746871f6bec0a4adcffbe4b7d50891264f9aaf9657c0eccc23dc0868753e506a44805559037c4f7db560bd3be46ef14abaca336e8039a

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.DS_Store
+test.rb
+Schemafile

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Genki Sugawara
+
+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,35 @@
+# Ridgepole
+
+Ridgepole is a tool to DB schema.
+
+It defines DB schema using [Rails DSL](http://guides.rubyonrails.org/migrations.html#types-of-schema-dumps), and updates DB schema according to DSL.
+(like Chef/Puppet)
+
+[![Gem Version](https://badge.fury.io/rb/ridgepole.png)](http://badge.fury.io/rb/ridgepole)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ridgepole'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ridgepole
+
+## Usage
+
+```sh
+ridgepole --export -o Schemafile
+vi Schemafile
+ridgepole --apply --dry-run
+ridgepole --apply
+```
+
+## Demo
+
+* [asciinema.org/a/9349](https://asciinema.org/a/9349)

data/Rakefile

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

data/bin/ridgepole

@@ -0,0 +1,88 @@
+#!/usr/bin/env ruby
+$: << File.expand_path('../../lib', __FILE__)
+require 'rubygems'
+require 'yaml'
+require 'optparse'
+require 'ridgepole'
+
+Version = Ridgepole::VERSION
+DEFAULT_FILENAME = 'Schemafile'
+
+config = nil
+mode = nil
+file = DEFAULT_FILENAME
+output_file = '-'
+
+options = {
+  :dry_run => false,
+  :debug   => false,
+}
+
+ARGV.options do |opt|
+  begin
+    opt.on('-c', '--config CONF_OR_FILE') {|v| config            = v       }
+    opt.on('-a', '--apply')               {    mode              = :apply  }
+    opt.on('-f', '--file FILE')           {|v| file              = v       }
+    opt.on('',   '--dry-run')             {    options[:dry_run] = true    }
+    opt.on('-e', '--export')              {    mode              = :export }
+    opt.on('-o', '--output FILE')         {|v| output_file       = v       }
+    opt.on(''  , '--debug')               {    options[:debug]   = true    }
+    opt.parse!
+
+    unless config and mode
+      puts opt.help
+      exit 1
+    end
+  rescue => e
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  end
+end
+
+begin
+  logger = Ridgepole::Logger.instance
+  logger.set_debug(options[:debug])
+
+  config = open(config) {|f| f.read } if File.exist?(config)
+  config = YAML.load(config)
+  client = Ridgepole::Client.new(config, options)
+
+  case mode
+  when :export
+    if output_file == '-'
+      logger.info('# Export Schema')
+      puts client.dump
+    else
+      logger.info("Export Schema to `#{output_file}`")
+      open(output_file, 'wb') {|f| f.puts client.dump }
+    end
+  when :apply
+    unless File.exist?(file)
+      raise "No Schemafile found (looking for: #{file})"
+    end
+
+    msg = "Apply `#{file}`"
+    msg << ' (dry-run)' if options[:dry_run]
+    logger.info(msg)
+
+    dsl = open(file) {|f| f.read }
+    delta = client.diff(dsl)
+
+    if options[:dry_run]
+      puts delta.script if delta.differ?
+    else
+      delta.migrate
+    end
+
+    unless delta.differ?
+      logger.info('No change')
+    end
+  end
+rescue => e
+  if options[:debug]
+    raise e
+  else
+    $stderr.puts("[ERROR] #{e.message}")
+    exit 1
+  end
+end

data/lib/ridgepole.rb

@@ -0,0 +1,15 @@
+require 'logger'
+require 'singleton'
+require 'stringio'
+
+require 'active_record'
+
+module Ridgepole; end
+require 'ridgepole/client'
+require 'ridgepole/delta'
+require 'ridgepole/diff'
+require 'ridgepole/dsl_parser'
+require 'ridgepole/dumper'
+require 'ridgepole/logger'
+require 'ridgepole/string_ext'
+require 'ridgepole/version'

data/lib/ridgepole/client.rb

@@ -0,0 +1,20 @@
+class Ridgepole::Client
+  def initialize(conn_spec, options = {})
+    @options = options
+    ActiveRecord::Base.establish_connection(conn_spec)
+
+    @dumper = Ridgepole::Dumper.new(@options)
+    @parser = Ridgepole::DSLParser.new(@options)
+    @diff = Ridgepole::Diff.new(@options)
+  end
+
+  def dump
+    @dumper.dump
+  end
+
+  def diff(dsl)
+    expected_definition = @parser.parse(dsl)
+    current_definition = @parser.parse(@dumper.dump)
+    @diff.diff(current_definition, expected_definition)
+  end
+end

data/lib/ridgepole/delta.rb

@@ -0,0 +1,166 @@
+class Ridgepole::Delta
+  def initialize(delta, options = {})
+    @delta = delta
+    @options = options
+  end
+
+  def migrate
+    ActiveRecord::Schema.new.instance_eval(script)
+  end
+
+  def script
+    buf = StringIO.new
+
+    (@delta[:add] || {}).each do |table_name, attrs|
+      append_create_table(table_name, attrs, buf)
+    end
+
+    (@delta[:rename] || {}).each do |table_name, attrs|
+      append_rename_table(table_name, attrs, buf)
+    end
+
+    (@delta[:change] || {}).each do |table_name, attrs|
+      append_change(table_name, attrs, buf)
+    end
+
+    (@delta[:delete] || {}).each do |table_name, attrs|
+      append_drop_table(table_name, attrs, buf)
+    end
+
+    buf.string.strip
+  end
+
+  def differ?
+    not script.empty?
+  end
+
+  private
+
+  def append_create_table(table_name, attrs, buf)
+    options = attrs[:options] || {}
+    definition = attrs[:definition] || {}
+    indices = attrs[:indices] || {}
+
+    buf.puts(<<-EOS)
+create_table(#{table_name.inspect}, #{options.inspect}) do |t|
+    EOS
+
+    definition.each do |column_name, column_attrs|
+      column_type = column_attrs.fetch(:type)
+      column_options = column_attrs[:options] || {}
+
+      buf.puts(<<-EOS)
+  t.#{column_type}(#{column_name.inspect}, #{column_options.inspect})
+      EOS
+    end
+
+    buf.puts(<<-EOS)
+end
+    EOS
+
+    indices.each do |index_name, index_attrs|
+      append_add_index(table_name, index_name, index_attrs, buf)
+    end
+
+    buf.puts
+  end
+
+  def append_rename_table(to_table_name, from_table_name, buf)
+    buf.puts(<<-EOS)
+rename_table(#{from_table_name.inspect}, #{to_table_name.inspect})
+    EOS
+
+    buf.puts
+  end
+
+  def append_drop_table(table_name, attrs, buf)
+    buf.puts(<<-EOS)
+drop_table(#{table_name.inspect})
+    EOS
+
+    buf.puts
+  end
+
+  def append_change(table_name, attrs, buf)
+    append_change_definition(table_name, attrs[:definition] || {}, buf)
+    append_change_indices(table_name, attrs[:indices] || {}, buf)
+    buf.puts
+  end
+
+  def append_change_definition(table_name, delta, buf)
+    (delta[:add] || {}).each do |column_name, attrs|
+      append_add_column(table_name, column_name, attrs, buf)
+    end
+
+    (delta[:rename] || {}).each do |column_name, attrs|
+      append_rename_column(table_name, column_name, attrs, buf)
+    end
+
+    (delta[:change] || {}).each do |column_name, attrs|
+      append_change_column(table_name, column_name, attrs, buf)
+    end
+
+    (delta[:delete] || {}).each do |column_name, attrs|
+      append_remove_column(table_name, column_name, attrs, buf)
+    end
+  end
+
+  def append_add_column(table_name, column_name, attrs, buf)
+    type = attrs.fetch(:type)
+    options = attrs[:options] || {}
+
+    buf.puts(<<-EOS)
+add_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{options.inspect})
+    EOS
+  end
+
+  def append_rename_column(table_name, to_column_name, from_column_name, buf)
+    buf.puts(<<-EOS)
+rename_column(#{table_name.inspect}, #{from_column_name.inspect}, #{to_column_name.inspect})
+    EOS
+  end
+
+  def append_change_column(table_name, column_name, attrs, buf)
+    type = attrs.fetch(:type)
+    options = attrs[:options] || {}
+
+    buf.puts(<<-EOS)
+change_column(#{table_name.inspect}, #{column_name.inspect}, #{type.inspect}, #{options.inspect})
+    EOS
+  end
+
+  def append_remove_column(table_name, column_name, attrs, buf)
+    buf.puts(<<-EOS)
+remove_column(#{table_name.inspect}, #{column_name.inspect})
+    EOS
+  end
+
+  def append_change_indices(table_name, delta, buf)
+    (delta[:add] || {}).each do |index_name, attrs|
+      append_add_index(table_name, index_name, attrs, buf)
+    end
+
+    (delta[:delete] || {}).each do |index_name, attrs|
+      append_remove_index(table_name, index_name, attrs, buf)
+    end
+  end
+
+  def append_add_index(table_name, index_name, attrs, buf)
+    column_name = attrs.fetch(:column_name)
+    options = attrs[:options] || {}
+
+    buf.puts(<<-EOS)
+add_index(#{table_name.inspect}, #{column_name.inspect}, #{options.inspect})
+    EOS
+  end
+
+  def append_remove_index(table_name, index_name, attrs, buf)
+    column_name = attrs.fetch(:column_name)
+    options = attrs[:options] || {}
+    target = options[:name] ? {:name => options[:name]} : column_name
+
+    buf.puts(<<-EOS)
+remove_index(#{table_name.inspect}, #{target.inspect})
+    EOS
+  end
+end

data/lib/ridgepole/diff.rb

@@ -0,0 +1,136 @@
+class Ridgepole::Diff
+  def initialize(options = {})
+    @options = options
+  end
+
+  def diff(from, to)
+    from = (from || {}).dup
+    to = (to || {}).dup
+    delta = {}
+
+    to.dup.each do |table_name, to_attrs|
+      if (from_table_name = (to_attrs[:options] || {}).delete(:from))
+        next unless from.has_key?(from_table_name)
+        delta[:rename] ||= {}
+        delta[:rename][table_name] = from_table_name
+        from.delete(from_table_name)
+        to.delete(table_name)
+      end
+    end
+
+    to.each do |table_name, to_attrs|
+      if (from_attrs = from.delete(table_name))
+        scan_change(table_name, from_attrs, to_attrs, delta)
+      else
+        delta[:add] ||= {}
+        delta[:add][table_name] = to_attrs
+      end
+    end
+
+    from.each do |table_name, from_attrs|
+      delta[:delete] ||= {}
+      delta[:delete][table_name] = from_attrs
+    end
+
+    Ridgepole::Delta.new(delta, @options)
+  end
+
+  private
+
+  def scan_change(table_name, from, to, delta)
+    from = (from || {}).dup
+    to = (to || {}).dup
+    table_delta = {}
+
+    scan_options_change(from[:options], to[:options], table_delta)
+    scan_definition_change(from[:definition], to[:definition], table_delta)
+    scan_indices_change(from[:indices], to[:indices], table_delta)
+
+    unless table_delta.empty?
+      delta[:change] ||= {}
+      delta[:change][table_name] = table_delta
+    end
+  end
+
+  def scan_options_change(from, to, table_delta)
+    # XXX: Warn differences of options
+  end
+
+  def scan_definition_change(from, to, table_delta)
+    from = (from || {}).dup
+    to = (to || {}).dup
+    definition_delta = {}
+
+    to.dup.each do |column_name, to_attrs|
+      if (from_column_name = (to_attrs[:options] || {}).delete(:from))
+        next unless from.has_key?(from_column_name)
+        definition_delta[:rename] ||= {}
+        definition_delta[:rename][column_name] = from_column_name
+        from.delete(from_column_name)
+        to.delete(column_name)
+      end
+    end
+
+    priv_column_name = nil
+
+    to.each do |column_name, to_attrs|
+      if (from_attrs = from.delete(column_name))
+        if from_attrs != to_attrs
+          definition_delta[:change] ||= {}
+          definition_delta[:change][column_name] = to_attrs
+        end
+      else
+        definition_delta[:add] ||= {}
+        to_attrs[:options] ||= {}
+
+        if priv_column_name
+          to_attrs[:options][:after] = priv_column_name
+        else
+          to_attrs[:options][:first] = true
+        end
+
+        definition_delta[:add][column_name] = to_attrs
+      end
+
+      priv_column_name = column_name
+    end
+
+    from.each do |column_name, from_attrs|
+      definition_delta[:delete] ||= {}
+      definition_delta[:delete][column_name] = from_attrs
+    end
+
+    unless definition_delta.empty?
+      table_delta[:definition] = definition_delta
+    end
+  end
+
+  def scan_indices_change(from, to, table_delta)
+    from = (from || {}).dup
+    to = (to || {}).dup
+    indices_delta = {}
+
+    to.each do |index_name, to_attrs|
+      if (from_attrs = from.delete(index_name))
+        if from_attrs != to_attrs
+          indices_delta[:add] ||= {}
+          indices_delta[:delete] ||= {}
+          indices_delta[:add][index_name] = to_attrs
+          indices_delta[:delete][index_name] = from_attrs
+        end
+      else
+        indices_delta[:add] ||= {}
+        indices_delta[:add][index_name] = to_attrs
+      end
+    end
+
+    from.each do |index_name, from_attrs|
+      indices_delta[:delete] ||= {}
+      indices_delta[:delete][index_name] = from_attrs
+    end
+
+    unless indices_delta.empty?
+      table_delta[:indices] = indices_delta
+    end
+  end
+end

data/lib/ridgepole/dsl_parser.rb

@@ -0,0 +1,81 @@
+class Ridgepole::DSLParser
+  class Context
+    class TableDefinition
+      attr_reader :__definition
+
+      def initialize
+        @__definition = {}
+      end
+
+      def column(name, type, options = {})
+        @__definition[name] = {
+          :type => type,
+          :options => options,
+        }
+      end
+
+      TYPES = [
+        :string,
+        :text,
+        :integer,
+        :float,
+        :decimal,
+        :datetime,
+        :timestamp,
+        :time,
+        :date,
+        :binary,
+        :boolean
+      ]
+
+      TYPES.each do |column_type|
+        define_method column_type do |*args|
+          options = args.extract_options!
+          column_names = args
+          column_names.each {|name| column(name, column_type, options) }
+        end
+      end
+    end
+
+    attr_reader :__definition
+
+    def initialize
+      @__definition = {}
+    end
+
+    def self.eval(dsl)
+      ctx = self.new
+      ctx.instance_eval(dsl)
+      ctx.__definition
+    end
+
+    def create_table(table_name, options = {})
+      # XXX: Add exist check
+      table_definition = TableDefinition.new
+      yield(table_definition)
+      @__definition[table_name] ||= {}
+      @__definition[table_name][:definition] = table_definition.__definition
+      options.delete(:force)
+      @__definition[table_name][:options] = options
+    end
+
+    def add_index(table_name, column_name, options = {})
+      # XXX: Add exist check
+      @__definition[table_name] ||= {}
+      @__definition[table_name][:indices] ||= {}
+      idx = options[:name] || column_name
+      @__definition[table_name][:indices][idx] = {
+        :column_name => column_name,
+        :options => options,
+      }
+    end
+  end
+
+  def initialize(options = {})
+    @options = options
+  end
+
+  def parse(dsl)
+    Context.eval(dsl)
+  end
+end

data/lib/ridgepole/dumper.rb

@@ -0,0 +1,16 @@
+class Ridgepole::Dumper
+  def initialize(options = {})
+    @options = options
+  end
+
+  def dump
+    stream = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, stream)
+
+    stream.string.lines.select {|line|
+      line !~ /\A#/ &&
+      line !~ /\AActiveRecord::Schema\.define/ &&
+      line !~ /\Aend/
+    }.join.undent.strip
+  end
+end

data/lib/ridgepole/logger.rb

@@ -0,0 +1,17 @@
+class Ridgepole::Logger < ::Logger
+  include Singleton
+
+  def initialize
+    super($stdout)
+
+    self.formatter = proc do |severity, datetime, progname, msg|
+      "#{msg}\n"
+    end
+
+    self.level = Logger::INFO
+  end
+
+  def set_debug(value)
+    self.level = value ? Logger::DEBUG : Logger::INFO
+  end
+end

data/lib/ridgepole/string_ext.rb

@@ -0,0 +1,11 @@
+class String
+  def undent
+    min_space_num = self.split("\n").delete_if {|s| s =~ /^\s*$/ }.map {|s| (s[/^\s+/] || '').length }.min
+
+    if min_space_num and min_space_num > 0
+      gsub(/^[ \t]{,#{min_space_num}}/, '')
+    else
+      self
+    end
+  end
+end

data/lib/ridgepole/version.rb

@@ -0,0 +1,3 @@
+module Ridgepole
+  VERSION = '0.0.1'
+end

data/ridgepole.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ridgepole/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'ridgepole'
+  spec.version       = Ridgepole::VERSION
+  spec.authors       = ['Genki Sugawara']
+  spec.email         = ['sugawara@cookpad.com']
+  spec.summary       = %q{Ridgepole is a tool to DB schema.}
+  spec.description   = %q{Ridgepole is a tool to DB schema. It defines DB schema using Rails DSL, and updates DB schema according to DSL.}
+  spec.homepage      = 'https://bitbucket.org/winebarrel/ridgepole'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'activerecord'
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 2.14.1'
+  spec.add_development_dependency 'mysql2'
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: ridgepole
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Genki Sugawara
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-05-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  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: '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: 2.14.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 2.14.1
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  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: Ridgepole is a tool to DB schema. It defines DB schema using Rails DSL,
+  and updates DB schema according to DSL.
+email:
+- sugawara@cookpad.com
+executables:
+- ridgepole
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/ridgepole
+- lib/ridgepole.rb
+- lib/ridgepole/client.rb
+- lib/ridgepole/delta.rb
+- lib/ridgepole/diff.rb
+- lib/ridgepole/dsl_parser.rb
+- lib/ridgepole/dumper.rb
+- lib/ridgepole/logger.rb
+- lib/ridgepole/string_ext.rb
+- lib/ridgepole/version.rb
+- ridgepole.gemspec
+homepage: https://bitbucket.org/winebarrel/ridgepole
+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.0.14
+signing_key: 
+specification_version: 4
+summary: Ridgepole is a tool to DB schema.
+test_files: []