duck_duck_duck 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 57a6021e6db81052a0d1ded7aadb527cbb99059e
+  data.tar.gz: 3c2522c40d726f5cab897321d87488ab693705e1
+SHA512:
+  metadata.gz: 6a037d4aaef8c580f04fcd5fd50f3f5bc5f0b3d9a67a8bcb2ecb91131e377a88829e506c708f7ce93de664087dfecf0d269a09f568ecccc2740e3e45d98c62bc
+  data.tar.gz: efda3885fc1f6303b701eafaf3f22f471018060fac6cb861d70ec6c2c98c68b6a3228deabcba05131b59d371f7dfd5067a824c81462003e371e517e94fe73ec6

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,23 @@
+
+Copyright (c) 2013 da99
+
+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,19 @@
+
+duck_duck_duck
+==============
+You won't find this useful.
+
+However, if you are still curious:
+
+* If you like to break up apps into smaller apps,
+  and you want them to use the smae db, but
+  different tables, duck\_duck\_duck
+  lets you migrate those mini-apps
+  to the same db.
+
+Previously...
+=============
+
+Originally, this was a node module.
+The node module is no longer maintained. It is now
+a Ruby gem.

data/VERSION

@@ -0,0 +1 @@
+1.0.0

data/bin/duck_duck_duck

@@ -0,0 +1,33 @@
+#!/usr/bin/env ruby
+#
+
+case ARGV[0]
+
+when 'help'
+
+  puts "========================"
+  puts ""
+  puts "help"
+  puts "create Model table"
+  puts "create Model default_data create"
+  puts "up"
+  puts "down"
+  puts "migrate_schema"
+  puts ""
+  puts "=== ENV/options: ==="
+  puts ""
+  puts "SCHEMA_TABLE=_schema_"
+  puts "DATABASE_URL='postgres://...@...:../..'"
+  puts ""
+  puts "========================"
+
+else
+
+  require 'duck_duck_duck'
+  fail "Unknown cmd: #{ARGV[0]}" unless %w{ migrate_schema reset create up down }.include?(ARGV[0])
+  Duck_Duck_Duck.send(*ARGV)
+
+end # === case ARGV[0]
+
+
+

data/duck_duck_duck.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "duck_duck_duck"
+  spec.version       = `cat VERSION`
+  spec.authors       = ["da99"]
+  spec.email         = ["i-hate-spam-1234567@mailinator.com"]
+  spec.summary       = %q{Migrations for apps composed of mini-apps.}
+  spec.description   = %q{
+    I use it to keep track of various mini-apps
+    within a larger app.
+  }
+  spec.homepage      = "https://github.com/da99/duck_duck_duck"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |file|
+    file.index('bin/') == 0 && file != "bin/#{File.basename Dir.pwd}"
+  }
+  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_development_dependency "pry"           , "~> 0.9"
+  spec.add_development_dependency "rake"          , "~> 10.3"
+  spec.add_development_dependency "bundler"       , "~> 1.5"
+  spec.add_development_dependency "bacon"         , "~> 1.2.0"
+  spec.add_development_dependency "Bacon_Colored" , "~> 0.1"
+
+  spec.add_development_dependency "sequel"        , "~> 4.13"
+  spec.add_development_dependency "pg"            , "~> 0.16"
+  spec.add_development_dependency "Exit_0"        , ">= 1.4.1"
+end

data/lib/duck_duck_duck.rb

