cableguy 0.2.3 → 0.5.0.pre2

data/lib/palmade/cableguy/cabler.rb

@@ -1,115 +1,319 @@
+require 'logger'
+
 module Palmade::Cableguy
   class Cabler
     include Constants
+    include CliHelper
+
+    APP_CABLING_PATH = 'cabling'
+
+    DEFAULT_OPTIONS = {
+      :target => :development,
+      :location => nil,
+      :path => nil,
+      :values_path => nil,
+      :apply_path => nil,
+      :templates_path => nil,
+      :logger => nil,
+      :save_db => false,
+      :unload_cabling => true,
+      :include_global_cabling => false
+    }
 
     attr_reader :app_root
-    attr_reader :builds
+    attr_reader :app_group
+    attr_reader :options
+
     attr_reader :cabling_path
+    attr_reader :app_cabling_path
     attr_reader :target
     attr_reader :location
-    attr_reader :database
-    attr_reader :cabler
-    attr_reader :logger
-    attr_reader :options
-    attr_reader :db_path
+    attr_reader :apply_path
+
+    attr_reader :values_path
+    attr_reader :cabling_values
+    attr_reader :templates_path
+
+    attr_reader :cablefile
     attr_reader :db
-    attr_accessor :targets
-    attr_accessor :group
+    attr_reader :save_db
+    attr_reader :logger
 
-    def initialize(app_root, options)
-      @options = options
+    attr_reader :builds
+    attr_reader :migrator
+    attr_reader :app_migrator
+
+    def initialize(app_root, options = { })
+      @options = DEFAULT_OPTIONS.merge(options)
       @app_root = app_root
+      @app_group = nil
+
       @cabling_path = @options[:path]
+      @app_cabling_path = File.join(@app_root, APP_CABLING_PATH)
+
       @target = @options[:target]
       @location = @options[:location]
+
+      unless @options[:apply_path].nil?
+        @apply_path = File.expand_path(@options[:apply_path])
+      end
+
+      @values_path = @options[:values_path]
+      @cabling_values = nil
+
+      @cablefile = nil
+
+      if @options[:templates_path].nil?
+        @templates_path = File.join(@app_root, DEFAULT_TEMPLATES_PATH)
+      else
+        @templates_path = File.expand_path(@options[:templates_path])
+      end
+
+      if options[:logger]
+        @logger = options[:logger]
+      else
+        @logger = create_logger
+      end
+
+      @db = nil
+      @save_db = nil
       @builds = nil
-      @logger = Logger.new($stdout)
-      @targets = [ :development ]
-      @db_path = File.join(@cabling_path, DB_DIRECTORY, "#{@target}.#{DB_EXTENSION}")
 
+      @migrator = nil
+      @app_migrator = nil
+    end
+
+    def boot
       if @options[:verbose]
         @logger.level = Logger::DEBUG
       else
         @logger.level = Logger::WARN
       end
 
-      @db = Palmade::Cableguy::DB.new(self)
-    end
+      expand_cabling_path!
 
-    def boot
-      @database = @db.boot
+      @save_db = determine_save_db
+      @db = Palmade::Cableguy::DB.new(self, { :save_db => @save_db }).boot
+
+      load_cabling_values
+      load_cablefile
 
       self
     end
 
-    def migrate
-      init_file = File.join(@cabling_path, 'init.rb')
-      require init_file if File.exist?(init_file)
+    def set_app_group(g)
+      # normalize group key, to be consistent everywhere
+      g = g.to_s unless g.is_a?(String)
+
+      @db.group(g)
+      @app_group = g
+    end
+    alias :group= :set_app_group
 
-      say_with_time "Migrating..." do
-        Migration.new(self).boot
+    def values
+      unless @cabling_values.nil?
+        @cabling_values.values
+      else
+        nil
       end
+    end
 
-      say "Done!"
+    def determine_apply_path(opts = { })
+      if @apply_path.nil?
+        ap = @app_root
+      else
+        ap = @apply_path
+      end
+
+      if opts[:for_templates]
+        File.join(ap, DEPRECATED_DEFAULT_TARGET_PATH)
+      else
+        ap
+      end
     end
 
     def configure
-      @configurator = CableConfigurator.new
-      @configurator_path = File.join(@app_root, DEFAULT_CABLEGUY_PATH)
+      unless @db.migrated?
+        migrate
+      end
+
+      if @db.empty?
+        raise 'Empty config data from [%s], did you provide some cabling data?' % @cabling_path
+      end
 
