codersdojo 0.9.7 → 0.9.8

data/app/console_view.rb

@@ -0,0 +1,108 @@
+require 'shell_wrapper'
+
+class ConsoleView
+	
+	@@VERSION = '0.9'
+	
+	def show_help
+		puts <<-helptext
+Personal CodersDojo, Version #{@@VERSION}, http://www.codersdojo.com, Copyright by it-agile GmbH (http://www.it-agile.de)
+PersonalCodersDojo automatically runs your tests of a code kata.
+
+helptext
+		show_usage
+	end
+	
+	def show_usage
+		puts <<-helptext
+Usage: #{$0} command [options]
+Commands:
+  help, -h, --help                   Print this help text.
+  help <command>                     See the details of the command.
+  setup <framework> <kata_file>      Setup the environment for running the kata.
+  upload <framework> <session_dir>   Upload the kata to http://www.codersdojo.org
+
+Report bugs to <codersdojo@it-agile.de>
+helptext
+	end
+
+	def show_detailed_help command
+		if command == 'setup' then
+			show_help_setup
+		elsif command == 'start' then
+			show_help_start
+		elsif command == 'upload' then
+			show_help_upload
+		else
+			show_help_unknown command
+		end
+	end
+
+	def show_help_setup
+			templates = ShellWrapper.new.list_templates
+			puts <<-helptext
+			
+setup <framework> <kata_file_no_ext>  Setup the environment for the kata for the given framework and kata file.
+                                      The kata_file should not have an extension. Use 'prime' and not 'prime.java'.
+                                      By now <framework> is one of #{templates}.
+                                      Use ??? as framework if your framework isn't in the list.
+
+Example:
+    :/dojo/my_kata% #{$0} setup ruby.test/unit prime
+        Show the instructions how to setup the environment for kata execution with Ruby and test/unit.
+helptext
+	end
+
+	def show_help_start
+		puts <<-helptext
+		
+start <shell_command> <kata_file>  Start the continuous test runner, that runs <shell-command> whenever <kata_file>
+                                   changes. The <kata_file> has to include the whole source code of the kata.
+                                   Whenever the test runner is started, it creates a new session directory in the 
+                                   directory .codersdojo where it logs the steps of the kata.
+helptext
+	end
+
+	def show_help_upload
+		templates = ShellWrapper.new.list_templates
+		puts <<-helptext
+		
+upload <framework> <session_directory>  Upload the kata written with <framework> in <session_directory> to codersdojo.com. 
+                                        <session_directory> is relative to the working directory.
+                                        By now <framework> is one of #{templates}.
+                                        If you used another framework, use ??? and send an email to codersdojo@it-agile.de
+
+Example:
+    :/dojo/my_kata$ #{$0} upload ruby.test/unit .codersdojo/2010-11-02_16-21-53
+        Upload the kata (written in Ruby with the test/unit framework) located in directory ".codersdojo/2010-11-02_16-21-53" to codersdojo.com.
+helptext
+	end
+	
+	def show_help_unknown command
+		puts <<-helptext
+Command #{command} not known. Try '#{$0} help' to list the supported commands.
+helptext
+	end
+	
+	def show_start_kata command, file
+	  puts "Starting PersonalCodersDojo with command #{command} and kata file #{file}. Use Ctrl+C to finish the kata."		
+	end
+	
+	def show_missing_command_argument_error command
+		puts "Command <#{command}> recognized but no argument was provided (at least one argument is required).\n\n"
+		show_usage
+	end
+	
+	def show_upload_start hostname
+		puts "Start upload to #{hostname}"
+	end
+	
+	def show_upload_result result
+		puts result
+	end
+	
+	def show_socket_error command
+		puts "Encountered network error while <#{command}>. Is http://www.codersdojo.com down?"
+	end
+	
+end

data/app/controller.rb

