cableguy 0.1.0

data/.gitignore

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

data/Gemfile

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

data/Manifest

@@ -0,0 +1,19 @@
+README
+Rakefile
+bin/cable
+lib/palmade/cableguy.rb
+lib/palmade/cableguy/builders.rb
+lib/palmade/cableguy/builders/cable_chmod.rb
+lib/palmade/cableguy/builders/cable_copy.rb
+lib/palmade/cableguy/builders/cable_custom.rb
+lib/palmade/cableguy/builders/cable_mkdir.rb
+lib/palmade/cableguy/builders/cable_move.rb
+lib/palmade/cableguy/builders/cable_symlink.rb
+lib/palmade/cableguy/builders/cable_template.rb
+lib/palmade/cableguy/cable.rb
+lib/palmade/cableguy/cable_configurator.rb
+lib/palmade/cableguy/cabler.rb
+lib/palmade/cableguy/configurator.rb
+lib/palmade/cableguy/templatebinding.rb
+lib/palmade/hash.rb
+Manifest

data/README

@@ -0,0 +1 @@
+Build config files for your rails apps

data/Rakefile

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

data/bin/cable

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+
+CABLE_LIB_PATH = File.expand_path(File.join(File.dirname(__FILE__), '../lib/palmade'))
+require File.join(CABLE_LIB_PATH, 'cableguy')
+require 'optparse'
+
+options = {}
+options[:verbose] = false
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Set cable options.\n"
+
+  opts.on('-p', '--path PATH', 'Specify cabling path') do |path|
+    options[:path] = path
+  end
+
+  opts.on('-l', '--location LOCATION', 'Specify cabling location') do |location|
+    options[:location] = location
+  end
+
+  opts.on('-t', '--target TARGET', 'Specify cabling target') do |target|
+    options[:target] = target
+  end
+
+  opts.on('-v', '--verbose', 'Verbose logging') do
+    options[:verbose] = true
+  end
+
+  opts.on('-h', '--help', 'Help screen') do
+    puts opts
+    exit
+  end
+end
+
+
+optparse.parse!
+
+Palmade::Cableguy::Runner.run(Dir.pwd, ARGV.shift, options)
+
+

data/cableguy.gemspec

@@ -0,0 +1,26 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require 'palmade/cableguy/version'
+
+Gem::Specification.new do |s|
+  s.name        = "cableguy"
+  s.version     = Palmade::Cableguy::VERSION
+  s.authors     = ["Jan Mendoza"]
+  s.email       = ["poymode@gmail.com"]
+  s.homepage    = "https://github.com/poymode/cableguy"
+  s.summary     = %q{Generate rails configurations from a sqlite key-value storage}
+  s.description = %q{cableguy}
+
+  s.rubyforge_project = "cableguy"
+  s.add_dependency "sqlite3"
+  s.add_dependency "sequel"
+
+  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/lib/palmade/cableguy/builders/cable_chmod.rb

@@ -0,0 +1,12 @@
+module Palmade::Cableguy
+  class Builders::CableChmod < Cable
+    add_as :chmod
+
+    def configure(cabler, cabling, target)
+      cabler.say_with_time "changing permissions #{args.join(' -> ')}" do
+        FileUtils.chmod(@args.shift.to_i(8), File.join(cabler.app_root, @args.shift))
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_copy.rb

@@ -0,0 +1,12 @@
+module Palmade::Cableguy
+  class Builders::CableCopy < Cable
+    add_as :copy
+
+    def configure(cabler, cabling, target)
+      cabler.say_with_time "copying #{@args.join(' -> ')}" do
+        FileUtils.cp(@args.shift, @args.shift)
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_custom.rb

@@ -0,0 +1,12 @@
+module Palmade::Cableguy
+  class Builders::CableCustom < Cable
+    add_as :custom
+
+    def configure(cabler, cabling, target)
+      unless @block.nil?
+        @block.call(self)
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_mkdir.rb

@@ -0,0 +1,14 @@
+module Palmade::Cableguy
+  class Builders::CableMkdir < Cable
+    add_as :mkdir
+
+    def configure(cabler, cabling, target)
+      cabler.say_with_time "mkdir #{@args.join(' ')}" do
+        @args.each do |path|
+          FileUtils.mkdir_p(File.join(cabler.app_root, path))
+        end
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_move.rb

