gigantron 0.1.2 → 0.1.3

data/app_generators/gigantron/templates/lib/shoulda/general.rb

@@ -0,0 +1,118 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    module General
+      def self.included(other) # :nodoc:
+        other.class_eval do
+          extend ThoughtBot::Shoulda::General::ClassMethods
+        end
+      end
+      
+      module ClassMethods
+        # Loads all fixture files (<tt>test/fixtures/*.yml</tt>)
+        def load_all_fixtures
+          all_fixtures = Dir.glob(File.join(Test::Unit::TestCase.fixture_path, "*.yml")).collect do |f| 
+            File.basename(f, '.yml').to_sym
+          end
+          fixtures *all_fixtures
+        end
+      end
+      
+      # Prints a message to stdout, tagged with the name of the calling method.
+      def report!(msg = "")
+        puts("#{caller.first}: #{msg}")
+      end
+
+      # Asserts that two arrays contain the same elements, the same number of times.  Essentially ==, but unordered.
+      #
+      #   assert_same_elements([:a, :b, :c], [:c, :a, :b]) => passes
+      def assert_same_elements(a1, a2, msg = nil)
+        [:select, :inject, :size].each do |m|
+          [a1, a2].each {|a| assert_respond_to(a, m, "Are you sure that #{a.inspect} is an array?  It doesn't respond to #{m}.") }
+        end
+
+        assert a1h = a1.inject({}) { |h,e| h[e] = a1.select { |i| i == e }.size; h }
+        assert a2h = a2.inject({}) { |h,e| h[e] = a2.select { |i| i == e }.size; h }
+
+        assert_equal(a1h, a2h, msg)
+      end
+
+      # Asserts that the given collection contains item x.  If x is a regular expression, ensure that
+      # at least one element from the collection matches x.  +extra_msg+ is appended to the error message if the assertion fails.
+      #
+      #   assert_contains(['a', '1'], /\d/) => passes
+      #   assert_contains(['a', '1'], 'a') => passes
+      #   assert_contains(['a', '1'], /not there/) => fails
+      def assert_contains(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} not found in #{collection.to_a.inspect} #{extra_msg}"
+        case x
+        when Regexp: assert(collection.detect { |e| e =~ x }, msg)
+        else         assert(collection.include?(x), msg)
+        end        
+      end
+
+      # Asserts that the given collection does not contain item x.  If x is a regular expression, ensure that
+      # none of the elements from the collection match x.
+      def assert_does_not_contain(collection, x, extra_msg = "")
+        collection = [collection] unless collection.is_a?(Array)
+        msg = "#{x.inspect} found in #{collection.to_a.inspect} " + extra_msg
+        case x
+        when Regexp: assert(!collection.detect { |e| e =~ x }, msg)
+        else         assert(!collection.include?(x), msg)
+        end        
+      end
+      
+      # Asserts that the given object can be saved
+      #
+      #  assert_save User.new(params)
+      def assert_save(obj)
+        assert obj.save, "Errors: #{pretty_error_messages obj}"
+        obj.reload
+      end
+
+      # Asserts that the given object is valid
+      #
+      #  assert_valid User.new(params)
+      def assert_valid(obj)
+        assert obj.valid?, "Errors: #{pretty_error_messages obj}"
+      end
+      
+      # Asserts that an email was delivered.  Can take a block that can further
+      # narrow down the types of emails you're expecting. 
+      #
+      #  assert_sent_email 
+      #
+      # Passes if ActionMailer::Base.deliveries has an email
+      #  
+      #  assert_sent_email do |email|
+      #    email.subject =~ /hi there/ && email.to.include?('none@none.com')
+      #  end
+      #  
+      # Passes if there is an email with subject containing 'hi there' and
+      # 'none@none.com' as one of the recipients.
+      #    
+      def assert_sent_email
+        emails = ActionMailer::Base.deliveries
+        assert !emails.empty?, "No emails were sent"
+        if block_given?
+          matching_emails = emails.select {|email| yield email }
+          assert !matching_emails.empty?, "None of the emails matched."
+        end
+      end
+
+      # Asserts that no ActionMailer mails were delivered
+      #
+      #  assert_did_not_send_email
+      def assert_did_not_send_email
+        msg = "Sent #{ActionMailer::Base.deliveries.size} emails.\n"
+        ActionMailer::Base.deliveries.each { |m| msg << "  '#{m.subject}' sent to #{m.to.to_sentence}\n" }
+        assert ActionMailer::Base.deliveries.empty?, msg
+      end
+
+      def pretty_error_messages(obj)
+        obj.errors.map { |a, m| "#{a} #{m} (#{obj.send(a).inspect})" }
+      end
+      
+    end
+  end
+end