@@ -0,0 +1,50 @@
+class Controller
+
+	def initialize view, hostname
+		@view = view
+		@hostname = hostname
+	end
+
+	def help command=nil
+		if command then
+			@view.show_detailed_help command.downcase
+		else
+			@view.show_help
+		end
+	end
+
+	def generate framework, kata_file
+		shell = ShellWrapper.new
+		shell.scaffold framework
+		generator_text = IO.readlines("README").to_s;
+		generator_text = generator_text.gsub('#{kata_file}', kata_file)
+		generator_text = generator_text.gsub('#{$0}', $0)
+		generator_text = shell.make_os_specific generator_text
+		puts "\n" + generator_text
+	end
+
+	def start command, file
+		if not command or not file then
+			@view.show_missing_command_argument_error "start"
+			return
+		end
+	  @view.show_start_kata command, file
+	  dojo = Runner.new ShellWrapper.new, SessionIdGenerator.new
+	  dojo.file = file
+	  dojo.run_command = command
+	  scheduler = Scheduler.new dojo
+	  scheduler.start
+	end
+
+	def upload framework, session_directory
+		@view.show_upload_start @hostname
+		if session_directory then
+		  uploader = Uploader.new @hostname, framework, session_directory
+		  p uploader.upload
+		else
+			@view.show_missing_command_argument_error "upload"
+		end
+	end
+
+end
+

data/app/filename_formatter.rb

@@ -0,0 +1,34 @@
+class FilenameFormatter
+
+  CODERSDOJO_WORKSPACE = ".codersdojo"
+  RESULT_FILE = "result.txt"
+  STATE_DIR_PREFIX = "state_"
+
+	def self.state_dir_prefix
+		STATE_DIR_PREFIX
+	end
+
+  def source_code_file state_dir
+    Dir.entries(state_dir).each { |file|
+      return state_file state_dir, file unless file =='..' || file == '.' ||file == RESULT_FILE }
+  end
+
+  def result_file state_dir
+    state_file state_dir, RESULT_FILE
+  end
+
+  def state_file state_dir, file
+    "#{state_dir}/#{file}"
+  end
+
+  def state_dir session_id, step
+    session_directory = session_dir session_id
+    "#{session_directory}/#{STATE_DIR_PREFIX}#{step}"
+  end
+
+  def session_dir session_id
+    "#{CODERSDOJO_WORKSPACE}/#{session_id}"
+  end
+
+end
+

data/app/progress.rb

@@ -0,0 +1,19 @@
+class Progress
+
+  def self.write_empty_progress states
+    STDOUT.print "#{states} states to upload"
+    STDOUT.print "["+" "*states+"]"
+    STDOUT.print "\b"*(states+1)
+    STDOUT.flush
+  end
+
+  def self.next
+    STDOUT.print "."
+    STDOUT.flush
+  end
+
+  def self.end
+    STDOUT.puts
+  end
+end
+

data/app/runner.rb

@@ -0,0 +1,39 @@
+require "filename_formatter"
+
+class Runner
+
+  attr_accessor :file, :run_command
+
+  def initialize shell, session_provider
+    @filename_formatter = FilenameFormatter.new
+    @shell = shell
+    @session_provider = session_provider
+  end
+
+  def start
+    init_session
+    execute
+  end
+
+  def init_session
+    @step = 0
+    @session_id = @session_provider.generate_id
+    @shell.mkdir_p(@filename_formatter.session_dir @session_id)
+  end
+
+  def execute
+    change_time = @shell.ctime @file
+    if change_time == @previous_change_time then
+      return
+    end
+    result = @shell.execute "#{@run_command} #{@file}"
+    state_dir = @filename_formatter.state_dir @session_id, @step
+    @shell.mkdir state_dir
+    @shell.cp @file, state_dir
+    @shell.write_file @filename_formatter.result_file(state_dir), result
+    @step += 1
+    @previous_change_time = change_time
+  end
+
+end
+

data/app/scheduler.rb

@@ -0,0 +1,15 @@
+class Scheduler
+
+  def initialize runner
+    @runner = runner
+  end
+
+  def start
+    @runner.start
+    while true do
+      sleep 1
+      @runner.execute
+    end
+  end
+
+end

data/app/session_id_generator.rb

