ey_resolver 0.1.1 → 0.2.0

data/lib/ey_resolver/examiner.rb

@@ -10,8 +10,7 @@ class EY::Resolver
 
     def initialize(query, user)
       @query, @user = query, user
-      problems ||= []
-      @suggestions ||= {}
+      @suggestions = []
     end
 
     def app_unconstrained_errors
@@ -70,12 +69,20 @@ class EY::Resolver
       if query.app_constrained? && accounts.any? && apps.any? && acc_apps.empty?
         app_names = apps.map {|a|a.name.inspect}.join(', ')
         problems << "Application #{app_names} found, but does not exist in account #{account_name}."
-        @suggestions[:apps] = apps
+        apps.each do |app|
+          app.environments.each do |env|
+            add_suggestion(app, env)
+          end
+        end
       end
 
       if query.environment_name && accounts.any? && envs.any? && acc_envs.empty?
         problems << "Environment #{environment_name} found, but does not exist in account #{account_name}."
-        @suggestions[:environments] = envs
+        envs.each do |env|
+          env.apps.each do |app|
+            add_suggestion(app, env)
+          end
+        end
       end
       return problems if problems.any?
     end
@@ -85,7 +92,6 @@ class EY::Resolver
 
       if !query.environment_name && query.remotes && acc_envs.empty? && acc_apps.any?
         problems << "No environment found for applications matching remotes:" + query.remotes.map { |uri| "\n\t#{uri}" }.join
-        #@suggestions[:apps] = acc_apps
       end
 
       return problems if problems.any?
@@ -97,12 +103,23 @@ class EY::Resolver
 
       if query.environment_name && query.app_name && acc_envs.any? && acc_apps.any?
         problems << "Application #{app_name} and environment #{environment_name} are not associated."
-        @suggestions[:apps] = acc_apps
-        @suggestions[:environments] = acc_envs
+        acc_envs.each do |env|
+          env.apps.each do |app|
+            add_suggestion(app, env)
+          end
+        end
+        acc_apps.each do |app|
+          app.environments.each do |env|
+            add_suggestion(app, env)
+          end
+        end
       elsif query.remotes && acc_envs.any? && acc_apps.any?
         problems << "Application #{acc_apps.map {|a|a.name.inspect}.join(', ')} and environment #{environment_name} are not associated."
-        @suggestions[:apps] = acc_apps
-        @suggestions[:environments] = acc_envs
+        acc_apps.each do |app|
+          app.environments.each do |env|
+            add_suggestion(app, env)
+          end
+        end
       end
 
       return problems if problems.any?
@@ -139,5 +156,9 @@ class EY::Resolver
     def acc_envs
       @acc_envs ||= EnvironmentResolver.new(@user, :environment_name => query.environment_name, :remotes => query.remotes, :account_name => query.account_name).matches
     end
+
+    def add_suggestion(app, env)
+      @suggestions << {'account_name' => app.account.name, 'app_name' => app.name, 'environment_name' => env.name}
+    end
   end
 end

data/lib/ey_resolver/version.rb

@@ -1,5 +1,5 @@
 module EY
   class Resolver
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

data/spec/account_resolver_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 
 describe EY::Resolver::AppEnvResolver do
 
-  def account_resolver(*args)
-    EY::Resolver.account_resolver(user, to_query(args))
-  end
-
-  def accounts(*models)
-    models.map { |model| model[:account] }
-  end
-
   before(:all) do
     # More correct names, even though it doesn't matter
     @ey = @production
@@ -83,38 +75,50 @@ describe EY::Resolver::AppEnvResolver do
 
   describe "#errors" do
     it "no account" do
-      account_resolver('gibberish', 'app', 'production').errors.should ==
+      resolver = account_resolver('gibberish', 'app', 'production')
+      resolver.errors.should ==
         [%|No account found matching "gibberish".|]
+      resolver.suggestions.should == []
     end
 
     it "no app" do
