bin_script 0.1

data/.gitignore

@@ -0,0 +1,2 @@
+log
+locks

data/Gemfile

@@ -0,0 +1,11 @@
+source "http://rubygems.org"
+
+# Will automatically pull in this gem and all its
+# dependencies specified in the gemspec
+gem "bin_script", :path => File.expand_path("..", __FILE__)
+
+gem 'rails'
+gem 'activesupport'
+# These are development dependencies 
+gem "rspec"
+gem 'rake'

data/Gemfile.lock

@@ -0,0 +1,104 @@
+PATH
+  remote: .
+  specs:
+    bin_script (0.1)
+      activesupport (>= 2.3.2)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (3.2.3)
+      actionpack (= 3.2.3)
+      mail (~> 2.4.4)
+    actionpack (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+      erubis (~> 2.7.0)
+      journey (~> 1.0.1)
+      rack (~> 1.4.0)
+      rack-cache (~> 1.2)
+      rack-test (~> 0.6.1)
+      sprockets (~> 2.1.2)
+    activemodel (3.2.3)
+      activesupport (= 3.2.3)
+      builder (~> 3.0.0)
+    activerecord (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+      arel (~> 3.0.2)
+      tzinfo (~> 0.3.29)
+    activeresource (3.2.3)
+      activemodel (= 3.2.3)
+      activesupport (= 3.2.3)
+    activesupport (3.2.3)
+      i18n (~> 0.6)
+      multi_json (~> 1.0)
+    arel (3.0.2)
+    builder (3.0.0)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.1)
+    i18n (0.6.0)
+    journey (1.0.3)
+    json (1.6.6)
+    mail (2.4.4)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.18)
+    multi_json (1.2.0)
+    polyglot (0.3.3)
+    rack (1.4.1)
+    rack-cache (1.2)
+      rack (>= 0.4)
+    rack-ssl (1.3.2)
+      rack
+    rack-test (0.6.1)
+      rack (>= 1.0)
+    rails (3.2.3)
+      actionmailer (= 3.2.3)
+      actionpack (= 3.2.3)
+      activerecord (= 3.2.3)
+      activeresource (= 3.2.3)
+      activesupport (= 3.2.3)
+      bundler (~> 1.0)
+      railties (= 3.2.3)
+    railties (3.2.3)
+      actionpack (= 3.2.3)
+      activesupport (= 3.2.3)
+      rack-ssl (~> 1.3.2)
+      rake (>= 0.8.7)
+      rdoc (~> 3.4)
+      thor (~> 0.14.6)
+    rake (0.9.2.2)
+    rdoc (3.12)
+      json (~> 1.4)
+    rspec (2.9.0)
+      rspec-core (~> 2.9.0)
+      rspec-expectations (~> 2.9.0)
+      rspec-mocks (~> 2.9.0)
+    rspec-core (2.9.0)
+    rspec-expectations (2.9.1)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.9.0)
+    sprockets (2.1.2)
+      hike (~> 1.2)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    thor (0.14.6)
+    tilt (1.3.3)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.32)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  activesupport
+  bin_script!
+  rails
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2012 Makarchev K, Lifshits D
+
+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,68 @@
+Rails BinScript
+===============
+
+Easy writing and executing bins (espesually for crontab or god) in Rails project.
+For my purposes much better than Rake, Thor and Rails Runner.
+
+Features:
+
+1. Each bin is a class
+2. Easy writing tests
+3. Bin use lock file and logger with formatter when executing
+  
+Rails 2.3 and 3 compatible
+
+``` ruby
+gem 'bin_script'
+```
+
+    rails g bin:bin bla
+    (for 2.3 copy generator into lib/generators and run: ./script/generate bin bla)
+
+Call like:
+
+    $ cd project && ./bin/bla.rb -e production -a -b -c -d "asdf"
+
+Examples (default features):
+
+    $ ./bin/bla.rb -e production 
+    $ ./bin/bla.rb -e production -L ./locks/bla.lock
+    $ ./bin/bla.rb -e production -l ./log/bla.log
+    $ ./bin/bla.rb -e production --daemonize --pidfile=./tmp/bla.pid
+
+
+
+Example Bin
+-----------
+app/models/bin/stuff_script.rb
+
+``` ruby
+class StuffScript < BinScript
+  optional :u, "Update string"
+  required :d, "Date in format YYYY-MM-DD or YYYY-MM"
+  noarg    :t, "Test run"
+  
+  def test?
+    params(:t)
+  end
+
+  def do!
+    if test?
+      logger.info "update string #{params(:u)}"        
+    else  
+      logger.info "data #{Time.parse(params(:d))}"
+    end
+  end
+end
+```
+
+### Custom exception notifier (create initializer with:)
+
+``` ruby
+class BinScript
+  def notify_about_error(exception)
+    Mailter.some_notification(exception)...
+  end
+end
+```
+  