-      # checks for config/cableguy.rb
-      if File.exists?(@configurator_path)
-        @configurator.configure(@configurator_path)
+      if @cablefile.configured?
+        check_requirements
+        builds = build_setups
+        builds.each do |s|
+          s.configure(self)
+        end
       else
-        raise MissingFile, "Required cableguy file (#{@configurator_path}) not found!"
+        raise 'Cablefile not configured or not loaded, configure will not work!'
       end
 
-      check_requirements
+      self
+    end
+
+    def migrate
+      cabling_paths = determine_useable_cabling_paths
 
-      build_setups.each do |s|
-        s.configure(self, @cabling, @target)
+      unless cabling_paths.empty?
+        cabling_paths.each do |cp|
+          perform_migrate(cp)
+        end
       end
+
+      @db.migrated!
+
+      self
     end
 
-    def check_requirements
-      if @configurator.include?(:requirements)
-        @configurator.requirements(self, @cabling, @target)
+    def app_migrate
+      @db.prepare_for_use
+
+      unless @app_cabling_path.nil?
+        if File.exist?(@app_cabling_path)
+          perform_migrate(@app_cabling_path)
+        end
       end
-    end
 
-    def say(message, subitem = false)
-      puts "#{subitem ? "   ->" : "--"} #{message}"
+      self
     end
 
-    def 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
+    def cabling_migrate
+      @db.prepare_for_use
+
+      unless @cabling_path.nil?
+        if @cabling_path != @app_cabling_path && File.exists?(@cabling_path)
+          perform_migrate(@cabling_path)
+        end
+      end
+
+      self
     end
 
-    def require_cables(path)
-      if path =~ /\//
-        require(path)
-      else
-        require(File.join(@app_root, DEFAULT_CABLES_PATH, path))
+    def remigrate
+      if @db.migrated?
+        @db.reset
       end
+
+      migrate
     end
 
     protected
 
+    def perform_migrate(cp)
+      @db.prepare_for_use
+
+      if !cp.nil? && File.exists?(cp)
+        @migrator = Palmade::Cableguy::Migrator.boot(self, cp, :unload_cabling => @options[:unload_cabling])
+        @migrator.run!
+      end
+
+      @migrator
+    end
+
+    def determine_useable_cabling_paths
+      cabling_paths = [ ]
+
+      if !@app_cabling_path.nil? && File.exist?(@app_cabling_path)
+        cabling_paths << @app_cabling_path
+      end
+
+      if cabling_paths.empty? || @options[:include_global_cabling]
+        if !@cabling_path.nil? && @cabling_path != @app_cabling_path && File.exists?(@cabling_path)
+          cabling_paths << @cabling_path
+        end
+      end
+
+      cabling_paths
+    end
+
+    def expand_cabling_path!
+      unless @cabling_path.nil?
+        cpath = File.expand_path(@cabling_path)
+
+        loop do
+          if File.symlink?(cpath)
+            cpath = File.readlink(cpath)
+          else
+            break
+          end
+        end
+
+        @cabling_path = cpath
+      end
+
+      @cabling_path
+    end
+
+    def determine_save_db
+      save_db = nil
+
+      if @options[:save_db]
+        if @options[:save_db] === true
+          use_cabling_path = nil
+
+          cabling_paths = determine_useable_cabling_paths
+          unless cabling_paths.empty?
+            use_cabling_path = cabling_paths.first
+          end
+
+          unless use_cabling_path.nil?
+            if @location.nil?
+              save_db = File.join(use_cabling_path, DB_DIRECTORY, '%s.%s' % [ @target, DB_EXTENSION ])
+            else
+              save_db = File.join(use_cabling_path, DB_DIRECTORY, '%s_%s.%s' % [ @target, @location, DB_EXTENSION ])
+            end
+          end
+        else
+          save_db = @options[:save_db]
+        end
+      end
+
+      save_db
+    end
+
+    def load_cablefile
+      @cablefile = Cablefile.parse!(self)
+
+      if @app_root != @cablefile.app_root
+        @app_root = @cablefile.app_root
+      end
+
+      if @cablefile.configured?
+        @cablefile.cabling(self, @cablefile, @target)
+      end
+    end
+
+    def load_cabling_values
+      if !@values_path.nil? && File.exist?(@values_path)
+        @cabling_values = Palmade::Cableguy::CablingValues.load_cabling_values(self, @values_path)
+      else
+        @cabling_values = Palmade::Cableguy::CablingValues.new_empty(self)
+      end
+    end
+
     def build_setups
