shelly 0.0.16 → 0.0.17

data/lib/core_ext/hash.rb

@@ -0,0 +1,17 @@
+class Hash
+  def deep_stringify_keys
+    new_hash = {}
+    self.each do |key, value|
+      new_hash.merge!(key.to_s => (value.is_a?(Hash) ? value.deep_stringify_keys : value))
+    end
+    new_hash
+  end
+
+  def deep_symbolize_keys
+    new_hash = {}
+    self.each do |key, value|
+      new_hash.merge!(key.to_sym => (value.is_a?(Hash) ? value.deep_symbolize_keys : value))
+    end
+    new_hash
+  end
+end

data/lib/shelly.rb

@@ -1,12 +1,16 @@
 require "rubygems"
 require "thor"
 require "core_ext/object"
+require "core_ext/hash"
 require "shelly/helpers"
 require "shelly/base"
+require "thor/options"
 
 module Shelly
   autoload :App, "shelly/app"
+  autoload :Cloudfile, "shelly/cloudfile"
   autoload :Client, "shelly/client"
   autoload :User, "shelly/user"
   autoload :VERSION, "shelly/version"
 end
+

data/lib/shelly/app.rb

@@ -4,7 +4,7 @@ require 'launchy'
 module Shelly
   class App < Base
     DATABASE_KINDS = %w(postgresql mongodb redis none)
-    attr_accessor :purpose, :code_name, :databases, :ruby_version, :environment, :git_url, :domains
+    attr_accessor :code_name, :databases, :ruby_version, :environment, :git_url, :domains
 
     def initialize
       @ruby_version = "MRI-1.9.2"
@@ -12,14 +12,14 @@ module Shelly
     end
 
     def add_git_remote
-      system("git remote rm #{purpose} &> /dev/null")
-      system("git remote add #{purpose} #{git_url}")
+      system("git remote rm production &> /dev/null")
+      system("git remote add production #{git_url}")
     end
 
     def generate_cloudfile
       @email = current_user.email
       @databases = databases
-      @domains = domains.nil? ? ["#{code_name}.winniecloud.com"] : domains
+      @domains = domains
       template = File.read(cloudfile_template_path)
       cloudfile = ERB.new(template, 0, "%<>-")
       cloudfile.result(binding)
@@ -35,10 +35,11 @@ module Shelly
         :code_name    => code_name,
         :environment  => environment,
         :ruby_version => ruby_version,
-        :domain_name  => "#{code_name}.shellycloud.com"
+        :domain_name  => domains
       }
       response = shelly.create_app(attributes)
       self.git_url = response["git_url"]
+      self.domains = response["domain_name"].split if domains.nil?
     end
 
     def create_cloudfile
@@ -68,4 +69,3 @@ module Shelly
     end
   end
 end
-

data/lib/shelly/cli/main.rb

@@ -8,6 +8,7 @@ module Shelly
       include Thor::Actions
       include Helpers
       register(Users, "users", "users <command>", "Manages users using this app")
+      check_unknown_options!
 
       map %w(-v --version) => :version
       desc "version", "Displays shelly version"
@@ -30,15 +31,16 @@ module Shelly
         say "Check you mailbox for email address confirmation"
       rescue Client::APIError => e
         if e.validation?
-          e.errors.each do |error|
-            say_error "#{error.first} #{error.last}", :with_exit => false
-          end
+          e.each_error { |error| say_error "#{error}", :with_exit => false }
           exit 1
         end
-        rescue RestClient::Conflict
-          say_error "User with your ssh key already exists.", :with_exit => false
-          say_error "You can login using: shelly login [EMAIL]", :with_exit => false
-          exit 1
+      rescue RestClient::Conflict
+        say_error "User with your ssh key already exists.", :with_exit => false
+        say_error "You can login using: shelly login [EMAIL]", :with_exit => false
+        exit 1
+      rescue Errno::ENOENT => e
+        say_error e, :with_exit => false
+        say_error "Use ssh-keygen to generate ssh key pair"
       end
 
       desc "login [EMAIL]", "Logins user to Shelly Cloud"
@@ -52,40 +54,38 @@ module Shelly
         user.apps.each do |app|
           say "  #{app["code_name"]}"
         end
-      rescue RestClient::Unauthorized
-        say_error "Wrong email or password", :with_exit => false
-        say_error "You can reset password by using link:", :with_exit => false
-        say_error "https://admin.winniecloud.com/users/password/new", :with_exit => false
-        exit 1
       rescue Client::APIError => e
         if e.validation?
-          e.errors.each { |error| say_error "#{error.first} #{error.last}", :with_exit => false }
+          e.each_error { |error| say_error "#{error}", :with_exit => false }
+          exit 1
+        end
+        if e.unauthorized?
+          say_error "Wrong email or password", :with_exit => false
+          say_error "You can reset password by using link:", :with_exit => false
+          say_error "#{e.url}", :with_exit => false
           exit 1
         end
       end
 
-      method_option :code_name, :type => :string, :aliases => "-c",
+      method_option "code-name", :type => :string, :aliases => "-c",
         :desc => "Unique code_name of your application"
-      method_option :environment, :type => :string, :aliases => "-e",
-        :desc => "Environment that your application will be running"
       method_option :databases, :type => :array, :aliases => "-d",
         :banner => "#{Shelly::App::DATABASE_KINDS.join(' ')}",
         :desc => "Array of databases of your choice"
       method_option :domains, :type => :array,
