marmalade 0.0.2 → 0.0.3

data/examples/file-fix-it/README.md

@@ -0,0 +1,4 @@
+# File Fix-It Example
+
+A working example of the 'File Fix-it' puzzle at https://code.google.com/codejam/contest/635101/dashboard#s=p0
+

data/examples/file-fix-it/file-fix-it.rb

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.expand_path('../../lib'))
+require 'marmalade'
+
+class TestCase
+  def each_dir(path)
+    path.split('/').reject { |d| d.nil? || d == '' }.each do |dir|
+      yield dir
+    end
+  end
+
+  def mkdir(path, root)
+    created = 0
+    cwd = root
+    puts_dbg "path: #{path}"
+    each_dir(path) do |dir|
+      puts_dbg "dir: #{dir}"
+      unless cwd.include?(dir)
+        puts_dbg "needs creating"
+        cwd[dir] = {}
+        created += 1
+      end
+      cwd = cwd[dir]
+    end
+    created
+  end
+
+  def solve(existing, to_create)
+    root = {}
+    existing.each do |path|
+      cwd = root
+      each_dir(path) do |dir|
+        cwd[dir] ||= {}
+        cwd = cwd[dir]
+      end
+    end
+    created = 0
+    to_create.each do |path|
+      created += mkdir(path, root)
+    end
+    created
+  end
+end
+
+Marmalade.jam do
+  read_num_cases
+  test_cases do
+    read [:e, :c], :type => :int
+    read :existing, :count => @e
+    read :to_create, :count => @c
+    run_case do
+      puts_dbg "Existing:"
+      @existing.each { |f| puts_dbg f }
+      puts_dbg "To create:"
+      @to_create.each { |f| puts_dbg f }
+      puts solve(@existing, @to_create)
+    end
+  end
+end

data/examples/reverse-words/reverse-words.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
+$LOAD_PATH.unshift(File.expand_path('../../lib'))
 require 'marmalade'
 
 Marmalade.jam do
@@ -8,6 +8,7 @@ Marmalade.jam do
   test_cases do
     read :words, :split => true
     run_case do
+      puts_dbg "Input was: #{@words.inspect}"
       puts @words.reverse.join(' ')
     end
   end

data/examples/rope-intranet/rope-intranet.rb

@@ -1,25 +1,27 @@
 #!/usr/bin/env ruby
 
-require 'rubygems'
+$LOAD_PATH.unshift(File.expand_path('../../lib'))
 require 'marmalade'
 
-def intersect?(segment_a, segment_b)
-  # They intersect if only one side is higher than the other
-  (segment_a[0] - segment_b[0]) * (segment_a[1] - segment_b[1]) < 0
-end
+class TestCase
+  def intersect?(segment_a, segment_b)
+    # They intersect if only one side is higher than the other
+    (segment_a[0] - segment_b[0]) * (segment_a[1] - segment_b[1]) < 0
+  end
 
-# Brute force check all wires
-def count_intersections(wires)
-  intersections = 0
-  wires.length.times do
-    wire = wires.pop
-    puts_dbg "Wire: #{wire.inspect}"
-    wires.each do |other_wire|
-      puts_dbg "Other wire: #{other_wire.inspect}"
-      intersections += intersect?(wire, other_wire) ? 1 : 0
+  # Brute force check all wires
+  def count_intersections(wires)
+    intersections = 0
+    wires.length.times do
+      wire = wires.pop
+      puts_dbg "Wire: #{wire.inspect}"
+      wires.each do |other_wire|
+        puts_dbg "Other wire: #{other_wire.inspect}"
+        intersections += intersect?(wire, other_wire) ? 1 : 0
+      end
     end
+    intersections
   end
-  intersections
 end
 
 Marmalade.jam do

data/lib/marmalade/puzzle.rb