+      Builders.load_all_builders
+
       if @builds.nil?
-        @configurator.setup_cabling(self, @cabling, @target)
-        @builds = @configurator.setups.collect do |s|
+        @builds = @cablefile.setups.collect do |s|
           Cable.build(s[0], *s[1], &s[2])
         end
       else
         @builds
       end
     end
+
+    def check_requirements
+      if @cablefile.include?(:requirements)
+        @cablefile.requirements(self, @cablefile, @target)
+      end
+    end
+
+    def create_logger
+      Logger.new($stdout)
+    end
   end
 end
-

data/lib/palmade/cableguy/cabling_values.rb

@@ -0,0 +1,54 @@
+require 'yaml'
+require 'erb'
+
+module Palmade::Cableguy
+  class CablingValues
+    attr_reader :cabler
+    attr_reader :values
+
+    def self.load_cabling_values(cabler, path)
+      self.new(cabler).load_values(path)
+    end
+
+    def self.new_empty(cabler)
+      self.new(cabler).empty!
+    end
+
+    def initialize(cabler)
+      @cabler = cabler
+      @values = nil
+    end
+
+    def load_values(path)
+      vf_contents = File.read(path)
+      vf_contents = ERB.new(vf_contents).result(binding)
+
+      parsed_vf = YAML.load(vf_contents)
+      if parsed_vf.nil? || parsed_vf == false
+        @values = new_values
+      else
+        @values = new_values(parsed_vf)
+      end
+
+      self
+    end
+
+    def empty!
+      @values = new_values
+
+      self
+    end
+
+    protected
+
+    def new_values(vals = nil)
+      if vals.nil?
+        h = Hash.new
+      else
+        h = Hash.new.update(vals)
+      end
+
+      h
+    end
+  end
+end

data/lib/palmade/cableguy/cli.rb

