chekku 0.0.5 → 0.1.0

data/README.md

@@ -54,6 +54,14 @@ imagemagick:
   executable: 'convert'
 ```
 
+## Use Definition object in your code
+
+Example on how to check a software dependency
+
+```
+definition = Chekku::Definition.new(name: 'mysql', executable: 'mysqld')
+definition.chekku('>= 5.0')
+```
 
 ## Future
 

data/chekku.gemspec

@@ -14,6 +14,7 @@ Gem::Specification.new do |gem|
   gem.required_ruby_version     = '>= 1.9'
   gem.required_rubygems_version = '>= 1.3.6'
   gem.add_development_dependency 'rspec', '>= 2.0'
+  gem.add_development_dependency 'simplecov'
   gem.add_dependency 'thor'
   gem.add_dependency 'rake'
   gem.files         = `git ls-files`.split($/)

data/lib/chekku.rb

@@ -4,6 +4,8 @@ require 'thor/group'
 require 'chekku/errors'
 
 module Chekku
+  # Launch the whole process of software dependencies checking
+  #
   class Command
     if ARGV.first ==  'version'
       puts Chekku::VERSION

data/lib/chekku/checker.rb

@@ -10,6 +10,7 @@ class Chekku::Checker < Thor
 
   method_option :chekkufile, type: :string, desc: 'Chekkufile Path', default: 'Chekkufile'
 
+  # Checks the software dependencies based on the chekku files
   def checks
     @chekkufile = options[:chekkufile]
     verify_chekku_file_existence

data/lib/chekku/definition.rb

@@ -1,85 +1,148 @@
 #encoding: utf-8
-class Chekku::Definition
+require_relative 'errors'
 
-  attr_accessor :name, :executable, :version_checker, :errors
+# This Definition object has attributes for checking
+# if the software is installed and respect conditions
+#
+# You can use this class in your code to easily embed software checks
+#
+# @example Check a software Dependency
+#   definition = Chekku::Definition.new(name: 'mysql', executable: 'mysqld')
+#   definition.chekku('>= 5.0', must_run: true)
+#
+# @attr [String] name the Definition name used in the Chekkufile and def.yml file
+# @attr [String] executable the actual software dependency executable name
+module Chekku
+  class Definition
 
-  def self.load(definitions_hash = {})
-    [].tap do |definitions|
-      definitions_hash.each_pair do |name, hash_definition|
-        definitions << self.new(hash_definition.merge(name: name))
+    attr_accessor :name, :executable
+
+    # Convert a formatted hash to an array of definitions
+    #
+    # @param [Hash] definitions_hash a valid hash of definitions
+    # @return [Array] an Array of Definition
+    def self.load(definitions_hash = {})
+      [].tap do |definitions|
+        definitions_hash.each_pair do |name, hash_definition|
+          definitions << self.new(hash_definition.merge(name: name))
+        end
       end
     end
-  end
 
-  def initialize(attributes = {})
-    attributes.each do |name, value|
-      send("#{name}=", value)
+    def initialize(attributes = {})
+      attributes.each do |name, value|
+        send("#{name}=", value)
+      end
     end
-    @errors = {}
-  end
 
-  def chekku(version = nil, args = {})
-    raise(DefinitionValidationError, "not installed") unless exists?
-    validates version, args
-    "[\033[32m✓\033[0m] #{name}"
-  end
+    # Check if version and other params are valid for current Definition instance and raise errors
+    #
+    # @param [String] version Version to check in the format '>= 4.0' accepts '~> 3.0'
+    # @param [Hash] args Possible checks that must be verified for current Definition
+    # @option args [Boolean] must_run Check if the software is running on the host
+    # @return [Boolean] true if valid, if not valid errors are raised
+    # @raise [DefinitionValidationError] An exception if the params requirements are not met
+    # @raise [AppNameNotStringError] if Definition is not correct and executable isn't a string
+    # @raise [AppNameNotSaneError] if Definition executable isn't safe (spaces, special chars and so on)
+    def chekku!(version = nil, args = {})
+      raise(DefinitionValidationError, "not installed") unless exists?
+      validates version, args
+    end
 
-  def exists?
-    verify_executable! && found?
-  end
+    # Check if version and other params are valid for current Definition instance and return false if errors
+    # @param (see #chekku!)
+    # @return [Boolean] version and args are valid => true else false
+    def chekku(version = nil, args = {})
+      chekku!(version, args)
+    rescue
+      false
+    end
 
-  def verify_executable!
-    raise(AppNameNotStringError, 'You need to use strings for app names') unless executable.is_a?(String)
-    raise(AppNameNotSaneError, "Sorry the app name '#{name}' is not sane") unless sane_executable?
-    true
-  end
+    # Verify existence of dependency
+    #
+    # @return [Boolean] corresponding to the existence
+    def exists?
+      verify_executable! && found?
+    end
 
-  def found?
-    system "which #{executable} > /dev/null 2>&1"
-  end
+    # Validates the params provided are the one of the local dependency
+    #
+    # @param (see #chekku)
+    # @return [Boolean] valid?
+    def validates(version = nil, args = {})
+      raise(DefinitionValidationError, "wrong version: wanted #{version}, got #{installed_version}") unless ( !version || check_version(version))
+      raise(DefinitionValidationError, "installed but not running (must_run: true)") unless (!args[:must_run] || is_running?)
+      true
+    end
 
-  def sane_executable?
-    executable == sanitized_executable
-  end
+    # Verify if the executable of the Definition is sane and correct
+    #
+    # @return [Boolean] valid?
+    def verify_executable!
+      raise(AppNameNotStringError, 'You need to use strings for app names') unless executable.is_a?(String)
+      raise(AppNameNotSaneError, "Sorry the app name '#{name}' is not sane") unless sane_executable?
+      true
+    end
 
-  def sanitized_executable
-    executable.gsub /&|"|'|;|\s/, ""
-  end
+    # Actual method which verifies if defined software is present
+    #
+    # @return [Boolean] found?
+    def found?
+      system "which #{executable} > /dev/null 2>&1"
+    end
 
-  def validates(version = nil, args = {})
-    raise(DefinitionValidationError, "wrong version: wanted #{version}, got #{installed_version}") unless ( !version || check_version(version))
-    raise(DefinitionValidationError, "installed but not running (must_run: true)") unless (!args[:must_run] || is_running?)
-    true
-  end
+    # Verify that the executable is harmless for the machine
+    #
+    # @return [Boolean] sane?
+    def sane_executable?
+      executable == sanitized_executable
+    end
 
-  def is_running?
-    ps_result = `ps aux | grep #{executable}`
-    ps_result_array = ps_result.split("\n")
-    ps_result_array.any? do |ps_line|
-      ps_line.include?(executable) && (executable == 'grep' || !ps_line.include?('grep'))
+    # Get the sanitized name of the executable
+    #
+    # @return [String] sane executable
+    def sanitized_executable
+      executable.gsub /&|"|'|;|\s/, ""
     end
