dockerize 0.1.0

data/lib/dockerize/version.rb

@@ -0,0 +1,7 @@
+# coding: utf-8
+
+unless defined?(Dockerize::VERSION)
+  module Dockerize
+    VERSION = '0.1.0'
+  end
+end

data/lib/dockerize.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+require 'dockerize/version'
+
+module Dockerize
+  autoload :VERSION, 'dockerize/version'
+  autoload :Cli, 'dockerize/cli'
+  autoload :Config, 'dockerize/config'
+  autoload :Error, 'dockerize/error'
+end

data/spec/lib/dockerize/cli_spec.rb

@@ -0,0 +1,94 @@
+# coding: utf-8
+
+require 'dockerize/cli'
+require 'dockerize/error'
+
+describe Dockerize::Cli do
+  let(:config) { Dockerize::Config }
+  let(:cli) { Dockerize::Cli }
+
+  describe 'accepting arguments' do
+    it 'explodes if no arguments are provided' do
+      expect { run }.to raise_error(
+        Dockerize::Error::MissingRequiredArgument
+      )
+    end
+
+    it 'does not explode if at least one argument is provided' do
+      tmpdir do |tmp|
+        expect { run tmp }.to_not raise_error
+      end
+    end
+  end
+
+  describe 'setting the project directory' do
+    let(:pwd) { Dir.pwd }
+
+    context 'command line arguments are provided' do
+      it 'sets the project dir to PWD when a . is specified' do
+        run '.'
+        config.project_dir.should == pwd
+      end
+
+      it 'sets the project dir to the first argument provided' do
+        tmpdir do |tmp|
+          run tmp
+          config.project_dir.should == tmp
+        end
+      end
+    end
+  end
+
+  describe 'parsing templates' do
+    let(:filename) { 'foo' }
+    let(:template) do
+      <<-EOB.gsub(/^ +/, '')
+      <% self.filename = '#{filename}' -%>
+      <% self.filter = 'Baxter the Dog' -%>
+      <% self.foo = 'pasta' -%>
+      <% self.executable = true -%>
+      This is the first line
+
+      This is the second line
+
+      This has some erb interpolation: "<%= foo %>"
+      EOB
+    end
+    let(:parsed_template) do
+      <<-EOB.gsub(/^ +/, '')
+      This is the first line
+
+      This is the second line
+
+      This has some erb interpolation: "pasta"
+      EOB
+    end
+
+    it 'writes files from the given templates' do
+      tmpdir do |project_dir|
+        tmpdir do |template_dir|
+          File.open("#{template_dir}/template.erb", 'w+') do |f|
+            f.puts template
+          end
+          run "#{project_dir} --template-dir #{template_dir}"
+          expect { cli.send(:handle_templates) }.to change {
+            File.exists?("#{project_dir}/#{filename}")
+          }
+        end
+      end
+    end
+
+    it 'writes correct content to the target files' do
+      tmpdir do |project_dir|
+        tmpdir do |template_dir|
+          File.open("#{template_dir}/template.erb", 'w+') do |f|
+            f.puts template
+          end
+          run "#{project_dir} --template-dir #{template_dir}"
+          cli.send(:handle_templates)
+          File.read("#{project_dir}/#{filename}").should == parsed_template
+        end
+      end
+    end
+  end
+end

data/spec/lib/dockerize/config_spec.rb