-        :banner => "CODE_NAME.shellycloud.com YOUR_DOMAIN.com",
+        :banner => "CODE-NAME.shellyapp.com YOUR-DOMAIN.com",
         :desc => "Array of your domains"
       desc "add", "Adds new application to Shelly Cloud"
       def add
         say_error "Must be run inside your project git repository" unless App.inside_git_repository?
         check_options(options)
         @app = Shelly::App.new
-        @app.purpose = options["environment"] || ask_for_purpose
-        @app.code_name = options["code_name"] || ask_for_code_name
+        @app.code_name = options["code-name"] || ask_for_code_name
         @app.databases = options["databases"] || ask_for_databases
         @app.domains = options["domains"]
         @app.create
 
-        say "Adding remote #{@app.purpose} #{@app.git_url}", :green
+        say "Adding remote production #{@app.git_url}", :green
         @app.add_git_remote
 
         say "Creating Cloudfile", :green
@@ -96,22 +96,28 @@ module Shelly
 
         info_adding_cloudfile_to_repository
         info_deploying_to_shellycloud
+
       rescue Client::APIError => e
         if e.validation?
-          e.errors.each { |error| say_error "#{error.first} #{error.last}", :with_exit => false }
-          exit 1
+          e.each_error { |error| say_error "#{error}", :with_exit => false }
+          say_new_line
+          say_error "Fix erros in the below command and type it again to create your application" , :with_exit => false
+          say_error "shelly add --code-name=#{@app.code_name} --databases=#{@app.databases.join} --domains=#{@app.code_name}.shellyapp.com"
         end
       end
 
       # FIXME: move to helpers
       no_tasks do
         def check_options(options)
-          unless ["environment", "code_name", "databases", "domains"].all? do |option|
-            options.include?(option.to_s) && options[option.to_s] != option.to_s
-          end && valid_databases?(options["databases"])
-            say "Wrong parameters. See 'shelly help add' for further information"
-            exit 1
-          end unless options.empty?
+          unless options.empty?
+            options["domains"].map! {|domain| domain.gsub(",", "") } if options["domains"]
+            options["databases"].map! {|kind| kind.gsub(",", "") } if options["databases"]
+            unless ["code-name", "databases", "domains"].all? do |option|
+              options.include?(option.to_s) && options[option.to_s] != option.to_s
+            end && valid_databases?(options["databases"])
+              say_error "Try 'shelly help add' for more information"
+            end
+          end
         end
 
         def valid_databases?(databases)
@@ -119,14 +125,6 @@ module Shelly
           databases.all? { |kind| kinds.include?(kind) }
         end
 
-        def ask_for_email
-          email_question = User.guess_email.blank? ? "Email:" : "Email (#{User.guess_email} - default):"
-          email = ask(email_question)
-          email = email.blank? ? User.guess_email : email
-          return email if email.present?
-          say_error "Email can't be blank, please try again"
-        end
-
         def ask_for_password(options = {})
           options = {:with_confirmation => true}.merge(options)
           loop do
@@ -146,13 +144,8 @@ module Shelly
           end
         end
 
-        def ask_for_purpose
-          purpose = ask("How will you use this system (production - default,staging):")
-          purpose.blank? ? "production" : purpose
-        end
-
         def ask_for_code_name
-          default_code_name = "#{Shelly::App.guess_code_name}-#{@app.purpose}"
+          default_code_name = "#{Shelly::App.guess_code_name}-production"
           code_name = ask("Application code name (#{default_code_name} - default):")
           code_name.blank? ? default_code_name : code_name
         end
@@ -184,8 +177,8 @@ module Shelly
           say '  git commit -m "Application added to Shelly Cloud"'
           say "  git push"
           say_new_line
-          say "Deploy to #{@app.purpose} using:", :green
-          say "  git push #{@app.purpose} master"
+          say "Deploy to production using:", :green
+          say "  git push production master"
           say_new_line
         end
       end

data/lib/shelly/cli/users.rb

@@ -1,5 +1,6 @@
 require "yaml"
 require "shelly/user"
+require "shelly/cloudfile"
 
 module Shelly
   module CLI
@@ -10,20 +11,29 @@ module Shelly
       desc "list", "List users who have access to current application"
       def list
         say_error "Must be run inside your project git repository" unless App.inside_git_repository?
-        code_names = YAML.load(File.open(File.join(Dir.pwd, "Cloudfile"))).keys
-        @app = Shelly::App.new
-        response = @app.users(code_names.sort)
-        response.each do |app|
-          say "Cloud #{app['code_name']}:"
-          app['users'].each do |user|
-            say "  #{user['email']} (#{user['name']})"
-          end
+        @cloudfile = Shelly::Cloudfile.new
+        @cloudfile.fetch_users.each do |app, users|
+          say "Cloud #{app}:"
+          users.each { |user| say "  #{user}" }
         end
       rescue Client::APIError => e
         say e.message
         exit 1
       end
 
+      desc "add [EMAIL]", "Add new developer to applications defined in Cloudfile"
+      def add(email = nil)
+        say_error "Must be run inside your project git repository" unless App.inside_git_repository?
+        user_email = email || ask_for_email({:guess_email => false})
+        @cloudfile = Shelly::Cloudfile.new
+        @user = Shelly::User.new
+        @user.send_invitation(@cloudfile.clouds, user_email)
+        say "Sending invitation to #{user_email}"
+      rescue Client::APIError => e
+        say e.message
+        exit 1
+      end
+
     end
   end
 end

