metacon 0.0.1

data/.attic/old/.cmd_common

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Just a fancy way to run rake against exactly the right Rakefile, with a
+# default WORKER_ENV always of development, and more easily pass in
+# command-line parameters to the task, etc. Meant to be symlinked to.
+#
+# ex:
+# $  do-something production blah
+# (becomes, more or less)
+# $  WORKER_ENV=production rake do-something[blah]
+
+set -e # Exit on error
+#------------------------------------------------------------------------------
+# Make sure we know exactly where the real script is so we can run from
+# anywhere. (follows sym-links etc.)
+SCRIPT_PATH="${BASH_SOURCE[0]}";
+if [ -h "${SCRIPT_PATH}" ]; then
+  while([ -h "${SCRIPT_PATH}" ]) do
+    if [[ `uname -s` == 'Darwin' ]]; then
+      SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`
+    else
+      SCRIPT_PATH=`readlink -f "${SCRIPT_PATH}"`
+    fi
+  done
+fi
+pushd . > /dev/null
+cd `dirname ${SCRIPT_PATH}` > /dev/null
+SCRIPT_PATH=`pwd`;
+popd  > /dev/null
+#------------------------------------------------------------------------------
+
+RAKEFILE="${SCRIPT_PATH}/Rakefile" # Explicit to this Rakefile
+
+pushd . > /dev/null   # Save cwd & go to that rakefile's directory
+cd "${SCRIPT_PATH}"
+
+task=`basename ${BASH_SOURCE[0]}`
+if [[ "$#" > 0 ]]; then
+  worker_env=$1
+  shift
+else
+  worker_env=development
+fi
+WORKER_ENV=$worker_env rake --nosearch -f "${RAKEFILE}" ${task}[$@]
+popd > /dev/null    # Restore old cwd

data/.attic/old/Gemfile.lock

@@ -0,0 +1,7 @@
+GEM
+  specs:
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES

data/.attic/old/README

@@ -0,0 +1,24 @@
+    overlord help    # (or -h or --help)
+    overlord version # (or -v or --version)
+
+    overlord setup
+
+    overlord goto gamer_transcode/development
+
+    overlord build
+    overlord rebuild
+    overlord test
+
+
+### Setup
+(was initialize)
+
+
+
+### ". __overlord_helper" in .bashrc
+ - Set up overlord command (function that makes sure it's in the right dir
+   tree)
+ - Set up Autocomplete based on conf
+ - Set up bash prompt
+ - 'cd' monkeypatch to keep things consistent
+

data/.attic/old/Rakefile

@@ -0,0 +1,96 @@
+require 'rake/clean'
+require 'rubygems'
+require './helpers/rake_help.rb'
+require 'pp'
+
+task :default => :test
+
+desc "Initialize everything on a new machine"
+task :initialize => [:core_deps, :virtual_envs, :update_submodules]
+
+task :core_deps do
+  status "Checking for pythonbrew"
+  unless command_exists? 'pythonbrew'
+    cmd = ''
+    cfail("pythonbrew not found. Please install via the following bash commands:\n" +
+          "   |{=== curl -kL http://xrl.us/pythonbrewinstall} | |{=== bash}\n" +
+          "   |{=== echo '[[ -s $HOME/.pythonbrew/etc/bashrc ]] && " +
+                         "source $HOME/.pythonbrew/etc/bashrc' >> ~/.bashrc}\n" +
+          "   |{=== source $HOME/.pythonbrew/etc/bashrc}\n" +
+          "or by following instructions at https://github.com/utahta/pythonbrew.")
+  end
+  result 'installed'
+
+  status "Checking for python versions"
+  versions = `pythonbrew list`.split("\n").map{|p| p.strip}
+  unless versions.include?('Python-2.7.2')
+    result "installing isolated/local python 2.7.2"
+    sh 'pythonbrew install --no-test 2.7.2'
+  end
+  result "Python instance ready"
+
+end
+
+task :virtual_envs do
+  status "Creating virtual environments for various workers / environments"
+
+  result "not yet implemented"
+end
+
+desc "Update submodules (initializes if necessary) - run first and often"
+task :update_submodules => [:global_gitignore] do
+  sh "git submodule init"
+  sh "git submodule update"
+end
+
+task :build do
+  puts "build"
+end
+
+task :rebuild do
+  puts "rebuild"
+end
+
+
+task :restart do
+  puts "restart"
+end
+
+task :sync do
+  # Make sure that git doesn't have anything dangling - esp submodule commit
+  # changes or uncommitted submodule changes etc.
+  puts "sync"
+end
+
+task :test do
+  puts "test"
+end
+
+task :info do
+  puts "environment:  ..."
+  puts "worker-type:  ..."
+  puts "..."
+end
+
+
+task :global_gitignore do
+  globalignore = `git config -l | grep core.excludesfile | cut -d= -f2`.strip
+  if globalignore.length == 0 || (! File.exist?(globalignore))
+    color_puts "|{blue Hmm... you don't have a global .gitignore file...}"
+    puts "I'm going to add one for you with a bunch of nice defaults at "+
+         "~/.gitignore. I hope you don't mind...\n\n"
+    sh "git config --global core.excludesfile ~/.gitignore"
+    sh "echo -e \".DS_Store\nThumbs.db\n.*.swp\n.bundle\n*.tmproj\ntmtags\n"+
+       "*~\n\\#*\n.\\#*\n.redcar\n*.rbc\" >> ~/.gitignore"
+    globalignore = `git config -l | grep core.excludesfile | cut -d= -f2`.strip
+  end
+
+  if globalignore.length > 0 && `grep description-pak \"#{globalignore}\"`.strip.length == 0
+    color_puts "|{blue Adding some generated package stuff to your global "+
+               "gitignore so that the submodules don't get messy.}"
+    color_puts "(Can't add to some individual .gitignores because the "+
+               "submodules may not be under our control)"
+    sh "echo \"\\ndescription-pak\\ndoc-pak\\nffmpeg_*.deb\\nx264_*.deb\" >> "+
+       "\"#{globalignore}\""
+  end
+end

