cableguy 0.2.3 → 0.5.0.pre2

data/lib/palmade/cableguy/configurator.rb

@@ -16,6 +16,11 @@ module Palmade::Cableguy
       end
     end
 
+    def include?(section)
+      @sections.include?(prep(section))
+    end
+    alias :has? :include?
+
     def method_missing(method, *args, &block)
       method = method.to_s
       if method[-1,1] == '='
@@ -54,12 +59,7 @@ EVAL
       end
     end
 
-    def include?(section)
-      @sections.include?(prep(section))
-    end
-    alias :has? :include?
-
-    def configure(file_path)
+    def configure_from_file(file_path)
       if File.exists?(file_path)
         fcontents = File.read(file_path)
         self.instance_eval(fcontents, file_path)
@@ -69,19 +69,6 @@ EVAL
       self
     end
 
-    def call_section(section, *args)
-      section = prep(section)
-      if @sections.include?(section)
-        @sections[section].each do |block|
-          block.call(*(args + @args))
-        end
-      else
-        raise ArgumentError, "Section #{section} not defined."
-      end
-    end
-    alias :call :call_section
-    alias :include :call_section
-
     protected
 
     def prep(section)
@@ -108,6 +95,18 @@ EVAL
         raise ArgumentError, "Unknown update command: #{command}"
       end
     end
+
+    def call_section(section, *args)
+      section = prep(section)
+      if @sections.include?(section)
+        @sections[section].each do |block|
+          block.call(*(args + @args))
+        end
+      else
+        raise ArgumentError, "Section #{section} not defined."
+      end
+    end
+    alias :call :call_section
+    alias :include :call_section
   end
 end
-

data/lib/palmade/cableguy/constants.rb

@@ -1,6 +1,21 @@
 module Palmade::Cableguy
   module Constants
-    DB_DIRECTORY = "db"
-    DB_EXTENSION = "sqlite3"
+    DB_DIRECTORY = 'db'
+    DB_EXTENSION = 'sqlite3'
+
+    DEFAULT_CABLEFILE_NAME = 'Cablefile'
+    DEFAULT_LEGACY_CABLEFILE_NAME = 'config/cableguy.rb'
+
+    DEFAULT_CABLING_PATH = File.join(ENV['HOME'], 'cabling')
+    DEFAULT_CABLING_VALUES_PATH = File.join(ENV['HOME'], '.cabling_values.yml')
+
+    DEFAULT_LOCK_FILE = File.join('.cabling.yml')
+    DEFAULT_LOCK_PATH = File.join(ENV['HOME'], DEFAULT_LOCK_FILE)
+
+    DEFAULT_TARGET = 'development'
+    DEFAULT_LOCATION = nil
+
+    DEFAULT_TEMPLATES_PATH = 'config/templates'
+    DEPRECATED_DEFAULT_TARGET_PATH = 'config'
   end
 end

data/lib/palmade/cableguy/db.rb

@@ -1,96 +1,131 @@
+require 'sequel'
+require 'fileutils'
+
 module Palmade::Cableguy
   class DB
     attr_reader :database
+    attr_reader :dataset
+
+    GLOBAL_GROUP = 'globals'
 
-    def initialize(cabler)
+    DEFAULT_OPTIONS = {
+      :save_db => nil
+    }
+
+    def initialize(cabler, options = { })
+      @options = DEFAULT_OPTIONS.merge(options)
       @cabler = cabler
+
       @database = nil
       @sql_options = { :logger => @cabler.logger, :sql_log_level => :info }
 
       if @cabler.options[:verbose]
         @sql_options[:sql_log_level] = :debug
       end
+
+      @migrated = false
     end
 
     def boot
-      @database = Sequel.sqlite(@cabler.db_path, @sql_options)
-      @group = ""
-      @prefix_stack = []
+      if @options[:save_db].nil?
+        connect_string = 'sqlite:/'
+      else
+        FileUtils.mkpath(File.dirname(@options[:save_db]))
+        connect_string = 'sqlite://%s' % @options[:save_db]
+      end
 
