gordon 0.0.21 → 0.1.0

data/spec/gordon/cli_spec.rb

@@ -2,18 +2,38 @@ require 'spec_helper'
 
 describe Gordon::CLI do
   describe 'running a recipe' do
-    it 'cooks a recipe based on options' do
-      options = instance_double Gordon::Options
+    let(:options)   { instance_double Gordon::Options }
+    let(:recipe)    { instance_double Gordon::Recipe }
+    let(:cooker)    { instance_double Gordon::Cooker }
+    let(:recipes)   { [ recipe ] }
+
+    before :each do
       expect(options).to receive(:app_source=).with(Dir.pwd)
       expect(options).to receive(:output_dir=).with(Dir.pwd)
+
       expect(Gordon::Options).to receive(:new).and_return(options)
+    end
+
+    it 'cooks a single recipe based on options' do
+      expect(Gordon::Cookbook).to receive(:exists?).and_return(false)
+      expect(Gordon::Cookbook).to_not receive(:read_and_merge_with)
 
-      recipe = instance_double Gordon::Recipe
       expect(Gordon::Recipe).to receive(:new).with(options).and_return(recipe)
+      expect(Gordon::Cooker).to receive(:new).with(recipes).and_return(cooker)
+
+      expect(cooker).to receive(:cook)
+
+      described_class.run
+    end
+
+    it 'cooks a list of recipes based on cookbook file' do
+      expect(Gordon::Cookbook).to receive(:exists?).and_return(true)
+      expect(Gordon::Cookbook).to receive(:read_and_merge_with).with(options).and_return(recipes)
+
+      expect(Gordon::Recipe).to_not receive(:new)
+      expect(Gordon::Cooker).to receive(:new).with(recipes).and_return(cooker)
 
-      cooker = instance_double Gordon::Cooker
       expect(cooker).to receive(:cook)
-      expect(Gordon::Cooker).to receive(:new).with(recipe).and_return(cooker)
 
       described_class.run
     end
@@ -24,21 +44,22 @@ describe Gordon::CLI do
 
     let(:options_map) do
       [
-        [ %w(-N --app-name),          "gordon" ],
-        [ %w(-D --app-description),   "a packager" ],
-        [ %w(-G --app-homepage),      "https://github.com/salizzar/gordon" ],
-        [ %w(-V --app-version),       Gordon::VERSION ],
-        [ %w(-S --app-source),        "." ],
-        [ %w(-T --app-type),          "ruby_web_app" ],
-        [ %w(-X --runtime-name),      "ruby" ],
-        [ %w(-R --runtime-version),   "2.2.0" ],
-        [ %w(-H --http-server-type),  "nginx" ],
-        [ %w(-W --web-server-type),   "unicorn" ],
-        [ %w(-I --init-type),         "systemd" ],
-        [ %w(-P --package-type),      "rpm" ],
-        [ %w(-O --output-dir),        "pkg" ],
-        [ %w(-d --debug),             true ],
-        [ %w(-t --trace),             true ],
+        [ %w(-N --app-name),            "gordon" ],
+        [ %w(-D --app-description),     "a packager" ],
+        [ %w(-G --app-homepage),        "https://github.com/salizzar/gordon" ],
+        [ %w(-V --app-version),         Gordon::VERSION ],
+        [ %w(-S --app-source),          "." ],
+        [ %w(-E --app-source-excludes), %(an path) ],
+        [ %w(-T --app-type),            "web" ],
+        [ %w(-X --runtime-name),        "ruby" ],
+        [ %w(-R --runtime-version),     "2.2.0" ],
+        [ %w(-H --http-server-type),    "nginx" ],
+        [ %w(-W --web-server-type),     "unicorn" ],
+        [ %w(-I --init-type),           "systemd" ],
+        [ %w(-P --package-type),        "rpm" ],
+        [ %w(-O --output-dir),          "pkg" ],
+        [ %w(-d --debug),               true ],
+        [ %w(-t --trace),               true ],
       ]
     end
 