@@ -1,70 +1,96 @@
-# TODO: RDoc this
-# TODO: read_array
-# TODO: read_integer_array
-# TODO: read_values
+require 'parallel'
 
 module Marmalade
   class Puzzle
     attr_accessor :reader
 
     def initialize(file_reader, options = {})
-      @options = options.dup
-      @debug = (@options.delete(:debug) == true)
       self.reader = file_reader
+      @options = options.dup
+      @debug = (@options[:debug] == true)
+      if @options[:processes].to_i > 1 && !@options[:parallel]
+        @options[:parallel] = true
+      end
+    end
+
+    def read_num_cases
+      read :num_cases, :type => :int
     end
 
     def read(assignments, options = {})
-      if @running_case
-        raise MarmaladeError.new("Cannot call read while in a run_case block")
-      end
-      options = @options.merge(options)
       assigns = reader.read(assignments, options)
       assigns.each do |k, v|
+        # Set an ivar on both the puzzle and the test case so we can support using them in
+        # subsequent calls to 'read' in the same block evaluation.
         instance_variable_set("@#{k.to_s}", v)
+        if @current_case
+          @current_case.instance_variable_set("@#{k.to_s}", v)
+        end
       end
     end
 
-    def read_num_cases
-      read :num_cases, :type => :int
-    end
-
     def test_cases(options = {}, &block)
       unless @num_cases.is_a?(Fixnum)
         raise MarmaladeError.new("@num_cases has not been set or is not an integer")
       end
       options = options.merge(@options)
-      1.upto(@num_cases) do |case_num|
-        @case_num = case_num
-        instance_eval(&block)
-        return if options[:case] == case_num
-        STDIN.getc if options[:step]
-      end
-    end
 
-    def run_case(&block)
-      @running_case = true
-      if @options[:case].nil? || @options[:case] == @case_num
+      # Set up all test cases and read each one's info from the file
+      test_cases = []
+      1.upto(@num_cases).each do |case_num|
+        test_case = TestCase.new(case_num, options)
+        test_case.debug = @debug
+
+        @current_case = test_case
         instance_eval(&block)
+        @current_case = nil
+
+        test_cases << test_case
       end
-      @running_case = false
-    end
 
