fail_fast 0.1.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/CHANGELOG.txt

@@ -0,0 +1,2 @@
+0.1.0
+  - initial version

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Alain Ravet
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,91 @@
+# fail_fast : don't start your application if some preconditions are not met.
+
+## How to use :
+
+Early in your project boot sequence insert code like
+
+    require 'fail_fast'
+    FailFast('database.yml').check do
+      has_active_record_db_for Rails.env
+    end
+
+    FailFast('database.mongo.yml').check do
+      has_mongoDB_for Rails.env
+    end
+
+    FailFast('path_to/config.yml', prefix=Rails.env).check do
+      has\_values_for 'author/fname', 'author/lname'
+      has\_url_for 'bug_tracker/url', :reachable => true
+      has\_email_for 'newsletter/to_address'
+
+      directory_exists_for  '/tmp'
+      file_exists_for       'public/nda.pdf'
+    end
+
+
+## Info :
+
+Failing fast is important.   
+This gem DSL lets you write tests scripts that run early in the boot sequence of an application.    
+An exception is raised if one or more tests fail, and you get a detailled report of all the problems encountered.
+
+Some rules are based on the contents of configuration files (database.yml, config.yml, etc...) :   
+
+- can a database connnection be established?
+- is the mongoDB server active?
+- is there an _:application\_name_ value in _config.yml_, and does it match a regexp pattern?
+- is the value of _:info\_email__ a valid email?
+- is the value of _:sponspor\_link_ a valid url, and is the site up?
+
+You can also add custom rules, not related to any config files :
+
+ - is there a _/tmp_, or an _public/upload_ directory on the server?
+ - can the server access _http://google.com_?
+ - is there a _public/nda\_pdf_ file?
+ - etc..
+
+
+## Features :
+
+### _free/direct_ commands (not linked to the yaml file contents) :
+
+    directory_exists  '/tmp'
+    file_exists       '/Users/me/.bash_profile'
+    has_mongoDB           'localhost', 'db_app_1'
+    has_active_record_db  :host => 'dbserv', :adapter => 'mysql', :database => 'db'
+
+
+### _keyed_ commands (linked to a value found in a yaml file) :
+
+####Test values linked to a key :   
+
+*presence :*
+
+      has_value_for :application_name
+      has_values_for 'author/fname', 'author/lname'
+
+*contents <-> a regexp or pattern :*
+
+      has_value_for   'level',  /(alpha|beta|production)/   
+      has_url_for     'bug_tracker/url'   
+      has_email_for   'newsletter/to_address'   
+
+Test the file system :
+
+      directory_exists_for  'public/assets'
+      file_exists_for       'public/500_custom.html'
+
+Test external services :
+
+    # is a webserver up ?
+    has_url_for 'bug_tracker/url', :reachable => true
+    has_url_for 'bug_tracker/url', :reachable => true, :may_add_trailing_slash => true
+
+
+    # can we connect to a mongoDB db/server :
+    has_mongoDB_for 'test/mongoDB'
+    has_mongoDB_for 'test/unknown_mongoDB_db', :check_database => false
+
+    # can we connect to a SQL db :
+    has_active_record_db_for 'production/db_connection'
+

data/Rakefile

@@ -0,0 +1,46 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "fail_fast"
+    gem.summary = %Q{raises an error if the yaml contents of a config file does pass a test script.}
+    gem.description = %Q{raises an error if the yaml contents of a config file does not pass a test script.}
+    gem.email = "alainravet@gmail.com"
+    gem.homepage = "http://github.com/alainravet/fail_fast"
+    gem.authors = ["Alain Ravet"]
+    gem.add_development_dependency "rspec", ">= 1.2.9"
+    gem.add_development_dependency "mongo"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "config_file_check #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/fail_fast.gemspec