data/app_generators/gigantron/templates/lib/shoulda/private_helpers.rb

@@ -0,0 +1,22 @@
+module ThoughtBot # :nodoc:
+  module Shoulda # :nodoc:
+    module Private # :nodoc:
+      # Returns the values for the entries in the args hash who's keys are listed in the wanted array.
+      # Will raise if there are keys in the args hash that aren't listed.
+      def get_options!(args, *wanted)
+        ret  = []
+        opts = (args.last.is_a?(Hash) ? args.pop : {})
+        wanted.each {|w| ret << opts.delete(w)}
+        raise ArgumentError, "Unsupported options given: #{opts.keys.join(', ')}" unless opts.keys.empty?
+        return *ret
+      end
+
+      # Returns the model class constant, as determined by the test class name.
+      #
+      #   class TestUser; model_class; end => User
+      def model_class
+        self.name.gsub(/^Test/, '').constantize
+      end
+    end
+  end
+end

data/app_generators/gigantron/templates/tasks/import.rake

@@ -0,0 +1,10 @@
+desc "Import data into the database"
+task :import do
+  # Acquire your data (e.g. from input/ or something) and parse it into
+  # your database.  Your models should probably be the ones doing the heavy
+  # lifting on this one.
+  #
+  # Ex:
+  #   Foo.import_yaml(FileList["input/*.yml"].to_a)
+  get_db_conn(ENV["GTRON_ENV"] || GTRON_ENV)
+end

data/app_generators/gigantron/templates/test/tasks/test_import.rb

@@ -0,0 +1,23 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class TestImport < Test::Unit::TestCase
+  def setup
+    get_db_conn(GTRON_ENV)
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    load File.dirname(__FILE__) + '/../../tasks/import.rake'
+  end
+
+  should "import data" do
+    # Testing rake is a bit different
+    # http://blog.nicksieger.com/articles/2007/06/11/test-your-rake-tasks
+    # Example:
+    #   @rake["task_name"].invoke
+    @rake["import"].invoke
+    assert true
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+end

data/app_generators/gigantron/templates/test/test_helper.rb

@@ -0,0 +1,22 @@
+require 'rubygems'
+require 'test/unit'
+
+require 'gigantron/migrator'
+require File.dirname(__FILE__) + '/../initialize'
+silence_warnings { GTRON_ENV = :test }
+ENV['GTRON_ENV'] = 'test'
+
+require 'shoulda'
+require 'shoulda/private_helpers'
+require 'shoulda/general'
+require 'shoulda_active_record_helpers'
+
+module Test
+  module Unit
+    class TestCase
+      include ThoughtBot::Shoulda::General
+      extend ThoughtBot::Shoulda::ActiveRecord
+    end
+  end
+end
+

data/bin/gigantron

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rubigen'
+
+if %w(-v --version).include? ARGV.first
+  require 'gigantron/version'
+  puts "#{File.basename($0)} #{Gigantron::VERSION::STRING}"
+  exit(0)
+end
+
+require 'rubigen/scripts/generate'
+source = RubiGen::PathSource.new(:application, 
+  File.join(File.dirname(__FILE__), "../app_generators"))
+RubiGen::Base.reset_sources
+RubiGen::Base.append_sources source
+RubiGen::Scripts::Generate.new.run(ARGV, :generator => 'gigantron')

data/config/hoe.rb

