reflection 0.0.2 → 0.3.1

data/Reflection.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{reflection}
-  s.version = "0.0.2"
+  s.version = "0.3.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andreas Wolff"]
-  s.date = %q{2009-11-15}
+  s.date = %q{2009-11-17}
   s.default_executable = %q{reflection}
   s.description = %q{
       Reflection is designed to keep your production assets (database comming soon) in sync with your development system.
@@ -38,6 +38,7 @@ Gem::Specification.new do |s|
      "lib/reflection/command/apply.rb",
      "lib/reflection/command/base.rb",
      "lib/reflection/command/stash.rb",
+     "lib/reflection/config.rb",
      "lib/reflection/directory.rb",
      "lib/reflection/directory/base.rb",
      "lib/reflection/directory/stash.rb",
@@ -48,6 +49,7 @@ Gem::Specification.new do |s|
      "lib/reflection/validations.rb",
      "spec/reflection/cli_spec.rb",
      "spec/reflection/command/stash_spec.rb",
+     "spec/reflection/config_spec.rb",
      "spec/reflection/directory/base_spec.rb",
      "spec/reflection/directory/stash_spec.rb",
      "spec/reflection/repository_spec.rb",
@@ -65,6 +67,7 @@ Gem::Specification.new do |s|
   s.test_files = [
     "spec/reflection/cli_spec.rb",
      "spec/reflection/command/stash_spec.rb",
+     "spec/reflection/config_spec.rb",
      "spec/reflection/directory/base_spec.rb",
      "spec/reflection/directory/stash_spec.rb",
      "spec/reflection/repository_spec.rb",

data/TODO

@@ -1,7 +1,9 @@
++ Add config files ('$ reflection path/to/config')
 + Add DB Dumper (include in cli-opt-parser)
 + Remove stash directory if its empty (on reinit)
 + Add Logger (Reflection::Support.log)
 + After command callbacks: Twitter, Campfire on Serverside
 + List existing reflections in client side
   + Allow to apply any (git) version, not just the latest
-+ Allow collection of assets from Akamai and/or CloudFront
++ Add cli option use tmp-apply (removes ~/.reflection/apply-dir after command) 
++ Allow collection of assets from Akamai and/or CloudFront (hm.. does that make sense?)

data/VERSION

@@ -1 +1 @@
-0.0.2
+0.3.1

data/lib/reflection.rb

@@ -2,6 +2,7 @@ require 'rubygems'
 
 module Reflection
   autoload :CLI,              'reflection/cli'
+  autoload :Config,           'reflection/config'
   autoload :Command,          'reflection/command'
   autoload :Directory,        'reflection/directory'
   autoload :Repository,       'reflection/repository'

data/lib/reflection/cli.rb

@@ -1,64 +1,29 @@
-require 'optparse'
-require 'ostruct'
-
 module Reflection
   module CLI
     class << self
 
       def run!(args = nil)
-        options = parse_options(args)
-        if options == false
+        config = Reflection::Config.parse(args)
+
+        if verify_config(config) == false
           Reflection::Support.exit_with_error("Ahh ja, missing arguments. Please read 'reflection --help' to get a feeling of how it works.")
         else
-          case options.command
-          when :apply
-            Reflection::Command::Apply.run!(options)
-          when :stash
-            Reflection::Command::Stash.run!(options)
-          else
-            Reflection::Support.exit_with_error("Couldn't identify command. Please run 'reflection --help'.")
-          end
-        end
-      end
-
-      def parse_options(args)
-        options = OpenStruct.new
-
-        opt_parser = OptionParser.new do |opts|
-          opts.banner = "Usage: reflection --COMMAND --repository=GIT_REPO --directory=PATH"
-
-          opts.separator " "
-          opts.separator "On the server side:"
-
-          opts.on("-s", "--stash", "Store your assets and/or a database dump in a git-repository.") do |stash|
-            options.command = :stash
-          end
-
-          opts.separator "On the client side:"
-          opts.on("-a", "--apply", "Apply assets and/or a database dump loaded from a git-repository.") do |apply|
-            options.command = :apply
-          end
-
-          opts.separator " "
-          opts.separator "Required options for both:"
-          opts.on("-r", "--repository GIT_URL", "A Git repository(url) to be used as storage") do |repository|
-            options.repository = repository
-          end
-
-          opts.on("-d", "--directory PATH", "Path to your asset directory") do |directory|
-            options.directory = directory
+          case config.command
+            when :apply
+              Reflection::Command::Apply.run!(config)
+            when :stash
+              Reflection::Command::Stash.run!(config)
+            else
+              Reflection::Support.exit_with_error("Couldn't identify command. Please run 'reflection --help'.")
           end
         end
-
-        opt_parser.parse!(args)
-        verify_options(options)
       end
 
 
       private
 
-        def verify_options(options)
-          return ([:stash, :apply].include?(options.command) && !options.repository.nil? && !options.directory.nil?) ? options : false
+        def verify_config(config)
+          return ([:stash, :apply].include?(config.command) && !config.repository.nil? && !config.directory.nil?) ? config : false
         end
     end
   end

data/lib/reflection/config.rb

@@ -0,0 +1,99 @@
+require 'optparse'
+require 'ostruct'
+require 'yaml'
+
+module Reflection
+
+  class ConfigArgumentError < StandardError; end
+
+  class Config
+    
+    attr_accessor :command
+    attr_accessor :directory
+    attr_accessor :repository
+    attr_accessor :store_configuration_path
+    
+    def self.parse(args = [])
+      config = Config.new
+      case
+        when !args.empty? && File.exists?(args.first)
+          config.read!(args.first)
+        when !args.empty?
+          config.parse_command_line_options(args)
+          config.write(config.store_configuration_path) if config.store_configuration_path
+        else
+          config.read!(File.join(Dir.pwd, 'reflection.yml'))
+      end
+      config
+    end
+
+    def to_hash
+      { :command => self.command, :repository => self.repository, :directory => self.directory }
+    end
+    
+    def from_hash(hash)
+      self.command = hash[:command]
+      self.directory = hash[:directory]
+      self.repository = hash[:repository]
+    end
+
+    def write(path)
+      begin
+        io = File.open(path, 'w')
+        YAML.dump(self.to_hash, io)
+        io.close
+      rescue => e
+        Reflection::Support.exit_with_error("Writing of config file to '#{path}' failed: #{e.message}")
+      end
+    end
+
+    def read!(path)
+      begin
+        if File.exist?(path)
+          options = YAML.load_file(path)
+          raise(Reflection::ConfigArgumentError, "Config file is invalid.") unless options.is_a?(Hash)
+          self.from_hash(options)
+        end
+      rescue => e
+        Reflection::Support.exit_with_error("Parsing of config file '#{path}' failed: #{e.message}")
+      end
+    end
+
+    def parse_command_line_options(args)
+      opt_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: reflection --COMMAND --repository=GIT_REPO --directory=PATH"
+
+        opts.separator " "
+        opts.separator "On the server side:"
+
+        opts.on("-s", "--stash", "Store your assets and/or a database dump in a git-repository.") do |stash|
+          self.command = :stash
+        end
+
+        opts.separator "On the client side:"
+        opts.on("-a", "--apply", "Apply assets and/or a database dump loaded from a git-repository.") do |apply|
+          self.command = :apply
+        end
+
+        opts.separator " "
+        opts.separator "Required options for both:"
+        opts.on("-r", "--repository GIT_URL", "A Git repository(url) to be used as storage") do |repository|
+          self.repository = repository
+        end
+
+        opts.on("-d", "--directory PATH", "Path to your asset directory") do |directory|
+          self.directory = directory
+        end
+
+        opts.separator " "
+        opts.separator "Additional options for both:"        
+        opts.on("--write [FILE]", "Create a configuration FILE from the current commandline options") do |config_file_path|
+          self.store_configuration_path = config_file_path if config_file_path
+        end
+      end
+
+      opt_parser.parse!(args)
+    end
+
+  end
+end

data/spec/reflection/cli_spec.rb

@@ -6,33 +6,34 @@ describe Reflection::CLI do
   end
   
   describe '#run!' do
-    it 'should parse commandline options' do
+    before(:each) do
+      @config = mock('Reflection::Config', :command => :stash)
+      Reflection::Config.stub!(:parse).and_return(@config)
+      @subject.stub!(:verify_config).and_return(true)
+    end
+    
+    it 'should create a config object, holding the parsed commandline options' do
+      Reflection::Config.should_receive(:parse).with("args").and_return(@config)
       Reflection::Command::Stash.stub!(:run!)
-      @subject.should_receive(:parse_options).and_return(OpenStruct.new(:command => :stash))
-      @subject.run!
+      @subject.run!("args")
     end
     
-    it 'should fail gracefully displaying a message if parse_options returns false' do
+    it 'should verify the config and fail gracefully displaying a message if verification fails' do
       Reflection::Support.should_receive(:exit_with_error).with(/reflection --help/)
-      @subject.stub!(:parse_options).and_return(false)
-      @subject.run!
+      @subject.stub!(:verify_config).and_return(false)
+      @subject.run!("args")
     end
     
-    context 'successful parsed options' do
-      before(:each) do
-        @parse_options = OpenStruct.new(:options => "more")
-        @subject.stub!(:parse_options).and_return(@parse_options)
-      end
-      
+    context 'successfully parsed options' do
       it 'should call the Stash command if parse_options returned succesfull with command :stash' do
-        @parse_options.command = :stash
-        Reflection::Command::Stash.should_receive(:run!).with(@parse_options)
+        Reflection::Command::Stash.should_receive(:run!).with(@config)
+        @config.stub!(:command).and_return(:stash)
         @subject.run!
       end
 
       it 'should call the Apply command if parse_options returned succesfull with command :apply' do
-        @parse_options.command = :apply        
-        Reflection::Command::Apply.should_receive(:run!).with(@parse_options)
+        Reflection::Command::Apply.should_receive(:run!).with(@config)
+        @config.stub!(:command).and_return(:apply)
         @subject.run!
       end
     end

data/spec/reflection/config_spec.rb

@@ -0,0 +1,110 @@
+require File.dirname(__FILE__) + '/../spec_helper'
+
+describe Reflection::Config do
+  before(:each) do
+    @valid_options = { :command => :stash, :repository => 'repo', :directory => 'dir' }
+  end
+  
+  describe 'parse' do
+    before(:each) do
+      @mock_config = mock('Reflection::Config', :store_configuration_path => nil)
+      Reflection::Config.stub!(:new).and_return(@mock_config)
+    end
+    
+    it 'should parse a yaml file if the first arg is an existing file' do
+      @mock_config.should_receive(:read!).with('/tmp')
+      Reflection::Config.parse(['/tmp'])
+    end
+    
+    it 'should parse args as options' do
+      @mock_config.should_receive(:parse_command_line_options).with(['-s', '-d'])
+      Reflection::Config.parse(['-s', '-d'])
+    end
+
+    it 'should write options to configuration file if --write params is set' do
+      @mock_config.should_receive(:write).with('/test/path')
+      @mock_config.stub!(:parse_command_line_options)
+      @mock_config.stub!(:store_configuration_path).and_return('/test/path')
+      Reflection::Config.parse(['-s','-d', '--write /test/path'])
+    end
+
+    it 'should expect a reflection.yml config file in path if args are empty' do
+      Dir.stub!(:pwd).and_return('/current_dir')
+      @mock_config.should_receive(:read!).with('/current_dir/reflection.yml')
+      Reflection::Config.parse
+    end    
+  end
+
+  describe '#to_hash' do
+    it 'should turn its attributes into a hash' do
+      @config = Reflection::Config.new
+      @config.command = :stash
+      @config.repository = 'repo'
+      @config.directory = 'dir'
+      @config.to_hash.should == @valid_options
+    end
+  end
+  
+  describe '#from_hash' do
+    it 'should assign attributes from a hash' do
+      @config = Reflection::Config.new
+      @config.from_hash( @valid_options )
+      @config.command.should eql(:stash)
+      @config.repository.should eql('repo')
+      @config.directory.should eql('dir')
+    end
+  end
+  
+  describe '#write' do
+    before(:each) do
+      @config = Reflection::Config.new
+      @mock_file = mock('File')
+      @mock_file.stub!(:close)
+    end
+    
+    it 'should dump the config values to a file at the given path' do
+      @config.stub!(:to_hash).and_return( @valid_options )
+      YAML.should_receive(:dump).with( @valid_options, @mock_file )
+      File.should_receive(:open).with('/test/path', 'w').and_return(@mock_file)
+      @config.write('/test/path')
+    end
+    
+    it 'should gracefully fail if it cannot dump the yaml file' do
+      Reflection::Support.should_receive(:exit_with_error)
+      File.should_receive(:open).with('/test/path', 'w').and_raise(StandardError)
+      @config.write('/test/path')
+    end
+  end
+
+  describe '#read!' do
+    before(:each) do
+      File.stub!(:exist?).and_return(true)
+      @config = Reflection::Config.new
+    end
+    
+    it 'should get the config attributes from a yaml file' do
+      YAML.should_receive(:load_file).with('/tmp/test').and_return( @valid_options )
+      @config.should_receive(:from_hash).with(@valid_options)
+      @config.read!('/tmp/test')
+    end
+    
+    it "should not try to load a yaml file if it doesn't exist" do
+      YAML.should_not_receive(:load_file)
+      File.stub!(:exist?).and_return(false)
+      @config.read!('/tmp/test')
+    end
+    
+    it "should gracefully fail if yaml file loading crashed" do
+      Reflection::Support.should_receive(:exit_with_error)
+      YAML.stub!(:load_file).and_raise(StandardError)
+      @config.read!('/tmp/test')
+    end
+    
+    it "should gracefully fail if parsing result is not a hash" do
+      Reflection::Support.should_receive(:exit_with_error)
+      YAML.stub!(:load_file).and_return("String Instead Of Hash")
+      @config.read!('/tmp/test')
+    end
+  end
+  
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: reflection
 version: !ruby/object:Gem::Version 
-  version: 0.0.2
+  version: 0.3.1
 platform: ruby
 authors: 
 - Andreas Wolff
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-15 00:00:00 +01:00
+date: 2009-11-17 00:00:00 +01:00
 default_executable: reflection
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -57,6 +57,7 @@ files:
 - lib/reflection/command/apply.rb
 - lib/reflection/command/base.rb
 - lib/reflection/command/stash.rb
+- lib/reflection/config.rb
 - lib/reflection/directory.rb
 - lib/reflection/directory/base.rb
 - lib/reflection/directory/stash.rb
@@ -67,6 +68,7 @@ files:
 - lib/reflection/validations.rb
 - spec/reflection/cli_spec.rb
 - spec/reflection/command/stash_spec.rb
+- spec/reflection/config_spec.rb
 - spec/reflection/directory/base_spec.rb
 - spec/reflection/directory/stash_spec.rb
 - spec/reflection/repository_spec.rb
@@ -106,6 +108,7 @@ summary: Helps you keeping your development machine in sync with production.
 test_files: 
 - spec/reflection/cli_spec.rb
 - spec/reflection/command/stash_spec.rb
+- spec/reflection/config_spec.rb
 - spec/reflection/directory/base_spec.rb
 - spec/reflection/directory/stash_spec.rb
 - spec/reflection/repository_spec.rb