@@ -0,0 +1,86 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{fail_fast}
+  s.version = "0.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Alain Ravet"]
+  s.date = %q{2010-06-20}
+  s.description = %q{raises an error if the yaml contents of a config file does not pass a test script.}
+  s.email = %q{alainravet@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.markdown"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "CHANGELOG.txt",
+     "LICENSE",
+     "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "fail_fast.gemspec",
+     "lib/fail_fast.rb",
+     "lib/fail_fast/check_active_record_db.rb",
+     "lib/fail_fast/check_email.rb",
+     "lib/fail_fast/check_file_system.rb",
+     "lib/fail_fast/check_mongo_db.rb",
+     "lib/fail_fast/check_url.rb",
+     "lib/fail_fast/check_value.rb",
+     "lib/fail_fast/main.rb",
+     "lib/fail_fast/report.txt.erb",
+     "show_all_errors.rb",
+     "spec/file_is_empty_spec.rb",
+     "spec/file_is_missing_spec.rb",
+     "spec/file_system_spec.rb",
+     "spec/fixtures/empty.yml",
+     "spec/fixtures/simple.yml",
+     "spec/has_active_record_db_spec.rb",
+     "spec/has_email_for_spec.rb",
+     "spec/has_mongoDB_for_spec.rb",
+     "spec/has_url_for_spec.rb",
+     "spec/has_value_for_spec.rb",
+     "spec/how_to_use_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/alainravet/fail_fast}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{raises an error if the yaml contents of a config file does pass a test script.}
+  s.test_files = [
+    "spec/file_is_empty_spec.rb",
+     "spec/file_is_missing_spec.rb",
+     "spec/file_system_spec.rb",
+     "spec/has_active_record_db_spec.rb",
+     "spec/has_email_for_spec.rb",
+     "spec/has_mongoDB_for_spec.rb",
+     "spec/has_url_for_spec.rb",
+     "spec/has_value_for_spec.rb",
+     "spec/how_to_use_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_development_dependency(%q<mongo>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 1.2.9"])
+      s.add_dependency(%q<mongo>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 1.2.9"])
+    s.add_dependency(%q<mongo>, [">= 0"])
+  end
+end
+

data/lib/fail_fast/check_active_record_db.rb

@@ -0,0 +1,107 @@
+require 'active_record'
+# ActiveRecord::Base.establish_connection(
+#    :adapter  => "mysql",
+#    :host     => "localhost",
+#    :username => "myuser",
+#    :password => "mypass",
+#    :database => "somedatabase"
+# )
+# ActiveRecord::Base.establish_connection(
+#    :adapter => "sqlite",
+#    :database  => "path/to/dbfile"
+#  )
+# ActiveRecord::Base.establish_connection(
+#    :adapter => "sqlite3",
+#    :dbfile  => ":memory:"
+#)
+
+class FailFast
+  module CheckActiveRecordDB
+
+    # Ensure the ActiveRecord connection can be established :
+    #
+    # Usage :
+    #   has_active_record_db :host => 'localhost', :adapter => 'sqlite3', :database=> 'prod_db'
+    #
+    def has_active_record_db(*params)
+      options = params.last.is_a?(Hash) ? params.pop : {}
+      begin
+        ActiveRecord::Base.establish_connection(options)
+        @connection = ActiveRecord::Base.connection
+        @success    = @connection && @connection.active?
+      rescue => e
+        @success        = false
+        @error_message  = e.message
+      end
+      unless @success
+        FailFast.errors << ErrorDetails.new(nil, :active_record_db_connection_error, @error_message)
+      end
+    end
+
+    # Ensure the ActiveRecord connection can be established :
+    #
+    # Usage :
+    #   has_active_record_db_for  'production/database'
+    #
+    def has_active_record_db_for(key, *params)
+      return unless has_value_for key
+      return unless has_value_for "#{key}/adapter"
+      return unless has_value_for "#{key}/database"
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      begin
+        connection_options = p.value
+        ActiveRecord::Base.establish_connection(connection_options)
+        @connection = ActiveRecord::Base.connection
+        @success    = @connection && @connection.active?
+      rescue => e
+        @success        = false
+        @error_message  = e.message
+      end
+      unless @success
+        FailFast.errors << ErrorDetails.new(key, :active_record_db_connection_error, @error_message)
+      end
+    end
+
+  end
+end
+
+FailFast.send  :include, FailFast::CheckActiveRecordDB
+
+__END__
+    # Ensure the mongoDB server can be reached, and the db could be opened :
+    #
+    # Usage :
+    #  has_mongoDB_for 'test/mongoDB'
+    #  has_mongoDB_for 'test/unknown_mongoDB_db', :check_database => false
+    #
+    def has_mongoDB_for(key, *params)
+      return unless has_value_for key
+      return unless has_value_for "#{key}/host"
+      return unless has_value_for "#{key}/database"
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      value = value_for_deep_key(key)
+      host, port, db = value['host'], value['port'], value['database']
+
+      begin
+        @conn = Mongo::Connection.new(host, port)
+      rescue Mongo::ConnectionFailure
+        FailFast.errors << ErrorDetails.new(key, :mongoDB_server_not_found, host)
+        return
+      end
+
+      must_check_db = !(false == options[:check_database])
+      if must_check_db && !@conn.database_names.include?(db)
+        FailFast.errors << ErrorDetails.new(key, :mongoDB_db_not_found, db)
+      end
+    end
+
+  end
+end
+
+

data/lib/fail_fast/check_email.rb

@@ -0,0 +1,34 @@
+class FailFast
+
+  module CheckEmail
+    # Usage
+    #  has_email_for 'test/admin_email'
+    #
+    def has_email_for(key, *params)
+      return unless has_value_for key
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      value = value_for_deep_key(key)
+      if EmailValidator.invalid_email_address?(value)
+        FailFast.errors << ErrorDetails.new(key, :not_an_email, value)
+      end
+    end
+  end
+
+  module EmailValidator
+    VALID_EMAIL_ADDRESS_REGEXP = /^[a-zA-Z][\w\.-]*[a-zA-Z0-9]@[a-zA-Z0-9][\w\.-]*[a-zA-Z0-9]\.[a-zA-Z][a-zA-Z\.]*[a-zA-Z]$/
+
+    def self.valid_email_address?(email)
+      email.strip!
+      !!(email =~ VALID_EMAIL_ADDRESS_REGEXP)
+    end
+
+    def self.invalid_email_address?(email)
+      !valid_email_address?(email)
+    end
+  end
+end
+
+FailFast.send  :include, FailFast::CheckEmail

data/lib/fail_fast/check_file_system.rb

@@ -0,0 +1,65 @@
+class FailFast
+  module CheckFileSystem
+
+    # Ensure the value is an existing directory
+    #
+    # Usage
+    #   directory_exists '/tmp'
+    #
+    def directory_exists(path, *params)
+      unless File.exists?(path) && File.directory?(path)
+        FailFast.errors << ErrorDetails.new(nil, :directory_not_found, path)
+      end
+    end
+
+    # Ensure the value is an existing file
+    #
+    # Usage
+    #   file_exists '~/.bash_profile'
+    #
+    def file_exists(path, *params)
+      unless File.exists?(path) && File.file?(path)
+        FailFast.errors << ErrorDetails.new(nil, :file_not_found, path)
+      end
+    end
+
+    # Ensure the key value is an existing directory
+    #
+    # Usage
+    #   directory_exists_for 'foo/config'
+    #
+    def directory_exists_for(key, *params)
+      return unless has_value_for key
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      path = value_for_deep_key(key)
+
+      unless File.exists?(path) && File.directory?(path)
+        FailFast.errors << ErrorDetails.new(key, :directory_not_found, p.value)
+      end
+    end
+
+    # Ensure the key value is an existing file exists
+    #
+    # Usage
+    #   file_exists_for 'foo/config/app.yml'
+    #
+    def file_exists_for(key, *params)
+      return unless has_value_for key
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      path = value_for_deep_key(key)
+
+      unless File.exists?(path) && File.file?(path)
+        FailFast.errors << ErrorDetails.new(key, :file_not_found, p.value)
+      end
+    end
+
+  end
+end
+
+FailFast.send  :include, FailFast::CheckFileSystem

data/lib/fail_fast/check_mongo_db.rb

@@ -0,0 +1,61 @@
+class FailFast
+  module CheckMongoDB
+
+    # Ensure the mongoDB server can be reached, and the db could be opened :
+    #
+    # Usage :
+    #  has_mongoDB 'localhost'
+    #  has_mongoDB 'localhost', 'my_db', :port => 1234, :timeout => 2
+    #  has_mongoDB 'localhost', :port => 1234, :timeout => 2
+    #
+    def has_mongoDB(host, *params)
+      options = params.last.is_a?(Hash) ? params.pop : {}
+      db      = params.first
+
+      begin
+        port = options.delete(:port)
+        @conn = Mongo::Connection.new(host, port, options)
+      rescue Mongo::ConnectionFailure
+        FailFast.errors << ErrorDetails.new(nil, :mongoDB_server_not_found, host)
+        return
+      end
+
+      if db && !@conn.database_names.include?(db)
+        FailFast.errors << ErrorDetails.new(nil, :mongoDB_db_not_found, db)
+      end
+    end
+
+    # Ensure the mongoDB server can be reached, and the db could be opened :
+    #
+    # Usage :
+    #  has_mongoDB_for 'test/mongoDB'
+    #  has_mongoDB_for 'test/unknown_mongoDB_db', :check_database => false
+    #
+    def has_mongoDB_for(key, *params)
+      return unless has_value_for key
+      return unless has_value_for "#{key}/host"
+      return unless has_value_for "#{key}/database"
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      value = value_for_deep_key(key)
+      host, port, db = value['host'], value['port'], value['database']
+
+      begin
+        @conn = Mongo::Connection.new(host, port)
+      rescue Mongo::ConnectionFailure
+        FailFast.errors << ErrorDetails.new(key, :mongoDB_server_not_found, host)
+        return
+      end
+
+      must_check_db = !(false == options[:check_database])
+      if must_check_db && !@conn.database_names.include?(db)
+        FailFast.errors << ErrorDetails.new(key, :mongoDB_db_not_found, db)
+      end
+    end
+
+  end
+end
+
+FailFast.send  :include, FailFast::CheckMongoDB

data/lib/fail_fast/check_url.rb

@@ -0,0 +1,73 @@
+class FailFast
+
+  module CheckUrl
+    # Usage
+    #   test if the url is valid :
+    #     has_url_for 'test/server_url'
+    #   test if the url is reachable :
+    #     has_url_for 'test/server_url', :reachable => true
+    #   test if the url is reachable, possibly after adding a trailing slash.
+    #   (ex: http://example.com  + http://example.com/)
+    #     has_url_for 'test/server_url', :reachable => true, :may_add_trailing_slash => true
+    #
+    def has_url_for(key, *params)
+      return unless has_value_for key
+
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      value = value_for_deep_key(key)
+      if UrlValidator.invalid_url?(value)
+        FailFast.errors << ErrorDetails.new(key, :not_a_url, value)
+        return
+      end
+      if true==options.delete(:reachable) && UrlValidator.unreachable_url?(value, options)
+        FailFast.errors << ErrorDetails.new(key, :url_not_reachable, value)
+      end
+    end
+  end
+
+  module UrlValidator
+    IPv4_PART = /\d|[1-9]\d|1\d\d|2[0-4]\d|25[0-5]/  # 0-255
+    VALID_URL_REGEXP = %r{
+      \A
+      https?://                                                    # http:// or https://
+      ([^\s:@]+:[^\s:@]*@)?                                        # optional username:pw@
+      ( (([^\W_]+\.)*xn--)?[^\W_]+([-.][^\W_]+)*\.[a-z]{2,6}\.? |  # domain (including Punycode/IDN)...
+          #{IPv4_PART}(\.#{IPv4_PART}){3} |                        # or IPv4
+          localhost )                                              # or localhost
+      (:\d{1,5})?                                                  # optional port
+      ([/?]\S*)?                                                   # optional /whatever or ?whatever
+      \Z
+    }iux
+
+    def self.valid_url?(url)
+      url.strip!
+      !!(url =~ VALID_URL_REGEXP)
+    end
+
+    def self.invalid_url?(url)
+      !valid_url?(url)
+    end
+
+    def self.reachable_url?(url_s, options = {:may_add_trailing_slash => false})
+      url_s = "http://#{url_s}" unless url_s =~ /http/
+      url   = URI.parse(url_s)
+      http  = Net::HTTP.new(url.host, url.port)
+      http.open_timeout = http.read_timeout = 5 #seconds
+      http.get(url.path)
+      true
+    rescue Exception
+      can_retry_after_appending_a_fwd_slash = (true == options[:may_add_trailing_slash]) && !(url_s =~ /\/$/)
+      can_retry_after_appending_a_fwd_slash ?
+        reachable_url?(url_s + '/', options) :
+        false
+    end
+
+    def self.unreachable_url?(url_s, options = {:may_add_trailing_slash => false})
+      !reachable_url?(url_s, options)
+    end
+  end
+end
+
+FailFast.send  :include, FailFast::CheckUrl

data/lib/fail_fast/check_value.rb

@@ -0,0 +1,38 @@
+class FailFast
+  module CheckValue
+
+    # Usage
+    #  has_value_for 'str_key'
+    #  has_value_for :sym_key, /localhost/
+    # returns
+    #   true if succesful, false otherwise
+    def has_value_for(key, *params)
+      p = key_value_regexp_options(key, params)
+      key, options = p.key, p.options
+
+      nof_errors = FailFast.errors.size
+      if blank?(p.value)
+        FailFast.errors << ErrorDetails.new(key, :missing_value, nil)
+
+      elsif p.regexp
+        FailFast.errors << ErrorDetails.new(key, :value_does_not_match, p.value) unless p.value =~ p.regexp
+
+      elsif hash?(options) && range?(options[:in])
+        FailFast.errors << ErrorDetails.new(key, :value_not_in_range, p.value) unless options[:in].include?(p.value)
+
+      elsif hash?(options) && array?(options[:in])
+        FailFast.errors << ErrorDetails.new(key, :value_not_in_array, p.value) unless options[:in].include?(p.value)
+      end
+      no_new_error = nof_errors == FailFast.errors.size
+    end
+
+    # Usage
+    #  has_values_for :sym_key, 'str_key'
+    #
+    def has_values_for(*keys)
+      keys.each{|key| has_value_for(key)}
+    end
+
+  end
+end
+FailFast.send  :include, FailFast::CheckValue