data/.attic/old/build

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Just a fancy way to run rake against exactly the right Rakefile, with a
+# default WORKER_ENV always of development, and more easily pass in
+# command-line parameters to the task, etc. Meant to be symlinked to.
+#
+# ex:
+# $  do-something production blah
+# (becomes, more or less)
+# $  WORKER_ENV=production rake do-something[blah]
+
+set -e # Exit on error
+#------------------------------------------------------------------------------
+# Make sure we know exactly where the real script is so we can run from
+# anywhere. (follows sym-links etc.)
+SCRIPT_PATH="${BASH_SOURCE[0]}";
+if [ -h "${SCRIPT_PATH}" ]; then
+  while([ -h "${SCRIPT_PATH}" ]) do
+    if [[ `uname -s` == 'Darwin' ]]; then
+      SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`
+    else
+      SCRIPT_PATH=`readlink -f "${SCRIPT_PATH}"`
+    fi
+  done
+fi
+pushd . > /dev/null
+cd `dirname ${SCRIPT_PATH}` > /dev/null
+SCRIPT_PATH=`pwd`;
+popd  > /dev/null
+#------------------------------------------------------------------------------
+
+RAKEFILE="${SCRIPT_PATH}/Rakefile" # Explicit to this Rakefile
+
+pushd . > /dev/null   # Save cwd & go to that rakefile's directory
+cd "${SCRIPT_PATH}"
+
+task=`basename ${BASH_SOURCE[0]}`
+if [[ "$#" > 0 ]]; then
+  worker_env=$1
+  shift
+else
+  worker_env=development
+fi
+WORKER_ENV=$worker_env rake --nosearch -f "${RAKEFILE}" ${task}[$@]
+popd > /dev/null    # Restore old cwd

data/.attic/old/initialize

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Just a fancy way to run rake against exactly the right Rakefile, with a
+# default WORKER_ENV always of development, and more easily pass in
+# command-line parameters to the task, etc. Meant to be symlinked to.
+#
+# ex:
+# $  do-something production blah
+# (becomes, more or less)
+# $  WORKER_ENV=production rake do-something[blah]
+
+set -e # Exit on error
+#------------------------------------------------------------------------------
+# Make sure we know exactly where the real script is so we can run from
+# anywhere. (follows sym-links etc.)
+SCRIPT_PATH="${BASH_SOURCE[0]}";
+if [ -h "${SCRIPT_PATH}" ]; then
+  while([ -h "${SCRIPT_PATH}" ]) do
+    if [[ `uname -s` == 'Darwin' ]]; then
+      SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`
+    else
+      SCRIPT_PATH=`readlink -f "${SCRIPT_PATH}"`
+    fi
+  done
+fi
+pushd . > /dev/null
+cd `dirname ${SCRIPT_PATH}` > /dev/null
+SCRIPT_PATH=`pwd`;
+popd  > /dev/null
+#------------------------------------------------------------------------------
+
+RAKEFILE="${SCRIPT_PATH}/Rakefile" # Explicit to this Rakefile
+
+pushd . > /dev/null   # Save cwd & go to that rakefile's directory
+cd "${SCRIPT_PATH}"
+
+task=`basename ${BASH_SOURCE[0]}`
+if [[ "$#" > 0 ]]; then
+  worker_env=$1
+  shift
+else
+  worker_env=development
+fi
+WORKER_ENV=$worker_env rake --nosearch -f "${RAKEFILE}" ${task}[$@]
+popd > /dev/null    # Restore old cwd

