expansions 0.0.6

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+.bundle
+Gemfile.lock

data/.rvmrc

@@ -0,0 +1 @@
+rvm 1.9.3@expander --create

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gemspec
+

data/Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec' do
+  watch(%r{^spec/specs/.+_spec\.rb$})
+  watch(%r{^lib/developwithpassion_expander/(.+)\.rb$})     { |m| "spec/specs/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec" }
+end

data/README.md

@@ -0,0 +1,61 @@
+#developwithpassion_expander
+
+This was one of the first projects I wrote when I was teaching myself ruby. A lot of the codebase definitely shows its age, but it is also what I use to this day to manage my [cross platform script configuration system].
+
+It is really an extremely scaled down rake built to suit one specific purpose (supporting the expansions for the scripts I was managing!!)
+
+#Usage
+
+Create an ExpansionFile and place it in a folder that you want to use the expander in.
+
+Here is the simplest possible ExpansionFile you could write:
+
+```ruby
+expand do
+  puts "Hello"
+end
+```
+
+Along with regular ruby, within the context of an expand block you have access to the following methods:
+
+-look_for_templates_in [pattern]
+  * This method allows you to specify glob style patterns for template files that will be used during the expansion process. Currently the system only supports Mustache and ERB templates and also expects the template files to end with their appropriate {mustache/erb} extension.
+    During the epansion process files that have been registered as templates will get expanded according to configuration information that has been provided to [configatron](https://github.com/markbates/configatron). My recommendation is to load configuration information near the start of your ExpansionFile. Here is an example of loading the configuration:
+
+```ruby
+configs = {
+  :core => 
+  { 
+    :home => ENV["HOME"] ,
+    :devtools_root => File.expand_path(File.dirname(__FILE__))
+  }
+}
+configatron.configure_from_hash configs
+load "#{File.basename(`whoami`.chomp)}.settings"
+
+platform_config_file = "expansions/config_#{platform}"
+log "Loading config file #{platform_config_file}"
+load "#{platform_config_file}"
+```
+Notice in the example above I am populating configatron with information from one hash in the main ExpansionFile as well as supplementing that configuration information with configuration information from another file. Here is what is in the platform_config_file:
+
+```ruby
+configatron.configure_from_hash :core =>{
+    :launcher => '',
+    :vim => 'mvim',
+    :editor => 'mvim -v -f -c "au VimLeave * !open -a Terminal"',
+    :is_windows => false,
+    :is_cygwin => false,
+    :is_mingw => false,
+    :is_osx => true,
+    :vi => "'mvim -v'",
+  },
+  :git => {
+    :autocrlf => 'input',
+    :merge_tool => 'vimdiff',
+    :diff_tool => 'vimdiff',
+  },
+  :vim => {
+    :environment => 'mac'
+  }
+```

data/Rakefile

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

data/bin/expansions

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require 'expansions'
+Expansions::CLIInterface.new.run(ARGV)

data/expansions.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib",__FILE__)
+require "core/version"
+
+Gem::Specification.new do |s|
+  s.name        = "expansions"
+  s.version     = Expansions::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Develop With Passion®"]
+  s.email       = ["open_source@developwithpassion.com"]
+  s.homepage    = "http://www.developwithpassion.com"
+  s.summary     = %q{Simple Expansion Automation Utility}
+  s.description = %q{Automation utitlity that I use to support cross platform file maintenance}
+  s.rubyforge_project = "expansions"
+
+  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 "guard"
+  s.add_development_dependency "guard-rspec"
+  s.add_development_dependency "fakes-rspec"
+  s.add_development_dependency "rb-notifu"
+  s.add_runtime_dependency 'configatron', '>=2.9.0'
+  s.add_runtime_dependency "mustache"
+  s.add_runtime_dependency "developwithpassion_arrays"
+end

data/lib/core/array.rb

@@ -0,0 +1,8 @@
+class Array
+  def as_home_files
+    self.map{|item| item.as_home_file}
+  end
+  def as_glob_pattern
+    File.join(self)
+  end
+end

data/lib/core/cli_interface.rb

@@ -0,0 +1,39 @@
+module Expansions
+  class CLIInterface
+    def startup
+      [
+        TemplateProcessors,
+        TemplateVisitor,
+        Expansion,
+        Shell
+      ].each{|item| item.send(:include,Singleton)}
+
+      TemplateProcessors.instance.register_processor(:erb,ERBTemplateFile.new)
+      TemplateProcessors.instance.register_processor(:mustache,MustacheTemplateFile.new)
+    end
+
+    def get_expansion_file_name(args)
+      return args.count > 0 ? args[0] : "Expansionfile"
+    end
+
+    def ensure_expansion_file_provided(file)
+      unless File.exist?(file)
+        print <<-prompt
+dwp_expand aborted!
+No Expansionfile found (looking for: Expansionfile)
+        prompt
+        exit
+      end
+    end
+
+    def run(args = [])
+      file_to_run = get_expansion_file_name(args)
+      ensure_expansion_file_provided file_to_run
+      startup
+      enable_logging
+      log "Running Expansions defined in file:#{file_to_run}"
+      load file_to_run
+      Expansion.instance.run
+    end
+  end
+end

data/lib/core/copy.rb

@@ -0,0 +1,19 @@
+module Expansions
+  class Copy
+    def initialize(copy_target)
+      array :sources do|a|
+        a.read_and_write
+        a.mutator :folder do|item| register(item,true) end
+        a.mutator :contents do|item| register(item,false) end
+        a.mutator :all_contents_in do|set_of_folders| set_of_folders.each{|item| contents(item)} end
+        a.mutator :all_folders_in do|set_of_folders| set_of_folders.each{|item| folder(item)} end
+        a.process_using :run, copy_target
+      end
+    end
+
+    :private
+    def register(folder,copy_containing_folder = false)
+      @sources.push(copy_containing_folder ? folder : File.join(folder,'.'))
+    end
+  end
+end

data/lib/core/copy_to_target.rb

@@ -0,0 +1,11 @@
+module Expansions
+  class CopyToTarget
+    def initialize(target)
+      @target = target
+    end
+
+    def run_using(source_item)
+      Shell.instance.run("cp -rf #{source_item} #{@target}")
+    end
+  end
+end

data/lib/core/enumerable_extensions.rb

@@ -0,0 +1,11 @@
+module Enumerable
+  def process_all_items_using(visitor)
+    self.each{|item| visitor.run_using(item)}
+  end
+end
+
+class Hash
+  def process_all_values_using(&block)
+    self.values.each{|item| yield item}
+  end
+end

data/lib/core/erb_template_file.rb

@@ -0,0 +1,31 @@
+module Expansions
+  class ERBTemplateFile
+    def prepare_template(template)
+      token_regex = /(@\w[\w\.\_]+\w@)/
+
+      hits = template.scan(token_regex)
+      tags = hits.map do |item|
+        item[0].gsub(/@/,'').squeeze
+      end
+      tags = tags.map{|tag| tag.to_sym}.uniq
+
+      tags.inject(template) do |text, tag|
+        text.gsub /@#{tag.to_s}@/, "<%= #{tag.to_s} %>"
+      end
+    end
+
+    def process_template(template,binding)
+      erb = ERB.new(template, 0, "%")
+      erb.result(binding)
+    end
+
+    def process(args)
+      template = prepare_template(File.read(args[:input]))
+      result = process_template(template,args[:binding])
+
+      File.open_for_write(args[:output]) do|file|
+        file.write(result)
+      end
+    end
+  end
+end

data/lib/core/expansion.rb

@@ -0,0 +1,79 @@
+module Expansions
+  class Expansion
+    attr_accessor :copies,:files_to_merge,:globber
+
+    def initialize
+      initialize_hashes :files_to_merge,:copies
+
+      @globber = lambda{|path| return glob(path)}
+
+      array :cleanup_items do|a| 
+        a.readable
+        a.process_using :run_cleanup,:call 
+      end
+
+      array :setup_items do|a| 
+        a.readable
+        a.process_using :run_setup_items,:call 
+      end
+
+      array :executable_files do|a|
+        a.mutator :register_executable
+        a.process_using :mark_files_executable,ShellActionAgainstFile.new("chmod +x")
+      end
+
+      array :files_with_line_endings_to_fix do|a|
+        a.mutator :fix_line_endings_for
+        a.process_using :fix_line_endings,ShellActionAgainstFile.new("d2u")
+      end
+
+      array :folders_to_purge do|a|
+        a.mutator :register_folder_to_purge
+        a.process_using :purge_targets,ShellActionAgainstFile.new("rm -rf")
+      end
+    end
+
+    def copy_to target,&block
+      hash_process(target,@copies,lambda{|key| return Copy.new(CopyToTarget.new(key))},&block)
+    end
+
+    def merge_to target,&block
+      hash_process(target,@files_to_merge,lambda{|key| return FileMerge.new(key)},&block)
+    end
+
+    def look_for_templates_in(path)
+      @globber.call(path).process_all_items_using(TemplateVisitor.instance)
+    end
+
+    def cleanup(&block)
+      @cleanup_items << block
+    end
+
+    def before(&block)
+      @setup_items << block
+    end
+
+    def run
+      run_setup_items
+      purge_targets
+      expand_items
+      merge_items
+      run_cleanup
+      fix_line_endings 
+      mark_files_executable
+    end
+
+    :private
+    def hash_process(target,hash,factory,&block)
+      symbol = target.to_sym
+      hash[symbol] = factory.call(target) unless hash.has_key?(symbol)
+      hash[symbol].instance_eval(&block)
+    end
+    def expand_items
+      @copies.process_all_values_using{|copy| copy.run}
+    end
+    def merge_items
+      @files_to_merge.process_all_values_using{|merge| merge.run}
+    end
+  end
+end

data/lib/core/file.rb

@@ -0,0 +1,32 @@
+class File
+  def self.open_for_read(file)
+    File.open(file,'r').each do|line|
+      yield line
+    end
+  end
+
+  def self.read_all_text(file)
+    File.read_all_text_after_skipping_lines(file,0)
+  end
+
+  def self.read_all_text_after_skipping_lines(file,number_of_lines_to_skip)
+    index = 1
+    contents = ''
+
+    if File.exist?(file)
+      File.open_for_read(file) do |line|
+        contents += line if index > number_of_lines_to_skip
+        index+=1
+      end
+    end
+
+    return contents
+  end
+
+  def self.open_for_write(file)
+    File.open(file,'w') do|new_file|
+      yield new_file
+    end
+  end
+
+end

data/lib/core/file_merge.rb

@@ -0,0 +1,45 @@
+module Expansions
+  class FileMerge
+    attr_accessor :read_original_contents
+
+    def initialize(output_file)
+      array :before_files do|a|
+        a.read_and_write
+        a.mutator :add_before_original_contents do |file| add_merge_file(@before_files,file) end
+        a.mutator :add do|file| add_before_original_contents(file) end
+      end
+      array :after_files do|a|
+        a.read_and_write
+        a.mutator :add_after_original_contents do|file| add_merge_file(@after_files,file) end
+      end
+      @output_file = output_file
+      @read_original_contents = true
+    end
+
+    def dont_read_original_file_contents
+      @read_original_contents = false
+    end
+
+    def run
+      original_contents = File.read_all_text(@output_file)
+      FileUtils.rm_f @output_file
+      File.open_for_write(@output_file) do |file|
+        merge_files(@before_files,file)
+        file.write original_contents if @read_original_contents
+        merge_files(@after_files,file)
+      end
+    end
+
+    def merge_files(source_files,target)
+      source_files.each do|source|
+        target.write File.read_all_text(source)
+      end
+    end
+
+    :private
+    def add_merge_file(items,file)
+      return if items.include?(file)
+      items << file if File.exists?(file)
+    end
+  end
+end

data/lib/core/kernel.rb

@@ -0,0 +1,35 @@
+module Kernel
+  def expand(title = "Expansion",&block)
+    DevelopWithPassion::Expander::Expansion.instance.instance_eval(&block)
+  end
+
+  def glob(path)
+    items = Dir.glob(path,File::FNM_DOTMATCH)
+    items.each{|item| yield item if block_given?}
+    return items
+  end
+
+  def disable_logging
+    DevelopWithPassion::Expander::Log.disable
+  end
+
+  def enable_logging
+    DevelopWithPassion::Expander::Log.enable
+  end
+
+  def delayed
+    Configatron::Delayed.new do
+      yield
+    end
+  end
+
+  def dynamic
+    Configatron::Dynamic.new do
+      yield
+    end
+  end
+
+  def log(message)
+    DevelopWithPassion::Expander::Log.message(message)
+  end
+end

data/lib/core/log.rb

@@ -0,0 +1,15 @@
+module Expansions
+  class Log
+    class << self
+      def message(item)
+        puts item if @enabled
+      end
+      def enable
+        @enabled = true
+      end
+      def disable
+        @enabled = false
+      end
+    end
+  end
+end

data/lib/core/mustache_template_file.rb

@@ -0,0 +1,9 @@
+module Expansions
+  class MustacheTemplateFile
+    def process(args)
+      template = File.read_all_text(args[:input])
+
+      File.open_for_write(args[:output]){|file| file << Mustache.render(template,configatron.to_hash)}
+    end
+  end
+end

data/lib/core/shell.rb

@@ -0,0 +1,7 @@
+module Expansions
+  class Shell
+    def run(cmd)
+      return `#{cmd}`
+    end
+  end
+end

data/lib/core/shell_action_against_file.rb

@@ -0,0 +1,10 @@
+module Expansions
+  class ShellActionAgainstFile
+    def initialize(cmd)
+      @cmd = cmd
+    end
+    def run_using(file_name)
+      Shell.instance.run("#{@cmd} #{file_name}")
+    end
+  end
+end

data/lib/core/string.rb

@@ -0,0 +1,5 @@
+class String
+  def as_home_file
+    File.join(ENV["HOME"],self)
+  end
+end

data/lib/core/template_processors.rb

@@ -0,0 +1,22 @@
+module Expansions
+  class TemplateProcessors
+    def initialize(processors = {})
+      @processors = processors
+    end
+
+    def get_processor_for(file_name)
+      template_type = File.extname(file_name).gsub(/\./,'').to_sym
+      raise "There is no processor for #{file_name}" unless processor_exists_for(template_type)
+      return @processors[template_type]
+    end
+
+    def register_processor(template_type,processor)
+      raise "The processor for the template already exists" if processor_exists_for(template_type)
+      @processors[template_type.to_sym] = processor
+    end
+
+    def processor_exists_for(template_type)
+      return @processors.has_key?(template_type.to_sym)
+    end
+  end
+end

data/lib/core/template_visitor.rb

@@ -0,0 +1,18 @@
+module Expansions
+  class TemplateVisitor
+    def initialize(args = {})
+      @processor_registry = args.fetch(:processor_registry,TemplateProcessors.instance)
+      @file = args.fetch(:file,File)
+    end
+
+    def run_using(file_name)
+      processor = @processor_registry.get_processor_for(file_name)
+      generated_name = File.basename(file_name,File.extname(file_name))
+      generated_name = generated_name.gsub(/\.dotfile/,"") 
+      generated_name = ".#{generated_name}" if (/\.dotfile/ =~ file_name) 
+      output = File.join(File.dirname(file_name),generated_name)
+      @file.delete(output) if @file.exists?(output)
+      processor.process(:input => file_name,:output => output)
+    end
+  end
+end

data/lib/core/version.rb

@@ -0,0 +1,3 @@
+module Expansions
+  VERSION = "0.0.6"
+end

data/lib/expansions.rb

@@ -0,0 +1,24 @@
+require 'configatron'
+require 'fileutils'
+require 'erb'
+require 'singleton'
+require 'mustache'
+require 'developwithpassion_arrays'
+
+require 'core/array'
+require 'core/cli_interface'
+require 'core/copy'
+require 'core/copy_to_target'
+require 'core/enumerable_extensions'
+require 'core/erb_template_file'
+require 'core/expansion'
+require 'core/file'
+require 'core/file_merge'
+require 'core/kernel'
+require 'core/log'
+require 'core/mustache_template_file'
+require 'core/shell'
+require 'core/shell_action_against_file'
+require 'core/string'
+require 'core/template_processors'
+require 'core/template_visitor'

data/spec/spec_helper.rb

@@ -0,0 +1,50 @@
+require 'rspec'
+require 'fileutils'
+require 'fakes'
+require 'fakes-rspec'
+
+Dir.chdir(File.join(File.dirname(__FILE__),"..,lib".split(','))) do
+  require 'expansions.rb'
+end
+
+class RelativeFileSystem
+  class << self
+    def base_path
+      path = File.join(File.expand_path(File.dirname(__FILE__)),"spec_filesytem")
+
+      return path
+    end
+
+    def file_name(name)
+      item = File.join(base_path,name)
+      return item
+    end
+  end
+
+  def initialize
+    @files = []
+    FileUtils.mkdir_p(RelativeFileSystem.base_path)
+  end
+
+
+  def teardown
+    FileUtils.rm_rf(RelativeFileSystem.base_path)
+  end
+
+  def write_file(name,contents)
+    FileUtils.mkdir_p File.dirname(RelativeFileSystem.file_name(name))
+    File.open(RelativeFileSystem.file_name(name),'w') do |file|
+      file << contents      
+    end
+  end
+end
+
+def catch_exception
+  begin
+    yield
+  rescue Exception => e
+    exception = e
+  end
+  exception
+end
+

data/spec/specs/array_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+module Expansions
+  describe Array do
+    it "should be able to return the array contents as a glob pattern" do
+      items = %w[this is cool **/*.rb]
+      %w[this is cool **/*.rb].as_glob_pattern.should == File.join(items)
+    end
+
+    it "should map each item as a home item" do
+      items = %w[this is cool]
+      items.as_home_files.should == items.map{|item| item.as_home_file}
+    end
+
+    it "should be able to be converted to a glob pattern" do
+      %w[this is cool].as_glob_pattern.should == "this/is/cool" 
+    end
+
+  end
+end