adhoc_script 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+*.gem
+*.rbc
+.bundle

data/Gemfile

@@ -0,0 +1,2 @@
+source :rubygems
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Ryan Funduk 2013
+
+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.md

@@ -0,0 +1,84 @@
+# AdhocScript
+
+So many times, mostly in Rails app, I find myself making a file
+like `bin/adhoc/regen_user_avatar_jan_2013.rb` that goes like this:
+
+~~~ ruby
+require File.expand_path( '../config/environment.rb', __FILE__ )
+
+User.where( 'avatar_upload IS NOT NULL' ).find_each do |user|
+  user.regenerate_avatar!
+end
+~~~
+
+...or something along those lines. And then I want to know, well, how
+long will this take? How far through all these users am I?
+
+What I _don't_ want to do is implement this progress status stuff everytime
+myself. So now I can just use `AdhocScript` :)
+
+
+## Installation
+
+Most likely you update your Gemfile and `bundle install`.
+
+~~~ ruby
+gem 'adhoc_script', require: false
+~~~
+
+
+## Usage
+
+The script above becomes:
+
+~~~ ruby
+require File.expand_path( '../config/environment.rb', __FILE__ )
+require 'adhoc_script'
+
+scope = User.where( 'avatar_upload IS NOT NULL' )
+AdhocScript.new( 'Regenerating avatars', scope ).run do |user|
+  user.regenerate_avatar!
+end
+~~~
+
+...almost the same, really. But the output looks like this:
+
+~~~
+- Regenerating avatars: 50% (Remaining: 26 minutes)
+~~~
+
+...and then a little while later:
+
+~~~
+/ Regenerating avatars: 75% (Remaining: 13 minutes)
+~~~
+
+You can also use it with just about any object that responds to `#count`:
+
+~~~ ruby
+#!/usr/bin/env ruby
+# A completely rediculous example!
+
+require 'adhoc_script'
+
+$total = 0
+def add( n )
+  $total += n
+end
+
+AdhocScript.new( 'Count to 10000', (1..100000), :each ).run(&method(:add))
+
+puts "Total: #{$total}"
+~~~
+
+
+
+## Contributing
+
+Maybe we could use a few other formatters? A progress bar, etc?
+
+1. Clone git://github.com/rfunduk/adhoc_script.git
+2. Create local branch.
+3. Make changes.
+4. `rake test` and return to 3 until passing.
+5. Commit, push and open a pull request.

data/Rakefile

@@ -0,0 +1,5 @@
+task :test do
+  ruby "test/*_test.rb"
+end
+
+task :default => [:test]

data/adhoc_script.gemspec

@@ -0,0 +1,17 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/adhoc_script', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors        = ["Ryan Funduk"]
+  gem.email          = ["ryan.funduk@gmail.com"]
+  gem.description    = %q{A simple wrapper class for running adhoc scripts on sets of data.}
+  gem.summary        = %q{}
+  gem.homepage       = "http://github.com/rfunduk/adhoc_script"
+
+  gem.executables    = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files          = `git ls-files`.split("\n")
+  gem.test_files     = `git ls-files -- test/*`.split("\n")
+  gem.name           = "adhoc_script"
+  gem.require_paths  = ["lib"]
+  gem.version        = '0.0.1'
+end

data/lib/adhoc_script.rb

