cableguy 0.2.3 → 0.5.0.pre2

data/lib/palmade/cableguy/utils.rb

@@ -1,12 +1,11 @@
 module Palmade::Cableguy
   class Utils
-    # some rails methods
-
-    def self.camelize(lower_case_and_underscored_word, first_letter_in_uppercase = true)
-      if first_letter_in_uppercase
-        lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }
-      else
-        lower_case_and_underscored_word.to_s[0].chr.downcase + camelize(lower_case_and_underscored_word)[1..-1]
+    def self.symbolize_keys(hash)
+      hash.inject({ }) do |result, (key, value)|
+        new_key = key.kind_of?(String) ? key.to_sym : key
+        new_value = value.kind_of?(Hash) ? symbolize_keys(value) : value
+        result[new_key] = new_value
+        result
       end
     end
   end

data/lib/palmade/cableguy/version.rb

@@ -1,5 +1,5 @@
 module Palmade
   module Cableguy
-    VERSION = "0.2.3"
+    VERSION = '0.5.0.pre2'
   end
 end

data/lib/palmade/cableguy.rb

@@ -1,43 +1,28 @@
-require 'rubygems'
-require 'benchmark'
-require 'fileutils'
-require 'sequel'
-require 'logger'
-require File.join(File.dirname(__FILE__), 'cableguy/version')
-
 module Palmade
   module Cableguy
-    autoload :Builders, File.join(File.dirname(__FILE__), 'cableguy/builders')
-    autoload :Cable, File.join(File.dirname(__FILE__), 'cableguy/cable')
-    autoload :Cabler, File.join(File.dirname(__FILE__), 'cableguy/cabler')
-    autoload :CableConfigurator, File.join(File.dirname(__FILE__), 'cableguy/cable_configurator')
-    autoload :Configurator, File.join(File.dirname(__FILE__), 'cableguy/configurator')
-    autoload :Constants, File.join(File.dirname(__FILE__), 'cableguy/constants')
-    autoload :DB, File.join(File.dirname(__FILE__), 'cableguy/db')
-    autoload :Migration, File.join(File.dirname(__FILE__), 'cableguy/migration')
-    autoload :Runner, File.join(File.dirname(__FILE__), 'cableguy/runner')
-    autoload :TemplateBinding, File.join(File.dirname(__FILE__), 'cableguy/templatebinding')
-    autoload :Utils, File.join(File.dirname(__FILE__), 'cableguy/utils')
+    autoload :Builders, 'palmade/cableguy/builders'
+    autoload :Cable, 'palmade/cableguy/cable'
+    autoload :Cabler, 'palmade/cableguy/cabler'
 
-    DEFAULT_CABLEGUY_PATH = "config/cableguy.rb"
-    DEFAULT_TEMPLATES_PATH = "config/templates"
-    DEFAULT_TARGET_PATH = "config"
+    autoload :CLI, 'palmade/cableguy/cli'
+    autoload :CliHelper, 'palmade/cableguy/cli_helper'
+    autoload :Constants, 'palmade/cableguy/constants'
+    autoload :DB, 'palmade/cableguy/db'
+    autoload :CablingValues, 'palmade/cableguy/cabling_values'
+    autoload :Migrator, 'palmade/cableguy/migrator'
+    autoload :Migration, 'palmade/cableguy/migration'
+    autoload :Runner, 'palmade/cableguy/runner'
+    autoload :TemplateBinding, 'palmade/cableguy/templatebinding'
 
-    class CableguyError < StandardError; end
-    class NotImplemented < CableguyError; end
-    class MissingFile < CableguyError; end
+    autoload :Configurator, 'palmade/cableguy/configurator'
+    autoload :LegacyConfigurator, 'palmade/cableguy/legacy_configurator'
+    autoload :Cablefile, 'palmade/cableguy/cablefile'
 
-    def self.check_requirements(app_root)
-      boot(app_root).check_requirements
-    end
+    autoload :Utils, 'palmade/cableguy/utils'
+    autoload :VERSION, 'palmade/cableguy/version'
 
-    def self.configure(app_root)
-      boot(app_root).configure
-    end
-
-    def self.require_erb
-      require 'erb'
+    def self.boot_cabler(app_path, opts = { })
+      Palmade::Cableguy::Cabler.new(app_path, opts).boot
     end
   end
 end