+      @database = Sequel.connect(connect_string, @sql_options)
       @dataset = @database[:cablingdatas]
-    end
 
-    def final_key(key)
-      unless @prefix_stack.empty?
-        @prefix_stack.push(key)
-        key = nil
-      end
+      @group_stack = [ ]
+      @prefix_stack = [ ]
 
-      key ||= @prefix_stack.join('.')
+      self
     end
 
-    def set(key, value, group = nil)
-      group ||= @group
-      key = final_key(key)
+    def prepare_for_use
+      prepare_table
+    end
 
-      @dataset.insert(:key => key, :value => value, :group => group)
+    def group(group, &block)
+      @group_stack.push(group.to_s)
+
+      if block_given?
+        begin
+          @database.transaction do
+            yield
+          end
+        ensure
+          @group_stack.pop
+        end
+      end
 
-      stack_pop
+      group
     end
 
-    def delete_key(key, group = nil)
-      group ||= @group
-
-      key = final_key(key)
+    def globals(&block)
+      group(GLOBAL_GROUP, &block)
+    end
 
-      @dataset.filter(:key => key, :group => group).delete
-      stack_pop
+    def prefix(prefix, &block)
+      @prefix_stack.push(prefix)
+      yield
+    ensure
+      @prefix_stack.pop
     end
 
-    def update(key, value, group = nil)
-      group ||= @group
-      key = final_key(key)
+    def final_key(key, group)
+      if key =~ /^([A-Za-z0-9\_]*)\:([A-Za-z0-9\_\-\.]+)$/
+        group = $~[1]
+        key = $~[2]
+      else
+        group = @group_stack.last if group.nil?
 
-      @dataset.filter(:key => key, :group => group).update(:value => value)
+        unless @prefix_stack.empty?
+          key = (@prefix_stack + [ key ]).join('.')
+        end
+      end
 
-      stack_pop
+      [ key, group ]
     end
 
-    def group(group = nil, &block)
-      @group = group
+    def final_value(group, key, value)
+      val_key = '%s:%s' % [ group, key ]
 
-      @database.transaction do
-        yield
-      end
+      g = @cabler.values.fetch(group, { })
+      g.fetch(key, value)
     end
 
-    def globals(&block)
-      @group = "globals"
+    def set(key, value, group = nil)
+      key, group = final_key(key, group)
+      value = final_value(group, key, value)
 
-      @database.transaction do
-        yield
+      if @dataset.where(:key => key, :group => group).count > 0
+        @dataset.filter(:key => key, :group => group).update(:value => value)
+      else
+        @dataset.insert(:key => key, :group => group, :value => value)
       end
     end
 
-    def prefix(prefix, &block)
-      @prefix_stack.push(prefix)
-      yield
+    def update(key, value, group = nil)
+      key, group = final_key(key, group)
+      value = final_value(group, key, value)
 
-      stack_pop
+      @dataset.filter(:key => key, :group => group).update(:value => value)
     end
 
-    def stack_pop
-      @prefix_stack.pop
+    def delete_key(key, group = nil)
+      key, group = final_key(key, group)
+
+      @dataset.filter(:key => key, :group => group).delete
     end
 
-    def has_key?(key, group)
-      group ||= @cabler.group.to_s
+    def has_key?(key, group = nil)
+      key, group = final_key(key, group)
 
       val = @dataset.where(:key => key, :group => group).count
-
       if val == 0
-        val = @dataset.where(:key => key, :group => "globals").count
-
+        val = @dataset.where(:key => key, :group => GLOBAL_GROUP).count
         val == 0 ? false : true
       else
         true
@@ -98,35 +133,31 @@ module Palmade::Cableguy
     end
 
     def get(key, group = nil)
-      group ||= @cabler.group.to_s
+      key, group = final_key(key, group)
 
       val = @dataset.where(:key => key, :group => group)
-
       if val.empty?