data/spec/gordon/cookbook_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Gordon::Cookbook do
+  let(:path) { File.join(Dir.pwd, 'gordon.yml') }
+
+  context 'checking if file exists' do
+    it 'returns true when exists' do
+      expect(File).to receive(:exists?).with(path).and_return(true)
+
+      expect(described_class.exists?).to be_truthy
+    end
+
+    it 'returns false otherwise' do
+      expect(File).to receive(:exists?).with(path).and_return(false)
+
+      expect(described_class.exists?).to be_falsey
+    end
+  end
+
+  context 'reading and merging with main options' do
+    let(:content) do
+      %{
+        recipes:
+          - app_name:           gordon
+            app_description:    some description
+            app_homepage:       https://github.com/salizzar/gordon
+            app_version:        <%= 1 + 1 %>.0.0
+            app_type:           web
+            app_source:         .
+      }
+    end
+
+    let(:result)        { ERB.new(content).result }
+    let(:yaml)          { YAML.load(result) }
+
+    let(:main_options)  { instance_double(Gordon::Options) }
+    let(:recipe)        { instance_double(Gordon::Recipe) }
+    let(:recipes)       { [ recipe ] }
+
+    it 'renders gordon yaml file and returns a list of recipes' do
+      expect(File).to receive(:read).with(path).and_return(content)
+
+      erb = instance_double(ERB)
+      expect(erb).to receive(:result).and_return(result)
+      expect(ERB).to receive(:new).with(content).and_return(erb)
+      expect(YAML).to receive(:load).with(result).and_return(yaml)
+
+      option = instance_double(Gordon::Options)
+      expect(Gordon::Options).to receive(:from).with(main_options, yaml['recipes'].first).and_return(option)
+      expect(Gordon::Recipe).to receive(:new).with(option).and_return(recipe)
+
+      expect(described_class.read_and_merge_with(main_options)).to eq(recipes)
+    end
+  end
+end
+

data/spec/gordon/cooker_spec.rb

@@ -3,28 +3,29 @@ require 'spec_helper'
 describe Gordon::Cooker do
   let(:options) do
     attrs = {
-      app_type:         "web",
-      app_name:         "gordon",
-      app_description:  "a packager",
-      app_homepage:     "https://github.com/salizzar/gordon",
-      app_version:      Gordon::VERSION,
-      app_source:       ".",
-      runtime_name:     "ruby",
-      runtime_version:  "2.2.0",
-      http_server_type: "nginx",
-      web_server_type:  "unicorn",
-      init_type:        "systemd",
-      package_type:     "rpm",
-      output_dir:       "pkg",
-      debug:            true,
-      trace:            true,
+      app_type:             "web",
+      app_name:             "gordon",
+      app_description:      "a packager",
+      app_homepage:         "https://github.com/salizzar/gordon",
+      app_version:          Gordon::VERSION,
+      app_source:           ".",
+      app_source_excludes:  %w(an path),
+      runtime_name:         "ruby",
+      runtime_version:      "2.2.0",
+      http_server_type:     "nginx",
+      web_server_type:      "unicorn",
+      init_type:            "systemd",
+      package_type:         "rpm",
+      output_dir:           "pkg",
+      debug:                true,
+      trace:                true,
     }
 
     instance_double(Gordon::Options, attrs)
   end
 
-  let(:recipe) do
-    instance_double(Gordon::Recipe, options: options, application_template_path: '/a/path')
+  let(:recipes) do
+    [ instance_double(Gordon::Recipe, options: options, application_template_path: '/a/path') ]
   end
 
   let(:env_vars) do
@@ -36,7 +37,7 @@ describe Gordon::Cooker do
     File.join(described_class::FPM_COOKERY_WORKING_DIR, app_name)
   end
 
-  subject { described_class.new(recipe) }
+  subject { described_class.new(recipes) }
 
   before :each do
     allow(subject).to receive(:debug)
@@ -67,7 +68,7 @@ describe Gordon::Cooker do
         #{File.expand_path(working_path)}
         --no-deps
         package
-        #{recipe.application_template_path}
+        #{recipes[0].application_template_path}
       }
 
       expect(Gordon::Process).to receive(:run).with(package_command.join " ")

data/spec/gordon/cookery/dependency_resolver_spec.rb

@@ -43,16 +43,48 @@ describe Gordon::Cookery::DependencyResolver do
       end
     end
 