@@ -0,0 +1,17 @@
+class SessionIdGenerator
+
+  def generate_id time=Time.new
+		year = format_to_length time.year, 4
+		month = format_to_length time.month, 2
+		day = format_to_length time.day, 2
+		hour = format_to_length time.hour, 2
+		minute = format_to_length time.min, 2
+		second = format_to_length time.sec, 2
+    "#{year}-#{month}-#{day}_#{hour}-#{minute}-#{second}"
+  end
+
+  def format_to_length value, len
+		value.to_s.rjust len,"0"
+	end
+
+end

data/app/shell_wrapper.rb

@@ -0,0 +1,96 @@
+require 'tempfile'
+
+class ShellWrapper
+
+  MAX_STDOUT_LENGTH = 100000
+  ANY_TEMPLATE = "any"
+
+  def cp source, destination
+    FileUtils.cp source, destination
+  end
+
+  def mkdir dir
+    FileUtils.mkdir dir
+  end
+
+  def mkdir_p dirs
+    FileUtils.mkdir_p dirs
+  end
+
+  def execute command
+    spec_pipe = IO.popen(command, "r")
+    result = spec_pipe.read MAX_STDOUT_LENGTH
+    spec_pipe.close
+    puts result
+    result
+  end
+
+  def write_file filename, content
+    file = File.new filename, "w"
+    file << content
+    file.close
+  end
+
+  def read_file filename
+    file = File.new filename
+    content = file.read
+    file.close
+    content
+  end
+
+  def ctime filename
+    File.new(filename).ctime
+  end
+
+	def list_templates
+		templates = real_dir_entries template_path
+		templates.delete ANY_TEMPLATE
+		templates.join(', ')
+	end
+
+	def scaffold template
+		begin
+			dir_path = "#{template_path}/#{template}"
+			to_copy = real_dir_entries dir_path
+		rescue
+			dir_path = "#{template_path}/#{ANY_TEMPLATE}"
+			to_copy = real_dir_entries dir_path
+		end
+		to_copy.each do |item|
+			FileUtils.cp_r "#{dir_path}/#{item}", "."
+		end
+	end
+	
+	def template_path
+		file_path_elements = __FILE__.split '/' 
+		file_path_elements[-2..-1] = nil
+		(file_path_elements << 'templates').join '/'
+	end
+
+	def real_dir_entries dir
+		current_and_parent = 2
+		Dir.new(dir).entries.drop current_and_parent
+	end
+
+	def make_os_specific text
+		text.gsub('%sh%', shell_extension).gsub('%:%', path_separator).gsub('%rm%', remove_command_name)
+	end
+
+	def remove_command_name
+		windows? ? 'delete' : 'rm'
+	end
+
+	def shell_extension
+		windows? ? 'cmd' : 'sh'
+	end
+	
+	def path_separator
+		windows? ? ';' : ':'
+	end
+	
+	def windows?
+		RUBY_PLATFORM.downcase.include? "windows"
+	end
+
+end
+

data/app/state_reader.rb

@@ -0,0 +1,57 @@
+require 'filename_formatter'
+
+class StateReader
+
+  attr_accessor :session_id, :next_step
+
+  def initialize shell
+    @filename_formatter = FilenameFormatter.new
+    @shell = shell
+    @next_step = 0
+  end
+
+  def state_count
+	  dummy_dirs_current_and_parent = 2
+    Dir.new(@filename_formatter.session_dir @session_id).count - dummy_dirs_current_and_parent
+  end
+
+  def enough_states?
+    state_count >= states_needed_for_one_move
+  end
+
+	def states_needed_for_one_move
+		2
+	end
+
+  def get_state_dir
+    @filename_formatter.state_dir(@session_id, @next_step)
+  end
+
+  def has_next_state
+    File.exist?(get_state_dir)
+  end
+
+  def read_next_state
+    state = State.new
+    state_dir = get_state_dir
+    state.time = @shell.ctime state_dir
+    state.code = @shell.read_file @filename_formatter.source_code_file(state_dir)
+    state.result = @shell.read_file @filename_formatter.result_file(state_dir)
+    @next_step += 1
+    state
+  end
+
+end
+
+class State
+
+  attr_accessor :time, :code, :result
+
+  def initialize time=nil, code=nil, result=nil
+    @time = time
+    @code = code
+    @result = result
+  end
+
+end
+