-        val = @dataset.where(:key => key, :group => "globals")
+        val = @dataset.where(:key => key, :group => GLOBAL_GROUP)
       end
 
       if val.count > 0
         val.first[:value]
       else
-        raise "key \'#{key}\' cannot be found!"
+        raise "key \'%s\' cannot be found!" % key
       end
     end
 
     def get_if_key_exists(key, group = nil)
-      group ||= @cabler.group.to_s
-
       get(key, group) if has_key?(key, group)
     end
 
     def get_children(key, group = nil)
-      group ||= @cabler.group.to_s
-      values = []
-
-      res = @dataset.where(:key.like("#{key}%"), :group => group)
+      key, group = final_key(key, group)
 
+      values = [ ]
+      res = @dataset.where(Sequel.like(:key, "#{key}%"), :group => group)
       if res.empty?
-        res = @dataset.where(:key.like("#{key}%"), :group => "globals")
+        res = @dataset.where(Sequel.like(:key, "#{key}%"), :group => GLOBAL_GROUP)
       end
 
       key = key.split('.')
@@ -140,19 +171,37 @@ module Palmade::Cableguy
       if values.count > 0
         values & values
       else
-        raise "no values for \'#{key}\'!"
+        raise "no values for \'%s\'!" % key
       end
     end
 
-    def create_table_if_needed
-      if @database.tables.include? :cablingdatas
-        @database.drop_table :cablingdatas
+    def empty?
+      !@database.tables.include?(:cablingdatas) || @dataset.count == 0
+    end
+
+    def migrated?
+      @migrated == true
+    end
+
+    def migrated!
+      @migrated = true
+    end
+
+    def reset
+      if @database.tables.include?(:cablingdatas)
+        @dataset.truncate
       end
 
-      @database.create_table :cablingdatas do
-        String :key
-        String :value
-        String :group
+      @migrated = false
+    end
+
+    def prepare_table
+      unless @database.tables.include?(:cablingdatas)
+        @database.create_table(:cablingdatas) do
+          String :key
+          String :value
+          String :group
+        end
       end
     end
   end

data/lib/palmade/cableguy/{cable_configurator.rb → legacy_configurator.rb}

@@ -1,5 +1,5 @@
 module Palmade::Cableguy
-  class CableConfigurator < Configurator
+  class LegacyConfigurator < Configurator
     attr_reader :setups
     attr_reader :requires
 
@@ -29,4 +29,3 @@ module Palmade::Cableguy
     end
   end
 end
-

data/lib/palmade/cableguy/migration.rb

@@ -2,91 +2,67 @@ module Palmade::Cableguy
   class Migration
     attr_reader :cabler
     attr_reader :db
+    attr_reader :cabling_path
 
-    def initialize(cabler)
-      @cabler = cabler
-
-      @db = @cabler.db
-      @cabling_path = @cabler.cabling_path
-      @utils = Palmade::Cableguy::Utils
+    def self.use_klass_stack(klass_stack)
+      @@klass_stack = klass_stack
+      ret = yield
+      @@klass_stack = nil
+      klass_stack
     end
 
-    def boot
-      @db.create_table_if_needed
-
-      file_stack = []
-
-      sort_directories.each do |p|
-        path = File.join(@cabling_path, p)
-
-        if p == 'targets'
-          if !@cabler.location.nil? && @cabler.location != @cabler.target
-            f = File.join(path, "#{@cabler.target}_#{@cabler.location}.rb")
-          else
-            f = File.join(path, "#{@cabler.target}.rb")
-          end
-
-          if File.exists?(f)
-            require f
-            file_stack.push(f)
-          else
-            raise "File #{f} doesn't exist!"
-          end
-        elsif p == '.'
-          if File.exist?(File.join(path, 'custom.rb'))
-            f = Dir["#{path}/custom.rb"].shift
-            require f
-            file_stack.push(f)
-          end
-        else
-          Dir["#{path}/*.rb"].each do |d|
-            require d
-            file_stack.push(d)
-          end
-        end
-
-        file_stack.each do |f|
-          class_name = File.basename(f).chomp(".rb")
-          camelized_class_name = (@utils.camelize(class_name))
-          klass = Palmade::Cableguy::Migrations.const_get(camelized_class_name)
-          k = klass.new(@cabler)
-          k.migrate!
-        end
-        file_stack.clear
+    def self.inherited(subclass)
+      if defined?(@@klass_stack) && !@@klass_stack.nil?
+        @@klass_stack << subclass
       end
     end
 