-    def puts(*args)
-      puts_with_case(*args)
+      # If we are to run in more than one process, we'll run all of the tests without
+      # regard to stepping or finding a single case to run
+      if options[:parallel]
+        # Setup pipes for the output of each test case
+        reader, writer = IO.pipe
+        test_cases.each do |test_case|
+          test_case.output = writer
+        end
+        # Run them
+        processes = options[:processes] || Parallel.processor_count
+        Parallel.each(test_cases, :in_processes => processes) do |test_case|
+          test_case.run
+        end
+        # Now output the buffers from each case
+        writer.close
+        outputs = []
+        # TODO: This could probably be done with a stable sort instead...
+        while message = reader.gets
+          match = message.match(/Case #(\d+)/)
+          if match
+            case_num = match[1].to_i
+            case_output = outputs[case_num] ||= []
+            case_output << message
+          else
+            outputs << message
+          end
+        end
+        outputs.flatten.compact.each { |msg| puts msg }
+      else
+        test_cases.each do |test_case|
+          if options[:case].nil? || options[:case] == test_case.case_num
+            test_case.run
+            if options[:step] == true
+              STDIN.getc if options[:step]
+            end
+          end
+        end
+      end
     end
 
-    def puts_dbg(*args)
-      puts_with_case(*args) if @debug
+    def run_case(&block)
+      @current_case.run_block = block
     end
 
-    private
-
-    def puts_with_case(*args)
-      unless @case_num.nil?
-        print "Case ##{@case_num}: "
-      end
-      print *args
-      print "\n"
-    end
   end
 end

data/lib/marmalade/test_case.rb

@@ -0,0 +1,37 @@
+class TestCase
+  attr_accessor :case_num
+  attr_accessor :debug
+  attr_accessor :output
+  attr_accessor :run_block
+
+  def initialize(case_num, options = {})
+    self.case_num = case_num
+    @output = options[:output] || STDOUT
+    @options = options
+  end
+
+  def run
+    unless @run_block.nil?
+      instance_eval(&@run_block)
+    end
+  end
+
+  def puts(*args)
+    puts_with_case(*args)
+  end
+
+  def puts_dbg(*args)
+    puts_with_case(*args) if debug
+  end
+
+  private
+
+  def puts_with_case(*args)
+    message = args.map(&:to_s).join("\n") + "\n"
+    unless @case_num.nil?
+      message = "Case ##{@case_num}: #{message}"
+    end
+    @output.print message
+  end
+
+end

data/lib/marmalade/version.rb

@@ -1,3 +1,3 @@
 module Marmalade
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 end

data/lib/marmalade.rb

@@ -1,8 +1,10 @@
 require 'rubygems'
 require 'trollop'
+require 'parallel'
 
 require 'marmalade/project_builder'
 require 'marmalade/file_reader'
+require 'marmalade/test_case'
 require 'marmalade/puzzle'
 require 'marmalade/version'
 
@@ -18,7 +20,7 @@ module Marmalade
       unless File.exist?(file_name)
         raise MarmaladeError.new("Cannot find input file #{file_name}")
       end
-      File.open(options[:file], 'r') do |file|
+      File.open(file_name, 'r') do |file|
         reader = FileReader.new(file)
         puzzle = Puzzle.new(reader, options)
         puzzle.instance_eval(&block)
@@ -31,11 +33,13 @@ module Marmalade
   private
 
   def self.parse_options
-    options = Trollop::options do
+    Trollop::options do
       opt :file, "Input file to read", :short => 'f', :type => :string
       opt :debug, "Debug mode", :short => 'd', :default => false
       opt :step, "Step through each case", :short => 's', :default => false
       opt :case, "Only run the given case", :short => 'c', :type => :integer, :default => nil
+      opt :parallel, "Run the cases in parallel processes", :short => 'p', :default => false
+      opt :processes, "Specify the number of processes to use", :type => :integer
     end
   end
 

data/marmalade.gemspec

@@ -16,6 +16,7 @@ Gem::Specification.new do |gem|
   gem.version       = Marmalade::VERSION
 
   gem.add_dependency 'trollop', '~>1.16.2'
+  gem.add_dependency 'parallel', '0.6.2'
 
   gem.add_development_dependency 'rspec', '~>2.9.0'
   gem.add_development_dependency 'mocha', '~>0.10.5'

data/spec/marmalade/puzzle_spec.rb

@@ -2,13 +2,12 @@ require 'spec_helper'
 
 describe Marmalade::Puzzle do
 
-  describe "#read" do
+  describe '#read' do
     before do
       @reader = mock()
       @puzzle = Marmalade::Puzzle.new(@reader)
     end
-
-    it "will pass the options to the reader and assign instance varialbes based on the results" do
+    it "assigns instance variables based on the results from the file reader" do
       @reader.expects(:read).with([:foo, :bar], { :a => 1 }).returns({:foo => "a", :bar => 2})
       @puzzle.read([:foo, :bar], :a => 1)
       @puzzle.instance_eval do
@@ -16,129 +15,132 @@ describe Marmalade::Puzzle do
         @bar.should == 2
       end
     end
+    it 'assigns the instance variables to the current test case if there is one' do
+      @reader.expects(:read).with([:foo, :bar], { :a => 1 }).returns({:foo => "a", :bar => 2})
+      current_case = Object.new
+      @puzzle.instance_variable_set('@current_case', current_case)
+      @puzzle.read([:foo, :bar], :a => 1)
+      current_case.instance_eval do
+        @foo.should == 'a'
+        @bar.should == 2
+      end
+    end
+  end
 
-    it "will read in the number of cases with read_num_cases" do
+  describe '#read_num_cases' do
+    before do
+      @reader = mock()
+      @puzzle = Marmalade::Puzzle.new(@reader)
+    end
+    it "will use the reader to read in the number of cases" do
       @reader.expects(:read).with(:num_cases, :type => :int).returns({:num_cases => 1234})
       @puzzle.read_num_cases
       @puzzle.instance_eval do
         @num_cases.should == 1234
       end
     end
-
-    it "will raise an error if it is called in a run_case block" do
-      expect do
-        @puzzle.run_case do
-          read :foo
-        end
-      end.to raise_error(MarmaladeError, /Cannot call read while in a run_case block/)
-    end
-
   end
 
-  describe "#test_cases" do
+  describe "test_cases and run_case blocks" do
     before do
-      @puzzle = Marmalade::Puzzle.new(mock('reader'))
-    end
-
-    it "will run through all the test cases" do
-      run_test_cases.should == [1, 2, 3]
-    end
-
-    it "will return after the specified case as part of support for run_case" do
-      run_test_cases(:case => 2).should == [1, 2]
-    end
-
-    it "will pause after each case if the :step option is set" do
-      STDIN.expects(:getc).times(3)
-      run_test_cases(:step => true)
-    end
-
-    it "will raise an error if num_cases hasn't been set" do
-      expect { @puzzle.test_cases }.to raise_error(MarmaladeError, /has not been set/)
-    end
-
-    def run_test_cases(options = {})
+      @reader = mock('reader')
+      @puzzle = Marmalade::Puzzle.new(@reader)
       @puzzle.instance_eval do
         @num_cases = 3
       end
-      case_numbers = []
-      @puzzle.test_cases(options) do
-        case_numbers << @case_num
-      end
-      case_numbers
-    end
-  end
-
-  describe "#run_case" do
-    before do
-      @puzzle = Marmalade::Puzzle.new(mock('file_reader'))
     end
 
-    it "will evaluate the given block if no case options are specified" do
-      value = nil
-      build_puzzle(3).run_case do
-        value = 'foo'
+    it 'sets the options for each TestCase base on its own options' do
+      values = []
+      @puzzle.test_cases :opt1 => :foo, :opt2 => 'bar' do
+        run_case do
+          values << @options
+        end
+      end
+      values.each do |options|
+        options.should == {:opt1 => :foo, :opt2 => 'bar'}
       end
-      value.should == 'foo'
     end
 
-    it "will set @running_case to true while in the block" do
-      running = false
-      build_puzzle(3).run_case do
-        running = @running_case
+    it 'sets the case_num for each TestCase' do
+      values = []
+      @puzzle.test_cases do
+        run_case do
+          values << case_num
+        end
       end
-      running.should be_true
+      values.should == [1, 2, 3]
     end
 
-    it "will evaluate the block if the given case and the current case match" do
-      value = nil
-      build_puzzle(3, :case => 3).run_case do
-        value = 'foo'
+    it 'sets the debug flag for each test case if debug is set' do
+      @puzzle.instance_eval do
+        @debug = true
       end
-      value.should == 'foo'
+      values = []
+      @puzzle.test_cases do
+        run_case do
+          values << debug
+        end
+      end
+      values.should == [true, true, true]
     end
 
-    it "will not evalulate the block if the case numbers don't match" do
-      value = nil
-      build_puzzle(3, :case => 4).run_case do
-        value = 'foo'
+    it 'sets test case instance variables based on what is read from the file' do
+      @reader.expects(:read).with(:foo, {}).times(3).
+        returns({:foo => :a}, {:foo => :b}, {:foo => :c})
+      values = []
+      @puzzle.test_cases do
+        read :foo
+        run_case do
+          values << @foo
+        end
       end
-      value.should be_nil
+      values.should == [:a, :b, :c]
     end
-  end
 
-  describe "#puts" do
-    it "will print the message along with the current case number" do
-      puzzle = build_puzzle(4)
-      puzzle.expects(:print).with("Case #4: ")
-      puzzle.expects(:print).with("hello")
-      puzzle.expects(:print).with("\n")
-      puzzle.puts("hello")
+    it 'only runs the given case if the :case option is set' do
+      values = []
+      @puzzle.test_cases :case => 2 do
+        run_case do
+          values << case_num
+        end
+      end
+      values.should == [2]
     end
-  end
 
-  describe "#puts_dbg" do
-    it "will print the message with the case number if in debug mode" do
-      puzzle = build_puzzle(4, :debug => true)
-      puzzle.expects(:print).with("Case #4: ")
-      puzzle.expects(:print).with("hello")
-      puzzle.expects(:print).with("\n")
-      puzzle.puts_dbg('hello')
+    it "pauses after each case if the :step option is set" do
+      STDIN.expects(:getc).times(3)
+      @puzzle.test_cases :step => true do
+        run_case do
+        end
+      end
     end
 
-    it "will not print the message if the puzzle isn't in debug mode" do
-      puzzle = build_puzzle(4)
-      puzzle.expects(:print).never
-      puzzle.puts_dbg('hello')
+    it "raises an error if num_cases hasn't been set" do
+      @puzzle.instance_eval { @num_cases = nil }
+      expect do
+        @puzzle.test_cases do
+          puts "this won't get called."
+        end
+      end.to raise_error(MarmaladeError, /has not been set/)
+    end
+
+    context 'when the parallel option is set' do
+      it 'runs the cases in parallel and prints the output in order' do
+        sleep_times = [0.75, 0.25, 0.5]
+        test_output = sequence('test_output')
+        @puzzle.expects(:puts).with("Case #1: hello\n").in_sequence(test_output)
+        @puzzle.expects(:puts).with("Case #2: hello\n").in_sequence(test_output)
+        @puzzle.expects(:puts).with("Case #3: hello\n").in_sequence(test_output)
+        @puzzle.test_cases :parallel => true do
+          run_case do
+            sleep sleep_times[case_num - 1]
+            puts "hello"
+          end
+        end
+      end
     end
-  end
 
-  def build_puzzle(case_num, options = {})
-    puzzle = Marmalade::Puzzle.new(mock('file_reader'), options)
-    puzzle.instance_eval do
-      @case_num = case_num
-    end
-    puzzle
   end
 
 end

data/spec/marmalade/test_case_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe TestCase do
+
+  before do
+    @test_case = TestCase.new(4)
+  end
+
+  describe '#initialize' do
+    it 'sets the case_num' do
+      @test_case.case_num.should == 4
+    end
+  end
+
+  describe "#puts" do
+    it 'will print the message along with the current case number to STDOUT' do
+      STDOUT.expects(:print).with("Case #4: hello\n")
+      @test_case.puts("hello")
+    end
+    it 'will print to the supplied IO buffer if an output option is given' do
+      output = mock()
+      output.expects(:print).with("Case #4: hello\n")
+      @test_case.output = output
+      @test_case.puts("hello")
+    end
+  end
+
+  describe "#puts_dbg" do
+    it "will print the message with the case number if in debug mode" do
+      @test_case.debug = true
+      STDOUT.expects(:print).with("Case #4: hello\n")
+      @test_case.puts_dbg('hello')
+    end
+
+    it "will not print the message if the @test_case isn't in debug mode" do
+      @test_case.debug = false
+      STDOUT.expects(:print).never
+      @test_case.puts_dbg('hello')
+    end
+  end
+
+end

data/templates/main.rb

@@ -3,12 +3,20 @@
 require 'rubygems'
 require 'marmalade'
 
+class TestCase
+  # Any methods you want to call in your individual cases can be defined here.
+end
+
 Marmalade.jam do
+
   # This assumes your input file has the number of test cases as the first line.
-  # Remove the call to read_num_cases this if that is not so.
   read_num_cases
 
   test_cases do
-    # Test case-specific code goes here
+    # read information about the test case here.
+    run_case do
+      # Test case-specific code goes here.
+    end
   end
+
 end