@@ -0,0 +1,165 @@
+
+require "sequel"
+
+class Duck_Duck_Duck
+
+  DB           = Sequel.connect(ENV['DATABASE_URL'])
+  SCHEMA_TABLE = ENV['SCHEMA_TABLE'] || '_schema'
+
+  class << self
+
+    def dev_only
+      fail "Not allowed on a dev machine." if ENV['IS_DEV']
+    end
+
+    def create *args
+      new(*args).create
+    end
+
+    def migrate_schema
+      DB << <<-EOF
+        CREATE TABLE IF NOT EXISTS #{SCHEMA_TABLE} (
+          name      varchar(255) NOT NULL PRIMARY KEY ,
+          version   smallint     NOT NULL DEFAULT 0
+        )
+      EOF
+    end
+
+    %w{reset up down}.each { |meth|
+      eval <<-EOF, nil, __FILE__, __LINE__ + 1
+        def #{meth} name = nil
+          migrate_schema
+          names = name ? [name] : models
+          names.each { |name|
+            new(name).#{meth}
+          }
+        end
+      EOF
+    }
+
+    private # ======================================
+
+    def models
+      @models ||= Dir.glob("*/migrates").
+        map { |dir| File.basename File.dirname(dir) }
+    end
+
+  end # === class self ===
+
+  # ===============================================
+  # Instance methods:
+  # ===============================================
+
+  attr_reader :name, :action, :sub_action
+
+  def initialize *args
+    @name, @action, @sub_action = args
+    @files = Dir.glob("#{name}/migrates/*.sql")
+  end
+
+  def file_to_ver str
+    str.split('/').last[/\d{4}/].to_i
+  end
+
+  def reset
+    down
+    up
+  end
+
+  def up
+    rec = DB.fetch("SELECT version FROM #{SCHEMA_TABLE} WHERE name = :name",  :name=>name).all.first
+
+    if !rec
+      ds = DB["INSERT INTO #{SCHEMA_TABLE} (name, version) VALUES (?, ?)", name, 0]
+      ds.insert
+      rec = {:version=>0}
+    end
+
+    if rec[:version] < 0
+      puts "#{name} has an invalid version: #{rec[:version]}\n"
+      exit 1
+    end
+
+    files = @files.sort.map { |f|
+      ver = file_to_ver(f)
+      if ver > rec[:version]
+        [ ver, File.read(f).split('-- DOWN').first ]
+      end
+    }.compact
+
+    files.each { |pair|
+      ver = pair.first
+      sql = pair[1]
+      DB << sql
+      DB[" UPDATE #{SCHEMA_TABLE.inspect} SET version = ? WHERE name = ? ", ver, name].update
+      puts "#{name} schema is now : #{ver}"
+    }
+
+    if files.empty?
+      puts "#{name} is already the latest: #{rec[:version]}"
+    end
+  end # === def up
+
+  def down
+    rec = DB.fetch("SELECT version FROM #{SCHEMA_TABLE} WHERE name = :name",  :name=>name).all.first
+
+    if !rec
+      ds = DB["INSERT INTO #{SCHEMA_TABLE} (name, version) VALUES (?, ?)", name, 0]
+      ds.insert
+      rec = {:version=>0}
+    end
+
+    if rec[:version] == 0
+      puts "#{name} is already the latest: #{rec[:version]}\n"
+      exit 0
+    end
+
+    if rec[:version] < 0
+      puts "#{name} is at invalid version: #{rec[:version]}\n"
+      exit 1
+    end
+
+    files = @files.sort.reverse.map { |f|
+      ver = file_to_ver(f)
+      next unless ver <= rec[:version]
+      [ ver, File.read(f).split('-- DOWN').last ]
+    }.compact
+
+    if files.empty?
+      puts "#{name} is already the latest: #{rec[:version]}\n"
+    end
+
+    new_ver = nil
+
+    files.each_with_index { |pair, i|
+      prev_pair = files[i+1] || [0, nil]
+      ver = prev_pair.first.to_i
+      sql = pair[1]
+      DB << sql
+      DB[" UPDATE #{SCHEMA_TABLE} SET version = ? WHERE name = ? ", ver, name].update
+      puts "#{name} schema is now : #{ver}"
+    }
+
+  end # === def down
+
+  def create
+    `mkdir -p #{name}/migrates`
+
+    files = Dir.glob("#{name}/migrates/*.sql").grep(/\/\d{4}\-/).sort
+
+    next_ver = begin
+                 (files.last || '')[/\/(\d{4})[^\/]+$/]
+                 v = ($1 ? $1 : '0')
+                 '%04d' % (v.to_i + (10 - v[/\d$/].to_i))
+               end
+
+    new_file = "#{name}/migrates/#{next_ver}-#{[action, sub_action].compact.join('-')}.sql"
+    File.open(new_file, 'a') do |f|
+      f.puts "\n\n\n\n-- DOWN\n\n\n\n"
+    end
+
+    puts new_file
+  end # === def create
+
+
+end # === class Duck_Duck_Duck ===

data/node/app.js