data/app/uploader.rb

@@ -0,0 +1,49 @@
+require 'state_reader'
+require 'progress'
+require 'xml_element_extractor'
+require 'rest_client'
+
+class Uploader
+
+  def initialize hostname, framework, session_dir, state_reader = StateReader.new(ShellWrapper.new)
+		@hostname = hostname
+	  @framework = framework
+    @state_reader = state_reader
+    @state_reader.session_id = session_dir.gsub('.codersdojo/', '')
+  end
+
+  def upload_kata
+    RestClient.post "#{@hostname}#{@@kata_path}", {:framework => @framework}
+  end
+
+  def upload_state kata_id
+    state = @state_reader.read_next_state
+    RestClient.post "#{@hostname}#{@@kata_path}/#{kata_id}#{@@state_path}", {:code => state.code, :result => state.result, :created_at => state.time}
+    Progress.next
+  end
+
+  def upload_states kata_id
+    Progress.write_empty_progress @state_reader.state_count
+    while @state_reader.has_next_state
+      upload_state kata_id
+    end
+    Progress.end
+  end
+
+  def upload_kata_and_states
+    kata = upload_kata
+    upload_states(XMLElementExtractor.extract('kata/id', kata))
+    "This is the link to review and comment your kata #{XMLElementExtractor.extract('kata/short-url', kata)}"
+  end
+
+  def upload
+    return upload_kata_and_states if @state_reader.enough_states?
+    return "You need at least two states"
+  end
+
+  private
+  @@kata_path = '/katas'
+  @@state_path = '/states'
+
+end
+

data/app/xml_element_extractor.rb

@@ -0,0 +1,11 @@
+require "rexml/document"
+
+class XMLElementExtractor
+  def self.extract element, xml_string
+    doc = REXML::Document.new xml_string
+    return doc.elements.each(element) do |found|
+      return found.text
+    end
+  end
+end
+

data/bin/codersdojo

@@ -1,4 +1,8 @@
 #!/usr/bin/env ruby
 codersdojo_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'app'))
+infrastructure_dir = "#{codersdojo_dir}/infrastructure"
+models_dir = "#{codersdojo_dir}/models"
 $LOAD_PATH.unshift(codersdojo_dir) unless $LOAD_PATH.include?(codersdojo_dir)
+$LOAD_PATH.unshift(infrastructure_dir) unless $LOAD_PATH.include?(infrastructure_dir)
+$LOAD_PATH.unshift(models_dir) unless $LOAD_PATH.include?(models_dir)
 require 'codersdojo'

data/spec/argument_parser_spec.rb

@@ -0,0 +1,54 @@
+require 'argument_parser'
+
+describe ArgumentParser do
+	
+	before (:each) do
+		@controller_mock = mock.as_null_object
+		@parser = ArgumentParser.new @controller_mock
+	end
+	
+	it "should reject empty command" do
+		lambda{@parser.parse []}.should raise_error
+	end
+	
+	it "should reject unknown command" do
+		lambda{@parser.parse "unknown command"}.should raise_error
+	end
+	
+	it "should accept help command" do
+		@controller_mock.should_receive(:help).with(nil)
+		@parser.parse ["help"]
+	end
+	
+	it "should accept start command" do
+		@controller_mock.should_receive(:start).with "aCommand", "aFile"
+		@parser.parse ["start", "aCommand","aFile"]
+	end
+	
+	it "should prepend *.sh start scripts with 'bash'" do
+		@controller_mock.should_receive(:start).with "bash aCommand.sh", "aFile"
+		@parser.parse ["start", "aCommand.sh","aFile"]		
+	end
+	
+	it "should prepend *.bat start scripts with 'start'" do
+		@controller_mock.should_receive(:start).with "start aCommand.bat", "aFile"
+		@parser.parse ["start", "aCommand.bat","aFile"]		
+	end
+	
+	it "should prepend *.cmd start scripts with 'start'" do
+		@controller_mock.should_receive(:start).with "start aCommand.cmd", "aFile"
+		@parser.parse ["start", "aCommand.cmd","aFile"]		
+	end
+	
+	it "should accept upload command" do
+		@controller_mock.should_receive(:upload).with "framework", "dir"
+		@parser.parse ["upload", "framework", "dir"]
+	end
+	
+	it "should accept uppercase commands" do
+		@controller_mock.should_receive(:help).with(nil)
+		@parser.parse ["HELP"]
+	end
+
+end
+

