manifests-vmc-plugin 0.6.0 → 0.6.1

data/lib/manifests-vmc-plugin.rb

@@ -98,6 +98,11 @@ module VMCManifests
 
   # splits the user's input, resolving paths with the manifest,
   # into internal/external apps
+  #
+  # internal apps are returned as their data in the manifest
+  #
+  # external apps are the strings that the user gave, to be
+  # passed along wholesale to the wrapped command
   def apps_in_manifest(input = nil, use_name = true, &blk)
     names_or_paths =
       if input.has?(:apps)
@@ -106,6 +111,8 @@ module VMCManifests
         input.direct(:apps)
       elsif input.has?(:app)
         [input.direct(:app)]
+      elsif input.has?(:name)
+        [input.direct(:name)]
       else
         []
       end
@@ -126,7 +133,7 @@ module VMCManifests
         end
 
         if !apps.empty?
-          internal += apps.collect { |app| app[:name] }
+          internal += apps
         else
           external << x
         end
@@ -202,6 +209,12 @@ module VMCManifests
     fail "No applications or manifest to operate on."
   end
 
+  def warn_reset_changes
+    line c("Not applying manifest changes without --reset", :warning)
+    line "See `vmc diff` for more details."
+    line
+  end
+
   def apps_by(attr, val)
     manifest[:applications].select do |info|
       info[attr] == val

data/lib/manifests-vmc-plugin/loader/resolver.rb

@@ -3,11 +3,8 @@ module VMCManifests
     def resolve(manifest, resolver)
       new = {}
 
-      new[:applications] = {}
-
-      manifest[:applications].each do |k, v|
-        new[:applications][k] =
-          resolve_lexically(resolver, v, [manifest])
+      new[:applications] = manifest[:applications].collect do |app|
+        resolve_lexically(resolver, app, [manifest])
       end
 
       resolve_lexically(resolver, new, [new])

data/lib/manifests-vmc-plugin/plugin.rb

@@ -6,12 +6,31 @@ require "manifests-vmc-plugin"
 
 class ManifestsPlugin < VMC::App::Base
   include VMCManifests
-  include VMC::App::Sync
 
   option :manifest, :aliases => "-m", :value => :file,
     :desc => "Path to manifest file to use"
 
 
+  [ :start, :restart, :instances, :logs, :env, :health, :stats,
+    :scale, :app, :stop, :delete
+  ].each do |wrap|
+    name_made_optional = change_argument(wrap, :app, :optional)
+
+    around(wrap) do |cmd, input|
+      wrap_with_optional_name(name_made_optional, cmd, input)
+    end
+  end
+
+
+  add_input :push, :reset, :desc => "Reset to values in the manifest",
+            :default => false
+
+  around(:push) do |push, input|
+    wrap_push(push, input)
+  end
+
+  private
+
   def wrap_with_optional_name(name_made_optional, cmd, input)
     return cmd.call if input[:all]
 
@@ -30,14 +49,14 @@ class ManifestsPlugin < VMC::App::Base
 
     show_manifest_usage
 
-    apps = internal + external
-
-    if apps.empty?
-      apps = current_apps if apps.empty?
-      apps = all_apps if apps.empty?
-      apps = apps.collect { |app| app[:name] }
+    if internal.empty? && external.empty?
+      internal = current_apps if internal.empty?
+      internal = all_apps if internal.empty?
     end
 
+    internal = internal.collect { |app| app[:name] }
+
+    apps = internal + external
     return no_apps if apps.empty?
 
     apps.each.with_index do |app, num|
@@ -46,115 +65,80 @@ class ManifestsPlugin < VMC::App::Base
     end
   end
 
-  # basic commands that, when given no name, act on the
-  # app(s) described by the manifest, in dependency-order
-  [ :start, :restart, :instances, :logs, :env,
-    :health, :stats, :scale, :app
-  ].each do |wrap|
-    name_made_optional = change_argument(wrap, :app, :optional)
-
-    around(wrap) do |cmd, input|
-      wrap_with_optional_name(name_made_optional, cmd, input)
-    end
+  def apply_changes(app, input)
+    app.memory = megabytes(input[:memory]) if input.has?(:memory)
+    app.total_instances = input[:instances] if input.has?(:instances)
+    app.command = input[:command] if input.has?(:command)
+    app.production = input[:plan].upcase.start_with?("P") if input.has?(:plan)
+    app.framework = input[:framework] if input.has?(:framework)
+    app.runtime = input[:runtime] if input.has?(:runtime)
+    app.buildpack = input[:buildpack] if input.has?(:buildpack)
   end
 
+  def wrap_push(push, input)
+    unless manifest
+      create_and_save_manifest(push, input)
+      return
+    end
 