-    context 'given a java standalone app' do
-      it 'returns all dependencies for web' do
+    context 'given a java app' do
+      it 'handles Oracle JRE 7 package' do
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("oracle-jre")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_80")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "jre = 1.7.0_80",
+          "httpd",
+          "tomcat",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
+      end
+
+      it 'handles Oracle JRE 8 package' do
+        allow(env_vars).to receive(:http_server_type).and_return("apache")
+        expect(env_vars).to receive(:runtime_name).and_return("oracle-jre")
+        allow(env_vars).to receive(:runtime_version).and_return("1.8.0_45")
+        allow(env_vars).to receive(:web_server_type).and_return("tomcat")
+        expect(env_vars).to receive(:init_type).and_return("")
+
+        expected = [
+          "jre1.8.0_45",
+          "httpd",
+          "tomcat",
+        ]
+
+        expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
+      end
+
+      it 'handles Oracle JDK 7 package' do
         allow(env_vars).to receive(:http_server_type).and_return("apache")
-        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
-        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        expect(env_vars).to receive(:runtime_name).and_return("oracle-jdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_80")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
 
         expected = [
-          "jre = 1.7.0_60",
+          "jdk = 1.7.0_80",
           "httpd",
           "tomcat",
         ]
@@ -60,15 +92,15 @@ describe Gordon::Cookery::DependencyResolver do
         expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
       end
 
-      it 'handles damn Oracle JRE 8 package name' do
+      it 'handles Oracle JDK 8 package' do
         allow(env_vars).to receive(:http_server_type).and_return("apache")
-        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
-        allow(env_vars).to receive(:runtime_version).and_return("1.8.0_25")
+        expect(env_vars).to receive(:runtime_name).and_return("oracle-jdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.8.0_45")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
 
         expected = [
-          "jre1.8.0_25",
+          "jdk1.8.0_45",
           "httpd",
           "tomcat",
         ]
@@ -78,8 +110,8 @@ describe Gordon::Cookery::DependencyResolver do
 
       it 'handles OpenJDK package name for centos' do
         allow(env_vars).to receive(:http_server_type).and_return("apache")
-        expect(env_vars).to receive(:runtime_name).and_return("java-openjdk")
-        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        expect(env_vars).to receive(:runtime_name).and_return("openjdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_80")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
 
@@ -92,10 +124,10 @@ describe Gordon::Cookery::DependencyResolver do
         expect(subject.resolve_dependencies(env_vars, :centos)).to eq(expected)
       end
 
-      it 'assigns java-oracle to OpenJDK for debian' do
+      it 'assigns oracle-jre to OpenJDK for debian' do
         allow(env_vars).to receive(:http_server_type).and_return("apache")
-        expect(env_vars).to receive(:runtime_name).and_return("java-oracle")
-        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        expect(env_vars).to receive(:runtime_name).and_return("oracle-jre")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_80")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
 
@@ -110,8 +142,8 @@ describe Gordon::Cookery::DependencyResolver do
 
       it 'handles OpenJDK package name for debian' do
         allow(env_vars).to receive(:http_server_type).and_return("apache")
-        expect(env_vars).to receive(:runtime_name).and_return("java-openjdk")
-        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_60")
+        expect(env_vars).to receive(:runtime_name).and_return("openjdk")
+        allow(env_vars).to receive(:runtime_version).and_return("1.7.0_80")
         allow(env_vars).to receive(:web_server_type).and_return("tomcat")
         expect(env_vars).to receive(:init_type).and_return("")
 

data/spec/gordon/cookery/http_server_spec.rb

@@ -9,7 +9,8 @@ describe Gordon::Cookery::HttpServer do
 
   let(:app_name)          { "gordon" }
   let(:http_server_type)  { :apache }
-  let(:env_vars)          { double Gordon::EnvVars, app_name: app_name, http_server_type: http_server_type }
+  let(:attributes)        { { app_name: app_name, app_source_excludes: %w(something), http_server_type: http_server_type } }
+  let(:env_vars)          { double Gordon::EnvVars, attributes }
   let(:skeleton)          { Gordon::Skeleton::Types::Apache.new }
   let(:all_files)         { %w(index.php pimp_my_system.php) }
   let(:blacklist)         { %w(.git) }
@@ -20,7 +21,7 @@ describe Gordon::Cookery::HttpServer do
 
   describe 'installing files' do
     it 'install files based on http server path' do