data/Rakefile

@@ -0,0 +1,17 @@
+require 'rubygems'
+require "bundler"
+Bundler.setup
+
+require 'rspec/core/rake_task'
+
+task :default => :spec
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubygems/package_task'
+require 'rubygems/specification'
+
+spec = eval(File.read('bin_script.gemspec'))
+
+Gem::PackageTask.new(spec) do |pkg|
+  pkg.gem_spec = spec
+end

data/bin/bin_helper

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+# This helper is useful for requiring from bin scripts.
+# Detect RAILS_ENV from '-e' parameter in ARGV (or 'development' as default) and load rails environment if need.
+#
+# Sample ./bin/script_name.rb
+# #!/usr/bin/env ruby
+#
+# #NO_RAILS = true # Uncomment this line if you don't need rails environment in your script
+# require File.join(File.dirname(__FILE__),'_bin_helper')
+#
+# Helper will detect class name for this script automatically. So for example above helper call something like this: ScriptName.new.run!
+
+APP_ROOT ||= File.expand_path(File.dirname($0)) + "/../"
+
+if defined?(DAEMONIZE) || ARGV.include?('--daemonize') # для демонизации бина
+  ARGV.delete('--daemonize')
+
+  # Stolen from activesupport
+  module Process
+    def self.daemon
+      exit if fork                     # Parent exits, child continues.
+      Process.setsid                   # Become session leader.
+      exit if fork                     # Zap session leader. See [1].
+      return 0
+    end
+  end
+
+  Process.daemon
+
+  if ARGV.include?('--pidfile')
+    pidfile = nil
+
+    ARGV.each_index do |i|
+      if ARGV[i] == '--pidfile' && ARGV.length > i
+        pidfile = ARGV[i+1]
+
+        ARGV.delete('--pidfile')
+        ARGV.delete(pidfile) if pidfile
+        break
+      end
+    end
+
+    if pidfile
+      File.open(pidfile, 'w'){|f| f.write($$) }
+    end
+  end
+end
+
+require 'rubygems'
+
+# Define RAILS_ENV
+ARGV.each_index do |i|
+  if ARGV[i] == '-e' && ARGV.length > i
+    RAILS_ENV = ARGV[i+1]
+    break
+  end
+end
+
+# Если задан ключ -h, то нам нужно только показать хэлп и environment грузить не обязательно
+NO_RAILS = true if ARGV.include?('-h') && !defined?(NO_RAILS)
+
+# Set defaults
+RAILS_ENV = 'development' if defined?(RAILS_ENV).nil?
+
+if !defined?(RAILS_ROOT) && !defined?(NO_RAILS)
+  # Load rails envoronment if not yet and we need it
+  require File.join(APP_ROOT, %w{config environment})
+else
+  require 'active_support'
+end
+
+# Load BinScript class source
+require 'bin_script' unless defined?(BinScript) == 'constant'
+
+# Call script runner
+BinScript.run_script