-

data/test/.cabling_values.yml

@@ -0,0 +1,9 @@
+# Comments are ok in this file.
+#
+
+redis:
+  host: 127.0.0.1
+  port: 6379
+
+blog:
+  'db.password': <%= 'password' %>

data/test/app/Cablefile

@@ -0,0 +1,10 @@
+# -*- mode: ruby -*-
+# vi: set ft=ruby :
+
+cabling do |cabler, cablefile, target|
+  cabler.set_app_group :blog
+
+  setup :mkdir, 'config/secrets'
+
+  setup :template, 'blog.yml'
+end

data/test/app/cabling/base/blog.rb

@@ -0,0 +1,21 @@
+module TestCableguyAppCabling::Base
+  class Blog < Palmade::Cableguy::Migration
+    def migrate!
+      group 'blog' do
+        set 'fb_oauth', 'true'
+
+        prefix 'mongo' do
+          set 'host', '127.0.0.1'
+          set 'port', '27019'
+        end
+
+        prefix 'db' do
+          set 'host', '192.168.0.1'
+          set 'port', '3307'
+          set 'username', 'user'
+          set 'password', ''
+        end
+      end
+    end
+  end
+end

data/test/app/cabling/init.rb

@@ -0,0 +1,16 @@
+# init file, that is loaded prior to loading the cabling files in this cabling directory.
+# this can be used to load custom gems / ruby codes, etc, that you can use
+# within your cabling files.
+#
+
+TEST_APP_CABLING_INIT_FILE_LOADED = true
+
+module TestCableguyAppCabling
+  module Base
+
+  end
+
+  module Targets
+
+  end
+end

data/test/app/config/templates/blog.yml

@@ -0,0 +1,10 @@
+auth:
+  require_2fa: {require_2fa}
+  twitter_auth: {twitter_auth}
+
+database:
+  adapter: mysql
+  host: {db.host}
+  port: {db.port}
+  username: {db.username}
+  password: {db.password}

data/test/app_cabling_test.rb

@@ -0,0 +1,33 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class AppCablingTest < MiniTest::Test
+  include TestHelper
+
+  def setup
+    @cabler = TestHelper.configure
+    @db = @cabler.db
+    @migrator = @cabler.migrator
+    @app_migrator = @cabler.app_migrator
+
+    @cabler.configure
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_app_cabling_path_is_set
+    assert_equal(@cabler.app_cabling_path, File.join(TestHelper::TEST_APP_ROOT, 'cabling'))
+  end
+
+  def test_cabling_init_is_loaded
+    assert(defined?(TEST_APP_CABLING_INIT_FILE_LOADED), 'App cabling init not loaded')
+    assert_equal(true, TEST_APP_CABLING_INIT_FILE_LOADED)
+  end
+
+  def test_blog_values_inserted
+    assert_equal('true', @db.get('fb_oauth', 'blog'))
+    assert_equal('127.0.0.1', @db.get('mongo.host', 'blog'))
+  end
+end

data/test/boboot.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+ROOT_PATH = CABLEGUY_ROOT_PATH = File.expand_path('../..', __FILE__)
+
+begin
+  require "rubygems"
+  require "bundler"
+rescue LoadError
+  raise "Could not load the bundler gem. Install it with `gem install bundler`."
+end
+
+begin
+  # Set up load paths for all bundled gems
+  ENV["BUNDLE_GEMFILE"] = File.join(ROOT_PATH, 'Gemfile')
+  Bundler.setup
+rescue Bundler::GemNotFound
+  raise RuntimeError, "Bundler couldn't find some gems." +
+    "Did you run bundle install?"
+end
+
+module Boboot
+  def self.root_path; ROOT_PATH; end
+
+  def self.add_lib_to_load_path
+    File.join(root_path, 'lib').tap { |p| $LOAD_PATH.unshift(p) unless $LOAD_PATH.include?(p) }
+  end
+
+  def self.require_relative_gem(gem_name, lib_path)
+    require File.join(self.root_path, '..', gem_name, 'lib', lib_path)
+  end
+
+  def self.disable_rubygem_warns
+    # Disables Rubygems warnings, as otherwise this is totally out of control
+    if (defined?(Deprecate))
+      Deprecate.skip = true
+    elsif (defined?(Gem::Deprecate))
+      Gem::Deprecate.skip = true
+    end
+  end
+
+  def self.silence_warns
+    original_verbosity = $VERBOSE
+    $VERBOSE = nil
+    result = yield
+    $VERBOSE = original_verbosity
+    result
+  end
+end
+
+Boboot.disable_rubygem_warns
+Boboot.add_lib_to_load_path
+
+# explicitly disable warnings!
+$VERBOSE = nil