data/lib/shelly/client.rb

@@ -16,9 +16,23 @@ module Shelly
         @response["errors"]
       end
 
+      def url
+        @response["url"]
+      end
+
       def validation?
         message == "Validation Failed"
       end
+
+      def unauthorized?
+        message == "Unauthorized"
+      end
+
+      def each_error
+        @response["errors"].each do |index,message|
+          yield index.gsub('_',' ').capitalize + " " + message
+        end
+      end
     end
 
     def initialize(email = nil, password = nil)
@@ -42,6 +56,12 @@ module Shelly
       get("/token")
     end
 
+    def send_invitation(apps, email)
+      apps.map do |app|
+        post("/apps/#{app}/collaborations", :email => email)
+      end
+    end
+
     def create_app(attributes)
       post("/apps", :app => attributes)
     end
@@ -102,7 +122,7 @@ module Shelly
     end
 
     def process_response(response)
-      if [404, 422, 500].include?(response.code)
+      if [401, 404, 422, 500].include?(response.code)
         raise APIError.new(response.body)
       end
 

data/lib/shelly/cloudfile.rb

@@ -0,0 +1,45 @@
+module Shelly
+  class Cloudfile < Base
+    attr_accessor :content
+
+    def initialize
+      open if File.exists?(path)
+    end
+
+    def path
+      File.join(Dir.pwd, "Cloudfile")
+    end
+
+    def open
+      @content = YAML.load(File.open(path))
+    end
+
+    def write(hash)
+      @content = hash
+      File.open(path, "w") do |f|
+        f.write(yaml(hash))
+      end
+    end
+
+    def clouds
+      @content.keys.sort
+    end
+
+    def yaml(hash)
+      string = hash.deep_stringify_keys.to_yaml
+      # FIXME: check if it possible to remove sub("---", "") by passing options to_yaml
+      string.sub("---","").split("\n").map(&:rstrip).join("\n").strip
+    end
+
+    def fetch_users
+      response = shelly.app_users(clouds)
+      response.inject({}) do |result, app|
+        result[app['code_name']] = app['users'].map do |user|
+          "#{user['email']} (#{user['name']})"
+        end
+        result
+      end
+    end
+  end
+end
+

data/lib/shelly/helpers.rb

@@ -16,5 +16,16 @@ module Shelly
       say  message, :red
       exit 1 if options[:with_exit]
     end
+
+    def ask_for_email(options = {})
+      options = {:guess_email => true}.merge(options)
+      email_question = options[:guess_email] && !User.guess_email.blank? ? "Email (#{User.guess_email} - default):" : "Email:"
+      email = ask(email_question)
+      email = email.blank? ? User.guess_email : email
+      return email if email.present?
+      say_error "Email can't be blank, please try again"
+    end
+
   end
 end
+

data/lib/shelly/user.rb

@@ -29,6 +29,10 @@ module Shelly
       shelly.token["token"]
     end
 
+    def send_invitation(apps, email)
+      shelly.send_invitation(apps, email)
+    end
+
     def load_credentials
       return unless credentials_exists?
       @email, @password = File.read(credentials_path).split("\n")
@@ -47,7 +51,7 @@ module Shelly
     def ssh_key_path
       File.expand_path("~/.ssh/id_rsa.pub")
     end
-    
+
     def ssh_key_registered?
     	ssh_key = File.read(ssh_key_path).strip
     	shelly.ssh_key_available?(ssh_key)
@@ -81,3 +85,4 @@ module Shelly
       end
     end
 end
+

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.0.16"
+  VERSION = "0.0.17"
 end

data/lib/thor/options.rb

@@ -0,0 +1,12 @@
+class Thor
+  class Options < Arguments
+
+    def check_unknown!
+      raise UnknownArgumentError, "shelly: unrecognized option '#{@unknown.join(', ')}'\n" +
+        "Usage: shelly [COMMAND]... [OPTIONS]\n" +
+        "Try 'shelly --help' for more information" unless @unknown.empty?
+    end
+
+  end
+end
+

data/spec/shelly/app_spec.rb

@@ -8,7 +8,6 @@ describe Shelly::App do
     @client = mock(:api_url => "https://api.example.com", :shellyapp_url => "http://shellyapp.example.com")
     Shelly::Client.stub(:new).and_return(@client)
     @app = Shelly::App.new
-    @app.purpose = "staging"
     @app.code_name = "foo-staging"
   end
 
@@ -42,12 +41,12 @@ describe Shelly::App do
     end
 
     it "should try to remove existing git remote" do
-      @app.should_receive(:system).with("git remote rm staging &> /dev/null")
+      @app.should_receive(:system).with("git remote rm production &> /dev/null")
       @app.add_git_remote
     end
 
     it "should add git remote with proper name and git repository" do
-      @app.should_receive(:system).with("git remote add staging git@git.shellycloud.com:foo-staging.git")
+      @app.should_receive(:system).with("git remote add production git@git.shellycloud.com:foo-staging.git")
       @app.add_git_remote
     end
   end
@@ -122,25 +121,52 @@ config
   end
 
   describe "#create" do
