popo 0.1.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem "cableguy"
+# Specify your gem's dependencies in popo.gemspec
+gemspec

data/README

@@ -0,0 +1 @@
+popo rails repo tool

data/Rakefile

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

data/bin/envy

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+require 'yaml'
+
+ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+BASH_PATH = `which bash`.strip
+ENV_PATH = `which env`.strip
+POPO_PATH = ENV['popo_path'] if ENV.include?('popo_path')
+POPO_TARGET = ENV['popo_target'] if ENV.include?('popo_target')
+POPO_WORK_PATH = '.manifest'
+ENVYRC = File.join(POPO_PATH, POPO_WORK_PATH, 'script/envyrc')
+
+cmd = ARGV.join(' ')
+
+finale = "#{ENV_PATH} popo_path=#{POPO_PATH} popo_target=#{POPO_TARGET} #{BASH_PATH} -c 'source #{ENVYRC}; cd #{POPO_PATH}; #{cmd}'"
+system(finale)
+

data/bin/popo

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+
+POPO_BASE_PATH = File.expand_path('../', File.dirname(__FILE__))
+require File.join(POPO_BASE_PATH, 'lib/popo')
+Popo::Runner.boot(ARGV)
+

data/config/envy.yml.sample

@@ -0,0 +1,4 @@
+# sample
+# popo_path: /opt/palmade/development
+# popo_target: development
+# envyrc_path: scripts/envyrc

data/config/popo_config.yml.sample

@@ -0,0 +1,15 @@
+repo:
+  popo: jan@localhost:/opt/popo.git
+  rvm: jan@git.caresharing:popo/rvm.git
+  tools: jan@git.caresharing:popo/tools.git
+manifest:
+  source: https://popo.caresharing.eu
+rvm:
+  rubies: [ree-1.8.7-2010.01, ruby-1.9.2]
+  default: ree-1.8.7-2010.01
+popo:
+  tree: [ 'apps', 'assets', 'frameworks', 'plugins', 'helpers', 'external', 'configs', 'out/logs', 'out/tmp/pids', 'out/tmp/caches', 'libwww']
+  default_target: development
+gems:
+  source: http://gems.caresharing.eu
+

data/lib/hash.rb

@@ -0,0 +1,23 @@
+class Hash
+  def deep_merge(hash)
+    target = dup
+    hash.keys.each do |key|
+      if hash[key].is_a? Hash and self[key].is_a? Hash
+        target[key] = target[key].deep_merge(hash[key])
+        next
+      end
+      target[key] = hash[key]
+    end
+    target
+  end
+
+  def deep_merge!(second)
+    second.each_pair do |k,v|
+      if self[k].is_a?(Hash) and second[k].is_a?(Hash)
+        self[k].deep_merge!(second[k])
+      else
+        self[k] = second[k]
+      end
+    end
+  end
+end

data/lib/popo.rb

@@ -0,0 +1,18 @@
+require 'rubygems'
+require 'palmade/cableguy'
+require 'optparse'
+require 'yaml'
+require 'fileutils'
+
+module Popo
+  POPO_LIB_ROOT = File.join(File.dirname(__FILE__), 'popo')
+
+  autoload :Constants, (File.join(POPO_LIB_ROOT, 'constants'))
+  autoload :Database, (File.join(POPO_LIB_ROOT, 'database'))
+  autoload :GitUtils, (File.join(POPO_LIB_ROOT, 'git_utils'))
+  autoload :Initializer, (File.join(POPO_LIB_ROOT, 'initializer'))
+  autoload :Runner, (File.join(POPO_LIB_ROOT, 'runner'))
+  autoload :RVM, (File.join(POPO_LIB_ROOT, 'rvm'))
+  autoload :Sync, (File.join(POPO_LIB_ROOT, 'sync'))
+  autoload :Utils, (File.join(POPO_LIB_ROOT, 'utils'))
+end

data/lib/popo/constants.rb