-      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist, attributes[:app_source_excludes]).and_return(all_files)
 
       installer = double 'a path helper'
       expect(subject).to receive(:root).with(skeleton.path).and_return(installer)

data/spec/gordon/cookery/standalone_spec.rb

@@ -7,11 +7,12 @@ describe Gordon::Cookery::Standalone do
     end.new
   end
 
-  let(:app_name)  { "gordon" }
-  let(:env_vars)  { instance_double Gordon::EnvVars, app_name: app_name }
-  let(:skeleton)  { Gordon::Skeleton::Types::Misc.new }
-  let(:all_files) { %w(.bundle app config lib .ruby-version .ruby-gemset) }
-  let(:blacklist) { %w(.git) }
+  let(:app_name)    { "gordon" }
+  let(:attributes)  { { app_name: app_name, app_source_excludes: %w(something) } }
+  let(:env_vars)    { instance_double Gordon::EnvVars, attributes }
+  let(:skeleton)    { Gordon::Skeleton::Types::Misc.new }
+  let(:all_files)   { %w(.bundle app config lib .ruby-version .ruby-gemset) }
+  let(:blacklist)   { %w(.git) }
 
   before :each do
     expect(Gordon::Skeleton::Types::Misc).to receive(:new).and_return(skeleton)
@@ -19,7 +20,7 @@ describe Gordon::Cookery::Standalone do
 
   describe 'installing files' do
     it 'install all files based on misc skeleton' do
-      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist, attributes[:app_source_excludes]).and_return(all_files)
 
       installer = double 'a path helper'
       expect(subject).to receive(:root).with(skeleton.path(app_name)).and_return(installer)

data/spec/gordon/cookery/web_server_spec.rb

@@ -9,7 +9,8 @@ describe Gordon::Cookery::WebServer do
 
   let(:app_name)        { "gordon" }
   let(:web_server_type) { :tomcat }
-  let(:env_vars)        { double Gordon::EnvVars, app_name: app_name, web_server_type: web_server_type }
+  let(:attributes)      { { app_name: app_name, app_source_excludes: %w(something), web_server_type: web_server_type } }
+  let(:env_vars)        { double Gordon::EnvVars, attributes }
   let(:skeleton)        { Gordon::Skeleton::Types::Tomcat.new }
   let(:all_files)       { %w(gordon.war) }
   let(:blacklist)       { %w(gordon.class) }
@@ -20,7 +21,7 @@ describe Gordon::Cookery::WebServer do
 
   describe 'installing web server files' do
     it 'install files based on web server path' do
-      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist).and_return(all_files)
+      expect(subject).to receive(:all_files_except_blacklisted).with(blacklist, attributes[:app_source_excludes]).and_return(all_files)
 
       installer = double 'a path helper'
       expect(subject).to receive(:root).with(skeleton.path).and_return(installer)

data/spec/gordon/env_vars_spec.rb

@@ -3,17 +3,18 @@ require 'spec_helper'
 describe Gordon::EnvVars do
   let(:attributes) do
     {
-      app_type:         "web",
-      app_name:         "xirubiru",
-      app_description:  "a nice description",
-      app_homepage:     "http://some.github.repo",
-      app_version:      "2.0.0",
-      app_source:       ".",
-      runtime_name:     "ruby",
-      runtime_version:  "2.2.0",
-      http_server_type: "nginx",
-      web_server_type:  "tomcat",
-      init_type:        "systemd",
+      app_type:             "web",
+      app_name:             "xirubiru",
+      app_description:      "a nice description",
+      app_homepage:         "http://some.github.repo",
+      app_version:          "2.0.0",
+      app_source:           ".",
+      app_source_excludes:  %w(one two three),
+      runtime_name:         "ruby",
+      runtime_version:      "2.2.0",
+      http_server_type:     "nginx",
+      web_server_type:      "tomcat",
+      init_type:            "systemd",
     }
   end
 
@@ -28,6 +29,7 @@ describe Gordon::EnvVars do
         "GORDON_APP_HOMEPAGE='#{options.app_homepage}'",
         "GORDON_APP_VERSION='#{options.app_version}'",
         "GORDON_APP_SOURCE='#{File.expand_path(options.app_source)}'",