-  # same as above but in reverse dependency-order
-  # TODO: do we care about this?
-  [:stop, :delete].each do |wrap|
-    around(wrap) do |cmd, input|
-      next cmd.call if input[:all] || !manifest
+    particular, external = apps_in_manifest(input)
 
-      show_manifest_usage
+    unless external.empty?
+      fail "Could not find #{b(external.join(", "))}' in the manifest."
+    end
 
-      reversed = []
-      rest =
-        specific_apps_or_all(input) do |info|
-          reversed.unshift info[:name]
-        end
+    apps = particular.empty? ? all_apps : particular
 
-      unless reversed.empty?
-        cmd.call(input.without(:apps).merge_given(:apps => reversed))
-      end
+    show_manifest_usage
 
-      unless rest.empty?
-        cmd.call(input.without(:apps).merge(:apps => rest))
-      end
+    spaced(apps) do |app_manifest|
+      push_with_manifest(app_manifest, push, input)
     end
   end
 
-
-  def wrap_push(cmd, input)
-
+  def push_with_manifest(app_manifest, push, input)
+    with_filters(
+      :push => {
+        :create_app => proc { |a|
+          setup_env(a, app_manifest)
+          a
+        },
+        :push_app => proc { |a|
+          setup_services(a, app_manifest)
+          a
+        }
+      }) do
+      app_input = push_input_for(app_manifest, input)
+
+      push.call(app_input)
+    end
   end
 
-  # push and sync meta changes in the manifest
-  # also sets env data on creation if present in manifest
-  #
-  # vmc push [name in manifest] = push that app from its path
-  # vmc push [name not in manifest] = push new app using given name
-  # vmc push [path] = push app from its path
-  change_argument :push, :name, :optional
-
-  add_input :push, :reset, :type => :boolean, :default => false,
-    :desc => "Reset to values in the manifest"
-
-  around(:push) do |push, input|
-    particular =
-      if input.has?(:name)
-        path = File.expand_path(input[:name])
-        find_by = File.exists?(path) ? path : input[:name]
-
-        find_apps(find_by)
-      else
-        []
-      end
+  def push_input_for(app_manifest, input)
+    existing_app = client.app_by_name(app_manifest[:name])
 
-    if particular.empty?
-      particular = find_apps(Dir.pwd)
+    if !existing_app || input[:reset]
+      input = input.rebase_given(app_manifest)
+    else
+      warn_reset_changes if manifest_differs?(existing_app, input)
     end
 
-    apps = particular.empty? ? all_apps : particular
+    input.merge(
+      :path => from_manifest(app_manifest[:path]),
+      :name => app_manifest[:name],
+      :bind_services => false,
+      :create_services => false)
+  end
 
-    if apps.empty?
-      with_filters(
-          :push => {
-            :push_app =>
-              proc { |a| ask_to_save(input, a); a }
-          }) do
-        push.call
-      end
-    else
-      show_manifest_usage
-
-      spaced(apps) do |app|
-        with_filters(
-            :push => {
-              :create_app => proc { |a|
-                setup_env(a, app)
-                a
-              },
-              :push_app => proc { |a|
-                setup_services(a, app)
-                a
-              }
-            }) do
-          existing_app = client.app_by_name(app[:name])
-
-          # only set inputs if creating app or updating with --reset
-          if input[:reset] || !existing_app
-            app_input = input.rebase_given(app)
-          else
-            # assign manifest values to detect differences
-            app_input = input.merge(:path => from_manifest(app[:path]))
-          end
-
-          push.call(app_input.merge(
-            :name => app[:name],
-            :bind_services => false,
-            :create_services => false))
-        end
-      end
+  def manifest_differs?(app, input)
+    apply_changes(app, input)
+    app.changed?
+  end
+
+  def create_and_save_manifest(push, input)
+    with_filters(
+        :push => { :push_app => proc { |a| ask_to_save(input, a); a } }) do
+      push.call
     end
   end
 end

data/lib/manifests-vmc-plugin/version.rb

@@ -1,3 +1,3 @@
 module VMCManifests
-  VERSION = "0.6.0".freeze
+  VERSION = "0.6.1".freeze
 end

data/spec/manifests-vmc-plugin/loader/plugin_spec.rb

@@ -9,25 +9,29 @@ describe ManifestsPlugin do
   let(:inputs_hash) { {} }
   let(:given_hash) { {} }
   let(:global_hash) { { :quiet => true } }
-  let(:inputs) { Mothership::Inputs.new(nil, nil, inputs_hash, given_hash, global_hash) }
-  let(:plugin) { ManifestsPlugin.new(nil, inputs) }
+  let(:command) { nil }
+  let(:inputs) { Mothership::Inputs.new(Mothership.commands[:push], nil, inputs_hash, given_hash, global_hash) }
+  let(:plugin) { ManifestsPlugin.new(command, inputs) }
+
+  let(:client) { fake_client }
 
   before do
     stub(plugin).manifest { manifest }
     stub(plugin).manifest_file { manifest_file } if manifest_file