@@ -0,0 +1,162 @@
+# coding: utf-8
+
+require 'tmpdir'
+require 'dockerize/config'
+require 'dockerize/error'
+
+describe Dockerize::Config do
+  subject(:config) { described_class }
+
+  describe 'configuring the project directory' do
+    it 'specifies a project directory' do
+      config.should respond_to(:project_dir=)
+    end
+
+    context 'assigning a project directory' do
+      let(:bogus_dir) { '/foobarbaz' }
+
+      it 'explodes when the project directory does not exist' do
+        expect { described_class.project_dir = bogus_dir }.to raise_error(
+          Dockerize::Error::NonexistentProjectDirectory
+        )
+      end
+
+      it 'explodes when the project directory is not a directory' do
+        expect { described_class.project_dir = $PROGRAM_NAME }.to raise_error(
+          Dockerize::Error::InvalidProjectDirectory
+        )
+      end
+
+      it 'does not explode if the project directory is valid' do
+        tmpdir do |tmp|
+          expect { described_class.project_dir = tmp }.to_not raise_error
+        end
+      end
+    end
+  end
+
+  describe 'accepting options' do
+    describe 'dry-run' do
+      %w(-d --dry-run).each do |arg|
+        it "sets dry-run for #{arg}" do
+          run ". #{arg}"
+          config.dry_run?.should == true
+        end
+      end
+
+      it 'turns dry run off for --no-dry-run' do
+        run '. --no-dry-run'
+        config.dry_run?.should == false
+      end
+
+      it 'defaults dry run to off' do
+        run '.'
+        config.dry_run?.should == false
+      end
+    end
+
+    describe 'quiet' do
+      %w(-q --quiet).each do |arg|
+        it "sets quiet for #{arg}" do
+          run ". #{arg}"
+          config.quiet?.should == true
+        end
+      end
+
+      it 'sets no quiet for --no-quiet' do
+        run '. --no-quiet'
+        config.quiet?.should == false
+      end
+
+      it 'sets no quiet when when specified' do
+        run '.'
+        config.quiet?.should == false
+      end
+    end
+
+    describe 'force' do
+      %w(-f --force).each do |arg|
+        it "sets force for #{arg}" do
+          run ". #{arg}"
+          config.force?.should == true
+        end
+      end
+
+      it 'sets no force for --no-force' do
+        run '. --no-force'
+        config.force?.should == false
+      end
+
+      it 'sets no force when when specified' do
+        run '.'
+        config.force?.should == false
+      end
+    end
+
+    describe 'version' do
+      let(:version) { Dockerize::VERSION }
+
+      %w(-v --version).each do |arg|
+        it "prints the version with #{arg}" do
+          $stderr.should_receive(:puts).with("dockerize #{version}")
+          expect { run arg }.to raise_error(SystemExit)
+        end
+      end
+    end
+
+    describe 'backup' do
+      %w(-b --backup).each do |arg|
+        it "sets backup for #{arg}" do
+          run ". #{arg}"
+          config.backup?.should == true
+        end
+      end
+
+      it 'sets no backup for --no-backup' do
+        run '. --no-backup'
+        config.backup?.should == false
+      end
+
+      it 'sets backup by default' do
+        run '.'
+        config.backup?.should == true
+      end
+    end
+
+    describe 'registry' do
+      let(:registry) { 'foo' }
+
+      %w(-r --registry).each do |arg|
+        it "sets registry for #{arg}" do
+          run ". #{arg} #{registry}"
+          config.registry.should == registry
+        end
+      end
+
+      it 'sets modcloth registry by default' do
+        run '.'
+        config.registry.should == 'quay.io/modcloth'
+      end
+    end
+
+    describe 'template_dir' do
+      it 'sets the default template dir to the top level' do
+        run '.'
+        config.template_dir.should == "#{top}/templates"
+      end
+    end
+  end
+
+  describe 'accepting options from the environment' do
+    %w(registry template_dir maintainer from).map do |var|
+      before(:each) do
+        ENV.stub(:[]).with("DOCKERIZE_#{var.upcase}").and_return('foo')
+      end
+
+      it "accepts #{var} from the environment" do
+        run '.'
+        config.send(var.to_sym).should == 'foo'
+      end
+    end
+  end
+end

data/spec/lib/dockerize/document_writer_spec.rb