data/test/boot_test.rb

@@ -0,0 +1,25 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class BootTest < MiniTest::Test
+  def setup
+    @cabler = TestHelper.configure
+  end
+
+  def teardown
+
+  end
+
+  def test_booted
+    assert_equal(@cabler.app_root, TestHelper::TEST_APP_ROOT)
+    assert_equal(@cabler.cabling_path, TestHelper::TEST_CABLING_PATH)
+    assert_equal(@cabler.target, :test)
+    assert_nil(@cabler.location)
+  end
+
+  def test_create_builtin_logger
+    refute_nil(@cabler.logger)
+    assert_respond_to(@cabler.logger, :log)
+    assert_respond_to(@cabler.logger, :add)
+  end
+end

data/test/cablefile_test.rb

@@ -0,0 +1,44 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class CablefileTest < MiniTest::Test
+  def setup
+    subdir_app_root = File.join(TestHelper::TEST_APP_ROOT, 'config')
+
+    @cabler = TestHelper.configure
+    @cablefile = @cabler.cablefile
+
+    @cabler_sub = TestHelper.configure(subdir_app_root)
+    @cablefile_sub = @cabler_sub.cablefile
+
+    @db = @cabler.db
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_cablefile_path
+    correct_cablefile_path = File.join(TestHelper::TEST_APP_ROOT, 'Cablefile')
+
+    assert_equal(correct_cablefile_path, @cabler.cablefile.file_path)
+    assert_equal(correct_cablefile_path, @cabler_sub.cablefile.file_path)
+  end
+
+  def test_app_root
+    assert_equal(@cabler.app_root, File.dirname(@cabler.cablefile.file_path))
+    assert_equal(@cabler_sub.app_root, File.dirname(@cabler_sub.cablefile.file_path))
+  end
+
+  def test_is_configured
+    assert(@cabler.cablefile.configured?, 'Cablefile not configured!')
+  end
+
+  def test_app_group_is_set
+    @group_stack = @db.instance_variable_get('@group_stack')
+
+    assert_equal('blog', @cabler.app_group)
+    assert_equal('blog', @group_stack[0])
+    assert_equal([ 'blog' ], @group_stack)
+  end
+end

data/test/cabler_test.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class CablerTest < MiniTest::Test
+  include TestHelper
+
+  def setup
+    @cabler = TestHelper.configure
+    @cabler_with_apply = TestHelper.configure(nil, :apply_path => TEST_APPLY_ROOT)
+    @cabler_app_cabling_only = TestHelper.configure(nil, :include_global_cabling => false)
+  end
+
+  def test_apply_path
+    assert_nil(@cabler.apply_path)
+  end
+
+  def test_apply_path_is_app_root
+    assert_equal(@cabler.determine_apply_path, @cabler.app_root)
+  end
+
+  def test_apply_path_for_templates
+    assert_equal(@cabler.determine_apply_path(:for_templates => true),
+                 File.join(@cabler.app_root, 'config'))
+  end
+
+  def test_with_apply_path
+    refute_equal(@cabler_with_apply.determine_apply_path, @cabler_with_apply.app_root)
+  end
+
+  def test_include_global_cabling_paths
+    cps = @cabler.send(:determine_useable_cabling_paths)
+
+    assert_includes(cps, TEST_CABLING_PATH)
+    assert_includes(cps, File.join(TEST_APP_ROOT, 'cabling'))
+    assert(cps.count, 2)
+  end
+
+  def test_app_cabling_only
+    cps = @cabler_app_cabling_only.send(:determine_useable_cabling_paths)
+
+    refute_includes(cps, TEST_CABLING_PATH)
+    assert_includes(cps, File.join(TEST_APP_ROOT, 'cabling'))
+    assert(cps.count, 1)
+  end
+end