@@ -0,0 +1,12 @@
+module Palmade::Cableguy
+  class Builders::CableMove < Cable
+    add_as :move
+
+    def configure(cabler, cabling, target)
+      cabler.say_with_time "moving #{@args.join(' -> ')}" do
+        FileUtils.mv(@args.shift, @args.shift)
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_symlink.rb

@@ -0,0 +1,15 @@
+module Palmade::Cableguy
+  class Builders::CableSymlink < Cable
+    add_as :symlink
+
+    def configure(cabler, cabling, target)
+
+    source = @args.shift
+    destination = @args.shift
+      cabler.say_with_time "creating symlink #{source} -> #{destination}" do
+        FileUtils.ln_s(source, destination, :force => true)
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders/cable_template.rb

@@ -0,0 +1,18 @@
+module Palmade::Cableguy
+  class Builders::CableTemplate < Cable
+    add_as :template
+
+    def configure(cabler, cabling, target)
+      cabler.say_with_time "configuring #{@args[0]}" do
+        unless @args[1].nil?
+          target_path = File.join(cabler.app_root, @args[1], @args[0])
+        else
+          target_path = nil
+        end
+
+        install_template(@args[0], cabler, cabling, target, target_path)
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/builders.rb

@@ -0,0 +1,22 @@
+module Palmade::Cableguy
+  module Builders
+    def self.load_all_builders
+      CableTemplate
+      CableMkdir
+      CableChmod
+      CableSymlink
+      CableCustom
+      CableMove
+      CableCopy
+    end
+
+    autoload :CableChmod, File.join(File.dirname(__FILE__), 'builders/cable_chmod')
+    autoload :CableCustom, File.join(File.dirname(__FILE__), 'builders/cable_custom')
+    autoload :CableMkdir, File.join(File.dirname(__FILE__), 'builders/cable_mkdir')
+    autoload :CableSymlink, File.join(File.dirname(__FILE__), 'builders/cable_symlink')
+    autoload :CableTemplate, File.join(File.dirname(__FILE__), 'builders/cable_template')
+    autoload :CableMove, File.join(File.dirname(__FILE__), 'builders/cable_move')
+    autoload :CableCopy, File.join(File.dirname(__FILE__), 'builders/cable_copy')
+  end
+end
+

data/lib/palmade/cableguy/cable.rb

@@ -0,0 +1,62 @@
+module Palmade::Cableguy
+  class Cable
+    attr_reader :args
+
+    @@builders = { }
+    def self.builders
+      @@builders
+    end
+
+    def self.add_as(key, klass = nil)
+      builders[key] = klass || self
+    end
+
+    def self.build_key(klass = nil)
+      builders.index(klass || self)
+    end
+
+    def self.build(what, *args, &block)
+      if builders.include?(what)
+        builders[what].new(*args, &block)
+      else
+        raise ArgumentError, "Unknown builder: #{what} -- supports: #{supported_builders.join(', ')}"
+      end
+    end
+
+    def self.supported_builders
+      builders.keys
+    end
+
+    def initialize(*args, &block)
+      @args = args
+      @block = block
+    end
+
+    def configure(cabler, cabling, target, &block)
+      puts "Not implemented: #{self.class.build_key}"
+    end
+
+    protected
+
+    def install_template(template_file, cabler, cabling, target, target_path = nil)
+      app_root = cabler.app_root
+
+      template_path = File.join(app_root, DEFAULT_TEMPLATES_PATH, template_file)
+      if target_path.nil?
+        target_path = File.join(app_root, DEFAULT_TARGET_PATH, template_file)
+      end
+
+      if File.exists?(template_path)
+        cabler.say "installing template file: #{template_file}", true
+
+        tb = TemplateBinding.new(self, cabler, cabling, target)
+        tb.install(template_path, target_path)
+      else
+        raise ArgumentError, "template file #{template_file} not found in #{DEFAULT_TEMPLATES_PATH}"
+      end
+    end
+  end
+
+  Builders.load_all_builders
+end
+

data/lib/palmade/cableguy/cable_configurator.rb