+        "GORDON_APP_SOURCE_EXCLUDES='#{options.app_source_excludes.map{ |path| File.expand_path(path) }.join(",") }'",
         "GORDON_RUNTIME_NAME='#{options.runtime_name}'",
         "GORDON_RUNTIME_VERSION='#{options.runtime_version}'",
         "GORDON_HTTP_SERVER_TYPE='#{options.http_server_type}'",
@@ -42,24 +44,27 @@ describe Gordon::EnvVars do
   describe 'loading from environment' do
     it 'returns a instance with all specified values' do
       env = {
-        'GORDON_APP_TYPE'         => options.app_type,
-        'GORDON_APP_NAME'         => options.app_name,
-        'GORDON_APP_DESCRIPTION'  => options.app_description,
-        'GORDON_APP_HOMEPAGE'     => options.app_homepage,
-        'GORDON_APP_VERSION'      => options.app_version,
-        'GORDON_APP_SOURCE'       => options.app_source,
-        'GORDON_RUNTIME_NAME'     => options.runtime_name,
-        'GORDON_RUNTIME_VERSION'  => options.runtime_version,
-        'GORDON_HTTP_SERVER_TYPE' => options.http_server_type,
-        'GORDON_WEB_SERVER_TYPE'  => options.web_server_type,
-        'GORDON_INIT_TYPE'        => options.init_type,
+        'GORDON_APP_TYPE'             => options.app_type,
+        'GORDON_APP_NAME'             => options.app_name,
+        'GORDON_APP_DESCRIPTION'      => options.app_description,
+        'GORDON_APP_HOMEPAGE'         => options.app_homepage,
+        'GORDON_APP_VERSION'          => options.app_version,
+        'GORDON_APP_SOURCE'           => options.app_source,
+        'GORDON_APP_SOURCE_EXCLUDES'  => options.app_source_excludes.join(","),
+        'GORDON_RUNTIME_NAME'         => options.runtime_name,
+        'GORDON_RUNTIME_VERSION'      => options.runtime_version,
+        'GORDON_HTTP_SERVER_TYPE'     => options.http_server_type,
+        'GORDON_WEB_SERVER_TYPE'      => options.web_server_type,
+        'GORDON_INIT_TYPE'            => options.init_type,
       }
 
       env.each_pair { |k, v| expect(ENV).to receive(:[]).with(k).and_return(v.to_s) }
 
       described_class.load.tap do |env_vars|
         env.each_pair do |k, v|
-          expect(env_vars.send(k.gsub(/GORDON_/, '').downcase)).to eq(v.to_s)
+          expected = k == 'GORDON_APP_SOURCE_EXCLUDES' ? options.app_source_excludes : v.to_s
+
+          expect(env_vars.send(k.gsub(/GORDON_/, '').downcase)).to eq(expected)
         end
       end
     end

data/spec/gordon/options_spec.rb

@@ -1,8 +1,74 @@
 require 'spec_helper'
 
 describe Gordon::Options do
-  describe 'mapping default accessors' do
-    pending
+  let(:main_option_attributes) do
+    {
+      app_name:             'a-test',
+      app_description:      'a description',
+      app_homepage:         'https://github.com/salizzar/gordon',
+      app_version:          Gordon::VERSION,
+      app_source:           '.',
+      app_source_excludes:  %w(something),
+      app_type:             'web',
+      runtime_name:         'ruby',
+      runtime_version:      '2.2.2',
+      http_server_type:     'nginx',
+      web_server_type:      nil,
+      init_type:            'systemd',
+      package_type:         'rpm',
+      output_dir:           'pkg',
+      debug:                false,
+      trace:                true,
+    }
+  end
+
+  let(:recipe) do
+    {
+      'app_name'            => 'xirubiru',
+      'app_description'     => 'another description',
+      'app_homepage'        => 'https://github.com/salizzar/xirubiru',
+      'app_version'         => '1.0.1',
+      'app_source'          => '/tmp',
+      'app_source_excludes' =>  %w(something),
+      'app_type'            => 'standalone',
+      'runtime_name'        => 'ruby',
+      'runtime_version'     => '2.2.1',
+      'http_server_type'    => nil,
+      'web_server_type'     => nil,
+      'init_type'           => 'systemd',
+      'package_type'        => 'rpm',
+      'output_dir'          => 'pkg',
+      'debug'               => true,
+      'trace'               => false,
+    }
+  end
+
+  let(:main_options)    { instance_double(described_class, main_option_attributes) }
+
+  describe 'returning instance based on main options and a recipe' do
+    it 'priorizes main options instead of recipe' do
+      instance = described_class.from(main_options, recipe)
+
+      main_option_attributes.delete_if do |(k, _)|
+        [ :app_source, :app_source_excludes ].include?(k)
+      end.each do |(k, v)|
+        expect(instance.send(k)).to eq(v)
+      end
+    end
+
+    it 'priorizes app source from recipe instead of main option' do
+      instance = described_class.from(main_options, recipe)
+
+      expect(instance.app_source).to eq(recipe['app_source'])
+    end
+
+    it 'merges app source excludes values from main options and recipes' do
+      instance = described_class.from(main_options, recipe)
+
+      expected = (main_option_attributes[:app_source_excludes].to_a + recipe['app_source_excludes'].to_a).flatten
+
+      expect(instance.app_source_excludes).to eq(expected)
+    end
   end
 end
 