@@ -0,0 +1,9 @@
+module Popo
+  module Constants
+    POPORC = 'script/poporc'
+    DEFAULT_CONFIG_FILE = "popo_config.yml"
+    POPO_WORK_PATH = ".manifest"
+    POPO_YML_FILE = "popo.yml"
+    POPO_CONFIG = {}
+  end
+end

data/lib/popo/database.rb

@@ -0,0 +1,23 @@
+module Popo
+  class Database
+    def initialize(app_root, options)
+      @cabler = Palmade::Cableguy::Cabler.new(app_root, options)
+    end
+
+    def boot_database
+      @cabler.boot
+    end
+
+    def migrate_database
+      @cabler.migrate
+    end
+
+    def get(key, group = 'manifest')
+      @cabler.db.get(key, group)
+    end
+
+    def get_children(key, group = 'manifest')
+      @cabler.db.get_children(key, group)
+    end
+  end
+end

data/lib/popo/git_utils.rb

@@ -0,0 +1,60 @@
+module Popo
+  module GitUtils
+    include Constants
+
+    def self.git_clone(repo, clone_path, branch)
+      clone_path ||= nil
+      branch = 'master' if branch.nil?
+
+      if clone_path.nil?
+        cmd = "#{GIT_CMD} clone -b #{branch} #{repo}"
+      else
+        cmd = "#{GIT_CMD} clone -b #{branch} #{repo} #{clone_path}"
+      end
+
+      clone_msg = "Cloning branch #{branch} from #{repo}" +
+                  " to #{clone_path}"
+
+      Utils.say_with_time clone_msg do
+       `#{cmd}`
+      end
+    end
+
+    def self.git_update(repo, branch)
+      Utils.say_with_time "Updating #{repo}" do
+        Dir.chdir(repo) do
+          `#{GIT_CMD} fetch`
+        end
+      end
+
+      git_stash(repo)
+      git_checkout(repo, branch)
+      git_reset(repo, branch)
+    end
+
+    def self.git_stash(repo)
+      Utils.say_with_time "Stashing changes for #{repo}" do
+        Dir.chdir(repo) do
+          `#{GIT_CMD} stash`
+        end
+      end
+    end
+
+    def self.git_reset(repo, branch)
+      Utils.say_with_time "Doing a hard reset for #{repo}" do
+        Dir.chdir(repo) do
+          `#{GIT_CMD} reset --hard origin/#{branch}`
+        end
+      end
+    end
+
+    def self.git_checkout(repo, branch)
+      Utils.say_with_time "Switching to #{branch} branch" do
+        Dir.chdir(repo) do
+          `#{GIT_CMD} checkout #{branch}`
+        end
+      end
+    end
+  end
+end
+

data/lib/popo/initializer.rb

@@ -0,0 +1,60 @@
+module Popo
+  class Initializer
+    include Constants
+
+    def self.boot(config, options)
+      self.new(config, options)
+    end
+
+    def initialize(config, options)
+      @repos = {}
+
+      config['repos'].each do |k, v|
+        @repos[k] = v
+      end
+
+      @options = options
+      @default_target = @options[:target] || 'development'
+      @deploy_path = File.absolute_path(@options[:path])
+      @location = @options[:location] || nil
+    end
+
+    def print_variables
+      instance_variables.each do |i|
+        say instance_variable_get(i)
+      end
+    end
+
+    def setup
+      print_variables if @options[:verbose]
+
+      @repos.each do |k, v|
+        basename = File.basename(v['git'])
+
+        if k == POPO_WORK_PATH.delete('.')
+          clone_path = File.join(@deploy_path, POPO_WORK_PATH)
+        else
+          clone_path = File.join(@deploy_path, basename)
+        end
+
+        GitUtils.git_clone(v['git'], clone_path, v['branch'])
+      end
+
+      write_config
+    end
+
+    def write_config
+      popo = {}
+      popo['target'] = @default_target
+      popo['path'] = @deploy_path
+      popo['location'] = @location if !@location.nil?
+
+      yml_path = File.join(@deploy_path, POPO_WORK_PATH, POPO_YML_FILE)
+
+      File.open(yml_path, "w") do |f|
+        YAML.dump(popo, f)
+      end
+    end
+  end
+end
+