-  end
 
-  def check_version(version)
-    operator, version = version.split(' ')
-    if version.nil?
-      version = operator
-      operator = '=='
+    # Verify that current executable is running or not on host
+    #
+    # @return [Boolean] running?
+    def is_running?
+      ps_result = `ps aux | grep #{executable}`
+      ps_result_array = ps_result.split("\n")
+      ps_result_array.any? do |ps_line|
+        ps_line.include?(executable) && (executable == 'grep' || !ps_line.include?('grep'))
+      end
     end
-    if operator == '~>'
-      installed_version >= Gem::Version.new(version) && installed_version <= Gem::Version.new(version).bump
-    else
-      installed_version.send(operator, Gem::Version.new(version))
+
+    # Verify version
+    #
+    # @param [String] version current version wanted
+    # @return [Boolean] good_version?
+    def check_version(version)
+      operator, version = version.split(' ')
+      if version.nil?
+        version = operator
+        operator = '=='
+      end
+      if operator == '~>'
+        installed_version >= Gem::Version.new(version) && installed_version <= Gem::Version.new(version).bump
+      else
+        installed_version.send(operator, Gem::Version.new(version))
+      end
     end
-  end
 
-  def installed_version
-    version_matches = `#{executable} --version`.scan(/(\d+[\.\d+]*)/).flatten
-    max_dot_number_version = ''
-    version_matches.each do |version|
-      max_dot_number_version = version if version.count('.') > max_dot_number_version.count('.')
+    # Get the current installed version on the host
+    #
+    # @return [String] string representation of version
+    def installed_version
+      version_matches = `#{executable} --version`.scan(/(\d+[\.\d+]*)/).flatten
+      max_dot_number_version = ''
+      version_matches.each do |version|
+        max_dot_number_version = version if version.count('.') > max_dot_number_version.count('.')
+      end
+      Gem::Version.new(max_dot_number_version)
     end