data/test/cabling/base/blog.rb

@@ -0,0 +1,17 @@
+module TestCableguyCabling::Base
+  class Blog < Palmade::Cableguy::Migration
+    def migrate!
+      group 'blog' do
+        set 'require_2fa', 'true'
+        set 'twitter_auth', 'true'
+
+        prefix 'db' do
+          set 'host', '127.0.0.1'
+          set 'port', '3306'
+          set 'username', 'root'
+          set 'password', ''
+        end
+      end
+    end
+  end
+end

data/test/cabling/init.rb

@@ -0,0 +1,16 @@
+# init file, that is loaded prior to loading the cabling files in this cabling directory.
+# this can be used to load custom gems / ruby codes, etc, that you can use
+# within your cabling files.
+#
+
+TEST_CABLING_INIT_FILE_LOADED = true
+
+module TestCableguyCabling
+  module Base
+
+  end
+
+  module Targets
+
+  end
+end

data/test/cabling_values_test.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class CablingValuesTest < MiniTest::Test
+  def setup
+    @cabler = TestHelper.configure
+    @cabler.configure
+
+    @db = @cabler.db
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_values_loaded
+    assert_equal('127.0.0.1', @cabler.values['redis']['host'])
+    assert_equal(6379, @cabler.values['redis']['port'])
+  end
+
+  def test_password_value_override
+    assert_equal('password', @db.get('db.password', 'blog'))
+  end
+end

data/test/cli_lock_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class CliLockTest < MiniTest::Test
+  include Palmade::Cableguy::Constants
+
+  def setup
+    @test_cli = TestHelper.new_cli_tester('configure', [ '--target=test' ])
+    @another_cli = TestHelper.new_cli_tester('configure', [ ])
+  end
+
+  def test_lock_target
+    test_lock_opts = @test_cli.prepare_lock_file(:lock_no_persist => true)
+    assert_equal('test', test_lock_opts[:target])
+
+    test_cabler = @test_cli.cabler(:lock_no_persist => true)
+    assert_equal('test', test_cabler.target)
+  end
+
+  def test_lock_file_target
+    @test_cli.prepare_lock_file
+
+    lock_opts = @another_cli.prepare_lock_file
+    File.delete(@test_cli.lock_file_path)
+
+    assert_equal('test', lock_opts[:target])
+  end
+end

data/test/cli_test.rb

@@ -0,0 +1,88 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class CliTest < MiniTest::Test
+  include Palmade::Cableguy::Constants
+
+  def setup
+    @cli = TestHelper.new_cli_tester('configure')
+    @lock_opts = @cli.prepare_lock_file
+
+    TestHelper.disable_default_cabling_path do
+      @cabler = @cli.cabler
+    end
+
+    @cabler.configure
+
+    @default_cli = TestHelper.new_cli_tester('configure', [ '--nolock' ])
+
+    TestHelper.disable_default_cabling_path do
+      @default_cabler = @default_cli.cabler
+    end
+
+    @default_db = @default_cabler.db
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_cabling_path_set
+    assert_equal(TestHelper::TEST_CABLING_PATH, @cabler.cabling_path)
+  end
+
+  def test_cabling_values_path_set
+    assert_equal(TestHelper::TEST_CABLING_VALUES_PATH, @cabler.values_path)
+  end
+
+  def test_app_root_is_set
+    assert_equal(TestHelper::TEST_APP_ROOT, @cabler.app_root)
+  end
+
+  def test_cabling_defaults_set
+    if ENV.include?('CABLING_PATH')
+      default_path = File.expand_path(ENV['CABLING_PATH'])
+    elsif File.exists?(DEFAULT_CABLING_PATH)
+      default_path = File.expand_path(DEFAULT_CABLING_PATH)
+    else
+      default_path = nil
+    end
+
+    unless default_path.nil?
+      loop do
+        if File.symlink?(default_path)
+          default_path = File.readlink(default_path)
+        else
+          break
+        end
+      end
+
+      assert_equal(default_path, @default_cabler.cabling_path)
+    end
+
+    values_path = File.expand_path(DEFAULT_CABLING_VALUES_PATH)
+    if File.exists?(values_path)
+      assert_equal(values_path, @default_cabler.values_path)
+    else
+      assert_nil(@default_cabler.values_path, 'Default cabling values path is not nil')
+    end
+  end
+
+  def test_cabling_defaults_will_raise_error
+    assert_raises(RuntimeError) do
+      @default_cabler.configure
+    end
+  end
+
+  def test_cabling_defaults_db_empty
+    assert(@default_db.empty?, 'Default database not empty!')
+  end
+
+  def test_lock_defaults_target
+    assert_equal(DEFAULT_TARGET, @lock_opts[:target])
+  end
+
+  def test_lock_defaults_location
+    assert_nil(@lock_opts[:location])
+  end
+end