data/lib/popo/runner.rb

@@ -0,0 +1,139 @@
+module Popo
+  class Runner
+    include Constants
+
+    def self.boot(args)
+      Popo::Constants.const_set("BASH_CMD", `which bash`.strip)
+      Popo::Constants.const_set("ENV_CMD", `which env`.strip)
+      Popo::Constants.const_set("GIT_CMD", `which git`.strip)
+
+      self.new(args)
+    end
+
+    def initialize(args)
+      @popo_path = ENV['popo_path'] || Dir.pwd
+      @options = {}
+      @cabler_options = {}
+      @options[:verbose] = false
+
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Popo tool."
+        opts.separator "Options:"
+
+        opts.on('-p', '--path PATH', 'Target path') do |path|
+          @options[:path] = path
+        end
+
+        opts.on('-t', '--target TARGET', 'Deployment target') do |target|
+          @options[:target] = target
+        end
+
+        opts.on('-u', '--user USER', 'Username') do |user|
+          @options[:user] = user
+        end
+
+        opts.on('-l', '--location LOCATION', 'Location') do |location|
+          @options[:location] = location
+        end
+
+        opts.on('-v', '--verbose', 'Verbose') do
+          @options[:verbose] = true
+        end
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+
+      optparse.parse!
+
+      if args.length == 0
+        Utils.say optparse.help
+      else
+        @cabler_options = { :path  => File.join(@popo_path, POPO_WORK_PATH),
+                         :target   => ENV['CABLING_TARGET'],
+                         :location => ENV['CABLING_LOCATION'],
+                         :verbose  => @options[:verbose] }
+
+        run(args)
+      end
+    end
+
+    def run(args)
+      case args.shift
+      when 'init'
+        if !@options[:path].nil?
+          if !File.exist?(File.join(@popo_path, @options[:path]))
+            Initializer.boot(get_config!, @options).setup
+          else
+            raise "Path already exists!"
+          end
+        else
+          raise "Supply a path with the -p option!"
+        end
+      when 'sync'
+        if Utils.in_popo?(@popo_path)
+          db = Database.new(@popo_path, @cabler_options)
+          db.boot_database
+
+          Sync.new(@popo_path, args, db).gather
+        end
+      when 'rvminstall'
+        if Utils.in_popo?(@popo_path)
+          print "Install all rubies?(y/N): "
+
+          ok = $stdin.gets.chomp!
+          if ok == 'y'
+            db = Database.new(@popo_path, @cabler_options)
+            db.boot_database
+            RVM.new(@popo_path, args, db).setup
+          else
+            Utils.say "y/N only!"
+          end
+        end
+      when 'migrate'
+        if Utils.in_popo?(@popo_path)
+          db = Database.new(@popo_path, @cabler_options)
+          db.boot_database
+          db.migrate_database
+        end
+      when 'status'
+        Utils.say `cat #{File.join(@popo_path, POPO_WORK_PATH, POPO_YML_FILE)}`
+      when 'upload'
+        puts "Pushing!"
+      when 'bash'
+        bash!
+      else
+        puts "I don't know what to do."
+      end
+    end
+
+    def bash!
+      Utils.require_relative_work_popo(Dir.pwd)
+
+      poporc_path = File.join(Dir.pwd, POPO_WORK_PATH, POPORC)
+      target = POPO_CONFIG['target']
+      path = POPO_CONFIG['path']
+      location = POPO_CONFIG['location']
+
+      bashcmd = "%s popo_target=%s popo_path=%s \
+                popo_location=%s %s --rcfile %s" \
+                % [ENV_CMD, target, path, location, BASH_CMD, poporc_path]
+
+      exec(bashcmd)
+    end
+
+    def get_config!
+      if File.exist?(File.join(ENV['HOME'], ".#{DEFAULT_CONFIG_FILE}"))
+        config_file_path = File.join(ENV['HOME'], ".#{DEFAULT_CONFIG_FILE}")
+      elsif File.exist?(File.join('/etc', DEFAULT_CONFIG_FILE))
+        config_file_path = "/etc/#{DEFAULT_CONFIG_FILE}"
+      else
+        raise "No popo_config.yml found in #{ENV['HOME']} or /etc"
+      end
+
+      config_hash = YAML.load_file(config_file_path)
+    end
+  end
+end