-    def sort_directories
-      dir_stack = ["base", "targets", '.']
+    def initialize(cabler)
+      @cabler = cabler
+      @db = cabler.db
+      @cabling_path = cabler.cabling_path
     end
 
-    def migrate!
-      raise "class #{self.class.name} doesn't have a migrate method. Override!"
-    end
+    protected
 
     def set(key, value, set = nil)
-      @db.set(key, value, set)
+      db.set(key, value, set)
+    end
+
+    def update(key, value)
+      db.update(key, value)
+    end
+
+    def get(key)
+      db.get(key)
     end
 
     def group(group, &block)
-      @group = group
-      @db.group(@group, &block)
+      db.group(group, &block)
     end
 
     def globals(&block)
-      @db.globals(&block)
+      db.globals(&block)
     end
 
     def prefix(prefix, &block)
-      @db.prefix(prefix, &block)
+      db.prefix(prefix, &block)
     end
 
     def delete_key(key, group = nil)
-      @db.delete_key(key, group)
+      db.delete_key(key, group)
     end
 
-    def update(key, value)
-      @db.update(key, value)
+    def values
+      cabler.values
+    end
+
+    def pre_migrate; end
+
+    def post_migrate; end
+
+    def migrate!
+      raise "class %s doesn't have a migrate! method. Override!" % self.class.name
     end
   end
 end

data/lib/palmade/cableguy/migrator.rb

@@ -0,0 +1,124 @@
+module Palmade::Cableguy
+  class Migrator
+    attr_reader :cabler
+    attr_reader :db
+    attr_reader :cabling_path
+
+    attr_accessor :klass_stack
+    attr_accessor :file_stack
+    attr_accessor :instance_stack
+
+    DIR_TREE = [ 'base', 'targets', '.' ]
+
+    DEFAULT_OPTS = {
+      :unload_cabling => true
+    }
+
+    def self.boot(cabler, cabling_path, opts = { })
+      Migrator.new(cabler, cabling_path, opts).tap { |o| o.boot }
+    end
+
+    def initialize(cabler, cabling_path, opts = { })
+      @options = DEFAULT_OPTS.merge(opts)
+
+      @cabler = cabler
+      @db = cabler.db
+      @cabling_path = cabling_path
+
+      @file_stack = [ ]
+      @klass_stack = [ ]
+      @instance_stack = [ ]
+    end
+
+    def boot
+      init_file = File.join(cabling_path, 'init.rb')
+      require init_file if File.exist?(init_file)
+    end
+
+    def load_cabling
+      if @instance_stack.empty?
+        search_for_files
+        require_files_once
+        instantiate_klasses
+      end
+    end
+
+    def unload_cabling
+      @klass_stack.each do |k|
+        klass_name = k.name
+
+        knames = klass_name.split('::')
+        if knames.count > 1
+          const_name = knames.pop
+          parent_module = ::Object.module_eval('::%s' % knames.join('::'), __FILE__, __LINE__)
+        else
+          parent_module = ::Object
+          const_name = knames[0]
+        end
+
+        parent_module.send(:remove_const, const_name.to_sym)
+      end
+    end
+
+    def run!
+      load_cabling
+
+      run_all_migrations(:pre_migrate)
+      run_all_migrations(:migrate!)
+      run_all_migrations(:post_migrate)
+
+      if @options[:unload_cabling]
+        unload_cabling
+      end
+
+      self
+    end
+
+    protected
+
+    def instantiate_klasses
+      @klass_stack.each do |klass|
+        @instance_stack << klass.new(cabler)
+      end
+    end
+
+    def run_all_migrations(migration)
+      @instance_stack.each do |i|
+        i.send(migration)
+      end
+    end
+
+    def require_files_once
+      Palmade::Cableguy::Migration.use_klass_stack(@klass_stack) do
+        file_stack.each { |file| load(file) }
+      end
+    end
+
+    def directory_tree; DIR_TREE; end
+
+    def search_for_files
+      directory_tree.each do |child|
+        path = File.join(cabling_path, child)
+
+        case child
+        when 'targets'
+          if !cabler.location.nil? && !cabler.location.empty? && cabler.location != cabler.target
+            file = File.join(path, '%s_%s.rb' % [ cabler.target, cabler.location ])
+          else
+            file = File.join(path, '%s.rb' % cabler.target)
+          end
+
+          if File.exists?(file)
+            file_stack.push(file)
+          end
+        when '.'
+          if File.exist?(File.join(path, 'custom.rb'))
+            file_stack.push(Dir['%s/custom.rb' % path].shift)
+          end
+        else
+          Dir['%s/*.rb' % path].each { |file| file_stack.push(file) }
+        end
+      end
+    end
+  end
+end