-    it "should create the app on shelly cloud via API client" do
-      @app.purpose = "dev"
-      @app.code_name = "fooo"
-      attributes = {
-        :code_name => "fooo",
-        :name => "fooo",
-        :environment => "production",
-        :ruby_version => "MRI-1.9.2",
-        :domain_name => "fooo.shellycloud.com"
-      }
-      @client.should_receive(:create_app).with(attributes).and_return("git_url" => "git@git.shellycloud.com:fooo.git")
-      @app.create
+    context "without providing domain" do
+      it "should create the app on shelly cloud via API client" do
+        @app.code_name = "fooo"
+        attributes = {
+          :code_name => "fooo",
+          :name => "fooo",
+          :environment => "production",
+          :ruby_version => "MRI-1.9.2",
+          :domain_name => nil
+        }
+        @client.should_receive(:create_app).with(attributes).and_return("git_url" => "git@git.shellycloud.com:fooo.git",
+          "domain_name" => "fooo.shellyapp.com")
+        @app.create
+      end
+
+      it "should assign returned git_url and domain" do
+        @client.stub(:create_app).and_return("git_url" => "git@git.example.com:fooo.git",
+          "domain_name" => "fooo.shellyapp.com")
+        @app.create
+        @app.git_url.should == "git@git.example.com:fooo.git"
+        @app.domains.should == ["fooo.shellyapp.com"]
+      end
     end
 
-    it "should assign returned git_url" do
-      @client.stub(:create_app).and_return("git_url" => "git@git.example.com:fooo.git")
-      @app.create
-      @app.git_url.should == "git@git.example.com:fooo.git"
+    context "with providing domain" do
+      it "should create the app on shelly cloud via API client" do
+        @app.code_name = "boo"
+        @app.domains = ["boo.shellyapp.com", "boo.example.com"]
+        attributes = {
+          :code_name => "boo",
+          :name => "boo",
+          :environment => "production",
+          :ruby_version => "MRI-1.9.2",
+          :domain_name => ["boo.shellyapp.com", "boo.example.com"]
+        }
+        @client.should_receive(:create_app).with(attributes).and_return("git_url" => "git@git.shellycloud.com:fooo.git",
+          "domain_name" => "boo.shellyapp.com boo.example.com")
+        @app.create
+      end
+
+      it "should assign returned git_url and domain" do
+        @client.stub(:create_app).and_return("git_url" => "git@git.example.com:fooo.git",
+          "domain_name" => "boo.shellyapp.com boo.example.com")
+        @app.create
+        @app.domains.should == ["boo.shellyapp.com", "boo.example.com"]
+      end
     end
   end
 end
-

data/spec/shelly/cli/main_spec.rb

@@ -3,7 +3,6 @@ require "shelly/cli/main"
 
 describe Shelly::CLI::Main do
   before do
-    ENV['SHELLY_GIT_HOST'] = nil
     FileUtils.stub(:chmod)
     @main = Shelly::CLI::Main.new
     @client = mock
@@ -45,6 +44,16 @@ OUT
       Shelly::User.stub(:new).and_return(@user)
     end
 
+    it "should return false if ssh key don't exist on local hard drive" do
+      @user.stub(:ssh_key_registered?).and_raise(Errno::ENOENT)
+      File.exists?(File.expand_path("~/.ssh/id_rsa.pub")).should be_false
+      $stdout.should_receive(:puts).with("\e[31mNo such file or directory\e[0m")
+      $stdout.should_receive(:puts).with("\e[31mUse ssh-keygen to generate ssh key pair\e[0m")
+      lambda {
+        @main.register
+      }.should raise_error(SystemExit)
+    end
+
     it "should check ssh key in database" do
       @user.stub(:ssh_key_registered?).and_raise(RestClient::Conflict)
       $stdout.should_receive(:puts).with("\e[31mUser with your ssh key already exists.\e[0m")
@@ -134,7 +143,7 @@ OUT
         response = {"message" => "Validation Failed", "errors" => [["email", "has been already taken"]]}
         exception = Shelly::Client::APIError.new(response.to_json)
         @client.stub(:register_user).and_raise(exception)