data/.attic/old/rake_help.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+$KCODE='U' if RUBY_VERSION < '1.9.0'
+
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Going to run `bundle install` to install missing gems"
+  sh 'bundle install'
+  begin
+    Bundler.setup(:default, :development)
+  rescue Bundler::BundlerError => e
+    $stderr.puts e.message
+    $stderr.puts "Run `bundle install` to install missing gems"
+    exit e.status_code
+  end
+end
+
+#require 'rake'
+require 'yaml'
+
+#include Rake::DSL
+
+ROOTDIR        = File.expand_path(File.join(File.dirname(__FILE__),'..'))
+CONTEXT_OS = `uname -s`.strip.downcase.to_sym
+def mac?()    CONTEXT_OS == :darwin end
+def darwin?() CONTEXT_OS == :darwin end
+def linux?()  CONTEXT_OS == :linux  end
+
+ESCS = {:normal    =>"\e[0m",    :black     =>"\e[0;30m", :blue         =>"\e[0;34m",
+        :green     =>"\e[0;32m", :cyan      =>"\e[0;36m", :red          =>"\e[0;31m",
+        :purple    =>"\e[0;35m", :brown     =>"\e[0;33m", :gray         =>"\e[0;37m",
+        :dark_gray =>"\e[1;30m", :light_blue=>"\e[1;34m", :light_green  =>"\e[1;32m",
+        :light_cyan=>"\e[1;36m", :light_red =>"\e[1;31m", :light_purple =>"\e[1;35m",
+        :yellow    =>"\e[1;33m", :white     =>"\e[1;37m", :bg_black     =>"\e[40m",
+        :bg_red    =>"\e[41m",   :bg_green  =>"\e[42m",   :bg_yellow    =>"\e[43m",
+        :bg_blue   => "\e[44m",  :bg_magenta=>"\e[45m",   :bg_cyan      =>"\e[46m",
+        :bg_white  => "\e[47m",  :"="       =>"\e[44;1;37m", :"=="      =>"\e[4;1;37m",
+        :"==="     => "\e[1;34m"}
+
+def color_puts(str, emit=true)
+  begin
+    r = false
+    str.gsub!(/\|\{([^ \|]+ )([^\}\|]*)\}/){r=true; "#{ESCS[$1.strip.to_sym]}#{$2}#{ESCS[:normal]}"}
+  end while r
+  puts str if emit
+  return str
+end
+
+def cwarn(str) color_puts("---|{red Warning:} #{str}") end
+def cfail(str) color_fail("---|{red Fail:} #{str}") end
+def color_fail(str) fail color_puts(str, false) end
+
+def status(str) color_puts("\n---|{== #{str}}") end
+def result(str) color_puts("   |{green #{str}}\n") end
+
+def f(*args) File.expand_path(File.join(args)) end # Shortcut for File.join
+
+def chd(*args)
+  dir = f(args)
+  color_puts "|{gray cd #{dir}}"
+  Dir.chdir(dir)
+end
+
+def command_exists?(cmd)
+  `( command -v #{cmd} )`.length > 0
+end
+
+def vew(cmd)
+  sh "#{ROOTDIR}/vew #{cmd}"
+  #sh "/bin/bash -c '. /usr/local/bin/virtualenvwrapper.sh ; #{cmd}'"
+end
+
+# From http://svn.ruby-lang.org/repos/ruby/trunk/lib/shellwords.rb
+def shellescape(str)
+  return "''" if str.empty?
+  str = str.dup
+  str.strip!
+  str.gsub!(/([^A-Za-z0-9_\-.,:\/@\n])/n, "\\\\\\1")
+  str.gsub!(/\n/, "'\n'")
+  return str
+end
+
+def ensure_profile_has(cmd, also_run=true)
+    prof = Dir[ENV['HOME']+'/.bash_profile']
+    prof = Dir[ENV['HOME']+'/.profile'] if prof.size == 0
+    prof = Dir[ENV['HOME']+'/.bashrc'] if prof.size == 0
+    if prof.size == 0
+      color_puts("\n|{red IMPORTANT: Please put the following in your .bash_profile equivalent: #{cmd}}\n")
+    else
+      there = `grep -F #{shellescape(cmd)} '#{prof[0]}'`.length > 0
+      unless there
+        color_puts "|{brown ADDING >>> |{yellow #{cmd.strip}}} |{brown <<< to your #{prof[0]}!}"
+        sh "echo #{shellescape(cmd)} >> '#{prof[0]}'"
+      end
+    end
+    sh cmd if also_run
+end