@@ -0,0 +1,127 @@
+AdhocScript = Struct.new( :description, :scope, :method, :params ) do
+  SYMBOLS = ['-', "\\", '|', '/', '-', "\\", '|', '/']
+  RECENT_WINDOW = 10
+
+  def initialize( *args )
+    super
+
+    self.method ||= :find_each # the method to call on the scope
+    self.params ||= []         # the arguments to @method
+
+    unless self.scope.respond_to?(:count)
+      raise ArgumentError.new( "#{self.scope.inspect} does not respond to `#count`" )
+    end
+    unless self.scope.respond_to?(self.method)
+      raise ArgumentError.new( "#{self.scope.inspect} does not respond to `##{self.method}`" )
+    end
+
+    @terminal_columns = `/usr/bin/env tput cols`.to_i
+  end
+
+  def run( blk=nil )
+    unless blk.respond_to?(:call) || block_given?
+      raise ArgumentError.new( "A block or other callable is required to #run" )
+    end
+
+    reset
+    print_progress
+
+    scope.send( method, *params ) do |*args|
+      begin
+        block_given? ?
+          yield( *args ) :
+          blk.call( *args )
+        @current += 1
+        @complete = (@current / @total.to_f) * 100
+        print_progress
+      rescue => e
+        print_error( e, args )
+        return
+      end
+    end
+
+    print_progress
+    logger.puts "\n"
+  end
+
+  @logger = $stdout
+  def self.logger=( logger ); @logger = logger; end
+  def self.logger; @logger; end
+  def logger; self.class.logger; end
+
+  private
+
+  def reset
+    @start_time = Time.now.to_i # timestamp
+    @symbols = SYMBOLS.dup      # nice rotating symbols :)
+    @complete = 0.0             # completion percentage
+    @current = 0                # index of current item
+    @total = scope.count        # total items to process
+    @recent_times = []          # last RECENT_WINDOW items process time
+  end
+
+  def time_remaining
+    now = Time.now.to_i
+    creep = (((now - @start_time) * 100) / @complete) - (now - @start_time)
+    @recent_times = (@recent_times.unshift(creep)).slice( 0, RECENT_WINDOW )
+    estimated_complete_time = now + (@recent_times.inject(:+) / @recent_times.size).to_i rescue nil
+    distance_of_time_in_words( now, estimated_complete_time )
+  end
+
+  def next_symbol
+    case completion_percentage
+    when 100 then return '*'
+    when 0 then return '-'
+    else return @symbols.push( @symbols.shift ).first
+    end
+  end
+
+  def distance_of_time_in_words( from, to )
+    return nil if to.nil? || completion_percentage == 0 || @recent_times.empty?
+
+    distance_in_seconds = (to - from).abs
+    distance_in_minutes = (distance_in_seconds / 60.0).round
+
+    case distance_in_minutes
+    when 0
+      case distance_in_seconds
+      when 0..9 then 'less than 10 seconds'
+      when 10..50 then "#{distance_in_seconds} seconds"
+      else "less than 1 minute"
+      end
+    when 1 then "1 minute"
+    when 2..44 then "#{distance_in_minutes} minutes"
+    when 45..89 then "about 1 hour"
+    when 90..1439 then "about #{(distance_in_minutes / 60.0).round} hours"
+    when 1440..2519 then "1 day"
+    when 2520..43199 then "#{(distance_in_minutes / 1440.0).round} days"
+    else "an extremely long time"
+    end
+  end
+
+  def completion_percentage
+    @complete.ceil.to_i
+  end
+
+  def print_progress
+    report = "#{next_symbol} #{description}: #{completion_percentage}%"
+    unless (tr = time_remaining).nil?
+      report += " (Remaining: #{tr})"
+    end
+
+    output = report.ljust(description.length + 50)
+    output = output.slice( 0, @terminal_columns - 1 ) if @terminal_columns != 0
+
+    logger.print output + "\r"
+  end
+
+  def print_error( e, args )
+    # this is just for error handling/output purposes
+    klass = scope.respond_to?(:klass) ? scope.klass : scope.class
+    logger.print "\n\n"
+    logger.puts "Script failed at #{completion_percentage}% on #{klass.name.to_s} with arguments: #{args.inspect}!"
+    logger.print "\n\n"
+    logger.puts e.message
+    logger.puts e.backtrace.join("\n")
+  end
+end

data/test/adhoc_script_test.rb

@@ -0,0 +1,59 @@
+require_relative '../lib/adhoc_script'
+require_relative './fake_model'
+require 'minitest/autorun'
+require 'minitest/unit'
+
+AdhocScript.logger = File.open( "/dev/null", 'w' )
+
+describe AdhocScript do
+
+  it 'performs the base case' do
+    adhoc = AdhocScript.new( 'Going through stuff', FakeModel )
+    count = FakeModel::COUNT
+    adhoc.run { count -= 1 }
+    assert_equal 0, count
+  end
+
+  it 'works on other objects' do
+    count = 100
+    adhoc = AdhocScript.new( "Counting up to #{count}", (1..count), :each )
+    adhoc.run { count -= 1 }
+    assert_equal 0, count
+  end
+
+  it 'requires that the target responds to `#count`' do
+    assert_raises( ArgumentError ) do
+      AdhocScript.new( "Fail", 1 )
+    end
+  end
+
+  it 'requires that the target responds to the method specified' do
+    assert_raises( ArgumentError ) do
+      AdhocScript.new( "Fail", [1,2,3], :nope )
+    end
+  end
+
+  it 'requires a block (or other callable) to `#run`' do
+    adhoc = AdhocScript.new( "Fail", [1,2,3], :each )
+    assert_raises( ArgumentError ) { adhoc.run }
+    assert_raises( ArgumentError ) { adhoc.run( 1 ) }
+  end
+
+  it '`#run` accepts anything which can be `#call`ed' do
+    count = 100
+    adhoc = AdhocScript.new( "Counting up to #{count}", (1..count), :each )
+    callable = ->( i ) { count -= 1 }
+
+    adhoc.run( callable )
+    assert_equal 0, count
+
+    count = 100
+    adhoc.run( &callable )
+    assert_equal 0, count
+
+    count = 100
+    adhoc.run { |i| callable.(i) }
+    assert_equal 0, count
+  end
+
+end

data/test/fake_model.rb

@@ -0,0 +1,11 @@
+class FakeModel
+  COUNT = 10
+  def self.find_each( &block )
+    COUNT.times do
+      yield 1
+    end
+  end
+  def self.count
+    COUNT
+  end
+end

metadata

@@ -0,0 +1,56 @@
+--- !ruby/object:Gem::Specification
+name: adhoc_script
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Ryan Funduk
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-25 00:00:00.000000000 Z
+dependencies: []
+description: A simple wrapper class for running adhoc scripts on sets of data.
+email:
+- ryan.funduk@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- adhoc_script.gemspec
+- lib/adhoc_script.rb
+- test/adhoc_script_test.rb
+- test/fake_model.rb
+homepage: http://github.com/rfunduk/adhoc_script
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: ''
+test_files:
+- test/adhoc_script_test.rb
+- test/fake_model.rb