-    Gem::Version.new(max_dot_number_version)
   end
-
 end

data/lib/chekku/definitions.rb

@@ -6,41 +6,61 @@ class Chekku::Definitions
 
   attr_accessor :definitions_service, :dependency_checker
 
-  def self.evaluate(file)
-    new.eval_chekkufile(file)
+  # Evaluate the given Chekkufile and check every dependency
+  #
+  # @param [String] file_path Path to Chekkufile
+  def self.evaluate(file_path)
+    new.eval_chekkufile(file_path)
   end
 
+  # Instanciate a new instance and create a DefinitionService
   def initialize
     @definitions_service = Chekku::DefinitionsService.new
     @definitions_service.load_definitions_for @chekkufile
   end
 
-  def eval_chekkufile(file)
-    instance_eval(read_file(file))
+  # Parse the file and evaluate every dependency
+  #
+  # @param [String] file_path Path to Chekkufile
+  # @raise [NoMethodError] Wrong format of Chekkufile
+  def eval_chekkufile(file_path)
+    instance_eval(read_file(file_path))
   rescue NoMethodError => e
     puts "\033[31mERROR: Please verify the syntax of your Chekkufile"
   end
 
+  # Check against the Definition if depency is valid
+  # Actual method written in the Chekkufile
+  # It is responsible to output the result
+  #
+  # @param [String] name Name of the Definition
+  # @param [String] version Current version wanted on the host
+  # @param [Hash] args for the moment only must_run: true false Indicating if is running or not
   def check(name, version = nil, args = {})
     unless version.is_a?(String)
       args = version || {}
       version = nil
     end
     definition = get_definition! name
-    puts definition.chekku(version, args)
+    puts "[\033[32m✓\033[0m] #{name}" if definition.chekku(version, args)
   rescue DefinitionsError => e
     puts "[\033[31m✗\033[0m] #{name}: #{e.message}\n"
   rescue ChekkuError => e
     puts "\033[31mERROR: #{e.message}\033[0m\n"
   end
 
+  # Retrieve the Definition instance from the DefinitionService
+  #
+  # @param [String] name Definition name
+  # @return [Definition] actual definition
+  # @raise [DefinitionNotFoundError] if Definition is not found
   def get_definition!(name)
     @definitions_service.definition_for(name) ||
       raise(DefinitionNotFoundError, "#{name} definition not found. Check ~/.chekku/def.yml")
   end
 
-  def read_file(file)
-    File.open(file, "r") { |f| f.read }
+  def read_file(file_path)
+    File.open(file_path, "r") { |f| f.read }
   end
 
 end

data/lib/chekku/definitions_service.rb

@@ -4,11 +4,18 @@ class Chekku::DefinitionsService
 
   attr_accessor :definitions
 
-  def load_definitions_for(file)
-    @definitions = Chekku::Fetcher.fetch_for_chekkufile file
+  # load the Definition list for the needed dependencies
+  #
+  # @param [String] file_path Path to Chekkufile
+  def load_definitions_for(file_path)
+    @definitions = Chekku::Fetcher.fetch_for_chekkufile file_path
   end
 
-  def definition_for(dependency)
-    @definitions.select{ |definition| definition.name == dependency }.first if @definitions
+  # Retrieve one Definition from the list
+  #
+  # @param [String] definition_name The needed Definition name
+  # @return [Definition] The needed Definition
+  def definition_for(definition_name)
+    @definitions.select{ |definition| definition.name == definition_name }.first if @definitions
   end
 end