data/lib/palmade/cableguy/templatebinding.rb

@@ -2,7 +2,6 @@ module Palmade::Cableguy
   class TemplateBinding
     attr_reader :cable
     attr_reader :cabler
-    attr_reader :cabling
     attr_reader :arg_hash
     attr_reader :target
     attr_reader :location
@@ -10,20 +9,26 @@ module Palmade::Cableguy
     attr_reader :reserved_keys
     attr_accessor :output_buffer
 
-    def initialize(cable, cabler, cabling, target)
+    def self.require_erb
+      require 'erb'
+    end
+
+    def initialize(cable, cabler)
       @cable = cable
       @cabler = cabler
-      @cabling = cabling
-      @target = target
+
+      @target = @cabler.target
       @location = @cabler.location
+
       @arg_hash = @cable.args[2]
       @db = @cabler.db
-      @key_prefix = []
-      @reserved_keys = ['target', 'location']
+      @key_prefix = [ ]
+
+      @reserved_keys = ['target', 'location', 'cabler']
     end
 
     def join_keys(key)
-      "#{@key_prefix.join('.')}.#{key}"
+      '%s.%s' % [ @key_prefix.join('.'), key ]
     end
 
     def has_key?(key, group = nil)
@@ -84,24 +89,27 @@ module Palmade::Cableguy
     end
 
     def parse(file_path)
-      Palmade::Cableguy.require_erb
-      fcontents = File.read(file_path)
+      self.class.require_erb
 
+      fcontents = File.read(file_path)
       parsed = ERB.new(fcontents, nil, "-%>", "@output_buffer").result(binding)
-      parsed = special_parse(parsed, [ '{', '}' ], false)
+      parsed = special_parse(parsed)
     end
 
     def special_parse(parsed, delim = [ '{', '}' ], cabling_only = false)
-      delim0 = "\\#{delim[0]}"
-      delim1 = "\\#{delim[1]}"
+      delim0 = "\\%s" % delim[0]
+      delim1 = "\\%s" % delim[1]
 
-      parsed = parsed.gsub(/#{delim0}(.+)#{delim1}/) do |match|
-        found = $1
+      holders_re = '%s(([A-Za-z0-9\_]+)\:)?([A-Za-z0-9\.\_\-]+)%s' % [ delim0, delim1 ]
+
+      parsed = parsed.gsub(/#{holders_re}/) do |match|
+        group = $2
+        found = $3
 
         if @reserved_keys.include?(found)
           eval_ret = self.send(found)
         else
-          eval_ret = get(found)
+          eval_ret = get(found, group)
         end
       end
     end
@@ -134,4 +142,3 @@ module Palmade::Cableguy
     end
   end
 end
-