+    stub(plugin).client { client }
   end
 
   describe "#wrap_with_optional_name" do
     let(:name_made_optional) { true }
-    let(:command) { mock! }
+    let(:wrapped) { mock! }
 
-    subject { plugin.wrap_with_optional_name(name_made_optional, command, inputs) }
+    subject { plugin.send(:wrap_with_optional_name, name_made_optional, wrapped, inputs) }
 
     context "when --all is given" do
       let(:inputs_hash) { { :all => true } }
 
       it "skips all manifest-related logic, and invokes the command" do
-        mock(command).call
+        mock(wrapped).call
         dont_allow(plugin).show_manifest_usage
         subject
       end
@@ -40,7 +44,7 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "foo" } }
 
         it "passes through to the command" do
-          mock(command).call
+          mock(wrapped).call
           dont_allow(plugin).show_manifest_usage
           subject
         end
@@ -60,7 +64,7 @@ describe ManifestsPlugin do
           let(:name_made_optional) { false }
 
           it "passes through to the command" do
-            mock(command).call
+            mock(wrapped).call
             dont_allow(plugin).show_manifest_usage
             subject
           end
@@ -80,7 +84,7 @@ describe ManifestsPlugin do
           let(:manifest) { { :applications => [{ :name => "foo", :path => "/abc/foo" }] } }
 
           it "calls the command for only that app" do
-            mock(command).call(anything) do |inputs|
+            mock(wrapped).call(anything) do |inputs|
               expect(inputs.given[:app]).to eq "foo"
             end
 
@@ -95,7 +99,7 @@ describe ManifestsPlugin do
 
           it "calls the command for all apps in the manifest" do
             uncalled_apps = ["foo", "bar"]
-            mock(command).call(anything).twice do |inputs|
+            mock(wrapped).call(anything).twice do |inputs|
               uncalled_apps.delete inputs.given[:app]
             end
 
@@ -116,7 +120,7 @@ describe ManifestsPlugin do
             mock(plugin).show_manifest_usage
 
             uncalled_apps = ["a", "x"]
-            mock(command).call(anything).twice do |inputs|
+            mock(wrapped).call(anything).twice do |inputs|
               uncalled_apps.delete inputs.given[:app]
             end
 
@@ -136,7 +140,7 @@ describe ManifestsPlugin do
 
           it "passes through to the original command" do
             dont_allow(plugin).show_manifest_usage
-            mock(command).call
+            mock(wrapped).call
             subject
           end
         end
@@ -147,7 +151,7 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "foo" } }
 
         it "calls the command with that app" do
-          mock(command).call(anything) do |inputs|
+          mock(wrapped).call(anything) do |inputs|
             expect(inputs.given[:app]).to eq "foo"
           end
 
@@ -160,7 +164,7 @@ describe ManifestsPlugin do
         let(:given_hash) { { :app => "/abc/foo" } }
 
         it "calls the command with that app" do
-          mock(command).call(anything) do |inputs|
+          mock(wrapped).call(anything) do |inputs|
             expect(inputs.given[:app]).to eq "foo"
           end
 
@@ -171,12 +175,153 @@ describe ManifestsPlugin do
   end
 
   describe "#wrap_push" do
+    let(:wrapped) { mock! }
+    let(:command) { Mothership.commands[:push] }
+
+    subject { plugin.send(:wrap_push, wrapped, inputs) }
+
+    before do
+      stub(plugin).show_manifest_usage
+    end
+
     context "with a manifest" do
+      let(:manifest_file) { "/abc/manifest.yml" }
+
+      let(:manifest) do
+        { :applications => [
+          { :name => "a",
+            :path => "/abc/a",
+            :instances => "200",
+            :memory => "128M"
+          }
+        ]
+        }
+      end
+
+      # vmc push foo
+      context "and a name is given" do
+        context "and the name is present in the manifest" do
+          let(:given_hash) { { :name => "a" } }
+
+          context "and the app exists" do
+            let(:app) { fake :app, :name => "a" }
+            let(:client) { fake_client :apps => [app] }
+
+            context "and --reset was given" do
+              let(:inputs_hash) { { :reset => true } }
+              let(:given_hash) { { :name => "a", :instances => "100" } }
+
+              it "rebases their inputs on the manifest's values" do
+                mock(wrapped).call(anything) do |inputs|
+                  expect(inputs.given).to eq(
+                    :name => "a", :path => "/abc/a", :instances => "100", :memory => "128M")
+                end
+
+                subject
+              end
+            end
+
+            context "and --reset was NOT given" do
+              let(:given_hash) { { :name => "a", :instances => "100" } }
+
+              context "and the app settings differ" do
+                let(:app) { fake :app, :name => "a", :memory => 256 }
+
+                it "tells the user to use --reset to apply changes" do
+                  mock(plugin).warn_reset_changes
+                  mock(wrapped).call(anything) do |inputs|
+                    expect(inputs.given).to eq(
+                      :name => "a", :instances => "100")
+                  end
+                  subject
+                end
+              end
+
+              it "does not add the manifest's values to the inputs" do
+                stub(plugin).warn_reset_changes
+                mock(wrapped).call(anything) do |inputs|
+                  expect(inputs.given).to eq(
+                    :name => "a", :instances => "100")
+                end
+
+                subject
+              end
+            end
+          end
+
+          context "and the app does NOT exist" do
+            it "pushes a new app with the inputs from the manifest" do
+              mock(wrapped).call(anything) do |inputs|
+                expect(inputs.given).to eq(
+                  :name => "a", :path => "/abc/a", :instances => "200", :memory => "128M")
+              end
+
+              subject
+            end
+          end
+        end
+
+        context "and the name is NOT present in the manifest" do
+          let(:given_hash) { { :name => "x" } }
 