data/lib/chekku/fetcher.rb

@@ -8,7 +8,11 @@ class Chekku::Fetcher
 
   attr_accessor :dependencies
 
-  def self.fetch_for_chekkufile(file)
+  # Fetch the Definitions from the file
+  #
+  # @param [String] file_path Path to Chekkufile
+  # @return [Array] a list of Definition instances
+  def self.fetch_for_chekkufile(file_path)
     # TODO: Implements server side of the file checker
     # STUB: Load local file
     fetcher = new

data/lib/chekku/version.rb

@@ -1,3 +1,3 @@
 module Chekku
-  VERSION = '0.0.5'
+  VERSION = '0.1.0'
 end

data/spec/lib/definition_spec.rb

@@ -1,4 +1,5 @@
 #encoding: utf-8
+require 'spec_helper'
 require 'chekku/definition'
 require 'chekku/errors'
 
@@ -76,14 +77,27 @@ describe Chekku::Definition do
     end
   end
 
+  describe '.chekku!' do
+    it 'should says ✓ if soft exists' do
+      definition.stub(:exists?).and_return(true)
+      definition.chekku!.should be_true
+    end
+
+    it 'should says x if soft does not exist' do
+      definition.stub(:exists?).and_return(false)
+      expect { definition.chekku! }.to raise_error(DefinitionValidationError)
+    end
+  end
+
   describe '.chekku' do
     it 'should says ✓ if soft exists' do
       definition.stub(:exists?).and_return(true)
-      definition.chekku.should == "[\033[32m✓\033[0m] mysql"
+      definition.chekku.should be_true
     end
+
     it 'should says x if soft does not exist' do
       definition.stub(:exists?).and_return(false)
-      expect { definition.chekku }.to raise_error(DefinitionValidationError)
+      definition.chekku.should be_false
     end
   end
 

data/spec/lib/definitions_service_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'chekku/definitions_service'
 require 'chekku/errors'
 

data/spec/lib/definitions_spec.rb

@@ -1,4 +1,5 @@
 #encoding: utf-8
+require 'spec_helper'
 require 'chekku/definitions'
 require 'chekku/definitions_service'
 require 'chekku/errors'
@@ -13,11 +14,13 @@ describe Chekku::Definitions do
 
     describe '.get_definition' do
       it 'should return the definition' do
+        Chekku::DefinitionsService.any_instance.stub(:load_definitions_for)
         definitions.definitions_service.stub(:definition_for).with('mysql').and_return(definition)
         definitions.get_definition!('mysql').should == definition
       end
 
       it 'should raise an error if not found' do
+        Chekku::DefinitionsService.any_instance.stub(:load_definitions_for)
         definitions.definitions_service.stub(:definition_for).with('mysql').and_return(nil)
         expect{ definitions.get_definition!('mysql') }.to raise_error(DefinitionNotFoundError)
       end

data/spec/lib/fetcher_spec.rb

@@ -1,3 +1,4 @@
+require 'spec_helper'
 require 'chekku/fetcher'
 
 describe Chekku::Fetcher do

data/spec/spec_helper.rb

@@ -1,16 +1,3 @@
-require 'rubygems'
-require 'bundler/setup'
+require 'simplecov'
+SimpleCov.start
 
-require 'chekku'
-# Load support files
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
-
-# Load fixtures from the engine
-if ActiveSupport::TestCase.method_defined?(:fixture_path=)
-  ActiveSupport::TestCase.fixture_path = File.expand_path("../fixtures", __FILE__)
-end
-
-RSpec.configure do |config|
-  config.before :each do
-  end
-end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: chekku
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-10-16 00:00:00.000000000 Z
+date: 2012-10-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: thor
   requirement: !ruby/object:Gem::Requirement
@@ -121,3 +137,4 @@ test_files:
 - spec/lib/definitions_spec.rb
 - spec/lib/fetcher_spec.rb
 - spec/spec_helper.rb
+has_rdoc: