shelly 0.1.13 → 0.1.14

data/lib/shelly/cli/main.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "shelly/cli/command"
 require "shelly/cli/user"
 require "shelly/cli/backup"
@@ -81,6 +82,7 @@ module Shelly
       desc "add", "Add a new cloud"
       def add
         check_options(options)
+        return unless check(verbose = false)
         app = Shelly::App.new
         app.code_name = options["code-name"] || ask_for_code_name
         app.databases = options["databases"] || ask_for_databases
@@ -345,14 +347,59 @@ We have been notified about it. We will be adding new resources shortly}
         say_error "Cloud #{app} is not running. Cannot run console."
       end
 
-      desc "check", "List all requirements and check which are fulfilled"
-      def check
-        s = Shelly::StructureValidator.new
-        say "Checking dependencies:", :green
-        print_check s.gemfile_exists?, "Gemfile exists"
-        print_check s.gems.include?("thin"), "gem 'thin' present in Gemfile"
-        print_check s.config_ru_exists?, "config.ru exists"
-        print_check false, "application runs mysql (not supported on Shelly Cloud)" if s.gems.include?("mysql2") or s.gems.include?("mysql")
+      desc "check", "Check if application fulfills Shelly Cloud requirements"
+      # Public: Check if application fulfills shelly's requirements
+      #         and print them
+      # verbose - when true all requirements will be printed out
+      #           together with header and a summary at the end
+      #           when false only not fulfilled requirements will be
+      #           printed
+      # When any requirements is not fulfilled header and summary will
+      # be displayed regardless of verbose value
+      def check(verbose = true)
+        structure = Shelly::StructureValidator.new
+
+        if verbose or structure.invalid? or structure.warnings?
+          say "Checking Shelly Cloud requirements\n\n"
+        end
+
+        print_check(structure.gemfile?, "Gemfile is present",
+          "Gemfile is missing in git repository",
+          :show_fulfilled => verbose)
+
+        print_check(structure.gemfile_lock?, "Gemfile.lock is present",
+          "Gemfile.lock is missing in git repository",
+          :show_fulfilled => verbose)
+
+        print_check(structure.gem?("shelly-dependencies"),
+          "Gem 'shelly-dependencies' is present",
+          "Gem 'shelly-dependencies' is missing, we recommend to install it\n    See more at https://shellycloud.com/documentation/requirements#shelly-dependencies",
+          :show_fulfilled => verbose || structure.warnings?, :failure_level => :warning)
+
+        print_check(structure.gem?("thin"), "Gem 'thin' is present",
+          "Gem 'thin' is missing in the Gemfile", :show_fulfilled => verbose)
+
+        print_check(structure.gem?("rake"), "Gem 'rake' is present",
+          "Gem 'rake' is missing in the Gemfile", :show_fulfilled => verbose)
+
+        print_check(structure.config_ru?, "File config.ru is present",
+          "File config.ru is missing",
+          :show_fulfilled => verbose)
+
+        print_check(!structure.gem?("mysql") && !structure.gem?("mysql2"),"",
+          "mysql driver present in the Gemfile (not supported on Shelly Cloud)",
+          :show_fulfilled => false)
+
+        if structure.valid?
+          if verbose
+            say "\nGreat! Your application is ready to run on Shelly Cloud"
+          end
+        else
+          say "\nFix points marked with #{red("✗")} to run your application on the Shelly Cloud"
+          say "See more about requirements on https://shellycloud.com/documentation/requirements"
+        end
+
+        structure.valid?
       rescue Bundler::BundlerError => e
         say_new_line
         say_error e.message, :with_exit => false

data/lib/shelly/helpers.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module Shelly
   module Helpers
     def echo_disabled
@@ -129,8 +130,19 @@ module Shelly
       "\e[31m#{string}\e[0m"
     end
 
-    def print_check(checked, string, options = {})
-      print_wrapped (checked ? green("+") : red("-")) + " #{string}", :ident => 2
+    def yellow(string)
+      "\e[0;33m#{string}\e[0m"
+    end
+
+    def print_check(check, success_message, failure_message, options = {})
+      return if check && !options[:show_fulfilled]
+      message = check ? success_message : failure_message
+      indicator = if check
+                    green("✓")
+                  else
+                    options[:failure_level] == :warning ? yellow("ϟ") : red("✗")
+                  end
+      say "  #{indicator} #{message}"
     end
   end
 end

data/lib/shelly/structure_validator.rb

@@ -3,26 +3,58 @@ require 'bundler'
 
 module Shelly
   class StructureValidator