data/lib/popo/rvm.rb

@@ -0,0 +1,59 @@
+module Popo
+  class RVM
+    def initialize(app_root, args, db)
+      @db = db
+      @app_root = app_root
+      @rvm_bin = File.join(@app_root, 'rvm/bin/rvm')
+      @repos = args
+
+      @rubies = @db.get("rvm.rubies").split(",")
+      @default_ruby = @db.get("rvm.ruby.default")
+      @default_gems = @db.get("rvm.gems.default").split(",")
+      @gem_source = @db.get("rvm.gems.source")
+    end
+
+    def setup
+      Utils.say "Rubies to be installed #{@rubies}...\n\n"
+
+      @rubies.each do |r|
+        patch = File.join(@app_root, 'rvm', "#{r}.patch")
+
+        if File.exists?(patch)
+          Utils.say("Patch for #{r} is found at #{patch}")
+          cmd = "#{@rvm_bin} install #{r} --patch #{patch} --force"
+        else
+          cmd = "#{@rvm_bin} install #{r} --force"
+        end
+
+        system(cmd)
+      end
+
+      Utils.say_with_time "Setting #{@default_ruby} as default ruby..." do
+       `#{@rvm_bin} --default #{@default_ruby}`
+      end
+
+      Utils.say(POST_INSTALL_NOTE)
+
+#      Utils.say_with_time "Reloading rvm..." do
+#        `#{@rvm_bin} reload`
+#      end
+
+#      @default_gems.each do |g|
+#        Utils.say_with_time "Installing gem #{g}" do
+#          `gem install #{g} --source #{@gem_source}`
+#        end
+#      end
+    end
+  end
+
+POST_INSTALL_NOTE = <<NOTE
+You're almost done!\n\n
+Do the following inside popo:\n
+1. rvm reload\n
+2. gem install cableguy popo dbget_client --source http://gems.caresharing.eu --no-ri --no-rdoc\n\n
+OPTIONAL: (If you use another ruby version). In this example, ree.\n
+1. rvm use ree-1.8.7-2011.03\n
+2. gem install cableguy popo dbget_client --source http://gems.caresharing.eu --no-ri --no-rdoc\n
+NOTE
+
+end

data/lib/popo/sync.rb

@@ -0,0 +1,67 @@
+module Popo
+  class Sync
+    def initialize(app_root, args, db)
+      @db = db
+      @current_dir = File.basename(Dir.pwd)
+      @app_root = app_root
+      @cwd = Dir.pwd
+      @repos = args
+      @info = {}
+    end
+
+    def gather
+      @repos.each do |repo|
+        if repo =~ /\//
+          r = repo.split('/')
+          @info[:parent], @info[:name] = r
+          @info[:key] = [@info[:parent], @info[:name]].join('.')
+          @info[:path] = File.join(@app_root, @info[:parent], @info[:name])
+
+          get_repo_values(@info[:key])
+
+          clone_or_update
+        else
+          gather_many(repo)
+        end
+      end
+
+      if @repos.empty?
+        if @cwd.eql? @app_root
+          popo_folders = @db.get("popo_folders").split(',')
+          popo_folders.each { |p| gather_many(p) }
+        else
+          repo = File.basename(@cwd)
+          gather_many(repo)
+        end
+      end
+    end
+
+    def gather_many(repo)
+      children = @db.get_children(repo)
+
+      raise "No values for parent key \'#{repo}\'." if children.empty?
+
+      children.each do |c|
+        @info[:key] = [repo, c].join('.')
+        get_repo_values(@info[:key])
+        @info[:path] = File.join(@app_root, repo,  c)
+
+        clone_or_update
+      end
+    end
+
+    def clone_or_update
+      if !File.exists?(@info[:path])
+        GitUtils.git_clone(@info[:host], @info[:path], @info[:branch])
+      else
+        GitUtils.git_update(@info[:path], @info[:branch])
+      end
+    end
+
+
+    def get_repo_values(key)
+      @info[:branch] = @db.get("#{key}.branch")
+      @info[:host] = @db.get("#{key}.repo")
+    end
+  end
+end

data/lib/popo/utils.rb

@@ -0,0 +1,46 @@
+require 'benchmark'
+
+module Popo
+  module Utils
+    include Constants
+
+    def self.say(message, subitem = false)
+      puts "#{subitem ? "   ->" : "--"} #{message}"
+    end
+
+    def self.say_with_time(message)
+      say(message)
+      result = nil
+      time = Benchmark.measure { result = yield }
+      say "%.4fs" % time.real, :subitem
+      say("#{result} rows", :subitem) if result.is_a?(Integer)
+      result
+    end
+
+    def self.in_popo?(root_path)
+      if !ENV.include?('popo_path')
+        raise "You must be inside popo!"
+      end
+      true
+    end
+
+    def self.require_relative_work_popo(root_path)
+      popo_work_path = File.expand_path(File.join(root_path, POPO_WORK_PATH))
+
+      popo_yml = File.expand_path(File.join(popo_work_path, POPO_YML_FILE))
+
+      if File.exists?(popo_yml)
+        popo_config = YAML.load_file(popo_yml)
+
+        if popo_config.is_a?(Hash)
+          POPO_CONFIG.update(popo_config)
+        else
+          raise "#{POPO_WORK_PATH}/#{POPO_YML_FILE} seems to be wrong."
+        end
+      else
+        raise "#{POPO_YML_FILE} not found."
+      end
+    end
+  end
+end
+

data/lib/templates/envy.yml

@@ -0,0 +1,4 @@
+# sample
+popo_path: %popo_path%
+popo_target: %popo_target%
+envyrc_path: script/envyrc

data/popo.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+VERSION = "0.1.1"
+
+Gem::Specification.new do |s|
+  s.name        = "popo"
+  s.version     = VERSION
+  s.authors     = ["Jan Mendoza"]
+  s.email       = ["poymode@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Popo ruby and rails repo tool}
+  s.description = %q{Ruby and rails repo tool}
+
+  s.rubyforge_project = "popo"
+  s.add_dependency "sequel"
+  s.add_dependency "sqlite3"
+  s.add_dependency "cableguy"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  # s.add_development_dependency "rspec"
+  # s.add_runtime_dependency "rest-client"
+end

data/script/Rakefile

@@ -0,0 +1,60 @@
+POPO_VERSION = 1.2
+POPO_PACKAGE_VERSION = 1
+POPO_PACKAGE_NAME = "popo-#{POPO_VERSION}-#{POPO_PACKAGE_VERSION}_all"
+
+def control_file
+  "Package: popo\n" +
+  "Version: #{POPO_VERSION}-#{POPO_PACKAGE_VERSION}\n" +
+  "Section: Caresharing Tools\n" +
+  "Priority: optional\n" +
+  "Architecture: all\n" +
+  "Depends: ruby, git-core, curl, g++\n" +
+  "Maintainer: Caresharing Framework Team <framework@caresharing.eu>\n" +
+  "Description: Popo utilities\n" +
+  " Popo allows you to easily deploy and configure Caresharing applications"
+end
+
+def popo_puts(message)
+  puts "\e[33m#{message}\e[0;0m"
+end
+
+desc "Creates a debian package of popo"
+task :deb do
+  popo_puts "Packaging popo version #{POPO_VERSION} as deb..."
+
+  system "mkdir -p #{POPO_PACKAGE_NAME}/usr/local/bin"
+  system "cp popo #{POPO_PACKAGE_NAME}/usr/local/bin"
+  system "cp -r ../../popo /tmp/.popo"
+  system "mv /tmp/.popo #{POPO_PACKAGE_NAME}/usr/local/bin"
+
+#  system "mkdir -p #{POPO_PACKAGE_NAME}/etc"
+#  system "cp popo_config.yml #{POPO_PACKAGE_NAME}/etc"
+
+  system "mkdir -p #{POPO_PACKAGE_NAME}/DEBIAN"
+  system "echo \"#{control_file}\" > #{POPO_PACKAGE_NAME}/DEBIAN/control"
+
+  system "dpkg-deb -b #{POPO_PACKAGE_NAME}"
+  system "rm -rf #{POPO_PACKAGE_NAME}"
+
+  popo_puts "Done!"
+end
+
+desc "Deploys debian package to remote deb repository"
+task :deploy do
+  popo_puts "Copying deb package to remote server..."
+  system "scp #{POPO_PACKAGE_NAME}.deb root@styx.caresharing:/var/www/caresharing/"
+  popo_puts "Done!"
+
+  popo_puts "Generating index on deb repo..."
+  system "ssh root@styx.caresharing \"cd /var/www/caresharing; ./generate_index\""
+  popo_puts "Done!"
+end
+
+desc "Cleans up the working directory"
+task :clean do
+  popo_puts "Cleaning up... "
+  system "rm #{POPO_PACKAGE_NAME}.deb"
+  popo_puts "Done!"
+end
+
+task :default => "deb"

data/script/envy

@@ -0,0 +1,24 @@
+#!/usr/bin/env ruby
+require 'yaml'
+
+ROOT_PATH = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+BASH_PATH = `which bash`.strip
+ENV_PATH = `which env`.strip
+
+env_config_file = File.join(ROOT_PATH, 'config/envy.yml')
+
+if File.exists? env_config_file
+  env_conf = YAML.load_file(env_config_file)
+  popo_path = env_conf['popo_path']
+  popo_target = env_conf['popo_target']
+  envyrc = "#{ROOT_PATH}/#{env_conf['envyrc_path']}"
+else
+  puts "envyrc file not found. Byebye!"
+  exit
+end
+
+cmd = ARGV.join(' ')
+
+finale = "#{ENV_PATH} popo_path=#{popo_path} popo_target=#{popo_target} #{BASH_PATH} -c 'source #{envyrc}; cd #{popo_path}; #{cmd}'"
+system(finale)
+exit $?.exitstatus

data/script/envyrc

@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+
+# Let's unload system installed rvm and move path prefix to popo
+unset $(env | awk -F= '/^rvm_/{print $1" "}')
+export rvm_reload_flag=1
+export rvm_prefix=$popo_path
+
+
+# Now let's load rvm inside popo
+source $rvm_prefix/rvm/scripts/rvm
+
+# Load default rvm
+rvm default 1>/dev/null 2>&1
+unset PALMADE_GEMS_DIR
+export PATH="$popo_path/rvm/bin:$popo_path/tools:$PATH"
+export CABLING_PATH=$popo_path/.popo/cabling.yml
+export CABLING_TARGET=$popo_target
+
+# this section is for backup
+#unset PALMADE_GEMS_DIR
+#unset rvm_loaded_flag
+#rvm_loaded_flag=1
+#export PATH="$popo_path/rvm/bin:$popo_path/tools:$PATH"
+#export rvm_prefix=$popo_path
+#export rvm_path=$popo_path/rvm
+#export rvm_scripts_path=$rvm_path/scripts
+#export rvm_archives_path=$rvm_path/archives
+#export rvm_src_path=$rvm_path/src
+#export rvm_log_path=$rvm_path/log
+#export rvm_bin_path=$rvm_path/bin
+#export rvm_gems_path=$rvm_path/gems
+#export rvm_hooks_path=$rvm_path/hooks
+#export rvm_tmp_path=$rvm_path/tmp
+#export rvm_gemsets_path=$rvm_path/gemsets
+#export rvm_bin_path=$rvm_path/bin
+#export rvm_patchsets_path=$rvm_path/patchsets
+#export rvm_patches_path=$rvm_path/patches
+#export rvm_gems_cache_path=$rvm_path/gems/cache
+#export rvm_config_path=$rvm_path/config
+#export rvm_rubies_path=$rvm_path/rubies
+#export rvm_gems_path=$rvm_path/gems
+#export rvm_repo_path=$rvm_path/repos
+#unset rvm_loaded_flag
+#source $rvm_scripts_path/rvm
+#rvm default 1>/dev/null 2>&1

data/script/poporc

@@ -0,0 +1,61 @@
+#!/usr/bin/env bash
+
+if [[ -z "$popo_path" ]] ; then
+    echo "FAIL Please set the popo_path environment var"
+    exit -1
+fi
+
+if [[ -z "$popo_target" ]] ; then
+    echo "FAIL Please set the popo_target environment var"
+    exit -1
+fi
+
+SHIT="\[\033[33m\]"
+NORMAL="\[\033[0;0m\]"
+BASEPATH=`which basename`
+BASENAME=`$BASEPATH $popo_path`
+
+if [[ $PS1 != "" ]] ; then
+    if [[ -f /etc/bash.bashrc ]] ; then
+        source /etc/bash.bashrc
+    fi
+
+    if [[ -f $HOME/.bashrc ]] ; then
+        source $HOME/.bashrc
+    fi
+
+    if [[ $BASENAME != $popo_target ]] ; then
+        export PS1="$SHIT(popo $popo_target/$BASENAME) $NORMAL$PS1"
+    else
+        export PS1="$SHIT(popo $popo_target) $NORMAL$PS1"
+    fi
+fi
+
+# Let's unload system installed rvm and move path prefix to popo
+unset $(env | awk -F= '/^rvm_/{print $1" "}')
+export rvm_reload_flag=1
+export rvm_prefix=$popo_path
+export CABLING_PATH=$popo_path/.popo/cabling.yml
+export CABLING_TARGET=$popo_target
+source $rvm_prefix/rvm/scripts/rvm
+
+# Load default rvm
+rvm default 1>/dev/null 2>&1
+unset PALMADE_GEMS_DIR
+export PATH="$popo_path/rvm/bin:$popo_path/tools:$PATH"
+export rvm_path=$popo_path/rvm
+if [[ -z "$PS1" ]] ; then
+	rvm $*
+else
+    echo ""
+    echo "Welcome to the popoed bash environment, where you can play with your very own popo."
+    echo ""
+    echo "  popo path: $popo_path"
+    echo "  popo target: $popo_target"
+    echo ""
+    echo "Remember to keep things clean and civil around here."
+    echo "To go back to your normal world, just hit exit."
+    echo ""
+    echo "But wait, you ask, who needs popo? Baahh, popo's for n00bs!"
+    echo ""
+fi

data/targets/beta.rb

@@ -0,0 +1 @@
+# BETA target

data/targets/common.rb

@@ -0,0 +1 @@
+# COMMON TARGET

data/targets/development.rb

@@ -0,0 +1 @@
+# DEVELOPMENT TARGET

data/targets/production.rb

@@ -0,0 +1 @@
+# PRODUCTION TARGET

data/targets/staging.rb

@@ -0,0 +1 @@
+# STAGING TARGET

data/targets/test.rb

@@ -0,0 +1 @@
+# TEST TARGET

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification 
+name: popo
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 1
+  version: 0.1.1
+platform: ruby
+authors: 
+- Jan Mendoza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-01-01 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sequel
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: cableguy
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+description: Ruby and rails repo tool
+email: 
+- poymode@gmail.com
+executables: 
+- envy
+- popo
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README
+- Rakefile
+- bin/envy
+- bin/popo
+- config/envy.yml.sample
+- config/popo_config.yml.sample
+- lib/hash.rb
+- lib/popo.rb
+- lib/popo/constants.rb
+- lib/popo/database.rb
+- lib/popo/git_utils.rb
+- lib/popo/initializer.rb
+- lib/popo/runner.rb
+- lib/popo/rvm.rb
+- lib/popo/sync.rb
+- lib/popo/utils.rb
+- lib/templates/envy.yml
+- popo.gemspec
+- script/Rakefile
+- script/envy
+- script/envyrc
+- script/poporc
+- targets/beta.rb
+- targets/common.rb
+- targets/development.rb
+- targets/production.rb
+- targets/staging.rb
+- targets/test.rb
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: popo
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Popo ruby and rails repo tool
+test_files: []
+