@@ -0,0 +1,193 @@
+
+var _    = require('underscore')
+, path   = require('path')
+, fs     = require('fs')
+, exec   = require('child_process').exec
+, River  = require('da_river').River
+, Topogo = require('topogo').Topogo
+, argv   = require('optimist').argv
+;
+
+var schema_table    = process.env.SCHEMA_TABLE || '_schema';
+var MIGRATE_PATTERN = /^\d+\-/;
+var name            = path.basename(process.cwd());
+
+// From: stackoverflow.com/questions/1267283/how-can-i-create-a-zerofilled-value-using-javascript
+function pad_it(n, p, c) {
+    var pad_char = typeof c !== 'undefined' ? c : '0';
+    var pad = new Array(1 + p).join(pad_char);
+    return (pad + n).slice(-pad.length);
+}
+
+function read_migrates() {
+  var folder = 'migrates';
+  return (fs.existsSync(folder)) ? _.select(fs.readdirSync(folder), function (file, i) {
+    return file.match(MIGRATE_PATTERN);
+  }) : []
+}
+
+if (argv._[0] === 'list') {
+
+  River.new(null)
+  .job(function (j) {
+    Topogo.run('SELECT * FROM ' + schema_table + ' ;', [], j);
+  })
+  .job(function (j, list) {
+    _.each(list, function (o) {
+      var v = o.version;
+      if (o.version < 10)
+        v = ' ' + v;
+      console.log(v, o.name);
+    });
+    j.finish(list);
+  })
+  .run(function () {
+    Topogo.close();
+  });
+
+} else if (argv._[0] === 'create') {
+
+  var template  = fs.readFileSync(process.env.DUCK_TEMPLATE).toString();
+  var file_name = _.last(process.argv);
+  exec("mkdir -p migrates", function (err, data) {
+    if (err) throw err;
+
+    var max = _.map(read_migrates(), function (f_name, i) {
+      return parseInt(f_name, 10);
+    }).sort().pop() || 0;
+
+    var final_file_name = pad_it(max + 1, 3) + "-" + file_name + '.js';
+
+    process.chdir('migrates')
+    fs.writeFile(final_file_name, template, function () {
+    });
+  });
+
+} else if (_.contains(['up','down', 'drop_it'], argv._[0])) {
+  var migrates  = read_migrates();
+  var versions  = _.map(migrates, function (f) {
+    return parseInt(f, 10);
+  });
+
+  var orig_dir  = argv._[0];
+  var direction = (_.contains(['down', 'drop_it'], argv._[0])) ? 'down' : 'up';
+
+
+  if (direction === 'down')
+    migrates.sort().reverse();
+  else
+    migrates.sort();
+
+  River.new(null)
+  .job(function (j) {
+    Topogo.run('CREATE TABLE IF NOT EXISTS ' + schema_table + ' (' +
+               ' name varchar(255) NOT NULL UNIQUE ,   ' +
+               ' version smallint NOT NULL DEFAULT 0 ' +
+               ')', [], j);
+  })
+  .job(function (j) {
+    Topogo.run('SELECT * FROM ' + schema_table + ' WHERE name = $1 ;', [name], j);
+  })
+  .job(function (j, last) {
+    j.finish(last[0]);
+  })
+  .job(function (j, last) {
+    if (last)
+      j.finish(last.version);
+    else {
+      River.new(null)
+      .job(function (j_create) {
+        Topogo.new(schema_table)
+        .create({name: name}, j_create);
+      })
+      .run(function (j_create, last) {
+        j.finish(last.version);
+      });
+    }
+  })
+  .job(function (j, last_max) {
+    var r = River.new(null);
+    var has_migrates = false;
+
+    _.each(migrates, function (f) {
+      var max = parseInt(f, 10);
+
+      // Should it run?
+      if (direction === 'up' && last_max >= max)
+        return;
+      if (direction === 'down' && last_max < max)
+        return;
+
+      has_migrates = true;
+
+      // Yes? Then run it..
+      var m = require(process.cwd() + '/migrates/' + f);
+
+      r.job(function (j) {
+
+        var PG = j.PG = Topogo;
+
+        j.drop = function () {
+          var table_name = arguments[0];
+          var name       = function (str) { return str.replace(new RegExp('@_t', 'ig'), '"' + table_name + '"'); };
+          var r          = River.new(j);
+
+          _.each(_.toArray(arguments).reverse(), function (t_name) {
+            r.job(function (j) {
+              PG.run("DROP TABLE IF EXISTS \"" + t_name + "\" ;", [], j);
+            });
+          });
+
+          r.run();
+        }; // ================= .drop
+
+        j.create = function () {
+          var r = River.new(j);
+          _.each(_.toArray(arguments), function (sql) {
+            r.job(function (j) {
+              PG.run(sql, [], j);
+            });
+          });
+          r.run();
+        };
+
+        m.migrate(direction, j);
+      });
+
+      r.job(function (j) {
+        var t = Topogo.new(schema_table);
+        if (direction === 'down') {
+          max = _.find(versions.slice().reverse(), function (n) {
+            return n < max;
+          }) || 0;
+        }
+        t.update_where_set({name: name}, {version: max}, j);
+      });
+
+    });
+
+    if (has_migrates) {
+      r.run(function () {
+        j.finish();
+      });
+    } else {
+      j.finish();
+    }
+
+  })
+  .job(function (j, last) {
+    if (orig_dir !== 'drop_it')
+      return j.finish(last);
+    Topogo.run("DELETE FROM \"" + schema_table + "\" WHERE name = $1;", [name], j);
+  })
+  .run(function (r, last) {
+    Topogo.close();
+  });
+
+
+} else {
+  throw new Error("Unknown argument: " + JSON.stringify(argv._));
+}
+
+
+

data/node/drop.js

@@ -0,0 +1,17 @@
+
+
+var _  = require('underscore')
+, path = require('path')
+, fs = require('fs')
+, River = require('da_river').River
+, Topogo = require('topogo').Topogo
+;
+
+
+River.new(null)
+.job(function (j) {
+  Topogo.run('DROP TABLE IF EXISTS ' + (process.env.MIGRATE_TABLE || '_test_schema')+ ';', [], j);
+})
+.run(function () {
+  Topogo.close();
+});