data/test/configure_test.rb

@@ -0,0 +1,31 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class ConfigureTest < MiniTest::Test
+  include TestHelper
+
+  def setup
+    @cabler = TestHelper.configure
+    @cabler.configure
+    @builds = @cabler.builds
+
+    TestHelper.unload_cabling
+
+    @cabler_with_apply = TestHelper.configure(nil, :apply_path => TEST_APPLY_ROOT)
+    @cabler_with_apply.configure
+
+    TestHelper.unload_cabling
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_built
+    assert(@builds.count > 0, 'No builds configured')
+  end
+
+  def test_apply_path_different
+    refute_equal(@cabler_with_apply.determine_apply_path, @cabler_with_apply.app_root)
+  end
+end

data/test/db_methods_test.rb

@@ -0,0 +1,19 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class DbMethodsTest < MiniTest::Test
+  def setup
+    @cabler = TestHelper.configure
+    @db = @cabler.db
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_data_methods
+    assert_respond_to(@db, :group)
+    assert_respond_to(@db, :prefix)
+    assert_respond_to(@db, :globals)
+  end
+end

data/test/migrate_legacy_test.rb

@@ -0,0 +1,34 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class MigrateLegacyTest < MiniTest::Test
+  def setup
+    @cabler = TestHelper.configure(nil, :save_db => true)
+    @db = @cabler.db
+    @save_db = @cabler.save_db
+
+    @migrate = @cabler.migrate
+    @migrator = @cabler.migrator
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+
+    unless @save_db.nil?
+      File.delete(@save_db)
+    end
+  end
+
+  def test_migrator_created
+    refute_nil(@migrator, '@migrator not initiated')
+  end
+
+  def test_migrate_migrated
+    assert(@db.migrated?, 'DB not migrated')
+  end
+
+  def test_db_created
+    refute_nil(@save_db, 'SQLite DB not set')
+    assert(File.exists?(@save_db), 'SQLite DB not created')
+  end
+end

data/test/migrate_test.rb

@@ -0,0 +1,39 @@
+require File.expand_path('../test_helper', __FILE__)
+require 'minitest/autorun'
+
+class MigrateTest < MiniTest::Test
+  def setup
+    @cabler = TestHelper.configure(nil, :unload_cabling => false)
+    @db = @cabler.db
+    @migrate = @cabler.migrate
+    @migrator = @cabler.migrator
+  end
+
+  def teardown
+    TestHelper.unload_cabling
+  end
+
+  def test_cabling_init_is_loaded
+    assert(defined?(TEST_CABLING_INIT_FILE_LOADED), 'Cabling init not loaded')
+    assert_equal(true, TEST_CABLING_INIT_FILE_LOADED)
+  end
+
+  def test_cabling_blog_loaded
+    assert(defined?(TestCableguyCabling::Base::Blog), 'Base::Blog expected from cabling not loaded')
+    assert_includes(@migrator.klass_stack, TestCableguyCabling::Base::Blog)
+    assert_equal(@migrator.klass_stack, [ TestCableguyCabling::Base::Blog ])
+  end
+
+  def test_blog_values_inserted
+    assert_equal('true', @db.get('require_2fa', 'blog'))
+    assert_equal('true', @db.get('twitter_auth', 'blog'))
+  end
+
+  def test_migration_instantiated
+    refute_empty(@migrator.instance_stack)
+  end
+
+  def test_cabling_path_values_are_retained
+    assert_equal('127.0.0.1', @db.get('db.host', 'blog'))
+  end
+end