-    attr_reader :gemfile_path, :gemfile_lock_path
+    def initialize
+      @gemfile_path = "Gemfile"
+      @gemfile_lock_path = "Gemfile.lock"
+    end
+
+    def gemfile?
+      repo_paths.include?(@gemfile_path)
+    end
+
+    def gemfile_lock?
+      repo_paths.include?(@gemfile_lock_path)
+    end
+
+    def config_ru?
+      repo_paths.include?("config.ru")
+    end
+
+    def gem?(name)
+      gems.include?(name)
+    end
 
-    def initialize(options = {})
-      @gemfile_path = options[:gemfile] || "Gemfile"
-      @gemfile_lock_path = options[:gemfile_lock] || "Gemfile.lock"
+    # Public: Check all requirements that app has to fulfill
+    def valid?
+      gemfile? && gemfile_lock? && gem?("thin") &&
+        gem?("rake") && config_ru?
     end
 
-    def gemfile_exists?
-      File.exists?(@gemfile_path)
+    def invalid?
+      !valid?
     end
 
-    def config_ru_exists?
-      repo = Grit::Repo.new(".")
-      repo.status.map(&:path).include?("config.ru")
+    # Public: Check if there are any warnings regarding app
+    # structure, these warning don't prevent from deploying
+    # to shelly
+    def warnings?
+      !gem?("shelly-dependencies")
     end
 
+    private
+
     def gems
-      return [] unless gemfile_exists?
-      @d = Bundler::Definition.build(@gemfile_path, @gemfile_lock_path, nil)
-      @gems = @d.specs.map(&:name)
+      return [] unless gemfile? or gemfile_lock?
+      definition = Bundler::Definition.build(@gemfile_path,
+        @gemfile_lock_path, nil)
+      @gems ||= definition.specs.map(&:name)
+    end
+
+    def repo_paths
+      @repo_paths ||= begin
+        repo = Grit::Repo.new(".")
+        repo.status.map(&:path)
+      end
     end
   end
 end

data/lib/shelly/version.rb

@@ -1,3 +1,3 @@
 module Shelly
-  VERSION = "0.1.13"
+  VERSION = "0.1.14"
 end

data/spec/helpers.rb

@@ -16,6 +16,10 @@ module RSpec
       "\e[31m#{string}\e[0m"
     end
 
+    def yellow(string)
+      "\e[0;33m#{string}\e[0m"
+    end
+
     def hooks(model, method)
       model.class.hooks.inject([]) do |result, v|
         result << v[0] if v[1][:only].include?(method)

data/spec/shelly/cli/main_spec.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 require "spec_helper"
 require "shelly/cli/main"
 require "grit"
@@ -27,7 +28,7 @@ describe Shelly::CLI::Main do
 Tasks:
   shelly add                # Add a new cloud
   shelly backup <command>   # Manage database backups
-  shelly check              # List all requirements and check which are fulfilled
+  shelly check              # Check if application fulfills Shelly Cloud requirements
   shelly config <command>   # Manage application configuration files
   shelly console            # Open application console
   shelly delete             # Delete the cloud
@@ -287,6 +288,7 @@ OUT
       @client.stub(:token).and_return("abc")
       @app.stub(:attributes).and_return({"trial" => false})
       @app.stub(:git_remote_exist?).and_return(false)
+      @main.stub(:check => true)
     end
 
     # This spec tests inside_git_repository? hook
@@ -497,6 +499,24 @@ OUT
         invoke(@main, :add)
       end
     end
+
+    it "should check shelly requirements" do
+      $stdout.should_receive(:puts) \
+        .with("\e[32mWhen you make sure all settings are correct please issue following commands:\e[0m")
+      @main.should_receive(:check).with(false).and_return(true)
+      fake_stdin(["foooo", "none"]) do
+        invoke(@main, :add)
+      end
+    end
+
+    it "should abort when shelly requirements are not met" do
+      $stdout.should_not_receive(:puts) \
+        .with("\e[32mWhen you make sure all settings are correct please issue following commands:\e[0m")
+      @main.should_receive(:check).with(false).and_return(false)
+      fake_stdin(["foooo", "none"]) do
+        invoke(@main, :add)
+      end
+    end
   end
 
   describe "#list" do
@@ -1268,9 +1288,10 @@ We have been notified about it. We will be adding new resources shortly")
   describe "#check" do
     before do
       Shelly::App.stub(:inside_git_repository?).and_return(true)