data/bin_script.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + "/lib/bin_script/version"
+
+Gem::Specification.new do |s|
+  s.name = %q{bin_script}
+  s.version = BinScript::VERSION
+
+  s.authors = ["Lifshits Dmitry", "Makarchev Konstantin"]
+  s.autorequire = %q{init}
+  
+  s.description = %q{Easy writing and executing bins (espesually for crontab or god) in Rails project}
+  
+  s.summary = %q{Easy writing and executing bins (espesually for crontab or god) in Rails project
+For my purposes much better than Rake, Thor and Rails Runner}
+
+  s.email = %q{kostya27@gmail.com}
+  s.homepage = %q{http://github.com/kostya/bin_script}
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'activesupport', ">=2.3.2"  
+  s.add_development_dependency "rspec"
+  
+end

data/init.rb

@@ -0,0 +1 @@
+require File.dirname(__FILE__) + '/lib/bin_script'

data/lib/bin_script.rb

@@ -0,0 +1,2 @@
+# -*- encoding: utf-8 -*-
+require File.dirname(__FILE__) + '/bin_script/bin_script'

data/lib/bin_script/bin_script.rb

@@ -0,0 +1,389 @@
+# -*- encoding: utf-8 -*-
+require 'getoptlong'
+require 'pathname'
+require 'rails' unless defined?(Rails)
+require File.dirname(__FILE__) + '/lock_file'
+require File.dirname(__FILE__) + '/xlogger'
+require File.dirname(__FILE__) + '/class_inheritable_attributes'
+#require 'active_support/core_ext/class/attribute.rb'
+
+class BinScript
+  include ClassLevelInheritableAttributes
+  class_inheritable_attributes :parameters, :log_level, :enable_locking, :enable_logging, :date_log_postfix, :disable_puts_for_tests
+  
+  # Default parameters
+  @parameters = [
+      {:key => :e, :type => :optional, :description => "Rails environment ID (default - development)"},
+      {:key => :h, :type => :noarg,    :description => "Print usage message", :alias => [:H, :help]},
+      {:key => :l, :type => :optional, :description => "Path to log file (default \#{Rails.root}/log/[script_name].log"},
+      {:key => :L, :type => :optional, :description => "Path to lock file (default \#{Rails.root}/lock/[script_name].lock"}
+  ]
+
+  # Default log level INFO or DEBUG for test env
+  @log_level = (Rails.env.development? ? XLogger::DEBUG : XLogger::INFO)
+
+  # Enable locking by default
+  @enable_locking = true
+
+  # Enable logging by default
+  @enable_logging = true
+
+  # По умолчанию мы при каждом запуске скрипта продолжаем писать в основной лог. Но можно записать сюда формат, который
+  # можно скормить time.strftime(format) и результат подставится в конец имени файла лога. Таким образом можно делать
+  # отдельные лог-файлы для каждого запуска, для каждого дня/месяца/года/часа и т.д...
+  # Например "_%Y-%m-%d_%H-%M-%S" - каждый запуск новый лог
+  #          "_%Y-%m-%d"          - каждый день новый лог
+  @date_log_postfix = ''
+
+  # По умолчанию puts работает как обычно, но BinScript может ничего не выводить если RAILS_ENV=test
+  # Если скрипт что-то выводит, это попадает в лог спеков, что не красиво. Так что для таких скриптов лучше включать эту опцию
+  @disable_puts_for_tests = false
+
+  # Allowed parameter types. Equivalence aliases with GetoptLong constants.
+  PARAMETER_TYPES = {
+    :noarg     => GetoptLong::NO_ARGUMENT,
+    :optional  => GetoptLong::OPTIONAL_ARGUMENT,
+    :required  => GetoptLong::REQUIRED_ARGUMENT
+  }
+
+  # Place for logger object
+  attr_accessor :logger
+
+  # Place for store exit status.
+  attr_accessor :exit_status
+
+  # Create shortcuts to simplify logging from scripts
+  singleton = (class << self; self end)
+  Logger::Severity.constants.each do |level|
+    method = level.to_s.downcase
+
+    # Define class level helper method
+    singleton.class_eval do
+      define_method :info do |message|
+        return unless Rails.logger
+        Rails.logger.send(method,message)
+      end
+    end
+
+    # Define instance level helper method
+    define_method method do |message|
+      return unless @logger
+      @logger.send(method,message)
+    end
+  end
+
+  class << self
+    # Get parameter by key
+    def get_parameter(key)
+      param = @parameters.find{|p| p[:key] == key || (p[:alias].present? && p[:alias].include?(key))}
+      raise "Can't find parameter with key #{key.inspect} for class #{self.inspect}!" if param.nil?
+      param
+    end
+
+    # Prepare readable script name
+    def script_name
+      self.to_s.underscore.gsub('/','__')
+    end
+
+    # Parse script filename. Extract important path parts
+    def parse_script_file_name(filename)
+      result = {}
+      # Prepare important parts of source script filename
+      parts = filename.split(File::SEPARATOR)
+      parts = parts[parts.index('bin')+1..-1]
+      parts.map!{|p| File.basename(p).split('.').first}
+
+      result[:parts] = parts
+
+      result[:class] = calculate_script_class_name(parts)
+      result[:files]  = calculate_script_class_filename(parts)
+
+      result
+    end
+
+    # Prepare class name from filename parts
+    def calculate_script_class_name(parts)
+      # Calculate class name and paths from source script filename parts
+      if(parts.length > 1)
+        class_name = parts.map{|p| p.camelize}.join('::') + parts.first.camelize
+      else
+        class_name = parts.first.camelize
+      end
+      class_name += "Script"
+    end
+
+    # Prepare class name from filename parts
+    def calculate_script_class_filename(parts)
+      files = []
+
+      # Calculate and add to list file with script class itself
+      class_file = File.join(%w{app models bin}, parts)
+      class_file += '_nagios' if(parts.length > 1)
+      class_file += '_script.rb'
+      files << class_file
+
+      # Add intermediate classes
+      parts[0..-2].each { |p| files << "app/models/#{p}_script.rb" }
+
+      files.reverse
+    end
+
+    # Run script detected by the filename of source script file
+    def run_script(filename = $0)
+      cfg = parse_script_file_name(Pathname.new(filename).realpath.to_s)
+      cfg[:files].each { |f| require File.join(rails_root, f) }
+
+      # Create instance and call run! for script class
+      klass = cfg[:class].constantize
+      script = klass.new
+      script.run!
+
+      # Exit with specified exit status
+      exit script.exit_status || 0
+    end
+
+    # Prepare aliases for adding parameters in child classes
+    PARAMETER_TYPES.keys.each do |type|
+      define_method type do |key, opts|
+        param = {:key => key, :type => type}
+        if opts.is_a?(String)
+          param[:description] = opts
+        else
+          param = param.merge(opts)
+        end
+
+        # We want aliases always to be an array
+        param[:alias] = [param[:alias]].flatten.compact
+
+        @parameters = @parameters + [param]
+      end
+    end
+
+    # Remove parameter
+    def remove_parameter(key)
+      new = []
+      @parameters.each { |p| new << p if p[:key] != key }
+      @parameters = new
+    end
+
+    # RAILS_ROOT is not availible if rails environment was not loaded. So detect application root in this case from current file path
+    def rails_root
+      Pathname.new(Rails.root ? Rails.root : File.join(File.dirname(__FILE__), %w{.. ..})).realpath.to_s
+    end
+
+    # Prepare ARGV parameters as hash
+    def get_argv_values
+      values = {}
+      o = GetoptLong.new(*get_getoptlong_params)
+      o.quiet = true   # Don't write arg error to STDERR
+      o.each { |opt, arg| values[opt[1..-1].to_sym] = arg }
+      values
+    end
+
+    # Prepare usage message
+    def usage(message = nil)
+      usage_msg = ''
+      usage_msg += "Error: #{message}\n\n" unless message.nil?
+      usage_msg += "Use: ./bin/#{script_name}.rb [OPTIONS]\n\nAvailible options:\n\n"
+      @parameters.each do |param|
+        usage_msg += "  #{prefix_key param[:key]}  #{param[:description]}\n"
+      end
+      usage_msg += "\n"
+      usage_msg
+    end
+
+    private
+    # Prepare parameters in Getoptlong lib format
+    def get_getoptlong_params
+      result = []
+      @parameters.each do |param|
+        cfg = [prefix_key(param[:key])]
+        param[:alias].each{|als| cfg << prefix_key(als) } unless param[:alias].blank?
+        cfg << PARAMETER_TYPES[param[:type]]
+        result << cfg
+      end
+      result
+    end
+
+    # Prepare argument name with short or long prefix
+    def prefix_key(key)
+      key = key.to_s
+      (key.length > 1 ? "--" : "-") + key
+    end
+  end
+
+  def puts(*arg)
+    return if self.class.disable_puts_for_tests && Rails.env.test?
+    Kernel.puts(*arg)
+  end
+
+  # Initialize script
+  def initialize
+    begin
+      @source_argv = ARGV.dup
+      @overrided_parameters = {}
+      @params_values = (Rails.env.test? ? {} : self.class.get_argv_values)
+
+      # Create logger if logging enabled
+      if self.class.enable_logging
+        @logger = XLogger.new(:file => log_filename, :dont_touch_rails_logger => (Rails.env.test?))
+        @logger.level = self.class.log_level
+      end
+
+    rescue GetoptLong::InvalidOption, GetoptLong::MissingArgument, GetoptLong::NeedlessArgument => e
+      usage_exit e.message
+    end
+  end
+
+  # Create lock file, call script code and unlock file even if error happend.
+  def run!
+
+    # Print usage and exit if asked
+    usage_exit if params(:h)
+
+    # Create and check lock file if enabled
+    if self.class.enable_locking
+      @lock = LockFile.new(lock_filename)
+      @lock.quiet = true # Don't write errors to STDERR
+      info "Use lock file: #{@lock.path}"
+      if(@lock.lock)
+        warn "Lock file '#{@lock.path}' already open in exclusive mode. Exit!"
+        exit
+      end
+    end
+
+    begin
+      # Log important info and call script job
+      info "Log level = #{@logger.level}" if self.class.enable_logging
+      info "Parameters: #{@source_argv.join(', ')}"
+      info "Starting script #{self.class.script_name}..."
+      start = Time.now
+
+      # Инкрементируем счетчик запусков этого скрипта
+      inc_counter("#{self.class.script_name}_times")
+
+      do!
+      duration = Time.now - start
+      info "Script #{self.class.script_name} finished!"
+      info "Script job duration: #{duration}"
+      info "Exit status: #{@exit_status}" if @exit_status
+
+      # Инкрементируем время работы э
+      inc_counter("#{self.class.script_name}_long", duration)
+
+      # Log benchmarker info if it's not empty
+      log_benchmarker_data
+    rescue Exception => e
+      # Print error info if it's not test env or exit
+      if !Rails.env.test? && e.class != SystemExit && e.class != Interrupt 
+        msg = self.class.prepare_exception_message(e)
+        puts "\n" + msg
+        fatal msg
+        notify_about_error(e)
+      end
+
+      # Инкрементируем счетчик ошибок этого скрипта
+      inc_counter("#{self.class.script_name}_raised")
+    ensure
+      # Unlock lock file
+      @lock.unlock if self.class.enable_locking && @lock
+    end
+  end
+
+  # Print usage message and exit
+  def usage_exit(message = nil)
+    error "Exit with error message: #{message}"
+    Kernel.puts(self.class.usage(message))
+    exit
+  end
+
+  # Dummy for do! method
+  def do!; end
+
+  # Override one or more parameters for testing purposes
+  def override_parameters(args)
+    if args.is_a?(Symbol)
+      override_parameter(self.class.get_parameter(args))
+    elsif args.is_a?(Hash)
+      args.each{|key, value| override_parameter(self.class.get_parameter(key), value)}
+    else
+      raise "Parameter should be Symbol or Hash"
+    end
+  end
+
+  # Return parameter value by key
+  def params(key)
+    param = self.class.get_parameter(key)
+
+    # Use dafault key (if call by alias)
+    key = param[:key]
+
+    case param[:type]
+    when :noarg
+      return (@overrided_parameters.has_key?(key) && @overrided_parameters[key]) || !@params_values[key].nil?
+    when :optional
+      #return nil unless @overrided_parameters.has_key?(key) || @params_values.has_key?(key)
+      return @overrided_parameters[key] || @params_values[key] || param[:default]
+      when :required
+      value = @overrided_parameters[key] || @params_values[key] || param[:default]
+      return value
+    end
+  end
+
+  # Prepare filename of log file
+  def lock_filename
+    params(:L).blank? ? File.join(self.class.rails_root, 'locks', "#{self.class.script_name}.lock") : params(:L)
+  end
+
+  # Prepare filename of log file
+  def log_filename
+    params(:l).blank? ? File.join(self.class.rails_root, 'log', "#{self.class.script_name}#{log_filename_time_part}.log") : params(:l)
+  end
+
+  private
+
+  # Current time logname part.
+  def log_filename_time_part
+    Time.now.strftime(self.class.date_log_postfix)
+  end
+
+  # Override value for one parameter
+  def override_parameter(param, value = nil)
+    value = case param[:type]
+      when :noarg
+        true
+      when :optional
+        value.to_s
+      when :required
+        value
+    end
+    @overrided_parameters[param[:key]] = value
+  end
+
+  # Print benchmarker statistic to log if its not empty
+  def log_benchmarker_data
+    benchmark_data = {} #benchmark_get_data
+    return if benchmark_data.empty?
+    info "Benchmarker data:"
+    info benchmark_data.to_yaml
+  end
+
+  # Prepare string with exception details
+  def self.prepare_exception_message(e)
+<<-EXCEPTION
+Exception happend
+Type: #{e.class.inspect}
+Error occurs: #{e.message}
+Backtrace: #{e.backtrace.join("\n")}
+EXCEPTION
+  end
+
+  def inc_counter(id, counter = 1)
+    # stub    
+  end
+  
+  def notify_about_error(ex)
+    # stub
+  end
+  
+end

data/lib/bin_script/class_inheritable_attributes.rb

@@ -0,0 +1,25 @@
+module ClassLevelInheritableAttributes
+  def self.included(base)
+    base.extend(ClassMethods)
+  end
+
+  module ClassMethods
+    def class_inheritable_attributes(*args)
+      @class_inheritable_attributes ||= [:class_inheritable_attributes]
+      @class_inheritable_attributes += args
+      args.each do |arg|
+        class_eval %(
+          class << self; attr_accessor :#{arg} end
+        )
+      end
+      @class_inheritable_attributes
+    end
+
+    def inherited(subclass)
+      @class_inheritable_attributes.each do |class_inheritable_attribute|
+        instance_var = "@#{class_inheritable_attribute}"
+        subclass.instance_variable_set(instance_var, instance_variable_get(instance_var))
+      end
+    end
+  end
+end

data/lib/bin_script/lock_file.rb

@@ -0,0 +1,45 @@
+# -*- encoding: utf-8 -*-
+class LockFile
+  attr_accessor :logger, :path, :quiet
+
+  # By default print errors
+  @quiet = false
+
+  def initialize(path, logger = nil)
+    if path == nil
+      raise "file path cannot be nil"
+    end
+    @path = path
+    @logger = logger || $logger
+  end
+
+  def lock(waiting_unlock = false)
+    flags = File::WRONLY | File::TRUNC | File::CREAT
+
+    @f = File.open(@path, flags)
+    flags = File::LOCK_EX
+    flags |= File::LOCK_NB if waiting_unlock == false
+
+    unless @f.flock flags
+      log "File '#{@path}' already open in exclusive mode.\n"
+      return true
+    end
+    return false
+  end
+
+  def unlock
+    @f.close
+    File.delete( @f.path)
+  rescue Errno::ENOENT
+    #do nothing
+  end
+
+  def log(str)
+    return if @quiet
+    if @logger
+      @logger.warn str
+    else
+      print str
+    end
+  end
+end

data/lib/bin_script/version.rb

@@ -0,0 +1,4 @@
+# -*- encoding: utf-8 -*-
+class BinScript
+  VERSION = "0.1"
+end

data/lib/bin_script/xlogger.rb

@@ -0,0 +1,60 @@
+# -*- encoding: utf-8 -*-
+
+require 'logger'
+
+class XLogger < Logger
+  def initialize(hint = {})
+
+    if(hint[:rotate])
+      super(hint[:file] || STDOUT, hint[:rotate])
+    else
+      super(hint[:file] || STDOUT)
+    end
+
+    STDOUT.sync = true
+    self.formatter = Formatter.new
+    self.datetime_format = hint[:date_format] || "%d.%m %H:%M:%S"
+
+    # Don't change default logger if asked
+    if hint[:dont_touch_rails_logger].blank? && defined?(ActiveRecord::Base)
+      ActiveRecord::Base.logger = self
+      def Rails.logger; ActiveRecord::Base.logger; end
+
+      # This raise warning to STDOUT
+      #Object.const_set "RAILS_DEFAULT_LOGGER", self
+    end
+
+    self.level = hint[:log_level] || rails_env_log_level
+    log_sql if hint[:log_sql] || !Rails.env.production?
+  end
+
+  class Formatter < Logger::Formatter
+    def call(severity, time, progname, msg)
+      if severity == 'INFO' && msg.nil?
+        # use this if you want a simple blank line without date in your logs:
+        # just call a logger.info without any params
+        "\n"
+      else
+        format_datetime(time) << " " <<  msg2str(msg) << "\n"
+      end
+    end
+  end
+
+  def log_sql
+    ActiveRecord::Base.connection.logger = self if defined?(ActiveRecord::Base)
+  end
+
+  def rails_env_log_level
+    Rails.env.production? ? Logger::INFO : Logger::DEBUG
+  end
+end
+
+module ActiveRecord
+  module ConnectionAdapters
+    class AbstractAdapter
+      def logger=(val)
+        @logger = val
+      end
+    end
+  end
+end

data/lib/generators/bin/bin_generator.rb

@@ -0,0 +1,33 @@
+# for Rails 3
+if Rails::VERSION::MAJOR >= 3
+
+  module Bin
+    class BinGenerator < Rails::Generators::NamedBase
+      source_root File.expand_path("../templates", __FILE__)
+
+      def add_files
+        template "script.rb", "bin/#{file_path}.rb"
+        template "script_class.rb", "app/models/bin/#{file_path}_script.rb"
+        template "spec.rb", "spec/models/bin/#{file_path}_script_spec.rb"
+        chmod "bin/#{file_path}.rb", 0755
+      end
+    end
+  end
+
+end
+
+# for Rails 2.3
+if Rails::VERSION::MAJOR == 2
+
+  class BinGenerator < Rails::Generator::NamedBase
+    def manifest
+      record do |m|
+        m.template "script.rb", "bin/#{file_path}.rb", :chmod => 0755
+        m.template "script_class.rb", "app/models/bin/#{file_path}_script.rb"
+        m.directory "spec/models/bin"
+        m.template "spec.rb", "spec/models/bin/#{file_path}_script_spec.rb"
+      end
+    end
+  end
+
+end

data/lib/generators/bin/templates/script.rb

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'pathname'
+path = File.expand_path("../../Gemfile", Pathname.new(__FILE__).realpath)
+
+APP_ROOT = File.dirname(path)
+ENV['BUNDLE_GEMFILE'] ||= path
+
+require 'rubygems'
+require 'bundler/setup'
+
+load Gem.bin_path('bin_script', 'bin_helper')

data/lib/generators/bin/templates/script_class.rb

@@ -0,0 +1,42 @@
+class <%= class_name %>Script < BinScript
+  # You can define script parameters this way:
+  # {type} {key}, {options}
+  #
+  # Availible types: noarg, optional and required
+  # Key is the Symbol with parameter key
+  # Options is a hash that may contain this keys:
+  #   :description - parameters descriptions to automatic prepare usage message
+  #   :alias       - symbol or array of symbols with aliases for this parameters
+  #   :default     - default value for this parameter
+  #
+  # Instead of options hash you can use just string with description.
+  #
+  # Some examples:
+  # noarg    :n,  "This is a parameter without argument. 'params(:n)' in script will return true or false."
+  # optional :o,  :description => "Optional parameter that can has argument. 'params()'"
+  # optional :oo, :description => "Optional parameter with default value and aliases. 'params(:o)' and 'params(:oo)' will return argument value or default key value", :default => "some default value", :alias => :oo
+  # required :r,  :description => "Required argemtn. Script will exit if you use this parameter without argument value. Also you can use multiple aliases.", :alias => [:rr, :rrr]
+  #
+  # You may override default log level (Logger::INFO) for this script log this way:
+  # self.log_level = Logger::INFO
+  #
+  # Availible log levels:
+  #   DEBUG	=	0
+  #   INFO	=	1
+  #   WARN	=	2
+  #   ERROR	=	3
+  #   FATAL	=	4
+  #   UNKNOWN	=	5
+  #
+  # По умолчанию мы при каждом запуске скрипта продолжаем писать в основной лог. Но можно записать сюда формат, который
+  # можно скормить time.strftime(format) и результат подставится в конец имени файла лога. Таким образом можно делать
+  # отдельные лог-файлы для каждого запуска, для каждого дня/месяца/года/часа и т.д...
+  # Например "_%Y-%m-%d_%H-%M-%S" - каждый запуск новый лог
+  #          "_%Y-%m-%d"          - каждый день новый лог
+  # self.date_log_postfix = "_%Y-%m-%d"
+
+  # Do script job!
+  def do!
+    logger.info "Script <%= class_name %> works!"
+  end
+end

data/lib/generators/bin/templates/spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe <%= class_name %>Script do
+  before :each do
+    @bin = <%= class_name %>Script.new
+    
+    # if want to point some params into bin => @bin.override_parameters({:i => 10, :a => '20'})
+  end
+  
+  it 'should do! and not raise' do
+    @bin.do!
+  end
+end

data/spec/bin_script_spec.rb

@@ -0,0 +1,184 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe BinScript do
+  before :each do
+    root = Pathname.new(File.dirname(__FILE__) + '/../').realpath.to_s
+    Rails.stub!(:root).and_return(root)
+  end
+  
+  class TestScript < BinScript
+    noarg    :n, "Test parameter that can't have argument"
+    optional :o, :description => "Test parameter that can have argument", :alias => :oo
+    required :r, :description => "Test parameter that should have argument", :alias => [:rr, :rrr]
+  end
+
+  describe "class name detection" do
+    before(:all) do
+      @test_date = [
+        {:filename => "/prj/bin/nagios/some.rb", :parts => ['nagios','some'], :class => "Nagios::SomeNagiosScript", :files => ["app/models/nagios_script.rb", "app/models/bin/nagios/some_nagios_script.rb"]},
+        {:filename => "/prj/bin/another.rb", :parts => ['another'], :class => "AnotherScript", :files => ["app/models/bin/another_script.rb"]}
+      ]
+      @test_keys = [:parts, :class, :files]
+    end
+    it 'should detect class name and filenames from source script filename' do
+      @test_date.each do |test|
+        result = BinScript.parse_script_file_name(test[:filename])
+        @test_keys.each { |key| result[key].should == test[key] }
+      end
+    end
+  end
+
+  describe "parameters" do
+    it 'should accept string as description' do
+      TestScript.get_parameter(:n)[:description].should == "Test parameter that can't have argument"
+    end
+
+    it 'should accept hash as second parameter' do
+      TestScript.get_parameter(:o)[:description].should == "Test parameter that can have argument"
+    end
+
+    it "should accept parameters of all types" do
+      {:n => :noarg, :o => :optional, :r => :required}.each do |key,type|
+        TestScript.get_parameter(key)[:type].should == type
+      end
+    end
+
+    describe "required parameters" do
+      it "should return correct requred argument value" do
+        @script.override_parameters(:r => 'value')
+        @script.params(:r).should == 'value'
+      end
+    end
+
+    describe "overrided parameters for testing" do
+      it "should return false or true for noarg parameters even without value" do
+        @script.params(:n).should be_false
+        @script.override_parameters(:n)
+        @script.params(:n).should be_true
+      end
+
+      describe "optional parameters" do
+        it "should return nil if parameter not set or empty string if no argument defined" do
+          @script.params(:o).should be_nil
+          @script.override_parameters(:o)
+          @script.params(:o).should == ''
+        end
+
+        it "should return value of argument" do
+          @script.params(:o).should be_nil
+          @script.override_parameters(:o => 'value')
+          @script.params(:o).should == 'value'
+        end
+      end
+
+      describe "aliases" do
+        it 'should accept and handle one alias' do
+          @script.override_parameters(:o => 'value')
+          @script.params(:o).should == 'value'
+          @script.params(:o).should == @script.params(:oo)
+        end
+
+        it 'should accept and handle some alias' do
+          @script.override_parameters(:r => 'value')
+          @script.params(:r).should == 'value'
+          @script.params(:r).should == @script.params(:rr)
+          @script.params(:rr).should == @script.params(:rrr)
+        end
+
+        it 'should override parameters by alias' do
+          @script.override_parameters(:oo => 'value')
+          @script.params(:o).should == 'value'
+        end
+
+        describe "default values" do
+          class DevValTestScript < BinScript
+            optional :o, :default => "def opt value"
+            required :r, :default => "def req value"
+          end
+          it 'should return default value if value for optional argument was not defiend' do
+            DevValTestScript.new.params(:o).should == 'def opt value'
+            DevValTestScript.new.params(:r).should == 'def req value'
+          end
+        end
+      end
+    end
+  end
+
+  describe "usage" do
+    it "should generate usage message" do
+      USAGE = <<USAGE
+Use: ./bin/test_script.rb [OPTIONS]
+
+Availible options:
+
+  -e  Rails environment ID (default - development)
+  -h  Print usage message
+  -l  Path to log file (default \#{Rails.root}/log/[script_name].log
+  -L  Path to lock file (default \#{Rails.root}/lock/[script_name].lock
+  -n  Test parameter that can't have argument
+  -o  Test parameter that can have argument
+  -r  Test parameter that should have argument
+
+USAGE
+      TestScript.usage.should == USAGE
+    end
+  end
+
+  before(:each) do
+    @script = TestScript.new
+  end
+
+  describe "locking" do
+    it "should set default lock file" do
+      @script.lock_filename.should == File.join(Rails.root, %w{locks test_script.lock})
+    end
+
+    it "should overwrite lock filename with option -L" do
+      @script.override_parameters(:L => '/tmp/test_script.lock')
+      @script.lock_filename.should == '/tmp/test_script.lock'
+    end
+
+    it "should create lock file while execute do! and delete it after even when exceptions occurs" do
+      # Extend test script
+      class TestScript
+        attr_accessor :lock_file_has_been_created
+        attr_accessor :raise_before_finish
+        def do!
+          self.lock_file_has_been_created = File.exist?(lock_filename)
+          raise "Test exception" if self.raise_before_finish
+        end
+      end
+      @script.raise_before_finish = false
+      @script.lock_file_has_been_created.should_not be_true
+      @script.run!
+      @script.lock_file_has_been_created.should be_true
+      File.exist?(@script.lock_filename).should be_false
+
+      # And now test case when execptions occurs while script executed
+      @script.lock_file_has_been_created = false
+      @script.raise_before_finish = true
+      @script.run!
+      @script.lock_file_has_been_created.should be_true
+      @script.raise_before_finish = true
+      File.exist?(@script.lock_filename).should be_false
+    end
+  end
+
+  describe "logging" do
+    it "should set default log file correctly" do
+      @script.log_filename.should == File.join(Rails.root, %w{log test_script.log})
+    end
+
+    it "should overwrite log filename with option -l" do
+      @script.override_parameters(:l => '/tmp/test_script.log')
+      @script.log_filename.should == '/tmp/test_script.log'
+    end
+
+    it "should create default logger" do
+      default_log = File.join(Rails.root, %w{tmp test_script.log})
+      File.delete(default_log) if File.exist?(default_log)
+      @script.logger.should_not be_nil
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require 'rubygems'
+require "bundler"
+Bundler.setup
+ENV['RAILS_ENV'] ||= 'test'
+
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+require 'bin_script'

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification 
+name: bin_script
+version: !ruby/object:Gem::Version 
+  hash: 9
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- Lifshits Dmitry
+- Makarchev Konstantin
+autorequire: init
+bindir: bin
+cert_chain: []
+
+date: 2012-04-07 00:00:00 +04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        - 3
+        - 2
+        version: 2.3.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+description: Easy writing and executing bins (espesually for crontab or god) in Rails project
+email: kostya27@gmail.com
+executables: 
+- bin_helper
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.markdown
+- Rakefile
+- bin/bin_helper
+- bin_script.gemspec
+- init.rb
+- lib/bin_script.rb
+- lib/bin_script/bin_script.rb
+- lib/bin_script/class_inheritable_attributes.rb
+- lib/bin_script/lock_file.rb
+- lib/bin_script/version.rb
+- lib/bin_script/xlogger.rb
+- lib/generators/bin/bin_generator.rb
+- lib/generators/bin/templates/script.rb
+- lib/generators/bin/templates/script_class.rb
+- lib/generators/bin/templates/spec.rb
+- spec/bin_script_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/kostya/bin_script
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Easy writing and executing bins (espesually for crontab or god) in Rails project For my purposes much better than Rake, Thor and Rails Runner
+test_files: []
+