@@ -0,0 +1,254 @@
+# coding: utf-8
+
+require 'dockerize/document_writer'
+require 'fileutils'
+
+describe Dockerize::DocumentWriter do
+  let(:writer) { described_class.new }
+
+  describe 'determining file path to write' do
+    context 'no document_name is specified' do
+      it 'raises an error' do
+        run '.'
+        expect { writer.output_target }.to raise_error(
+          Dockerize::Error::DocumentNameNotSpecified
+        )
+      end
+    end
+
+    context 'document name is specified' do
+      it 'produces the correct document path' do
+        tmpdir do |tmp|
+          run tmp
+          writer.stub(:document_name).and_return('foo_file')
+          writer.output_target.should == "#{tmp}/foo_file"
+        end
+      end
+    end
+  end
+
+  describe 'determining if the file should be written' do
+    let(:filename) { 'foo_file' }
+    let(:backup_filename) { 'foo_file.bak' }
+    let(:content) { '12345' }
+
+    before(:each) { writer.stub(:document_name).and_return(filename) }
+
+    context 'without force' do
+      context 'the file already exists' do
+        it 'does not modify the existing file' do
+          tmpdir do |tmp|
+            file_path = "#{tmp}/#{filename}"
+            FileUtils.touch(file_path)
+            run "#{tmp} --no-force"
+            expect { writer.write(content) }.to_not change {
+              File::Stat.new(file_path).inspect
+            }
+          end
+        end
+
+        it 'marks the file as ignored' do
+          tmpdir do |tmp|
+            file_path = "#{tmp}/#{filename}"
+            FileUtils.touch(file_path)
+            run "#{tmp} --no-force"
+            writer.should_receive(:inform_of_write).with(
+              Dockerize::DocumentWriter::IGNORE_WORD
+            )
+            writer.write(content)
+          end
+        end
+      end
+
+      context 'the file does not already exist' do
+        it 'creates the file' do
+          tmpdir do |tmp|
+            file_path = "#{tmp}/#{filename}"
+            run "#{tmp} --no-force"
+            expect { writer.write(content) }.to change {
+              File.exists?(file_path)
+            }
+          end
+        end
+
+        it 'marks the file as created' do
+          tmpdir do |tmp|
+            run "#{tmp} --no-force"
+            writer.should_receive(:inform_of_write).with(
+              Dockerize::DocumentWriter::CREATE_WORD
+            )
+            writer.write(content)
+          end
+        end
+      end
+    end
+
+    context 'with force' do
+      context 'the file already exists' do
+        it 'modifies the file' do
+          tmpdir do |tmp|
+            file_path = "#{tmp}/#{filename}"
+            run "#{tmp} --force"
+            FileUtils.touch(file_path)
+            expect { writer.write(content) }.to change {
+              File::Stat.new(file_path).inspect
+            }
+          end
+        end
+
+        it 'marks the file as replaced' do
+          tmpdir do |tmp|
+            run "#{tmp} --force"
+            FileUtils.touch("#{tmp}/#{filename}")
+            writer.should_receive(:inform_of_write).with(
+              Dockerize::DocumentWriter::REPLACE_WORD
+            )
+            writer.write(content)
+          end
+        end
+
+        context 'backup option is specified' do
+          it 'creates a backup file' do
+            tmpdir do |tmp|
+              file_path = "#{tmp}/#{filename}"
+              backup_path = "#{tmp}/#{backup_filename}"
+              run "#{tmp} --force --backup"
+              FileUtils.touch(file_path)
+              expect { writer.write(content) }.to change {
+                File.exists?(backup_path)
+              }
+            end
+          end
+        end
+
+        context '--no-backup option is specified' do
+          it 'does not create create a backup file' do
+            tmpdir do |tmp|
+              file_path = "#{tmp}/#{filename}"
+              backup_path = "#{tmp}/#{backup_filename}"
+              run "#{tmp} --force --no-backup"
+              FileUtils.touch(file_path)
+              expect { writer.write(content) }.to_not change {
+                File.exists?(backup_path)
+              }
+            end
+          end
+        end
+      end
+
+      context 'the file does not already exist' do
+        it 'creates the file' do
+          tmpdir do |tmp|
+            file_path = "#{tmp}/#{filename}"
+            run "#{tmp} --force"
+            expect { writer.write(content) }.to change {
+              File.exists?(file_path)
+            }
+          end
+        end
+
+        it 'marks the file as created' do
+          tmpdir do |tmp|
+            run "#{tmp} --force"
+            writer.should_receive(:inform_of_write).with(
+              Dockerize::DocumentWriter::CREATE_WORD
+            )
+            writer.write(content)
+          end
+        end
+      end
+    end
+  end
+
+  describe 'writing' do
+    let(:filename) { 'foo_file' }
+    let(:writer) { described_class.new(filename) }
+
+    context 'dry run' do
+      it 'writes to standard out' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --dry-run)
+          $stdout.should_receive(:print).with('12345')
+          writer.write('12345')
+        end
+      end
+
+      it 'writes nothing to its file' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --dry-run)
+          writer.write('12345')
+          File.exists?("#{tmp}/#{filename}").should == false
+        end
+      end
+    end
+
+    context 'dry run and quiet' do
+      it 'writes nothing to standard out' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --dry-run --quiet)
+          $stdout.should_not_receive(:print)
+          writer.write('12345')
+        end
+      end
+
+      it 'writes nothing to its file' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --dry-run --quiet)
+          writer.write('12345')
+          File.exists?("#{tmp}/#{filename}").should == false
+        end
+      end
+    end
+
+    context 'normal run' do
+      it 'writes nothing to standard out' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --no-dry-run)
+          $stdout.should_not_receive(:print)
+          writer.write('12345')
+        end
+      end
+
+      it 'writes to its file' do
+        tmpdir do |tmp|
+          run %W(#{tmp} --no-dry-run)
+          writer.write('12345')
+          File.size("#{tmp}/#{filename}").should == 5
+        end
+      end
+
+      it 'creates the file path leading up to the document' do
+        tmpdir do |tmp|
+          run tmp
+          writer.stub(:document_name).and_return('foo_dir/foo_file')
+          writer.write('12345')
+          File.directory?("#{tmp}/foo_dir").should == true
+        end
+      end
+    end
+
+    context 'invalid content is provided' do
+      it 'should not create the file' do
+        tmpdir do |tmp|
+          run tmp
+          writer.stub(:document_name).and_return('foo_file')
+          expect { writer.write(nil) }.to_not change {
+            File.exists?("#{tmp}/foo_file")
+          }
+        end
+      end
+
+      it 'should print useful output mesages' do
+        tmpdir do |tmp|
+          run tmp
+          writer.stub(:document_name).and_return('foo_file')
+          writer.should_receive(:inform_of_write).with(
+            writer.send(:invalid_word)
+          )
+          writer.write(nil)
+        end
+
+      end
+    end
+  end
+end

data/spec/lib/dockerize/template_parser_spec.rb

@@ -0,0 +1,139 @@
+# coding: utf-8
+
+require 'dockerize/template_parser'
+
+describe Dockerize::TemplateParser do
+  let(:filename) { 'Dockerfile' }
+  let(:contents) do
+    <<-EOB.gsub(/^ +/, '')
+    <% self.filename = '#{filename}' -%>
+    <% self.filter = 'Baxter the Dog' -%>
+    <% self.foo = 'pasta' -%>
+    <% self.executable = true -%>
+    This is the first line
+
+    This is the second line
+
+    This has some erb interpolation: "<%= foo %>"
+    EOB
+  end
+  let(:non_executable_contents) do
+    <<-EOB.gsub(/^ +/, '')
+    <% self.filename = '#{filename}' -%>
+    <% self.filter = 'Baxter the Dog' -%>
+    <% self.foo = 'pasta' -%>
+    <% self.executable = false -%>
+    This is the first line
+
+    This is the second line
+
+    This has some erb interpolation: "<%= foo %>"
+    EOB
+
+  end
+  let(:parsed_contents) do
+    <<-EOB.gsub(/^ +/, '')
+    This is the first line
+
+    This is the second line
+
+    This has some erb interpolation: "pasta"
+    EOB
+  end
+
+  subject(:parser) { described_class.new(contents) }
+  subject(:non_executable_file_parser) do
+    described_class.new(non_executable_contents)
+  end
+
+  it 'assigns the contents passed in as the raw text' do
+    parser.raw_text.should == contents
+  end
+
+  describe 'retrieving template file contents' do
+    context 'parsing the template' do
+      it 'retrieves the correct header vars' do
+        parser.parsed_erb
+        parser.metadata.should == {
+          filename: filename,
+          filter: 'Baxter the Dog',
+          foo: 'pasta',
+          executable: true
+        }
+      end
+    end
+
+    context 'parsing the erb' do
+      it 'produces the correct output text' do
+        parser.parsed_erb.should == parsed_contents
+      end
+    end
+  end
+
+  describe 'writing the file' do
+    let(:writer) { Dockerize::DocumentWriter.new }
+
+    it 'creates the file' do
+      tmpdir do |tmp|
+        run tmp
+        expect { parser.write_with writer }.to change {
+          File.exists?("#{tmp}/#{filename}")
+        }
+      end
+    end
+
+    it 'writes the correct contents to the file' do
+      tmpdir do |tmp|
+        run tmp
+        parser.write_with writer
+        File.read("#{tmp}/#{filename}").should == parsed_contents
+      end
+    end
+
+    context 'the file should be executable' do
+      it 'makes the file executable' do
+        tmpdir do |tmp|
+          run tmp
+          parser.write_with writer
+          File.executable?("#{tmp}/#{filename}").should == true
+        end
+      end
+    end
+
+    context 'the file should not be executable' do
+      it 'makes the file executable' do
+        tmpdir do |tmp|
+          run tmp
+          non_executable_file_parser.write_with writer
+          File.executable?("#{tmp}/#{filename}").should == false
+        end
+      end
+    end
+  end
+
+  describe 'handling invalid templates' do
+    let(:invalid_erb) do
+      <<-ERB.gsub(/^\s+/, '')
+      This is the first line
+
+      This is the second line
+
+      This has some erb interpolation: <%= foo #%>
+      ERB
+    end
+
+    context 'invalid erb' do
+      subject(:invalid_erb_parser) do
+        described_class.new(invalid_erb)
+      end
+
+      it 'does not explode when given invalid erb' do
+        expect { invalid_erb_parser.parsed_erb }.to_not raise_error
+      end
+
+      it 'returns nil as the parsed content' do
+        invalid_erb_parser.parsed_erb.should be_nil
+      end
+    end
+  end
+end

data/spec/lib/dockerize_spec.rb

@@ -0,0 +1,9 @@
+# coding: utf-8
+
+describe Dockerize do
+  subject(:dockerize) { described_class }
+
+  it 'has a valid version string' do
+    dockerize::VERSION.should match(/\d+\.\d+\.\d+/)
+  end
+end