data/spec/gordon/process_spec.rb

@@ -18,7 +18,7 @@ describe Gordon::Process do
     it 'raises error if call returns one' do
       expect(Process).to receive(:wait2).with(pid).and_return([ pid, 1 ])
 
-      expect{ described_class.run(command) }.to raise_error
+      expect{ described_class.run(command) }.to raise_error(SystemCallError)
     end
   end
 end

data/spec/spec_helper.rb

@@ -1 +1,8 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'spec'
+end
+
 require 'gordon'
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: gordon
 version: !ruby/object:Gem::Version
-  version: 0.0.21
+  version: 0.1.0
 platform: ruby
 authors:
 - Marcelo Pinheiro
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-03 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -38,6 +38,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fpm-cookery
   requirement: !ruby/object:Gem::Requirement
@@ -85,11 +113,13 @@ files:
 - gordon.gemspec
 - lib/gordon.rb
 - lib/gordon/application/factory.rb
+- lib/gordon/application/templates/java_standalone_app.rb
 - lib/gordon/application/templates/java_web_app.rb
 - lib/gordon/application/templates/ruby_standalone_app.rb
 - lib/gordon/application/templates/ruby_web_app.rb
 - lib/gordon/application/types.rb
 - lib/gordon/cli.rb
+- lib/gordon/cookbook.rb
 - lib/gordon/cooker.rb
 - lib/gordon/cookery/application_user.rb
 - lib/gordon/cookery/common.rb
@@ -112,11 +142,13 @@ files:
 - lib/gordon/skeleton/types.rb
 - lib/gordon/version.rb
 - spec/gordon/application/factory_spec.rb
+- spec/gordon/application/templates/java_standalone_app_spec.rb
 - spec/gordon/application/templates/java_web_app_spec.rb
 - spec/gordon/application/templates/ruby_standalone_app_spec.rb
 - spec/gordon/application/templates/ruby_web_app_spec.rb
 - spec/gordon/application/types_spec.rb
 - spec/gordon/cli_spec.rb
+- spec/gordon/cookbook_spec.rb
 - spec/gordon/cooker_spec.rb
 - spec/gordon/cookery/application_user_spec.rb
 - spec/gordon/cookery/common_spec.rb
@@ -156,17 +188,19 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.4.6
+rubygems_version: 2.4.8
 signing_key: 
 specification_version: 4
 summary: A tool to create application OS packages
 test_files:
 - spec/gordon/application/factory_spec.rb
+- spec/gordon/application/templates/java_standalone_app_spec.rb
 - spec/gordon/application/templates/java_web_app_spec.rb
 - spec/gordon/application/templates/ruby_standalone_app_spec.rb
 - spec/gordon/application/templates/ruby_web_app_spec.rb
 - spec/gordon/application/types_spec.rb
 - spec/gordon/cli_spec.rb
+- spec/gordon/cookbook_spec.rb
 - spec/gordon/cooker_spec.rb
 - spec/gordon/cookery/application_user_spec.rb
 - spec/gordon/cookery/common_spec.rb