+          it "fails, saying that name was not found in the manifest" do
+            expect { subject }.to raise_error(VMC::UserError, /Could not find .+ in the manifest./)
+          end
+        end
+      end
+
+      # vmc push ./abc
+      context "and a path is given" do
+        context "and there are apps matching that path in the manifest" do
+          let(:manifest) do
+            { :applications => [
+              { :name => "a",
+                :path => "/abc/a",
+                :instances => "200",
+                :memory => "128M"
+              },
+              { :name => "b",
+                :path => "/abc/a",
+                :instances => "200",
+                :memory => "128M"
+              }
+            ]
+            }
+          end
+
+          let(:given_hash) { { :name => "/abc/a" } }
+
+          it "pushes the found apps" do
+            pushed_apps = []
+            mock(wrapped).call(anything).twice do |inputs|
+              pushed_apps << inputs[:name]
+            end
+
+            subject
+
+            expect(pushed_apps).to eq(["a", "b"])
+          end
+        end
+
+        context "and there are NOT apps matching that path in the manifest" do
+          let(:given_hash) { { :name => "/abc/x" } }
+
+          it "fails, saying that the path was not found in the manifest" do
+            expect { subject }.to raise_error(VMC::UserError, /Path .+ is not present in manifest/)
+          end
+        end
+      end
     end
 
     context "without a manifest" do
-      
+      let(:app) { mock! }
+      let(:manifest) { nil }
+
+      it "asks to save the manifest when uploading the application" do
+        mock_ask("Save configuration?", :default => false)
+        stub(wrapped).call { plugin.filter(:push_app, app) }
+        subject
+      end
     end
   end
 end

data/spec/manifests-vmc-plugin_spec.rb

@@ -224,13 +224,11 @@ describe VMCManifests do
   end
 
   describe "#apps_in_manifest" do
-    let(:manifest) do
-      {:applications => [
-        {:name => "foo", :path => "/abc/foo"},
-        {:name => "bar", :path => "/abc/bar"},
-        {:name => "baz", :path => "/abc/baz"}
-      ]}
-    end
+    let(:foo_hash) { { :name => "foo", :path => "/abc/foo" } }
+    let(:bar_hash) { { :name => "bar", :path => "/abc/bar" } }
+    let(:baz_hash) { { :name => "baz", :path => "/abc/baz" } }
+
+    let(:manifest) { { :applications => [foo_hash, bar_hash, baz_hash] } }
 
     subject { cmd.apps_in_manifest(inputs) }
 
@@ -245,14 +243,14 @@ describe VMCManifests do
       context "and all of them are in the manifest" do
         let(:given_hash) { { :apps => ["foo", "bar"] } }
 
-        its(:first) { should eq ["foo", "bar"] }
+        its(:first) { should eq [foo_hash, bar_hash] }
         its(:last) { should eq [] }
       end
 
       context "and one of them is in the manifest" do
         let(:given_hash) { { :apps => ["foo", "xxx"] } }
 
-        its(:first) { should eq ["foo"] }
+        its(:first) { should eq [foo_hash] }
         its(:last) { should eq ["xxx"] }
       end
 
@@ -268,7 +266,7 @@ describe VMCManifests do
       context "and the paths are in the manifest" do
         let(:given_hash) { { :apps => ["/abc/foo"] } }
 
-        its(:first) { should eq ["foo"] }
+        its(:first) { should eq [foo_hash] }
         its(:last) { should eq [] }
       end
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: manifests-vmc-plugin
 version: !ruby/object:Gem::Version 
-  hash: 7
+  hash: 5
   prerelease: 
   segments: 
   - 0
   - 6
-  - 0
-  version: 0.6.0
+  - 1
+  version: 0.6.1
 platform: ruby
 authors: 
 - Alex Suraci