trackable_tasks 0.0.1

data/.document

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/CHANGELOG

@@ -0,0 +1,7 @@
+== 0.0.1
+
+* Initial release
+* TrackableTasks::Base class that determines how data is logged and stored
+* Includes tests that show how to instantiate the Base class to use a trackable task
+* TaskRun model that stores logging data associated with a trackable task
+* Set of rake tasks to instantiate and run the trackable tasks

data/Gemfile

@@ -0,0 +1,22 @@
+source "http://rubygems.org"
+
+gem "rails", "3.0.7"
+gem "capybara", ">= 0.4.0"
+gem "sqlite3"
+
+group :development do
+  gem 'ruby-debug19'
+  gem "rspec", "~> 2.6.0"
+  gem "rspec-rails", "~>2.6.1"
+  gem "yard", "~> 0.6.0"
+  gem "cucumber", ">= 0"
+  gem "cucumber-rails"
+  gem "database_cleaner"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.3"
+  gem "rcov", ">= 0"
+  gem "json"
+
+  # hudson ci
+  gem "ci_reporter"
+end

data/Gemfile.lock

@@ -0,0 +1,159 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.7)
+      actionpack (= 3.0.7)
+      mail (~> 2.2.15)
+    actionpack (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.5.0)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.14)
+      rack-test (~> 0.5.7)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.7)
+      activesupport (= 3.0.7)
+      builder (~> 2.1.2)
+      i18n (~> 0.5.0)
+    activerecord (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+      arel (~> 2.0.2)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.7)
+      activemodel (= 3.0.7)
+      activesupport (= 3.0.7)
+    activesupport (3.0.7)
+    archive-tar-minitar (0.5.2)
+    arel (2.0.10)
+    builder (2.1.2)
+    capybara (1.0.1)
+      mime-types (>= 1.16)
+      nokogiri (>= 1.3.3)
+      rack (>= 1.0.0)
+      rack-test (>= 0.5.4)
+      selenium-webdriver (~> 2.0)
+      xpath (~> 0.1.4)
+    childprocess (0.2.1)
+      ffi (~> 1.0.6)
+    ci_reporter (1.6.5)
+      builder (>= 2.1.2)
+    columnize (0.3.4)
+    cucumber (1.0.2)
+      builder (>= 2.1.2)
+      diff-lcs (>= 1.1.2)
+      gherkin (~> 2.4.5)
+      json (>= 1.4.6)
+      term-ansicolor (>= 1.0.5)
+    cucumber-rails (1.0.2)
+      capybara (>= 1.0.0)
+      cucumber (~> 1.0.0)
+      nokogiri (>= 1.4.6)
+    database_cleaner (0.6.7)
+    diff-lcs (1.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    ffi (1.0.9)
+    gherkin (2.4.16)
+      json (>= 1.4.6)
+    git (1.2.5)
+    i18n (0.5.0)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    json (1.5.3)
+    json_pure (1.5.3)
+    linecache19 (0.5.12)
+      ruby_core_source (>= 0.1.4)
+    mail (2.2.19)
+      activesupport (>= 2.3.6)
+      i18n (>= 0.4.0)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    mime-types (1.16)
+    nokogiri (1.5.0)
+    polyglot (0.3.2)
+    rack (1.2.3)
+    rack-mount (0.6.14)
+      rack (>= 1.0.0)
+    rack-test (0.5.7)
+      rack (>= 1.0)
+    rails (3.0.7)
+      actionmailer (= 3.0.7)
+      actionpack (= 3.0.7)
+      activerecord (= 3.0.7)
+      activeresource (= 3.0.7)
+      activesupport (= 3.0.7)
+      bundler (~> 1.0)
+      railties (= 3.0.7)
+    railties (3.0.7)
+      actionpack (= 3.0.7)
+      activesupport (= 3.0.7)
+      rake (>= 0.8.7)
+      thor (~> 0.14.4)
+    rake (0.9.2)
+    rcov (0.9.10)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    rspec-rails (2.6.1)
+      actionpack (~> 3.0)
+      activesupport (~> 3.0)
+      railties (~> 3.0)
+      rspec (~> 2.6.0)
+    ruby-debug-base19 (0.11.25)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby_core_source (>= 0.1.4)
+    ruby-debug19 (0.11.6)
+      columnize (>= 0.3.1)
+      linecache19 (>= 0.5.11)
+      ruby-debug-base19 (>= 0.11.19)
+    ruby_core_source (0.1.5)
+      archive-tar-minitar (>= 0.5.2)
+    rubyzip (0.9.4)
+    selenium-webdriver (2.5.0)
+      childprocess (>= 0.2.1)
+      ffi (>= 1.0.7)
+      json_pure
+      rubyzip
+    sqlite3 (1.3.4)
+    term-ansicolor (1.0.6)
+    thor (0.14.6)
+    treetop (1.4.10)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.29)
+    xpath (0.1.4)
+      nokogiri (~> 1.3)
+    yard (0.6.8)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  capybara (>= 0.4.0)
+  ci_reporter
+  cucumber
+  cucumber-rails
+  database_cleaner
+  jeweler (~> 1.6.3)
+  json
+  rails (= 3.0.7)
+  rcov
+  rspec (~> 2.6.0)
+  rspec-rails (~> 2.6.1)
+  ruby-debug19
+  sqlite3
+  yard (~> 0.6.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Jeremiah Hemphill
+
+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.rdoc

@@ -0,0 +1,77 @@
+= trackable_tasks
+
+A wrapper for rake tasks that include logging and stats.
+
+= Installation
+
+Add the gem to your gem file.
+
+    gem "trackable_tasks"
+
+Run the install generator and migrate.
+
+    rails generate trackable_tasks:install
+    rake db:migrate
+
+The generator also adds lib/tasks/trackable_tasks.rake.  There should be a new rake task called trackable_task:run.
+
+= How to use
+
+Create a trackable task.  Override the run method and put the code that needs to be tracked inside.
+
+  class MyTask < AbstractTrackableTask
+    def run 
+      log "hello"
+    end 
+  end
+
+This creates a new dynamic rake task.  Run the trackable task using either rake task.  The RAISL_ENV can also be specified here.
+
+  rake trackable_task:my_task
+  rake trackable_task:run task_num=my_task
+
+The results can be found by looking in:
+
+  TrackableTasks::TaskRun.last
+
+The log_text and error_text methods store logging and error information.  If an exception is generated by the run method, it's message is stored to the error_text, and success is set to false.
+
+= Logging
+
+Log levels can be set when running with a rake task
+
+  rake trackable_task:my_task log_level=notice
+  rake trackable_task:run task_num=my_task log_level=error
+
+Setting the log level here determines the highest level of logs that will be saved by the task.  The three log levels are 'error', 'notice', and 'debug'.
+
+- Error: only store error messages; task_run.log_text should not be used
+- Notice: store error messages and notice messages; this is the default level
+- Debug: store all messages
+
+Inside the script, the log function is used to store data to the task_run logs.
+
+  log("this is an error log", :error)
+  log("this is a notice log")
+  log("this is a debug log", :debug)
+
+The error level logs write to task_run.log_text.  Notice and debug level logs write to task_run.log_text.
+
+== Future Work
+
+* Adding a basic controller and views to show the trackable task runs.
+
+== Contributing to trackable_tasks
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Jeremiah Hemphill. See LICENSE.txt for
+further details.

data/Rakefile

@@ -0,0 +1,90 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "trackable_tasks"
+  gem.homepage = "http://github.com/jeremiahishere/trackable_tasks"
+  gem.license = "MIT"
+  gem.summary = %Q{Adds tracking to rake tasks}
+  gem.description = %Q{Adds tracking to rake tasks including error capturing and logging.}
+  gem.email = "jeremiah@cloudspace.com"
+  gem.authors = ["Jeremiah Hemphill"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new(:features)
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new
+
+# hudson ci
+require 'ci/reporter/rake/rspec'
+namespace :hudson do
+  def report_path
+    "spec/reports/"
+  end
+
+  task :report_setup do
+    rm_rf report_path
+    mkdir_p report_path
+  end
+
+  # hudson cucumber rake task
+  Cucumber::Rake::Task.new(:cucumber, "Run cucumber with hudson output") do |t|
+    t.cucumber_opts = %{spec/dummy/features --format junit --out #{report_path}}
+  end
+end
+
+#general cucumber rake tasks
+require 'cucumber/rake/task'
+namespace :cucumber do
+  Cucumber::Rake::Task.new(:all, 'run features that should pass') do |t|
+    t.cucumber_opts = "spec/dummy/features --format progress"
+  end
+  Cucumber::Rake::Task.new(:no_js, 'run features that should pass') do |t|
+    t.cucumber_opts = "spec/dummy/features --format progress --tags ~@javascript"
+  end
+
+  task :setup_js_with_vnc4server do
+    puts "Cucumber test with vnc4server"
+    ENV['DISPLAY'] = ":99"
+    %x{vncserver :99 2>/dev/null >/dev/null &}
+    %x{DISPLAY=:99 firefox 2>/dev/null >/dev/null &}
+  end
+
+  task :kill_js do
+    puts "Killing vnc, xvfb, and ff processes"
+    %x{killall Xvnc4}
+    %x{killall Xvfb}
+    %x{killall firefox}
+  end
+end
+#task :cucumber => ['cucumber:setup_js_with_vnc4server', 'cucumber:all', 'cucumber:kill_js']
+task :cucumber => ['cucumber:all']

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/app/models/trackable_tasks/task_run.rb

@@ -0,0 +1,39 @@
+module TrackableTasks
+  # Stores information about a single execution of a trackable task
+  # Records errors and logs, and gives information about how long the execution took
+  class TaskRun < ActiveRecord::Base
+    set_table_name "trackable_tasks_task_runs"
+
+    validates_presence_of :start_time, :task_type
+    validates_inclusion_of :success, :in => [true, false]
+    validate :end_time_after_start_time
+
+    # adds an error if the end time is after the start time
+    # does not add an error if the end time is not set
+    def end_time_after_start_time
+      if self.end_time && self.end_time < self.start_time
+        self.errors.add(:end_time, "The end time must be after the start time")
+      end
+    end
+
+    # Appends the input text onto the log text
+    #
+    # I am aware that these two methods are duplicates nd we could merge them
+    # I am not convinced that the code would be any more readable or maintainable
+    # It does cut down the number of tests though
+    #
+    # @param [String] text The text to append to the log text
+    def add_log_text(text)
+      self.log_text = "" if self.log_text.nil?
+      self.log_text += text + "\n"
+    end
+
+    # Appends the input text onto the error text
+    #
+    # @param [String] text The text to append to the error text
+    def add_error_text(text)
+      self.error_text = "" if self.error_text.nil?
+      self.error_text += text + "\n"
+    end
+  end
+end

data/lib/generators/trackable_tasks/install_generator.rb

@@ -0,0 +1,43 @@
+require 'rails/generators'
+require 'rails/generators/migration'
+require 'active_record'
+require 'rails/generators/active_record'
+
+module TrackableTasks 
+  module Generators
+    # Generator for copying the base migration and the rakefile to the including project
+    #
+    # @author Jeremiah Hemphill
+    class InstallGenerator < Rails::Generators::Base
+      include Rails::Generators::Migration
+
+      source_root File.expand_path(File.join(File.dirname(__FILE__), "templates"))
+
+      desc <<DESC
+Description:
+  Copies over migrations and rakefile for the trackable tasks system.
+DESC
+      # Implement the required interface for Rails::Generators::Migration.
+      # thanks Kaminari gem for this bit of code
+      def self.next_migration_number(dirname) #:nodoc:
+        next_migration_number = current_migration_number(dirname) + 1
+        if ActiveRecord::Base.timestamped_migrations
+          [Time.now.utc.strftime("%Y%m%d%H%M%S"), "%.14d" % next_migration_number].max
+        else
+          "%.3d" % next_migration_number
+        end
+      end
+
+      # Creates the rake file
+      def copy_rake_file
+        copy_file "trackable_tasks.rake", "lib/tasks/trackable_tasks.rake"
+      end
+
+      # Creates the migration
+      def copy_migration
+        migration_template "migrations/install_migration.rb.erb", "db/migrate/create_trackable_task_tables.rb"
+      end
+    end
+  end
+end
+

data/lib/generators/trackable_tasks/templates/migrations/install_migration.rb.erb

@@ -0,0 +1,16 @@
+class <%= migration_class_name %> < ActiveRecord::Migration
+  def self.up
+    create_table :trackable_tasks_task_runs do |t|
+      t.string :task_type
+      t.datetime :start_time
+      t.datetime :end_time
+      t.text :error_text
+      t.text :log_text
+      t.boolean :success, :default => false
+    end 
+  end
+
+  def self.down
+    drop_table :task_runs
+  end
+end

data/lib/generators/trackable_tasks/templates/trackable_tasks.rake

@@ -0,0 +1,48 @@
+include Rake::DSL
+
+# Careful when editing this file.  It may be overwritten when the gem is updated.
+namespace :trackable_task do
+
+  # loads the trackable tasks from /lib/trackable_tasks
+  # this may be moved to a config file at some point
+  trackable_task_list = []
+  Dir.foreach("#{::Rails.root.to_s}/lib/trackable_tasks/") do |file_name|
+    next if file_name == "." || file_name == ".."
+    file_name['.rb'] = ''
+    trackable_task_list.push(file_name.to_sym)
+  end
+
+  # turns the array of trackable tasks into individual rake tasks
+  trackable_task_list.each do |task_name|
+    desc "Trackable task for #{task_name.to_s.camelize}.  Optionally set the log_level ENV variable to debug, notice, and error."
+    task task_name => :environment do |t|
+      log_level = ENV["log_level"]
+      run_trackable_task(task_name.to_s, log_level)
+    end
+  end
+
+  # single rake task that can run any trackable task
+  desc "Runs a trackable task by passing in the task as an argument"
+  task :run => :environment do |t|
+    task_name = ENV["task_name"]
+    log_level = ENV["log_level"]
+    run_trackable_task(task_name, log_level)
+  end
+
+  # Runs the trackable task by constantizing the task name, initializing, and calling run task
+  #
+  # @param [String] The name of the task class
+  # @param [String] The log level for the task
+  def run_trackable_task(task_name, log_level)
+    #puts "I am running #{task_name} at log level #{log_level}"
+    require "#{::Rails.root.to_s}/lib/trackable_tasks/#{task_name}.rb"
+    # if the class exists
+    task = task_name.camelize.constantize.new(log_level)
+    # if the class has a superclass of trackable task base
+    if task.class.superclass == TrackableTasks::Base
+      task.run_task
+    else
+      puts "The task #{task_name} was not an instance of TrackableTasks::Base."
+    end
+  end
+end

data/lib/trackable_tasks/base.rb

@@ -0,0 +1,87 @@
+require 'ruby-debug'
+
+module TrackableTasks
+  # Abstract trackable task to be overriden when creating a trackable task.
+  #
+  # Usage:
+  #
+  # Create a class
+  # MyGenericTask < TrackableTasks:Base
+  #
+  # Override the run method
+  # def run
+  #   puts "Running my own code"
+  # end
+  #
+  # Instantiate and call run_task
+  #
+  # my_generic_task = MyGenericTask.new
+  # my_generic_task.run_task
+  #
+  # Bask in the glory of your saved logging information
+  #
+  # puts TrackableTasks.TaskRun.last.log_text
+  class Base
+
+    # Initializes the task run and sets the start time
+    #
+    # @param [Symbol] log_level The log level for the task, defaults to notice
+    def initialize(log_level = :notice)
+      @task_run = TrackableTasks::TaskRun.create(:start_time => Time.now, :task_type => self.class.name, :success => true)
+
+      @log_levels = [:debug, :notice, :error]
+      @log_level = allowable_log_level(log_level)
+    end
+
+    # Checks if the log level is an allowable level, then returns it or notice if it is not allowable
+    #
+    # @param [Sybmol] log_level Log level to check
+    # @return [Symbol] The given log level or notice if it is not allowable
+    def allowable_log_level(log_level) 
+      log_level = "" if log_level.nil?
+      log_level = log_level.to_sym unless log_level.is_a?(Symbol)
+      if !@log_levels.include?(log_level)
+        log_level = :notice
+      end
+      return log_level
+    end
+
+    # this calls task with error catching
+    # if an error is caught, sets success to false and records the error
+    # either way, sets an end time and saves the task run information
+    def run_task
+      begin
+        run 
+      rescue Exception => e
+        @task_run.add_error_text(e.class.name + ": " + e.message)
+        @task_run.success = false
+      end 
+      @task_run.end_time = Time.now
+      @task_run.save
+    end
+    
+    # The run method must be overridden for the task to work
+    # code for the actual task goes here
+    def run
+      raise NotImplementedError.new("The run method must be overridden")
+    end
+
+    # Adds test to the log for the task run
+    # Depending on the @log_level, save or don't save the text
+    # If the level is :error, save to the error log
+    #
+    # @param [String] text The text to add to the log
+    # @param [Symbol] level The log level of the text
+    def log(text, level = :notice)
+      level = allowable_log_level(level)
+
+      if level == :debug && @log_level == :debug
+        @task_run.add_log_text(text)
+      elsif level == :notice && (@log_level == :debug || @log_level == :notice)
+        @task_run.add_log_text(text)
+      elsif level == :error
+        @task_run.add_error_text(text)
+      end
+    end
+  end
+end

data/lib/trackable_tasks/engine.rb

@@ -0,0 +1,7 @@
+require "rails"
+
+module TrackableTasks 
+  class Engine < ::Rails::Engine
+  end
+end
+

data/lib/trackable_tasks/railtie.rb

@@ -0,0 +1,11 @@
+require 'rails'
+
+require 'trackable_tasks/config'
+
+module TrackableTasks
+  class Railtie < ::Rails::Railtie
+    initializer 'trackable_tasks' do |app|
+      # add mixins here
+    end
+  end
+end

data/lib/trackable_tasks.rb

@@ -0,0 +1,5 @@
+# make the TrackableTasks::Base available inside the project
+require File.join(%w{trackable_tasks base})
+
+require "trackable_tasks/engine"
+#require "trackable_tasks/railtie"

data/spec/dummy/Rakefile

@@ -0,0 +1,7 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+require 'rake'
+
+Dummy::Application.load_tasks

data/spec/dummy/app/controllers/application_controller.rb

@@ -0,0 +1,3 @@
+class ApplicationController < ActionController::Base
+  protect_from_forgery
+end

data/spec/dummy/app/helpers/application_helper.rb

@@ -0,0 +1,2 @@
+module ApplicationHelper
+end