@@ -0,0 +1,232 @@
+require 'thor'
+require 'yaml'
+
+module Palmade
+  module Cableguy
+    class CLI < Thor
+      include Constants
+
+      class_option :target, :default => nil
+      class_option :location, :default => nil
+
+      class_option :path, :default => nil
+      class_option :values_path, :default => nil
+      class_option :apply_path, :default => nil
+      class_option :templates_path, :default => nil
+
+      class_option :lock_file, :default => nil
+      class_option :unlock, :default => false, :type => :boolean
+      class_option :nolock, :default => false, :type => :boolean
+
+      class_option :app_root, :default => nil, :type => :string
+      class_option :include_global_cabling, :default => false, :type => :boolean
+
+      class_option :verbose, :default => false, :type => :boolean
+      class_option :silent, :default => false, :type => :boolean
+
+      class_option :save_db
+
+      attr_accessor :raise_error
+
+      desc 'configure', 'start configuring!'
+      def configure
+        cabler.configure
+      end
+
+      desc 'migrate', 'migrates data into sqlite'
+      def migrate
+        cabler(:save_db => true).migrate
+      end
+
+      desc 'version', 'show version'
+      def version
+        say Palmade::Cableguy::VERSION
+      end
+
+      no_tasks do
+        def app_path
+          if options[:app_root]
+            File.expand_path(options[:app_root])
+          else
+            File.expand_path(Dir.pwd)
+          end
+        end
+
+        def lock_file_path
+          file_path = options[:lock_file]
+
+          if file_path.nil?
+            file_path = File.join(app_path, DEFAULT_LOCK_FILE)
+
+            if !File.exists?(file_path) && File.exists?(DEFAULT_LOCK_PATH)
+              file_path = DEFAULT_LOCK_PATH
+            end
+          end
+
+          file_path = File.expand_path(file_path)
+        end
+
+        def cabler(opts = { })
+          if defined?(@cabler) && !@cabler.nil?
+            @cabler
+          else
+            lock_opts = prepare_lock_file(opts)
+            opts = opts.merge(lock_opts)
+            opts = opts.merge(Utils.symbolize_keys(options))
+
+            check_if_cabling_path_exists!(opts)
+            check_if_cabling_values_exists!(opts)
+
+            if opts[:save_db] == 'save_db'
+              opts[:save_db] = true
+            end
+
+            @cabler = Palmade::Cableguy.boot_cabler(app_path, opts)
+          end
+        end
+
+        def prepare_lock_file(opts = { })
+          default_lock_opts = { :target => DEFAULT_TARGET, :location => DEFAULT_LOCATION }
+
+          if options[:nolock]
+            lock_opts = default_lock_opts
+          else
+            lfp = lock_file_path
+
+            if !File.exists?(lfp) || options[:unlock]
+              lock_opts = default_lock_opts.dup
+
+              if !options[:target].nil? && !options[:target].empty?
+                lock_opts[:target] = options[:target]
+              end
+
+              if !options[:location].nil? && !options[:location].empty?
+                lock_opts[:location] = options[:location]
+              end
+
+              unless opts[:lock_no_persist]
+                File.open(lfp, 'w') { |file| file.write(YAML.dump(lock_opts)) }
+              end
+            else
+              lock_opts = YAML.load_file(lfp)
+              check_locked_values(lock_opts)
+            end
+          end
+
+          lock_opts
+        end
+
+        def check_locked_values(lock_opts)
+          if !options[:target].nil? && !options[:target].empty?
+            if lock_opts[:target] != options[:target]
+              safety_message(:target, lock_opts)
+
+              if raise_error
+                raise 'Lock target not the same (%s != %s)' % [ lock_opts[:target], options[:target] ]
+              else
+                exit 1
+              end
+            end
+          end
+
+          if !options[:location].nil? && !options[:location].empty?
+            if lock_opts[:location] != options[:location]
+              safety_message(:location, lock_opts)
+
+              if raise_error
+                raise 'Lock location not the same (%s != %s)' % [ lock_opts[:location], options[:location] ]
+              else
+                exit 2
+              end
+            end
+          end
+        end
+
+        def safety_message(val, lock_opts)
+          lockfile_error_message = <<-error_message
+Lockfile has a setting #{val} with value '#{lock_opts[val]}' \
+and it is not equal to the specified #{val} '#{options[val]}'. \
+This prevents accidental overriding of the cabling database. \
+You can fix this by running with cabling migrate --unlock"
+error_message
+
+          say_with_format(lockfile_error_message, :red)
+        end
+
+        def say_with_format(msg, color = nil)
+          unless options[:silent]
+            say("-- #{msg}", color)
+          end
+        end
+
+        def check_if_cabling_values_exists!(opts)
+          if opts[:values_path].nil?
+            vp = File.expand_path(DEFAULT_CABLING_VALUES_PATH)
+
+            if File.exists?(vp)
+              opts[:values_path] = vp
+            end
+          else
+            vp = File.expand_path(opts[:values_path])
+
+            if File.exists?(vp)
+              opts[:values_path] = vp
+            else
+              say_with_format 'Cabling values path (%s) does not exists' % vp, :red
+
+              if raise_error
+                raise 'Cabling values path does not exists'
+              else
+                exit 3
+              end
+            end
+          end
+
+          opts[:values_path]
+        end
+
+        def check_if_cabling_path_exists!(opts)
+          if opts[:path].nil?
+            if ENV.include?('CABLING_PATH')
+              path = ENV['CABLING_PATH']
+            else
+              path = DEFAULT_CABLING_PATH
+            end
+          else
+            path = opts[:path]
+          end
+
+          if path.empty?
+            path = nil
+          else
+            path = File.expand_path(path)
+          end
+
+          if !path.nil? && File.exists?(path)
+            loop do
+              if File.symlink?(path)
+                path = File.readlink(path)
+              else
+                break
+              end
+            end
+
+            opts[:path] = path
+          elsif !opts[:path].nil?
+            say_with_format 'Cabling path (%s) does not exists' % opts[:path], :red
+
+            if raise_error
+              raise 'Cabling path does not exists'
+            else
+              exit 3
+            end
+          else
+            # ignore no cabling path!
+          end
+        end
+      end
+
+      default_task :configure
+    end
+  end
+end

data/lib/palmade/cableguy/cli_helper.rb

@@ -0,0 +1,18 @@
+require 'benchmark'
+
+module Palmade::Cableguy
+  module CliHelper
+    def say(message, subitem = false)
+      puts "#{subitem ? "   ->" : "--"} #{message}"
+    end
+
+    def 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
+  end
+end