@@ -0,0 +1,32 @@
+module Palmade::Cableguy
+  class CableConfigurator < Configurator
+    attr_reader :setups
+    attr_reader :requires
+
+    def initialize(*args)
+      super
+      @setups = [ ]
+    end
+
+    def setup_cabling(*args, &block)
+      if block_given?
+        update_section(:setup_cabling, *args, &block)
+      else
+        call_section(:setup_cabling, *args)
+      end
+    end
+
+    def requirements(*args, &block)
+      if block_given?
+        update_section(:requirements, *args, &block)
+      else
+        call_section(:requirements, *args)
+      end
+    end
+
+    def setup(what, *args, &block)
+      @setups.push([ what, args, block ])
+    end
+  end
+end
+

data/lib/palmade/cableguy/cabler.rb

@@ -0,0 +1,115 @@
+module Palmade::Cableguy
+  class Cabler
+    include Constants
+
+    attr_reader :app_root
+    attr_reader :builds
+    attr_reader :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 :db
+    attr_accessor :targets
+    attr_accessor :group
+
+    def initialize(app_root, options)
+      @options = options
+      @app_root = app_root
+      @cabling_path = @options[:path]
+      @target = @options[:target]
+      @location = @options[:location]
+      @builds = nil
+      @logger = Logger.new($stdout)
+      @targets = [ :development ]
+      @db_path = File.join(@cabling_path, DB_DIRECTORY, "#{@target}.#{DB_EXTENSION}")
+
+      if @options[:verbose]
+        @logger.level = Logger::DEBUG
+      else
+        @logger.level = Logger::WARN
+      end
+
+      @db = Palmade::Cableguy::DB.new(self)
+    end
+
+    def boot
+      @database = @db.boot
+
+      self
+    end
+
+    def migrate
+      init_file = File.join(@cabling_path, 'init.rb')
+      require init_file if File.exist?(init_file)
+
+      say_with_time "Migrating..." do
+        Migration.new(self).boot
+      end
+
+      say "Done!"
+    end
+
+    def configure
+      @configurator = CableConfigurator.new
+      @configurator_path = File.join(@app_root, DEFAULT_CABLEGUY_PATH)
+
+      # checks for config/cableguy.rb
+      if File.exists?(@configurator_path)
+        @configurator.configure(@configurator_path)
+      else
+        raise MissingFile, "Required cableguy file (#{@configurator_path}) not found!"
+      end
+
+      check_requirements
+
+      build_setups.each do |s|
+        s.configure(self, @cabling, @target)
+      end
+    end
+
+    def check_requirements
+      if @configurator.include?(:requirements)
+        @configurator.requirements(self, @cabling, @target)
+      end
+    end
+
+    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
+
+    def require_cables(path)
+      if path =~ /\//
+        require(path)
+      else
+        require(File.join(@app_root, DEFAULT_CABLES_PATH, path))
+      end
+    end
+
+    protected
+
+    def build_setups
+      if @builds.nil?
+        @configurator.setup_cabling(self, @cabling, @target)
+        @builds = @configurator.setups.collect do |s|
+          Cable.build(s[0], *s[1], &s[2])
+        end
+      else
+        @builds
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/configurator.rb