data/spec/progress_spec.rb

@@ -0,0 +1,23 @@
+require 'progress'
+
+describe Progress do
+
+  it 'should print infos and empty progress in initialization' do
+    STDOUT.should_receive(:print).with("2 states to upload")
+    STDOUT.should_receive(:print).with("[  ]")
+    STDOUT.should_receive(:print).with("\b\b\b")
+    Progress.write_empty_progress 2
+  end
+
+  it 'should print dots and flush in next' do
+    STDOUT.should_receive(:print).with(".")
+    STDOUT.should_receive(:flush) 
+    Progress.next
+  end
+
+  it 'should print empty line in end' do
+    STDOUT.should_receive(:puts)
+    Progress.end
+  end
+
+end

data/spec/runner_spec.rb

@@ -0,0 +1,59 @@
+require 'runner'
+
+describe Runner, "in run mode" do
+
+  WORKSPACE_DIR = ".codersdojo"
+  SESSION_ID = "id0815"
+  SESSION_DIR = "#{WORKSPACE_DIR}/#{SESSION_ID}"
+  STATE_DIR_PREFIX = "#{SESSION_DIR}/state_"
+
+  before (:each) do
+    @shell_mock = mock.as_null_object
+    @session_id_provider_mock = mock.as_null_object
+    @session_id_provider_mock.should_receive(:generate_id).and_return SESSION_ID
+    @runner = Runner.new @shell_mock, @session_id_provider_mock
+    @runner.file = "my_file.rb"
+    @runner.run_command = "ruby"
+  end
+
+  it "should create codersdojo directory if it doesn't exist with session sub-directory" do
+    @shell_mock.should_receive(:mkdir_p).with SESSION_DIR
+    @runner.start
+  end
+
+  it "should run ruby command on kata file given as argument" do
+    @shell_mock.should_receive(:execute).with "ruby my_file.rb"
+    @runner.start
+  end
+
+  it "should create a state directory for every state" do
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return 1
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}0"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}0"
+    @runner.start
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return 2
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}1"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}1"
+    @runner.execute
+  end
+
+  it "should not run if the kata file wasn't modified" do
+    a_time = Time.new
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return a_time
+    @shell_mock.should_receive(:mkdir).with "#{STATE_DIR_PREFIX}0"
+    @shell_mock.should_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}0"
+    @runner.start
+    @shell_mock.should_receive(:ctime).with("my_file.rb").and_return a_time
+    @shell_mock.should_not_receive(:mkdir).with "#{STATE_DIR_PREFIX}1"
+    @shell_mock.should_not_receive(:cp).with "my_file.rb", "#{STATE_DIR_PREFIX}1"
+    @runner.execute
+  end
+
+  it "should capture run result into state directory" do
+    @shell_mock.should_receive(:execute).and_return "spec result"
+    @shell_mock.should_receive(:write_file).with "#{STATE_DIR_PREFIX}0/result.txt", "spec result"
+    @runner.start
+  end
+
+end
+

data/spec/session_id_generator_spec.rb

@@ -0,0 +1,21 @@
+require 'session_id_generator'
+
+describe SessionIdGenerator do
+	
+	before (:each) do
+		@time_mock = mock
+		@generator = SessionIdGenerator.new
+	end
+	
+	it "should format id as yyyy-mm-dd_hh-mm-ss" do
+		@time_mock.should_receive(:year).and_return 2010
+		@time_mock.should_receive(:month).and_return 8
+		@time_mock.should_receive(:day).and_return 7
+		@time_mock.should_receive(:hour).and_return 6
+		@time_mock.should_receive(:min).and_return 5
+		@time_mock.should_receive(:sec).and_return 0
+		@generator.generate_id(@time_mock).should == "2010-08-07_06-05-00"
+	end
+	
+end
+