@@ -0,0 +1,82 @@
+require 'gigantron/version'
+
+AUTHOR = 'Ben Hughes'  # can also be an array of Authors
+EMAIL = "ben@pixelmachine.org"
+DESCRIPTION = "description of gem"
+GEM_NAME = 'gigantron' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'gigantron' # The unix name for your project
+HOMEPATH = "http://#{RUBYFORGE_PROJECT}.rubyforge.org"
+DOWNLOAD_PATH = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+EXTRA_DEPENDENCIES = [
+  ['activesupport', '>= 2.0.2'],
+  ['rubigen', '>= 1.3.2'],
+  ['rake', '>= 0.8.1'],
+  ['Shoulda', '>= 1.1.1'],
+  ['activerecord', '>= 2.0.2'],
+]    # An array of rubygem dependencies [name, version]
+
+@config_file = "~/.rubyforge/user-config.yml"
+@config = nil
+RUBYFORGE_USERNAME = "unknown"
+def rubyforge_username
+  unless @config
+    begin
+      @config = YAML.load(File.read(File.expand_path(@config_file)))
+    rescue
+      puts <<-EOS
+ERROR: No rubyforge config file found: #{@config_file}
+Run 'rubyforge setup' to prepare your env for access to Rubyforge
+ - See http://newgem.rubyforge.org/rubyforge.html for more details
+      EOS
+      exit
+    end
+  end
+  RUBYFORGE_USERNAME.replace @config["username"]
+end
+
+
+REV = nil
+# UNCOMMENT IF REQUIRED:
+# REV = YAML.load(`svn info`)['Revision']
+VERS = Gigantron::VERSION::STRING + (REV ? ".#{REV}" : "")
+RDOC_OPTS = ['--quiet', '--title', 'gigantron documentation',
+    "--opname", "index.html",
+    "--line-numbers",
+    "--main", "README",
+    "--inline-source"]
+
+
+class Hoe
+  silence_warnings do
+    RUBY_FLAGS = "-I#{%w(lib ext bin test).join(File::PATH_SEPARATOR)}" +
+      (ENV['RUBY_DEBUG'] ? " #{ENV['RUBY_DEBUG']}" : '')
+  end
+  def extra_deps
+    @extra_deps.reject! { |x| Array(x).first == 'hoe' }
+    @extra_deps
+  end
+end
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.new(GEM_NAME, VERS) do |p|
+  p.developer(AUTHOR, EMAIL)
+  p.description = DESCRIPTION
+  p.summary = DESCRIPTION
+  p.url = HOMEPATH
+  p.rubyforge_name = RUBYFORGE_PROJECT if RUBYFORGE_PROJECT
+  p.test_globs = ["test/**/test_*.rb"]
+  p.clean_globs |= ['**/.*.sw?', '*.gem', '.config', '**/.DS_Store']  #An array of file patterns to delete on clean.
+
+  # == Optional
+  p.changes = p.paragraphs_of("History.txt", 0..1).join("\n\n")
+  p.extra_deps = EXTRA_DEPENDENCIES
+
+    #p.spec_extras = {}    # A hash of extra values to set in the gemspec.
+  end
+
+CHANGES = $hoe.paragraphs_of('History.txt', 0..1).join("\\n\\n")
+PATH    = (RUBYFORGE_PROJECT == GEM_NAME) ? RUBYFORGE_PROJECT : "#{RUBYFORGE_PROJECT}/#{GEM_NAME}"
+$hoe.remote_rdoc_dir = File.join(PATH.gsub(/^#{RUBYFORGE_PROJECT}\/?/,''), 'rdoc')
+$hoe.rsync_args = '-av --delete --ignore-errors'
+$hoe.spec.post_install_message = File.open(File.dirname(__FILE__) + "/../PostInstall.txt").read rescue ""

data/config/requirements.rb

@@ -0,0 +1,15 @@
+require 'fileutils'
+include FileUtils
+
+require 'rubygems'
+%w[rake hoe newgem rubigen activerecord activesupport shoulda].each do |req_gem|
+  begin
+    require req_gem
+  rescue LoadError
+    puts "This Rakefile requires the '#{req_gem}' RubyGem."
+    puts "Installation: gem install #{req_gem} -y"
+    exit
+  end
+end
+
+$:.unshift(File.join(File.dirname(__FILE__), %w[.. lib]))

data/gigantron_generators/mapreduce_task/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/gigantron_generators/mapreduce_task/mapreduce_task_generator.rb

@@ -0,0 +1,54 @@
+class MapreduceTaskGenerator < RubiGen::Base
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory 'test/'
+      m.directory 'test/tasks/'
+      m.template "test/tasks/test_task.rb", "test/tasks/test_#{@name}.rb"
+      m.directory 'tasks/'
+      m.template "tasks/task.rake", "tasks/#{@name}.rake"
+      m.directory 'mapreduce/'
+      m.template "mapreduce/mr_task.rb", "mapreduce/mr_#{@name}.rb"
+
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{$0} #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+end

data/gigantron_generators/mapreduce_task/templates/mapreduce/mr_task.rb

@@ -0,0 +1,22 @@
+class MapReduce<%= name.camelcase %>
+  include SkynetDebugger
+
+  def self.run
+    job = Skynet::Job.new(
+      :mappers => 2, #change to whatever is a good number
+      :reducers => 1, #same
+      :map_reduce_class => self,
+      :map_data => [] #acquire your data!
+    )
+    job.run
+  end
+
+  def self.map(profiles)
+    #map code
+  end
+
+  def self.reduce(pairs)
+    #reduce code
+  end
+end
+

data/gigantron_generators/mapreduce_task/templates/tasks/task.rake

@@ -0,0 +1,5 @@
+desc "Describe your MapReduce task"
+task :<%= name %> do
+  load 'mapreduce/mr_<%= name %>'
+  MapReduce<%= name.camelcase %>.run
+end

data/gigantron_generators/mapreduce_task/templates/test/tasks/test_task.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../test_helper.rb'
+
+class Test<%= name.camelcase %> < Test::Unit::TestCase
+  def setup
+    get_db_conn(GTRON_ENV)
+    @rake = Rake::Application.new
+    Rake.application = @rake
+    load File.dirname(__FILE__) + '/../../tasks/<%= name %>.rake'
+  end
+
+  should "be true" do
+    # Testing rake is a bit different
+    # http://blog.nicksieger.com/articles/2007/06/11/test-your-rake-tasks
+    # Example:
+    #   @rake["task_name"].invoke
+    assert true
+  end
+
+  def teardown
+    Rake.application = nil
+  end
+end

data/gigantron_generators/migration/USAGE

@@ -0,0 +1,5 @@
+Description:
+  
+  
+Usage:
+  

data/gigantron_generators/migration/migration_generator.rb

@@ -0,0 +1,61 @@
+class MigrationGenerator < RubiGen::Base
+
+  default_options :author => nil
+
+  attr_reader :name
+
+  def initialize(runtime_args, runtime_options = {})
+    super
+    usage if args.empty?
+    @name = args.shift
+    extract_options
+  end
+
+  def manifest
+    record do |m|
+      # Ensure appropriate folder(s) exists
+      m.directory "db/"
+      m.directory "db/migrate/"
+      m.template  "db/migrate/migration.rb", 
+        "db/migrate/#{next_migration_num}_#{name.underscore}.rb"
+
+    end
+  end
+
+  protected
+    def banner
+      <<-EOS
+Creates a ...
+
+USAGE: #{$0} #{spec.name} name
+EOS
+    end
+
+    def add_options!(opts)
+      # opts.separator ''
+      # opts.separator 'Options:'
+      # For each option below, place the default
+      # at the top of the file next to "default_options"
+      # opts.on("-a", "--author=\"Your Name\"", String,
+      #         "Some comment about this option",
+      #         "Default: none") { |options[:author]| }
+      # opts.on("-v", "--version", "Show the #{File.basename($0)} version number and quit.")
+    end
+
+    def extract_options
+      # for each option, extract it into a local variable (and create an "attr_reader :author" at the top)
+      # Templates can access these value via the attr_reader-generated methods, but not the
+      # raw instance variable value.
+      # @author = options[:author]
+    end
+
+    def next_migration_num
+      #blegh, catalog existing migrations, find next
+      current = Dir.glob(
+        "#{@destination_root}/db/migrate/[0-9][0-9][0-9]_*.rb").map{|x|
+          /(\d{3})_.*\.rb/.match(x)[1].to_i
+      }.max
+      current ||= 0
+      "%03d" % current.succ
+    end
+end