@@ -0,0 +1,113 @@
+module Palmade::Cableguy
+  class Configurator
+    def self.configure(file_path, *args)
+      c = Class.new(self).new(*args)
+      c.configure(file_path)
+    end
+
+    def initialize(*args)
+      @args = args
+      @sections = { }
+    end
+
+    def append_args(*args)
+      unless args.empty?
+        @args += @args
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      method = method.to_s
+      if method[-1,1] == '='
+        # this is a setter
+        # create a new accessor
+
+        var_name = method[0..-2]
+        eval = <<EVAL
+def #{var_name}=(val)
+@#{var_name} = val
+end
+
+def #{var_name}
+@#{var_name}
+end
+EVAL
+      self.class.send(:class_eval, eval, __FILE__, __LINE__)
+      self.send(method, *args)
+    elsif block_given?
+      update_section(method, *args, &block)
+
+      # create a new section
+      eval = <<EVAL
+def #{method}(*args, &block)
+if block_given?
+  update_section(#{method}, *args, &block)
+else
+  call_section(#{method}, *args)
+end
+end
+EVAL
+        self.class.send(:class_eval, eval, __FILE__, __LINE__)
+      else
+        # generate an error!
+        raise ArgumentError, "Section #{method} not defined."
+      end
+    end
+
+    def include?(section)
+      @sections.include?(prep(section))
+    end
+    alias :has? :include?
+
+    def configure(file_path)
+      if File.exists?(file_path)
+        fcontents = File.read(file_path)
+        self.instance_eval(fcontents, file_path)
+      else
+        raise ArgumentError, "File #{file_path} not found"
+      end
+      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)
+      section.to_sym
+    end
+
+    def update_section(section, *args, &block)
+      return unless block_given?
+
+      options = args.last.is_a?(Hash) ? args.pop : { }
+      command = args.first || :push
+
+      section = prep(section)
+      unless @sections.include?(section)
+        @sections[section] = [ ]
+      end
+
+      case command
+      when :unshift
+        @sections[section].unshift(block)
+      when :push
+        @sections[section].push(block)
+      else
+        raise ArgumentError, "Unknown update command: #{command}"
+      end
+    end
+  end
+end
+

data/lib/palmade/cableguy/constants.rb

@@ -0,0 +1,6 @@
+module Palmade::Cableguy
+  module Constants
+    DB_DIRECTORY = "db"
+    DB_EXTENSION = "sqlite3"
+  end
+end

data/lib/palmade/cableguy/db.rb

@@ -0,0 +1,150 @@
+module Palmade::Cableguy
+  class DB
+    attr_reader :database
+
+    def initialize(cabler)
+      @cabler = cabler
+      @database = nil
+      @sql_options = { :logger => @cabler.logger, :sql_log_level => :info }
+
+      if @cabler.options[:verbose]
+        @sql_options[:sql_log_level] = :debug
+      end
+    end
+
+    def boot
+      @database = Sequel.sqlite(@cabler.db_path, @sql_options)
+      @group = ""
+      @prefix_stack = []
+
+      @dataset = @database[:cablingdatas]
+    end
+
+    def final_key(key)
+      unless @prefix_stack.empty?
+        @prefix_stack.push(key)
+        key = nil
+      end
+
+      key ||= @prefix_stack.join('.')
+    end
+
+    def set(key, value, group = nil)
+      group ||= @group
+      key = final_key(key)
+
+      @dataset.insert(:key => key, :value => value, :group => group)
+
+      stack_pop
+    end
+
+    def delete(key, value)
+      key = final_key(key)
+      @dataset.filter(:key => key).delete
+      stack_pop
+    end
+
+    def update(key, value, group = nil)
+      group ||= @group
+      key = final_key(key)
+
+      @dataset.filter(:key => key, :group => group).update(:value => value)
+
+      stack_pop
+    end
+
+    def group(group = nil, &block)
+      @group = group
+
+      @database.transaction do
+        yield
+      end
+    end
+
+    def globals(&block)
+      @group = "globals"
+
+      @database.transaction do
+        yield
+      end
+    end
+
+    def prefix(prefix, &block)
+      @prefix_stack.push(prefix)
+      yield
+
+      stack_pop
+    end
+
+    def stack_pop
+      @prefix_stack.pop
+    end
+
+    def has_key?(key, group)
+      group ||= @cabler.group.to_s
+
+      val = @dataset.where(:key => key, :group => group).count
+
+      if val == 0
+        val = @dataset.where(:key => key, :group => "globals").count
+
+        val == 0 ? false : true
+      else
+        true
+      end
+    end
+
+    def get(key, group = nil)
+      group ||= @cabler.group.to_s
+
+      val = @dataset.where(:key => key, :group => group)
+
+      if val.empty?
+        val = @dataset.where(:key => key, :group => "globals")
+      end
+
+      if val.count > 0
+        val.first[:value]
+      else
+        raise "key \'#{key}\' cannot be found!"
+      end
+    end
+
+    def get_children(key, group = nil)
+      group ||= @cabler.group.to_s
+      values = []
+
+      res = @dataset.where(:key.like("#{key}%"), :group => group)
+
+      if res.empty?
+        res = @dataset.where(:key.like("#{key}%"), :group => "globals")
+      end
+
+      key = key.split('.')
+
+      res.each do |r|
+        res_key = r[:key].split('.')
+        res_key = (res_key - key).shift
+        values.push(res_key)
+      end
+
+      if values.count > 0
+        values & values
+      else
+        raise "no values for \'#{key}\'!"
+      end
+    end
+
+    def create_table_if_needed
+      if @database.tables.include? :cablingdatas
+        @database.drop_table :cablingdatas
+      end
+
+      @database.create_table :cablingdatas do
+        String :key
+        String :value
+        String :group
+      end
+    end
+  end
+end

data/lib/palmade/cableguy/migration.rb

@@ -0,0 +1,92 @@
+module Palmade::Cableguy
+  class Migration
+    attr_reader :cabler
+    attr_reader :db
+
+    def initialize(cabler)
+      @cabler = cabler
+
+      @db = @cabler.db
+      @cabling_path = @cabler.cabling_path
+      @utils = Palmade::Cableguy::Utils
+    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
+      end
+    end
+
+    def sort_directories
+      dir_stack = ["base", "targets", '.']
+    end
+
+    def migrate!
+      raise "class #{self.class.name} doesn't have a migrate method. Override!"
+    end
+
+    def set(key, value, set = nil)
+      @db.set(key, value, set)
+    end
+
+    def group(group, &block)
+      @group = group
+      @db.group(@group, &block)
+    end
+
+    def globals(&block)
+      @db.globals(&block)
+    end
+
+    def prefix(prefix, &block)
+      @db.prefix(prefix, &block)
+    end
+
+    def delete(key, value = nil)
+      @db.delete(key, value)
+    end
+
+    def update(key, value)
+      @db.update(key, value)
+    end
+  end
+end

data/lib/palmade/cableguy/runner.rb

@@ -0,0 +1,44 @@
+module Palmade::Cableguy
+  class Runner
+    def self.run(app_root, cmd, options)
+      if options[:path].nil?
+        if ENV.include?("CABLING_PATH")
+          options[:path] = ENV["CABLING_PATH"]
+        elsif File.exist?(File.expand_path('~/cabling'))
+          options[:path] = File.expand_path('~/cabling')
+        elsif File.exist?("/var/cabling")
+          options[:path] = "/var/cabling"
+        elsif File.exist?("/etc/cabling")
+          options[:path] = "/etc/cabling"
+        else
+          raise "You don't seem to have any paths for cabling.\n"
+        end
+      end
+
+      if options[:target].nil?
+        if ENV.include?("CABLING_TARGET")
+          options[:target] = ENV["CABLING_TARGET"]
+        else
+          options[:target] = 'development'
+        end
+      end
+
+      if options[:location].nil?
+        if ENV.include?("CABLING_LOCATION")
+          options[:location] = ENV["CABLING_LOCATION"]
+        else
+          options[:location] = options[:target]
+        end
+      end
+
+      ca = Cabler.new(app_root, options)
+
+      case cmd
+      when 'migrate'
+        ca.boot.migrate
+      else
+        ca.boot.configure
+      end
+    end
+  end
+end

data/lib/palmade/cableguy/templatebinding.rb

@@ -0,0 +1,129 @@
+module Palmade::Cableguy
+  class TemplateBinding
+    attr_reader :cable
+    attr_reader :cabler
+    attr_reader :cabling
+    attr_reader :arg_hash
+    attr_reader :target
+    attr_reader :location
+    attr_reader :db
+    attr_reader :reserved_keys
+    attr_accessor :output_buffer
+
+    def initialize(cable, cabler, cabling, target)
+      @cable = cable
+      @cabler = cabler
+      @cabling = cabling
+      @target = target
+      @location = @cabler.location
+      @arg_hash = @cable.args[2]
+      @db = @cabler.db
+      @key_prefix = []
+      @reserved_keys = ['target', 'location']
+    end
+
+    def join_keys(key)
+      "#{@key_prefix.join('.')}.#{key}"
+    end
+
+    def has_key?(key, group = nil)
+      if !@key_prefix.empty?
+        key = join_keys(key)
+      end
+
+      @db.has_key?(key, group)
+    end
+
+    def get(key, group = nil)
+      if !@key_prefix.empty?
+        key = join_keys(key)
+      end
+
+      @db.get(key, group)
+    end
+
+    def get_children(key, group = nil, &block)
+      if block_given?
+        fill_key_prefix(key)
+
+        yield @db.get_children(key, group)
+        @key_prefix.clear
+      else
+        @db.get_children(key, group)
+      end
+    end
+
+    def get_each_child(key, group = nil, &block)
+      if block_given?
+        fill_key_prefix(key)
+
+        children = @db.get_children(key, group)
+
+        children.each do |c|
+          yield c
+        end
+
+        @key_prefix.clear
+      else
+        @db.get_children(key, group)
+      end
+    end
+
+    def fill_key_prefix(key)
+      key.split('.').each do |k|
+        @key_prefix << k
+      end
+    end
+
+    def parse(file_path)
+      Palmade::Cableguy.require_erb
+      fcontents = File.read(file_path)
+
+      parsed = ERB.new(fcontents, nil, "-%>", "@output_buffer").result(binding)
+      parsed = special_parse(parsed, [ '{', '}' ], false)
+    end
+
+    def special_parse(parsed, delim = [ '{', '}' ], cabling_only = false)
+      delim0 = "\\#{delim[0]}"
+      delim1 = "\\#{delim[1]}"
+
+      parsed = parsed.gsub(/#{delim0}(.+)#{delim1}/) do |match|
+        found = $1
+
+        if @reserved_keys.include?(found)
+          eval_ret = self.send(found)
+        else
+          eval_ret = get(found)
+        end
+      end
+    end
+
+    def install(source_file, target_file)
+      parsed = parse(source_file)
+
+      File.open(target_file, 'w') do |f|
+        f.write(parsed)
+      end
+      target_file
+    end
+
+    protected
+
+    def concat(buffer)
+      output_buffer.concat(buffer)
+    end
+
+    def capture(*args, &block)
+      with_output_buffer { block.call(*args) }
+    end
+
+    def with_output_buffer(buf = '') #:nodoc:
+      self.output_buffer, old_buffer = buf, output_buffer
+      yield
+      output_buffer
+    ensure
+      self.output_buffer = old_buffer
+    end
+  end
+end
+

data/lib/palmade/cableguy/utils.rb

@@ -0,0 +1,13 @@
+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]
+      end
+    end
+  end
+end

data/lib/palmade/cableguy/version.rb

@@ -0,0 +1,5 @@
+module Palmade
+  module Cableguy
+    VERSION = "0.1.0"
+  end
+end

data/lib/palmade/cableguy.rb

@@ -0,0 +1,43 @@
+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')
+
+    DEFAULT_CABLEGUY_PATH = "config/cableguy.rb"
+    DEFAULT_TEMPLATES_PATH = "config/templates"
+    DEFAULT_TARGET_PATH = "config"
+
+    class CableguyError < StandardError; end
+    class NotImplemented < CableguyError; end
+    class MissingFile < CableguyError; end
+
+    def self.check_requirements(app_root)
+      boot(app_root).check_requirements
+    end
+
+    def self.configure(app_root)
+      boot(app_root).configure
+    end
+
+    def self.require_erb
+      require 'erb'
+    end
+  end
+end
+

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: cableguy
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Jan Mendoza
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-31 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: &21819640 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21819640
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: &21819220 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *21819220
+description: cableguy
+email:
+- poymode@gmail.com
+executables:
+- cable
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Manifest
+- README
+- Rakefile
+- bin/cable
+- cableguy.gemspec
+- lib/palmade/cableguy.rb
+- lib/palmade/cableguy/builders.rb
+- lib/palmade/cableguy/builders/cable_chmod.rb
+- lib/palmade/cableguy/builders/cable_copy.rb
+- lib/palmade/cableguy/builders/cable_custom.rb
+- lib/palmade/cableguy/builders/cable_mkdir.rb
+- lib/palmade/cableguy/builders/cable_move.rb
+- lib/palmade/cableguy/builders/cable_symlink.rb
+- lib/palmade/cableguy/builders/cable_template.rb
+- lib/palmade/cableguy/cable.rb
+- lib/palmade/cableguy/cable_configurator.rb
+- lib/palmade/cableguy/cabler.rb
+- lib/palmade/cableguy/configurator.rb
+- lib/palmade/cableguy/constants.rb
+- lib/palmade/cableguy/db.rb
+- lib/palmade/cableguy/migration.rb
+- lib/palmade/cableguy/runner.rb
+- lib/palmade/cableguy/templatebinding.rb
+- lib/palmade/cableguy/utils.rb
+- lib/palmade/cableguy/version.rb
+homepage: https://github.com/poymode/cableguy
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: cableguy
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Generate rails configurations from a sqlite key-value storage
+test_files: []