data/.attic/old/rebuild

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Just a fancy way to run rake against exactly the right Rakefile, with a
+# default WORKER_ENV always of development, and more easily pass in
+# command-line parameters to the task, etc. Meant to be symlinked to.
+#
+# ex:
+# $  do-something production blah
+# (becomes, more or less)
+# $  WORKER_ENV=production rake do-something[blah]
+
+set -e # Exit on error
+#------------------------------------------------------------------------------
+# Make sure we know exactly where the real script is so we can run from
+# anywhere. (follows sym-links etc.)
+SCRIPT_PATH="${BASH_SOURCE[0]}";
+if [ -h "${SCRIPT_PATH}" ]; then
+  while([ -h "${SCRIPT_PATH}" ]) do
+    if [[ `uname -s` == 'Darwin' ]]; then
+      SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`
+    else
+      SCRIPT_PATH=`readlink -f "${SCRIPT_PATH}"`
+    fi
+  done
+fi
+pushd . > /dev/null
+cd `dirname ${SCRIPT_PATH}` > /dev/null
+SCRIPT_PATH=`pwd`;
+popd  > /dev/null
+#------------------------------------------------------------------------------
+
+RAKEFILE="${SCRIPT_PATH}/Rakefile" # Explicit to this Rakefile
+
+pushd . > /dev/null   # Save cwd & go to that rakefile's directory
+cd "${SCRIPT_PATH}"
+
+task=`basename ${BASH_SOURCE[0]}`
+if [[ "$#" > 0 ]]; then
+  worker_env=$1
+  shift
+else
+  worker_env=development
+fi
+WORKER_ENV=$worker_env rake --nosearch -f "${RAKEFILE}" ${task}[$@]
+popd > /dev/null    # Restore old cwd

data/.attic/old/restart

@@ -0,0 +1,44 @@
+#!/bin/bash
+# Just a fancy way to run rake against exactly the right Rakefile, with a
+# default WORKER_ENV always of development, and more easily pass in
+# command-line parameters to the task, etc. Meant to be symlinked to.
+#
+# ex:
+# $  do-something production blah
+# (becomes, more or less)
+# $  WORKER_ENV=production rake do-something[blah]
+
+set -e # Exit on error
+#------------------------------------------------------------------------------
+# Make sure we know exactly where the real script is so we can run from
+# anywhere. (follows sym-links etc.)
+SCRIPT_PATH="${BASH_SOURCE[0]}";
+if [ -h "${SCRIPT_PATH}" ]; then
+  while([ -h "${SCRIPT_PATH}" ]) do
+    if [[ `uname -s` == 'Darwin' ]]; then
+      SCRIPT_PATH=`readlink "${SCRIPT_PATH}"`
+    else
+      SCRIPT_PATH=`readlink -f "${SCRIPT_PATH}"`
+    fi
+  done
+fi
+pushd . > /dev/null
+cd `dirname ${SCRIPT_PATH}` > /dev/null
+SCRIPT_PATH=`pwd`;
+popd  > /dev/null
+#------------------------------------------------------------------------------
+
+RAKEFILE="${SCRIPT_PATH}/Rakefile" # Explicit to this Rakefile
+
+pushd . > /dev/null   # Save cwd & go to that rakefile's directory
+cd "${SCRIPT_PATH}"
+
+task=`basename ${BASH_SOURCE[0]}`
+if [[ "$#" > 0 ]]; then
+  worker_env=$1
+  shift
+else
+  worker_env=development
+fi
+WORKER_ENV=$worker_env rake --nosearch -f "${RAKEFILE}" ${task}[$@]
+popd > /dev/null    # Restore old cwd