-        $stdout.should_receive(:puts).with("\e[31memail has been already taken\e[0m")
+        $stdout.should_receive(:puts).with("\e[31mEmail has been already taken\e[0m")
         lambda {
           fake_stdin(["kate@example.com", "pass", "pass"]) do
             @main.register
@@ -187,7 +196,8 @@ OUT
 
     context "on unauthorized user" do
       it "should exit with 1 and display error message" do
-        exception = RestClient::Unauthorized.new
+        response = {"message" => "Unauthorized", "url" => "https://admin.winniecloud.com/users/password/new"}
+        exception = Shelly::Client::APIError.new(response.to_json)
         @client.stub(:token).and_raise(exception)
         $stdout.should_receive(:puts).with("\e[31mWrong email or password\e[0m")
         $stdout.should_receive(:puts).with("\e[31mYou can reset password by using link:\e[0m")
@@ -219,68 +229,67 @@ OUT
       Shelly::App.stub(:inside_git_repository?).and_return(false)
       $stdout.should_receive(:puts).with("\e[31mMust be run inside your project git repository\e[0m")
       lambda {
-        fake_stdin(["staging", "", ""]) do
+        fake_stdin(["", ""]) do
           @main.add
         end
       }.should raise_error(SystemExit)
     end
 
-    it "should ask user how he will use application" do
-      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-      @app.should_receive(:purpose=).with("staging")
-      fake_stdin(["staging", "", ""]) do
-        @main.add
-      end
-    end
-
     context "command line options" do
       context "invalid params" do
         it "should show help and exit if not all options are passed" do
-          $stdout.should_receive(:puts).with("Wrong parameters. See 'shelly help add' for further information")
-          @main.options = {"code_name" => "foo"}
+          $stdout.should_receive(:puts).with("\e[31mTry 'shelly help add' for more information\e[0m")
+          @main.options = {"code-name" => "foo"}
           lambda { @main.add }.should raise_error(SystemExit)
         end
 
         it "should exit if databases are not valid" do
-          $stdout.should_receive(:puts).with("Wrong parameters. See 'shelly help add' for further information")
-          @main.options = {"code_name" => "foo", "environment" => "production", "databases" => ["not existing"], "domains" => ["foo.example.com"]}
+          $stdout.should_receive(:puts).with("\e[31mTry 'shelly help add' for more information\e[0m")
+          @main.options = {"code-name" => "foo", "databases" => ["not existing"], "domains" => ["foo.example.com"]}
           lambda { @main.add }.should raise_error(SystemExit)
         end
-      end
 
-      context "valid params" do
-        it "should create app on shelly cloud" do
-          @app.should_receive(:create)
-          @main.options = {"code_name" => "foo", "environment" => "production", "databases" => ["postgresql"], "domains" => ["foo.example.com"]}
+        it "should accept databases separated by comma" do
+          @main.options = {"code-name" => "foo", "databases" => ["postgresql,", "mongodb"], "domains" => ["foo.example.com"]}
+          @app.should_receive(:databases=).with(["postgresql", "mongodb"])
           @main.add
         end
+
+        it "should display which parameter was wrong" do
+          expected = "shelly: unrecognized option '--unknown=param'\n" +
+                      "Usage: shelly [COMMAND]... [OPTIONS]\n" +
+                      "Try 'shelly --help' for more information"
+
+          Open3.popen3("bin/shelly add --unknown=param") do |stdin, stdout, stderr, wait_thr|
+            out = stderr.read.strip
+            out.should == expected
+          end
+        end
+
       end
-    end
 
-    context "when user provided empty purpose" do
-      it "should use 'production' as default" do
-        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-        @app.should_receive(:purpose=).with("production")
-        fake_stdin(["", "", ""]) do
+      context "valid params" do
+        it "should create app on shelly cloud" do
+          @app.should_receive(:create)
+          @main.options = {"code-name" => "foo", "databases" => ["postgresql"], "domains" => ["foo.example.com"]}
           @main.add
         end
       end
     end
 
     it "should use code name provided by user" do
-      $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-      $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
+      $stdout.should_receive(:print).with("Application code name (foo-production - default): ")
       @app.should_receive(:code_name=).with("mycodename")
-      fake_stdin(["staging", "mycodename", ""]) do
+      fake_stdin(["mycodename", ""]) do
         @main.add
       end
     end
 
     context "when user provided empty code name" do
       it "should use 'current_dirname-purpose' as default" do
-        $stdout.should_receive(:print).with("How will you use this system (production - default,staging): ")
-        $stdout.should_receive(:print).with("Application code name (foo-staging - default): ")
-        fake_stdin(["staging", "", ""]) do
+        $stdout.should_receive(:print).with("Application code name (foo-production - default): ")
+        @app.should_receive(:code_name=).with("foo-production")
+        fake_stdin(["", ""]) do
           @main.add
         end
       end
@@ -289,7 +298,7 @@ OUT
     it "should use database provided by user (separated by comma or space)" do
       $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
       @app.should_receive(:databases=).with(["postgresql", "mongodb", "redis"])
-      fake_stdin(["staging", "", "postgresql  ,mongodb redis"]) do
+      fake_stdin(["", "postgresql  ,mongodb redis"]) do
         @main.add
       end
     end
@@ -297,7 +306,7 @@ OUT
     it "should ask again for databases if unsupported kind typed" do
       $stdout.should_receive(:print).with("Which database do you want to use postgresql, mongodb, redis, none (postgresql - default): ")
       $stdout.should_receive(:print).with("Unknown database kind. Supported are: postgresql, mongodb, redis, none: ")
-      fake_stdin(["staging", "", "postgresql,doesnt-exist", "none"]) do
+      fake_stdin(["", "postgresql,doesnt-exist", "none"]) do
         @main.add
       end
     end
@@ -305,7 +314,7 @@ OUT
     context "when user provided empty database" do
       it "should use 'postgresql' database as default" do
         @app.should_receive(:databases=).with(["postgresql"])
-        fake_stdin(["staging", "", ""]) do
+        fake_stdin(["", ""]) do
           @main.add
         end
       end
@@ -313,7 +322,7 @@ OUT
 
     it "should create the app on shelly cloud" do
       @app.should_receive(:create)
-      fake_stdin(["", "", ""]) do
+      fake_stdin(["", ""]) do
         @main.add
       end
     end
@@ -322,25 +331,27 @@ OUT
       response = {"message" => "Validation Failed", "errors" => [["code_name", "has been already taken"]]}
       exception = Shelly::Client::APIError.new(response.to_json)
       @app.should_receive(:create).and_raise(exception)
-      $stdout.should_receive(:puts).with("\e[31mcode_name has been already taken\e[0m")
+      $stdout.should_receive(:puts).with("\e[31mCode name has been already taken\e[0m")
+      $stdout.should_receive(:puts).with("\e[31mFix erros in the below command and type it again to create your application\e[0m")
+      $stdout.should_receive(:puts).with("\e[31mshelly add --code-name=foo-production --databases=postgresql --domains=foo-production.shellyapp.com\e[0m")
       lambda {
-        fake_stdin(["", "", ""]) do
+        fake_stdin(["", ""]) do
           @main.add
         end
       }.should raise_error(SystemExit)
     end
 
     it "should add git remote" do
-      $stdout.should_receive(:puts).with("\e[32mAdding remote staging git@git.shellycloud.com:foooo.git\e[0m")
+      $stdout.should_receive(:puts).with("\e[32mAdding remote production git@git.shellycloud.com:foooo.git\e[0m")
       @app.should_receive(:add_git_remote)
-      fake_stdin(["staging", "foooo", ""]) do
+      fake_stdin(["foooo", ""]) do
         @main.add
       end
     end
 
     it "should create Cloudfile" do
       File.exists?("/projects/foo/Cloudfile").should be_false
-      fake_stdin(["staging", "foooo", ""]) do
+      fake_stdin(["foooo", ""]) do
         @main.add
       end
       File.read("/projects/foo/Cloudfile").should == "Example Cloudfile"
@@ -349,7 +360,7 @@ OUT
     it "should browser window with link to edit billing information" do
       $stdout.should_receive(:puts).with("\e[32mProvide billing details. Opening browser...\e[0m")
       @app.should_receive(:open_billing_page)
-      fake_stdin(["staging", "foooo", ""]) do
+      fake_stdin(["foooo", ""]) do
         @main.add
       end
     end
@@ -358,7 +369,7 @@ OUT
       $stdout.should_receive(:puts).with("\e[32mProject is now configured for use with Shell Cloud:\e[0m")
       $stdout.should_receive(:puts).with("\e[32mYou can review changes using\e[0m")
       $stdout.should_receive(:puts).with("  git status")
-      fake_stdin(["staging", "foooo", "none"]) do
+      fake_stdin(["foooo", "none"]) do
         @main.add
       end
     end
@@ -368,9 +379,9 @@ OUT
       $stdout.should_receive(:puts).with("  git add .")
       $stdout.should_receive(:puts).with('  git commit -m "Application added to Shelly Cloud"')
       $stdout.should_receive(:puts).with("  git push")
-      $stdout.should_receive(:puts).with("\e[32mDeploy to staging using:\e[0m")
-      $stdout.should_receive(:puts).with("  git push staging master")
-      fake_stdin(["staging", "foooo", "none"]) do
+      $stdout.should_receive(:puts).with("\e[32mDeploy to production using:\e[0m")
+      $stdout.should_receive(:puts).with("  git push production master")
+      fake_stdin(["foooo", "none"]) do
         @main.add
       end
     end

data/spec/shelly/cli/users_spec.rb

@@ -12,17 +12,25 @@ describe Shelly::CLI::Users do
     $stdout.stub(:print)
   end
 
+  describe "#help" do
+    it "should show help" do
+      $stdout.should_receive(:puts).with("Tasks:")
+      $stdout.should_receive(:puts).with(/add \[EMAIL\]\s+# Add new developer to applications defined in Cloudfile/)
+      $stdout.should_receive(:puts).with(/list\s+# List users who have access to current application/)
+      @users.help
+    end
+  end
+
   describe "#list" do
     before do
       FileUtils.mkdir_p("/projects/foo")
       Dir.chdir("/projects/foo")
       File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
-      @app = mock
-      Shelly::App.stub(:new).and_return(@app)
       Shelly::App.stub(:inside_git_repository?).and_return(true)
     end
 
     it "should exit with message if command run outside git repository" do
+      @client.stub(:app_users).and_return(response)
       Shelly::App.stub(:inside_git_repository?).and_return(false)
       $stdout.should_receive(:puts).with("\e[31mMust be run inside your project git repository\e[0m")
       lambda {
@@ -32,35 +40,79 @@ describe Shelly::CLI::Users do
 
     context "on success" do
       it "should receive clouds from the Cloudfile" do
-        @app.should_receive(:users).with(["foo-production","foo-staging"]).
+        @client.should_receive(:app_users).with(["foo-production", "foo-staging"]).
           and_return(response)
         @users.list
       end
 
       it "should display clouds and users" do
-        @app.stub(:users).and_return(response)
+        @client.stub(:app_users).and_return(response)
         $stdout.should_receive(:puts).with("Cloud foo-staging:")
         $stdout.should_receive(:puts).with("  user@example.com (username)")
         $stdout.should_receive(:puts).with("Cloud foo-production:")
         $stdout.should_receive(:puts).with("  user2@example.com (username2)")
         @users.list
       end
+    end
 
-      def response
-        [{'code_name' => 'foo-staging','users' => [{'name' => 'username','email' => 'user@example.com'}]},
-         {'code_name' => 'foo-production','users' => [{'name' => 'username2','email' => 'user2@example.com'}]}]
-      end
+    def response
+      [{'code_name' => 'foo-staging','users' => [{'name' => 'username','email' => 'user@example.com'}]},
+       {'code_name' => 'foo-production','users' => [{'name' => 'username2','email' => 'user2@example.com'}]}]
     end
 
     context "on failure" do
-      it "should raise an error if user does not have to any app" do
+      it "should raise an error if user does not have access to any app" do
         response = {"message" => "You do not have access to this app"}
         exception = Shelly::Client::APIError.new(response.to_json)
-        @app.stub(:users).and_raise(exception)
+        @client.stub(:app_users).and_raise(exception)
         $stdout.should_receive(:puts).with("You do not have access to this app")
         lambda { @users.list }.should raise_error(SystemExit)
       end
     end
   end
+
+  describe "#add" do
+    before do
+      FileUtils.mkdir_p("/projects/foo")
+      Dir.chdir("/projects/foo")
+      File.open("Cloudfile", 'w') {|f| f.write("foo-staging:\nfoo-production:\n") }
+      Shelly::App.stub(:inside_git_repository?).and_return(true)
+      @client.stub(:token).and_return("abc")
+      @user = Shelly::User.new
+      @client.stub(:apps).and_return([{"code_name" => "abc"}, {"code_name" => "fooo"}])
+      Shelly::User.stub(:new).and_return(@user)
+    end
+
+    it "should exit with message if command run outside git repository" do
+      Shelly::App.stub(:inside_git_repository?).and_return(false)
+      $stdout.should_receive(:puts).with("\e[31mMust be run inside your project git repository\e[0m")
+      lambda {
+        @users.add
+      }.should raise_error(SystemExit)
+    end
+
+    context "on success" do
+      before do
+        @client.should_receive(:send_invitation).with(["foo-production", "foo-staging"], "megan@example.com")
+      end
+
+      it "should ask about email" do
+        fake_stdin(["megan@example.com"]) do
+          @users.add
+        end
+      end
+
+      it "should receive clouds from the Cloudfile" do
+        @users.add("megan@example.com")
+      end
+
+      it "should receive clouds from the Cloudfile" do
+        $stdout.should_receive(:puts).with("Sending invitation to megan@example.com")
+        @users.add("megan@example.com")
+      end
+    end
+
+  end
+
 end
 

data/spec/shelly/client_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe Shelly::Client::APIError do
   before do
-    body = {"message" => "something went wrong", "errors" => [{"first" => "foo"}]}
+    body = {"message" => "something went wrong", "errors" => [["first", "foo"]], "url" => "https://foo.bar"}
     @error = Shelly::Client::APIError.new(body.to_json)
   end
 
@@ -10,8 +10,16 @@ describe Shelly::Client::APIError do
     @error.message.should == "something went wrong"
   end
 
-  it "should return list of errors" do
-    @error.errors.should == [{"first" => "foo"}]
+  it "should return array of errors" do
+    @error.errors.should == [["first", "foo"]]
+  end
+
+  it "should return url" do
+    @error.url.should == "https://foo.bar"
+  end
+
+  it "should return user friendly string" do
+    @error.each_error{|error| error.should == "First foo"}
   end
 
   describe "#validation?" do
@@ -29,6 +37,22 @@ describe Shelly::Client::APIError do
       end
     end
   end
+
+  describe "#unauthorized?" do
+    context "when error is caused by unauthorized error" do
+      it "should return true" do
+        body = {"message" => "Unauthorized"}
+        error = Shelly::Client::APIError.new(body.to_json)
+        error.should be_unauthorized
+      end
+    end
+
+    context "when error is not caused by unauthorized" do
+      it "should return false" do
+        @error.should_not be_unauthorized
+      end
+    end
+  end
 end
 
 describe Shelly::Client do
@@ -93,6 +117,15 @@ describe Shelly::Client do
     end
   end
 
+  describe "#send_invitation" do
+    it "should send post with developer's email" do
+      FakeWeb.register_uri(:post, @url + "/apps/staging-foo/collaborations", :body => {}.to_json)
+      FakeWeb.register_uri(:post, @url + "/apps/production-foo/collaborations", :body => {}.to_json)
+      response = @client.send_invitation(["staging-foo", "production-foo"], "megan@example.com")
+      response.should == [{}, {}]
+    end
+  end
+
   describe "#update_ssh_key" do
     it "should send put with give SSH key" do
       @client.should_receive(:put).with("/ssh_key", {:ssh_key => "abc"})
@@ -169,7 +202,7 @@ describe Shelly::Client do
       @client.get('/account')
     end
 
-    %w(404 422 500).each do |code|
+    %w(401, 404 422 500).each do |code|
       context "on #{code} response code" do
         it "should raise APIError" do
           @response.stub(:code).and_return(code.to_i)

data/spec/shelly/cloudfile_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "shelly/cloudfile"
+
+describe Shelly::Cloudfile do
+  before do
+    FileUtils.mkdir_p("/projects/foo")
+    Dir.chdir("/projects/foo")
+    @hash = {:code_name => {:code => "test"}}
+    @client = mock
+    Shelly::Client.stub(:new).and_return(@client)
+    @cloudfile = Shelly::Cloudfile.new
+  end
+
+  describe "#hash converting" do
+    it "should convert hash to proper string" do
+      @cloudfile.yaml(@hash).should == "code_name:\n  code: test"
+    end
+
+    it "should conver a hash to yaml format" do
+      @cloudfile.write(@hash)
+      @cloudfile.open.should == {"code_name" => {"code" => "test"}}
+    end
+  end
+
+  describe "#fetch_users" do
+    it "should return array to display with clouds and users" do
+      @cloudfile.write(@hash)
+      @client.should_receive(:app_users).and_return(response)
+      response = @cloudfile.fetch_users
+      response.should == {"foo-staging" => ["user@example.com (username)"]}
+    end
+
+    def response
+      [{'code_name' => 'foo-staging','users' => [{'name' => 'username','email' => 'user@example.com'}]}]
+    end
+  end
+
+end

data/spec/shelly/user_spec.rb

@@ -92,6 +92,13 @@ describe Shelly::User do
     end
   end
 
+  describe "#send_invitation" do
+    it "should send invitation" do
+      @client.should_receive(:send_invitation).with(["foo-staging"], "megan@example.com")
+      @user.send_invitation(["foo-staging"], "megan@example.com")
+    end
+  end
+
   describe "#ssh_key_path" do
     it "should return path to public ssh key file" do
       @user.ssh_key_path.should == File.expand_path("~/.ssh/id_rsa.pub")
@@ -105,7 +112,7 @@ describe Shelly::User do
       @user.should_not be_ssh_key_exists
     end
   end
-  
+
   describe "#ssh_key_registered?" do
     it "should read and check if ssh key exists in database" do
       @client.should_receive(:ssh_key_available?).with('ssh-key AAbbcc')
@@ -155,3 +162,4 @@ describe Shelly::User do
     end
   end
 end
+

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shelly
 version: !ruby/object:Gem::Version
-  version: 0.0.16
+  version: 0.0.17
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-25 00:00:00.000000000Z
+date: 2011-11-03 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &2153427120 !ruby/object:Gem::Requirement
+  requirement: &2156677640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153427120
+  version_requirements: *2156677640
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &2153426700 !ruby/object:Gem::Requirement
+  requirement: &2156677220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153426700
+  version_requirements: *2156677220
 - !ruby/object:Gem::Dependency
   name: guard
-  requirement: &2153426280 !ruby/object:Gem::Requirement
+  requirement: &2156676800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153426280
+  version_requirements: *2156676800
 - !ruby/object:Gem::Dependency
   name: guard-rspec
-  requirement: &2153425840 !ruby/object:Gem::Requirement
+  requirement: &2156676380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,10 +54,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153425840
+  version_requirements: *2156676380
 - !ruby/object:Gem::Dependency
   name: growl_notify
-  requirement: &2153425360 !ruby/object:Gem::Requirement
+  requirement: &2156675920 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153425360
+  version_requirements: *2156675920
 - !ruby/object:Gem::Dependency
   name: rb-fsevent
-  requirement: &2153424920 !ruby/object:Gem::Requirement
+  requirement: &2156675500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -76,10 +76,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153424920
+  version_requirements: *2156675500
 - !ruby/object:Gem::Dependency
   name: fakefs
-  requirement: &2153424500 !ruby/object:Gem::Requirement
+  requirement: &2156675080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -87,10 +87,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153424500
+  version_requirements: *2156675080
 - !ruby/object:Gem::Dependency
   name: fakeweb
-  requirement: &2153424080 !ruby/object:Gem::Requirement
+  requirement: &2156674660 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -98,10 +98,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2153424080
+  version_requirements: *2156674660
 - !ruby/object:Gem::Dependency
   name: thor
-  requirement: &2153423660 !ruby/object:Gem::Requirement
+  requirement: &2156674240 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -109,10 +109,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153423660
+  version_requirements: *2156674240
 - !ruby/object:Gem::Dependency
   name: rest-client
-  requirement: &2153423240 !ruby/object:Gem::Requirement
+  requirement: &2156673780 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -120,10 +120,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153423240
+  version_requirements: *2156673780
 - !ruby/object:Gem::Dependency
   name: json
-  requirement: &2153422820 !ruby/object:Gem::Requirement
+  requirement: &2156673340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -131,10 +131,10 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153422820
+  version_requirements: *2156673340
 - !ruby/object:Gem::Dependency
   name: launchy
-  requirement: &2153422400 !ruby/object:Gem::Requirement
+  requirement: &2156672840 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -142,7 +142,7 @@ dependencies:
         version: '0'
   type: :runtime
   prerelease: false
-  version_requirements: *2153422400
+  version_requirements: *2156672840
 description: Tool for managing applications and clouds at shellycloud.com
 email:
 - support@shellycloud.com
@@ -158,6 +158,7 @@ files:
 - README.md
 - Rakefile
 - bin/shelly
+- lib/core_ext/hash.rb
 - lib/core_ext/object.rb
 - lib/shelly.rb
 - lib/shelly/app.rb
@@ -165,10 +166,12 @@ files:
 - lib/shelly/cli/main.rb
 - lib/shelly/cli/users.rb
 - lib/shelly/client.rb
+- lib/shelly/cloudfile.rb
 - lib/shelly/helpers.rb
 - lib/shelly/templates/Cloudfile.erb
 - lib/shelly/user.rb
 - lib/shelly/version.rb
+- lib/thor/options.rb
 - shelly.gemspec
 - spec/helpers.rb
 - spec/input_faker.rb
@@ -177,6 +180,7 @@ files:
 - spec/shelly/cli/main_spec.rb
 - spec/shelly/cli/users_spec.rb
 - spec/shelly/client_spec.rb
+- spec/shelly/cloudfile_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb
 homepage: http://shellycloud.com
@@ -211,5 +215,6 @@ test_files:
 - spec/shelly/cli/main_spec.rb
 - spec/shelly/cli/users_spec.rb
 - spec/shelly/client_spec.rb
+- spec/shelly/cloudfile_spec.rb
 - spec/shelly/user_spec.rb
 - spec/spec_helper.rb