developwithpassion_expander 0.0.1

data/lib/developwithpassion_expander/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/developwithpassion_expander/file_merge.rb

@@ -0,0 +1,54 @@
+module DevelopWithPassion
+  module Expander
+    class FileMerge
+      attr_accessor :before_files,:after_files,: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.readable
+          a.writable
+          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
+end

data/lib/developwithpassion_expander/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/developwithpassion_expander/log.rb

@@ -0,0 +1,17 @@
+module DevelopWithPassion
+  module Expander
+    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
+end

data/lib/developwithpassion_expander/mustache_template_file.rb

@@ -0,0 +1,11 @@
+module DevelopWithPassion
+  module Expander
+    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
+end

data/lib/developwithpassion_expander/object_extensions.rb

@@ -0,0 +1,28 @@
+class Object
+  def initialize_defaults(factory,*items)
+    items.each do|item|
+      instance_variable_set("@#{item}",factory.call)
+    end
+  end
+
+  def initialize_arrays(*items)
+    initialize_defaults(lambda{[]},*items)
+  end
+
+  def initialize_hashes(*items)
+    initialize_defaults(lambda{{}},*items)
+  end
+
+  def initialize_false(*items)
+    initialize_defaults(lambda{false},*items)
+  end
+
+  def array(name,&block)
+    initialize_arrays(name)
+    dsl = DevelopWithPassion::Expander::ArrayDSL.new(name)
+    yield dsl if block_given?
+    modules = DevelopWithPassion::Expander::ArrayDSLModuleFactory.new.create_modules_from(dsl)
+    modules.each{|new_module| self.extend(new_module)}
+  end
+
+end

data/lib/developwithpassion_expander/shell.rb

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

data/lib/developwithpassion_expander/shell_action_against_file.rb

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

data/lib/developwithpassion_expander/string.rb

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

data/lib/developwithpassion_expander/template_processors.rb

@@ -0,0 +1,24 @@
+module DevelopWithPassion
+  module Expander
+    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
+end

data/lib/developwithpassion_expander/template_visitor.rb

@@ -0,0 +1,20 @@
+module DevelopWithPassion
+  module Expander
+    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
+end

data/lib/developwithpassion_expander/version.rb

@@ -0,0 +1,5 @@
+module DevelopWithPassion
+  module Expander
+    VERSION = "0.0.1"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,77 @@
+require 'rspec'
+require 'fileutils'
+require 'developwithpassion_fakes'
+
+Dir.chdir(File.join(File.dirname(__FILE__),"..,lib".split(','))) do
+  Dir.glob("**/*.rb").each do |file| 
+    full_path = File.expand_path(file)
+    $:.unshift File.expand_path(File.dirname(full_path))
+    require full_path
+  end
+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 fake
+  DevelopWithPassion::Fakes::Fake.new
+end
+
+def catch_exception
+  begin
+    yield
+  rescue Exception => e
+    exception = e
+  end
+  exception
+end
+
+module RSpec
+  Matchers.define :have_received do|symbol,*args|
+    match do|fake|
+      fake.received(symbol).called_with(*args) != nil
+    end
+  end
+
+  Matchers.define :never_receive do|symbol,*args|
+    match do|fake|
+      item = fake.received(symbol)
+      result = true
+      if (item == nil)
+        result = (args.count == 0)
+      else
+        result = (item.called_with(*args) == nil)
+      end
+      result
+    end
+  end
+end

data/spec/specs/array_dsl_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+module DevelopWithPassion
+  module Expander
+    describe ArrayDSL do
+      context "when a mutator is specified" do
+        let(:mutator){fake}
+        let(:name){"sdfsdf"}
+        let(:sut){ArrayDSL.new("sdf")}
+        before (:each) do
+          ArrayMutator.stub(:new).with(name,nil).and_return(mutator)
+        end
+        before (:each) do
+          sut.mutator(name)
+        end
+        it "should be added to the list of mutators for the list" do
+          sut.mutators[0].should == mutator
+        end
+      end
+
+      context "when a visitor is specified" do
+        let(:visitor){fake}
+        let(:the_visitor){fake}
+        let(:name){"sdfsdf"}
+        let(:sut){ArrayDSL.new("sdf")}
+        before (:each) do
+          ArrayVisitor.stub(:new).with(name,the_visitor).and_return(visitor)
+        end
+        before (:each) do
+          sut.process_using(name,the_visitor)
+        end
+        it "should be added to the list of visitors for the list" do
+          sut.visitors[0].should == visitor
+        end
+      end
+    end
+  end
+end

data/spec/specs/array_mutator_step_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+module DevelopWithPassion
+  module Expander
+    describe ArrayMutatorStep do
+      context "when run" do
+        let(:numbers){[]}
+        let(:target){Sample.new(numbers)}
+        let(:mutators){[]}
+        let(:sut){ArrayMutatorStep.new}
+        let(:builder){ArrayDSL.new(:numbers)}
+
+        context "using a dsl fragment that contains no block usage" do
+          before (:each) do
+            builder.mutator(:add_a_number)
+          end
+          before (:each) do
+            target.extend(sut.run_using(builder))
+          end
+          it "should create a member on the target that allows mutation of the original list" do
+            target.respond_to?(:add_a_number).should be_true
+            target.add_a_number(2)
+            numbers[0].should == 2
+          end
+        end
+        context "using a dsl fragment that contains block usage" do
+          before (:each) do
+            builder.mutator(:add_a_number) do|value|
+              @value_attempted_to_be_added = value
+            end
+          end
+          before (:each) do
+            target.extend(sut.run_using(builder))
+          end
+          it "should create a member on the target that intercepts mutation using the provided block" do
+            target.respond_to?(:add_a_number).should be_true
+            target.add_a_number(2)
+            numbers.count.should == 0
+            @value_attempted_to_be_added.should == 2
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/spec/specs/array_readable_step_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+module DevelopWithPassion
+  module Expander
+    describe ArrayReadableStep do
+      context "when run" do
+        let(:target){Sample.new}
+        let(:mutators){[]}
+        let(:sut){ArrayReadableStep.new}
+        let(:builder){ArrayDSL.new(:numbers)}
+
+        context "using a dsl fragment that contains no block usage" do
+          before (:each) do
+            builder.readable
+          end
+          before (:each) do
+            target.extend(sut.run_using(builder))
+          end
+          it "should create a member on the target that allows reading of the array" do
+            target.numbers.should be_a(Array)
+          end
+        end
+      end
+    end
+  end
+end