-      account_resolver(nil, 'gibberish', 'app_dup').errors.should ==
+      resolver = account_resolver(nil, 'gibberish', 'app_dup')
+      resolver.errors.should ==
         [%|No application found matching "gibberish".|]
+      resolver.suggestions.should == []
     end
 
     it "no env" do
-      account_resolver('ey', 'app', 'gibberish').errors.should ==
+      resolver = account_resolver('ey', 'app', 'gibberish')
+      resolver.errors.should ==
         [%|No environment found matching "gibberish".|]
+      resolver.suggestions.should == []
     end
 
     it "no account or app" do
-      account_resolver('gibberish', 'gibberish', nil).errors.should == [
+      resolver = account_resolver('gibberish', 'gibberish', nil)
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
       ]
+      resolver.suggestions.should == []
     end
 
     it "no account or app or env" do
-      account_resolver('gibberish', 'gibberish', 'gibberish').errors.should == [
+      resolver = account_resolver('gibberish', 'gibberish', 'gibberish')
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
         %|No environment found matching "gibberish".|,
       ]
+      resolver.suggestions.should == []
     end
 
     it "repo not found" do
-      account_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"]).errors.should ==
+      resolver = account_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"])
+      resolver.errors.should ==
         [%|No application found matching remotes:\n\tgit://fake.com/fake/fake.git|]
+      resolver.suggestions.should == []
     end
   end
 end

data/spec/app_env_resolver_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 
 describe EY::Resolver::AppEnvResolver do
 
-  def app_env_resolver(*args)
-    EY::Resolver.app_env_resolver(user, to_query(args))
-  end
-
-  def app_envs(*models)
-    models.map { |model| model[:app_env] }
-  end
-
   describe "#matches" do
     it "raises if the conditions are empty" do
       app_env_resolver(                 ).matches.should == []
@@ -80,80 +72,124 @@ describe EY::Resolver::AppEnvResolver do
     end
   end
 
-  describe "#errors" do
-
+  describe "errors and suggestions" do
     it "no constraints" do
-      app_env_resolver().errors.should ==
+      resolver = app_env_resolver()
+      resolver.errors.should ==
         [%|Must search by account name, app name, remotes, or environment name.|]
+      resolver.suggestions.should be_empty
     end
 
     it "no app constraints" do
-      app_env_resolver('ey').errors.should ==
+      resolver = app_env_resolver('ey')
+      resolver.errors.should ==
         [%|App name or repository remotes required.|]
+      resolver.suggestions.should be_empty
     end
 
     it "no account" do
-      app_env_resolver('gibberish', 'app', 'production').errors.should ==
+      resolver = app_env_resolver('gibberish', 'app', 'production')
+      resolver.errors.should ==
         [%|No account found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "no app" do
-      app_env_resolver(nil, 'gibberish', 'app_dup').errors.should ==
+      resolver = app_env_resolver(nil, 'gibberish', 'app_dup')
+      resolver.errors.should ==
         [%|No application found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "app found, but not on account" do
-      app_env_resolver('no', 'bigapp', 'app_dup').errors.should == [
+      resolver = app_env_resolver('no', 'bigapp', 'app_dup')
+      resolver.errors.should == [
         %|Application "bigapp" found, but does not exist in account "no".|,
         %|Environment "app_dup" found, but does not exist in account "no".|,
       ]
+      resolver.suggestions.should =~ [
+        {'account_name' => 'ey', 'app_name' => 'bigapp',  'environment_name' => 'bigapp_staging'},
+        {'account_name' => 'ey', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'other',   'environment_name' => 'app_dup'}
+      ]
     end
 
     it "no env" do
-      app_env_resolver('ey', 'app', 'gibberish').errors.should ==
+      resolver = app_env_resolver('ey', 'app', 'gibberish')
+      resolver.errors.should ==
         [%|No environment found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "no env on account" do
-      app_env_resolver('me', 'other', 'production').errors.should ==
+      resolver = app_env_resolver('me', 'other', 'production')
+      resolver.errors.should ==
         [%|Environment "production" found, but does not exist in account "me".|]
+      resolver.suggestions.should =~ [
+        {'account_name' => 'ey', 'app_name' => 'huge', 'environment_name' => 'production'}
+      ]
     end
 
     it "no account or app" do
-      app_env_resolver('gibberish', 'gibberish', nil).errors.should == [
+      resolver = app_env_resolver('gibberish', 'gibberish', nil)
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
       ]
+      resolver.suggestions.should be_empty
     end
 
     it "no account or app or env" do
-      app_env_resolver('gibberish', 'gibberish', 'gibberish').errors.should == [
+      resolver = app_env_resolver('gibberish', 'gibberish', 'gibberish')
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
         %|No environment found matching "gibberish".|,
       ]
+      resolver.suggestions.should be_empty
     end
 
     it "repo not found" do
-      app_env_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"]).errors.should ==
+      resolver = app_env_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"])
+      resolver.errors.should ==
         [%|No application found matching remotes:\n\tgit://fake.com/fake/fake.git|]
+      resolver.suggestions.should be_empty
     end
 
     it "repo not found in account" do
-      app_env_resolver('ey', nil, nil, ["git://github.com/repo/oth.git"]).errors.should ==
+      resolver = app_env_resolver('ey', nil, nil, ["git://github.com/repo/oth.git"])
+      resolver.errors.should ==
         [%|Application "other" found, but does not exist in account "ey".|]
+      resolver.suggestions.should =~
+        [{'account_name' => 'me', 'app_name' => 'other', 'environment_name' => 'app_dup'}]
     end
 
     it "app and environment not associated" do
-      app_env_resolver('ey', 'bigapp', 'app_dup').errors.should ==
-        [%|Application "bigapp" and environment "app_dup" are not associated.|]
-      app_env_resolver(nil,   nil,     'app_dup', ["git://github.com/repo/app.git"]).errors.should ==
+      resolver = app_env_resolver('ey', 'bigapp', 'app_staging')
+      resolver.errors.should ==
+        [%|Application "bigapp" and environment "app_staging" are not associated.|]
+      resolver.suggestions.should =~ [
+        {'account_name' => 'ey', 'app_name' => 'bigapp', 'environment_name' => 'bigapp_staging'},
+        {'account_name' => 'ey', 'app_name' => 'app', 'environment_name' => 'app_staging'}
+      ]
+    end
+
+    it "another app and environment not associated" do
+      resolver = app_env_resolver(nil, nil, 'app_dup', ["git://github.com/repo/app.git"])
+      resolver.errors.should ==
         [%|Application "app" and environment "app_dup" are not associated.|]
+      resolver.suggestions.should =~ [
+        {"account_name"=>"ey", 'app_name' => 'app', "environment_name"=>"app_production"},
+        {"account_name"=>"ey", 'app_name' => 'app', "environment_name"=>"app_staging"}
+      ]
     end
 
     it "app (by repo) does not have an environment" do
-      app_env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"]).errors.should ==
+      resolver = app_env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"])
+      resolver.errors.should ==
         [%|No environment found for applications matching remotes:\n\tgit://github.com/repo/noe.git|]
+      resolver.suggestions.should be_empty
     end
   end
 end

data/spec/app_resolver_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 
 describe EY::Resolver::AppEnvResolver do
 
-  def app_resolver(*args)
-    EY::Resolver.app_resolver(user, to_query(args))
-  end
-
-  def apps(*models)
-    models.map { |model| model[:app] }
-  end
-
   describe "#matches" do
     it "returns none if the conditions are empty" do
       app_resolver(                 ).matches.should == []

data/spec/environment_resolver_spec.rb

@@ -2,14 +2,6 @@ require 'spec_helper'
 
 describe EY::Resolver::EnvironmentResolver do
 
-  def env_resolver(*args)
-    EY::Resolver.environment_resolver(user, to_query(args))
-  end
-
-  def envs(*models)
-    models.map { |model| model[:env] }
-  end
-
   describe "#matches" do
     it "raises if the conditions are empty" do
       env_resolver(                   ).matches.should == []
@@ -90,77 +82,119 @@ describe EY::Resolver::EnvironmentResolver do
     end
   end
 
-  describe "#errors" do
+  describe "errors and suggestions" do
     it "no account" do
-      env_resolver('gibberish', 'app', 'production').errors.should ==
+      resolver = env_resolver('gibberish', 'app', 'production')
+      resolver.errors.should ==
         [%|No account found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "no app" do
-      env_resolver(nil, 'gibberish', 'app_dup').errors.should ==
+      resolver = env_resolver(nil, 'gibberish', 'app_dup')
+      resolver.errors.should ==
         [%|No application found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "app found, but not on account" do
-      env_resolver('no', 'bigapp', 'app_dup').errors.should == [
+      resolver = env_resolver('no', 'bigapp', 'app_dup')
+      resolver.errors.should == [
         %|Application "bigapp" found, but does not exist in account "no".|,
         %|Environment "app_dup" found, but does not exist in account "no".|,
       ]
+      resolver.suggestions.should =~ [
+        {'account_name' => 'ey', 'app_name' => 'bigapp',  'environment_name' => 'bigapp_staging'},
+        {'account_name' => 'ey', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'other',   'environment_name' => 'app_dup'}
+      ]
     end
 
     it "no env" do
-      env_resolver('ey', nil, 'gibberish').errors.should ==
+      resolver = env_resolver('ey', nil, 'gibberish')
+      resolver.errors.should ==
         [%|No environment found matching "gibberish".|]
+      resolver.suggestions.should be_empty
     end
 
     it "no env on account" do
-      env_resolver('no', nil, 'app_dup').errors.should ==
+      resolver = env_resolver('no', nil, 'app_dup')
+      resolver.errors.should ==
         [%|Environment "app_dup" found, but does not exist in account "no".|]
+      resolver.suggestions.should =~ [
+        {'account_name' => 'ey', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'app_dup', 'environment_name' => 'app_dup'},
+        {'account_name' => 'me', 'app_name' => 'other', 'environment_name' => 'app_dup'}
+      ]
     end
 
     it "no account or app" do
-      env_resolver('gibberish', 'gibberish', nil).errors.should == [
+      resolver = env_resolver('gibberish', 'gibberish', nil)
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
       ]
+      resolver.suggestions.should be_empty
     end
 
     it "no account or app or env" do
-      env_resolver('gibberish', 'gibberish', 'gibberish').errors.should == [
+      resolver = env_resolver('gibberish', 'gibberish', 'gibberish')
+      resolver.errors.should == [
         %|No account found matching "gibberish".|,
         %|No application found matching "gibberish".|,
         %|No environment found matching "gibberish".|,
       ]
+      resolver.suggestions.should be_empty
     end
 
     it "repo not found" do
-      env_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"]).errors.should ==
+      resolver = env_resolver(nil, nil, nil, ["git://fake.com/fake/fake.git"])
+      resolver.errors.should ==
         [%|No application found matching remotes:\n\tgit://fake.com/fake/fake.git|]
+      resolver.suggestions.should be_empty
     end
 
     it "repo found but env doesn't exist on it" do
-      env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"]).errors.should ==
+      resolver = env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"])
+      resolver.errors.should ==
         [%|No environment found for applications matching remotes:\n\tgit://github.com/repo/noe.git|]
+      resolver.suggestions.should be_empty
     end
 
     it "repo not found in account" do
-      env_resolver('ey', nil, nil, ["git://github.com/repo/oth.git"]).errors.should ==
+      resolver = env_resolver('ey', nil, nil, ["git://github.com/repo/oth.git"])
+      resolver.errors.should ==
         [%|Application "other" found, but does not exist in account "ey".|]
+      resolver.suggestions.should =~
+        [{"account_name"=>"me", "app_name"=>"other", "environment_name"=>"app_dup"}]
     end
 
     it "app and environment not associated" do
-      env_resolver('ey', 'bigapp', 'app_dup').errors.should ==
+      resolver = env_resolver('ey', 'bigapp', 'app_dup')
+      resolver.errors.should ==
         [%|Application "bigapp" and environment "app_dup" are not associated.|]
+      resolver.suggestions.should =~ [
+        {"account_name"=>"ey", "app_name"=>"app_dup", "environment_name"=>"app_dup"},
+        {"account_name"=>"ey", "app_name"=>"bigapp", "environment_name"=>"bigapp_staging"}
+      ]
     end
 
     it "app (by repo) and environment not associated" do
-      env_resolver(nil, nil, 'app_dup', ["git://github.com/repo/app.git"]).errors.should ==
+      resolver = env_resolver(nil, nil, 'app_dup', ["git://github.com/repo/app.git"])
+      resolver.errors.should ==
         [%|Application "app" and environment "app_dup" are not associated.|]
+      resolver.suggestions.should =~ [
+        {"account_name"=>"ey", 'app_name' => 'app', "environment_name"=>"app_production"},
+        {"account_name"=>"ey", 'app_name' => 'app', "environment_name"=>"app_staging"}
+      ]
     end
 
     it "app (by repo) does not have an environment" do
-      env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"]).errors.should ==
+      resolver = env_resolver(nil, nil, nil, ["git://github.com/repo/noe.git"])
+      resolver.errors.should ==
         [%|No environment found for applications matching remotes:\n\tgit://github.com/repo/noe.git|]
+      resolver.suggestions.should be_empty
     end
   end
 end

data/spec/spec_helper.rb

@@ -63,6 +63,38 @@ module Helpers
   def to_query(args)
     Hash[%w[account_name app_name environment_name remotes].zip(args)]
   end
+
+  def app_env_resolver(*args)
+    EY::Resolver.app_env_resolver(user, to_query(args))
+  end
+
+  def app_envs(*models)
+    models.map { |model| model[:app_env] }
+  end
+
+  def app_resolver(*args)
+    EY::Resolver.app_resolver(user, to_query(args))
+  end
+
+  def apps(*models)
+    models.map { |model| model[:app] }
+  end
+
+  def env_resolver(*args)
+    EY::Resolver.environment_resolver(user, to_query(args))
+  end
+
+  def envs(*models)
+    models.map { |model| model[:env] }
+  end
+
+  def account_resolver(*args)
+    EY::Resolver.account_resolver(user, to_query(args))
+  end
+
+  def accounts(*models)
+    models.map { |model| model[:account] }
+  end
 end
 
 RSpec.configure do |config|

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ey_resolver
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-21 00:00:00.000000000 Z
+date: 2012-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gitable
-  requirement: &70106287480080 !ruby/object:Gem::Requirement
+  requirement: &70293599453000 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 0.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *70106287480080
+  version_requirements: *70293599453000
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70106287479660 !ruby/object:Gem::Requirement
+  requirement: &70293599452580 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70106287479660
+  version_requirements: *70293599452580
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70106287479120 !ruby/object:Gem::Requirement
+  requirement: &70293599452040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '2.0'
   type: :development
   prerelease: false
-  version_requirements: *70106287479120
+  version_requirements: *70293599452040
 description: Resolves apps, environments, app_environments and accounts using a set
   of constraints
 email:
@@ -92,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 960271519958005982
+      hash: -4423758491052706735
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -101,7 +101,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: 960271519958005982
+      hash: -4423758491052706735
 requirements: []
 rubyforge_project: ey_resolver
 rubygems_version: 1.8.15