-      Bundler::Definition.stub_chain(:build, :specs, :map).and_return(["thin"])
-      Grit::Repo.stub_chain(:new, :status, :map).and_return(["config.ru"])
-      File.open("Gemfile", 'w')
+      Bundler::Definition.stub_chain(:build, :specs, :map) \
+        .and_return(["thin"])
+      Grit::Repo.stub_chain(:new, :status, :map) \
+        .and_return(["config.ru", "Gemfile", "Gemfile.lock"])
     end
 
     it "should ensure user is in git repository" do
@@ -1279,37 +1300,52 @@ We have been notified about it. We will be adding new resources shortly")
 
     context "when gemfile exists" do
       it "should show that Gemfile exists" do
-        $stdout.should_receive(:puts).with("  #{green("+")} Gemfile exists")
+        $stdout.should_receive(:puts).with("  #{green("✓")} Gemfile is present")
+        invoke(@main, :check)
+      end
+    end
+
+    context "when gemfile doesn't exist" do
+      it "should show that Gemfile doesn't exist" do
+        Grit::Repo.stub_chain(:new, :status, :map).and_return([])
+        $stdout.should_receive(:puts).with("  #{red("✗")} Gemfile is missing in git repository")
+        invoke(@main, :check)
+      end
+    end
+
+    context "when gemfile exists" do
+      it "should show that Gemfile exists" do
+        $stdout.should_receive(:puts).with("  #{green("✓")} Gemfile is present")
         invoke(@main, :check)
       end
     end
 
     context "when gemfile doesn't exist" do
       it "should show that Gemfile doesn't exist" do
-        File.delete("Gemfile")
-        $stdout.should_receive(:puts).with("  #{red("-")} Gemfile exists")
+        Grit::Repo.stub_chain(:new, :status, :map).and_return([])
+        $stdout.should_receive(:puts).with("  #{red("✗")} Gemfile is missing in git repository")
         invoke(@main, :check)
       end
     end
 
     context "when thin gem exists" do
       it "should show that necessary gem exists" do
-        $stdout.should_receive(:puts).with("  #{green("+")} gem 'thin' present in Gemfile")
+        $stdout.should_receive(:puts).with("  #{green("✓")} Gem 'thin' is present")
         invoke(@main, :check)
       end
     end
 
     context "when thin gem doesn't exist" do
-      it "should show that necessary gem dosn't exist" do
+      it "should show that necessary gem doesn't exist" do
         Bundler::Definition.stub_chain(:build, :specs, :map).and_return([])
-        $stdout.should_receive(:puts).with("  #{red("-")} gem 'thin' present in Gemfile")
+        $stdout.should_receive(:puts).with("  #{red("✗")} Gem 'thin' is missing in the Gemfile")
         invoke(@main, :check)
       end
     end
 
     context "when config.ru exists" do
       it "should show that config.ru exists" do
-        $stdout.should_receive(:puts).with("  #{green("+")} config.ru exists")
+        $stdout.should_receive(:puts).with("  #{green("✓")} File config.ru is present")
         invoke(@main, :check)
       end
     end
@@ -1317,7 +1353,7 @@ We have been notified about it. We will be adding new resources shortly")
     context "when config.ru doesn't exist" do
       it "should show that config.ru is neccessary" do
         Grit::Repo.stub_chain(:new, :status, :map).and_return([])
-        $stdout.should_receive(:puts).with("  #{red("-")} config.ru exists")
+        $stdout.should_receive(:puts).with("  #{red("✗")} File config.ru is missing")
         invoke(@main, :check)
       end
     end
@@ -1325,13 +1361,13 @@ We have been notified about it. We will be adding new resources shortly")
     context "when mysql gem exists" do
       it "should show that mysql gem is not supported by Shelly Cloud" do
         Bundler::Definition.stub_chain(:build, :specs, :map).and_return(["mysql"])
-        $stdout.should_receive(:puts).with("  #{red("-")} application runs mysql (not supported on Shelly Cloud)")
+        $stdout.should_receive(:puts).with("  #{red("✗")} mysql driver present in the Gemfile (not supported on Shelly Cloud)")
         invoke(@main, :check)
       end
 
       it "should show that mysql2 gem is not supported by Shelly Cloud" do
         Bundler::Definition.stub_chain(:build, :specs, :map).and_return(["mysql2"])
-        $stdout.should_receive(:puts).with("  #{red("-")} application runs mysql (not supported on Shelly Cloud)")
+        $stdout.should_receive(:puts).with("  #{red("✗")} mysql driver present in the Gemfile (not supported on Shelly Cloud)")
         invoke(@main, :check)
       end
     end
@@ -1347,5 +1383,14 @@ We have been notified about it. We will be adding new resources shortly")
         }.should raise_error(SystemExit)
       end
     end
+
+    it "should display only errors and warnings when in verbose mode" do
+      $stdout.should_not_receive(:puts).with("  #{green("✓")} Gem 'thin' is present")
+      $stdout.should_receive(:puts).with("  #{yellow("ϟ")} Gem 'shelly-dependencies' is missing, we recommend to install it\n    See more at https://shellycloud.com/documentation/requirements#shelly-dependencies")
+      $stdout.should_receive(:puts).with("  #{red("✗")} Gem 'rake' is missing in the Gemfile")
+      $stdout.should_receive(:puts).with("\nFix points marked with #{red("✗")} to run your application on the Shelly Cloud")
+      $stdout.should_receive(:puts).with("See more about requirements on https://shellycloud.com/documentation/requirements")
+      @main.check(false)
+    end
   end
 end

data/spec/shelly/structure_validator_spec.rb

@@ -2,71 +2,77 @@ require "spec_helper"
 
 describe Shelly::StructureValidator do
   before do
-    File.open("Gemfile", 'w')
-    File.open("config.ru", 'w')
     @validator = Shelly::StructureValidator.new
+    Grit::Repo.stub_chain(:new, :status).and_return([
+      mock(:path => "Gemfile"), mock(:path => "Gemfile.lock")
+    ])
   end
 
-  it "should return Gemfile path" do
-    @validator.gemfile_path.should == "Gemfile"
-  end
+  describe "#gemfile?" do
+    context "when Gemfile exists" do
+      it "should return true" do
+        @validator.gemfile?.should == true
+      end
+    end
 
-  it "should return Gemfile.lock path" do
-    @validator.gemfile_lock_path.should == "Gemfile.lock"
+    context "when Gemfile doesn't exist" do
+      it "should return false" do
+        Grit::Repo.stub_chain(:new, :status) \
+          .and_return([mock(:path => "Gemfile.lock")])
+        @validator.gemfile?.should == false
+      end
+    end
   end
 
-  describe "#gemfile_exists?" do
-    context "when Gemfile exists" do
+  describe "#gemfile_lock?" do
+    context "when Gemfile.lock exists" do
       it "should return true" do
-        @validator.gemfile_exists?.should == true
+        @validator.gemfile_lock?.should == true
       end
     end
 
-    context "when Gemfile doesn't exist" do
+    context "when Gemfile.lock doesn't exist" do
       it "should return false" do
-        File.delete("Gemfile")
-        @validator.gemfile_exists?.should == false
+        Grit::Repo.stub_chain(:new, :status) \
+          .and_return([mock(:path => "Gemfile")])
+        @validator.gemfile_lock?.should == false
       end
     end
   end
 
-  describe "#config_ru_exists?" do
+  describe "#config_ru?" do
     before do
-      @config_ru = mock(:path => "config.ru")
-      Grit::Repo.stub_chain(:new, :status).and_return([@config_ru])
+      Grit::Repo.stub_chain(:new, :status) \
+        .and_return([mock(:path => "config.ru")])
     end
 
     context "when config.ru exists" do
       it "should return true" do
-        @validator.config_ru_exists?.should == true
+        @validator.config_ru?.should == true
       end
     end
 
     context "when config.ru doesn't exist" do
       it "should return false" do
         Grit::Repo.stub_chain(:new, :status).and_return([])
-        @validator.config_ru_exists?.should == false
+        @validator.config_ru?.should == false
       end
     end
   end
 
-  describe "#gems" do
+  describe "#gem?" do
     before do
-      @thin = mock(:name => "thin")
-      @mysql = mock(:name => "mysql")
+      @validator.stub(:gemfile? => true, :gemfile_lock? => true)
+      Bundler::Definition.stub_chain(:build, :specs).and_return(
+        [mock(:name => "thin"), mock(:name => "mysql")])
     end
 
-    it "should return list of used gems" do
-      Bundler::Definition.stub_chain(:build, :specs).and_return([@thin, @mysql])
-      Bundler::Definition.should_receive(:build).with("Gemfile", "Gemfile.lock", nil)
-      @validator.gems.should == ["thin", "mysql"]
+    it "should return true if gem is present" do
+      @validator.gem?("thin").should be_true
     end
 
-    context "when gemfile doesn't exist" do
-      it "should return empty array" do
-        File.delete("Gemfile")
-        @validator.gems.should == []
-      end
+    it "should return false if gem is missing" do
+      @validator.gem?("rake").should be_false
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: shelly
 version: !ruby/object:Gem::Version
-  version: 0.1.13
+  version: 0.1.14
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-22 00:00:00.000000000 Z
+date: 2012-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec