loris 0.0.12

data/.gitignore

@@ -0,0 +1,2 @@
+.gitignore
+.DS_Store

data/README.rdoc

@@ -0,0 +1,9 @@
+== Autotest for Javascript ==
+
+Run your javascript unit tests any time a file in your project changes.
+
+Runs Javascript Lint (if jsl.conf is found)
+Runs JSpec (if spec/spec.rhino.js is found)
+Runs JS Test Driver (if jsTestDriver.conf is found)
+
+Also runs RSpec (if any file ending in _spec.rb is found in the spec directory)

data/Rakefile

@@ -0,0 +1,41 @@
+require 'rubygems'
+require 'rake'
+require 'spec/rake/spectask'
+require 'cucumber'
+require 'cucumber/rake/task'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "loris"
+    gem.summary = 'Automatically run javascript unit tests'
+    gem.description = 'Automatically run javascript unit tests'
+    gem.email = "loris@monket.net"
+    gem.homepage = "http://github.com/karl/loris"
+    gem.authors = ["Karl O'Keeffe"]
+
+    gem.add_dependency('visionmedia-bind', [">= 0.2.6"])
+    gem.add_dependency('karl-growl', [">= 1.0.3"])
+    gem.add_dependency('extensions', [">= 0.6.0"])
+    gem.add_dependency('win32-process', [">= 0.6.1"])
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+
+task :default => :spec
+
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = Dir.glob('spec/**/*_spec.rb')
+  # t.rcov = true
+end
+
+Cucumber::Rake::Task.new(:features) do |t|
+  t.cucumber_opts = "features --format pretty"
+end
+
+
+

data/TODO

@@ -0,0 +1,21 @@
+* Work out what is going on with fork in windows (running second copy of Loris?)
+
+* Remove JsTestDriver.jar from lib dir
+* Tidy Windows related if statements
+* Tidy JSL filename removing
+
+* javascript lint not installed? (package if not already installed?)
+* JSpec not installed? (can require as gem)
+
+* Detect file rename
+* Detect file deletion/directory rename
+
+* Factories to create tasks
+
+* Deal with filesystem exceptions
+* jspec task (just modified files?)
+* javascript lint task (just modified files?)
+* separate thread (create new and kill old)
+* listen for interrupt
+* cucumber task
+* Tidy growl windows code

data/VERSION

@@ -0,0 +1 @@
+0.0.12

data/bin/loris

@@ -0,0 +1,15 @@
+#!/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby
+$:.unshift(File.dirname(__FILE__ + '.rb') + '/../lib') unless $:.include?(File.dirname(__FILE__ + '.rb') + '/../lib')
+ 
+require 'loris'
+begin
+  # The dup is to keep ARGV intact, so that tools like ruby-debug can respawn.
+  failure = Loris::CLI::Main.execute(ARGV.dup)
+  Kernel.exit(failure ? 1 : 0)
+rescue SystemExit => e
+  Kernel.exit(e.status)
+rescue Exception => e
+  STDERR.puts("#{e.message} (#{e.class})")
+  STDERR.puts(e.backtrace.join("\n"))
+  Kernel.exit 1
+end

data/cucumber.yml

@@ -0,0 +1 @@
+default: features

data/examples/self_test/jsl.conf

@@ -0,0 +1 @@
++process tmp/*.js

data/examples/self_test/spec/spec.rhino.js

@@ -0,0 +1,6 @@
+
+load('/Library/Ruby/Gems/1.8/gems/visionmedia-jspec-2.2.1/lib/jspec.js')
+
+JSpec
+.run({ formatter : JSpec.formatters.Terminal })
+.report()

data/features/javascript_lint.feature

@@ -0,0 +1,34 @@
+Feature Javascript Lint
+
+	Scenario: Javascript Lint is run
+		Given I run loris --debug
+		When I create a file named "example.js" with:
+"""
+var foo = function() {
+	x = 'moo'
+}
+"""
+		And I wait until loris has finished processing changes
+		Then the Loris output should contain:
+"""
+Javascript Lint
+warning
+"""
+		And I should not see any errors
+
+# 	Scenario: Javascript Lint is run when Loris starts
+# 		When I create a file named "example.js" with:
+# """
+# var foo = function() {
+# 	x = 'moo'
+# }
+# """
+# 		Given I run loris --debug
+# 		And I wait until loris has finished processing changes
+# 		Then the Loris output should contain:
+# """
+# Javascript Lint
+# warning
+# """
+# 		And I should not see any errors
+# 

data/features/run.feature

@@ -0,0 +1,36 @@
+Feature: Run Loris
+
+	Scenario: Creating a file triggers loris
+		Given I run loris --debug
+		When I create a file named "created.txt"
+		And I wait until loris has finished processing changes
+		Then I should see "created.txt" in the Loris output 
+		And I should not see any errors
+	
+	Scenario: Modifying a file triggers loris
+		Given I create a file named "modified.txt"
+		When I run loris --debug
+		And I wait until loris has finished processing changes
+		And I start recording the Loris output
+		And I modify the "modified.txt" file
+		And I wait until loris has finished processing changes
+		Then I should see "modified.txt" in the recorded output 
+		And I should not see any errors
+	
+	Scenario: Modified only triggered once
+		Given I create a file named "modified.txt"
+		When I run loris --debug
+		And I wait until loris has finished processing changes
+		And I start recording the Loris output
+		And I modify the "modified.txt" file
+		And I wait until loris has finished processing changes
+		And I wait until loris has finished processing changes
+		Then I should only see "modified.txt" once in the recorded output 
+		And I should not see any errors
+
+	Scenario: Directories not included
+		Given I run loris --debug
+		When I create a directory named "dir"
+		And I wait until loris has finished processing changes
+		Then I should NOT see "dir" in the Loris output
+		And I should not see any errors

data/features/step_definitons/all.rb

@@ -0,0 +1,69 @@
+require 'spec/expectations'
+
+When /^I run loris(.*)$/ do |loris_opts|
+  run_in_background "#{Loris::RUBY_BINARY} #{Loris::BINARY} #{loris_opts}"
+end
+
+Given /^(?:I create )a file named "([^\"]*)"$/ do |file_name|
+  @current_dir = working_dir
+  create_file(file_name, '')
+end
+ 
+Given /^(?:I create )a directory named "([^\"]*)"$/ do |dir_name|
+  @current_dir = working_dir
+  create_dir(dir_name)
+end
+ 
+Given /^(?:I create )a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  @current_dir = working_dir
+  create_file(file_name, file_content)
+end
+
+When /^I modify the "([^\"]*)" file$/ do |file_name|
+  @current_dir = working_dir
+  touch_file(file_name)
+end
+
+When /^I wait until loris has finished processing changes$/ do
+  len = get_background_output.length
+  new_output = ""
+  while not new_output =~ /\[Poll complete\]/
+    new_output = get_background_output[len..-1]
+    sleep 0.5
+  end
+end
+
+When /^I start recording the Loris output$/ do
+  @pre_recorded_length = get_background_output.length
+end
+
+Then /^I should see "([^\"]*)" in the recorded output$/ do |text|
+  recorded = get_background_output[@pre_recorded_length..-1]
+  recorded.should include text
+end
+
+Then /^I should only see "([^\"]*)" once in the recorded output$/ do |text|
+  recorded = get_background_output[@pre_recorded_length..-1]
+  recorded.should include text
+  recorded.scan(text).length.should equal 1
+end
+
+Then /^I should see "([^\"]*)" in the Loris output$/ do |text|
+  get_background_output.should include text
+end
+
+Then /^the Loris output should contain:$/ do |text|
+  get_background_output.should include text
+end
+
+Then /^the Loris output should NOT contain:$/ do |text|
+  get_background_output.should_not include text
+end
+
+Then /^I should NOT see "([^\"]*)" in the Loris output$/ do |text|
+  get_background_output.should_not include text
+end
+
+Then /^I should not see any errors$/ do
+  get_background_error.strip.should == ""
+end

data/features/support/env.rb

@@ -0,0 +1,145 @@
+require 'rubygems'
+require 'tempfile'
+require 'spec/expectations'
+require 'fileutils'
+require 'forwardable'
+
+require 'lib/loris.rb'
+ 
+class CucumberWorld
+  extend Forwardable
+  def_delegators CucumberWorld, :examples_dir, :self_test_dir, :working_dir, :cucumber_lib_dir
+ 
+  def self.examples_dir(subdir=nil)
+    @examples_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../examples'))
+    subdir ? File.join(@examples_dir, subdir) : @examples_dir
+  end
+ 
+  def self.self_test_dir
+    @self_test_dir ||= examples_dir('self_test')
+  end
+ 
+  def self.working_dir
+    @working_dir ||= examples_dir('self_test/tmp')
+  end
+ 
+  def cucumber_lib_dir
+    @cucumber_lib_dir ||= File.expand_path(File.join(File.dirname(__FILE__), '../../lib'))
+  end
+ 
+  def initialize
+    @current_dir = self_test_dir
+  end
+ 
+  private
+  attr_reader :last_exit_status, :last_stderr
+ 
+  # The last standard out, with the duration line taken out (unpredictable)
+  def last_stdout
+    strip_duration(@last_stdout)
+  end
+ 
+  def strip_duration(s)
+    s.gsub(/^\d+m\d+\.\d+s\n/m, "")
+  end
+ 
+  def replace_duration(s, replacement)
+    s.gsub(/\d+m\d+\.\d+s/m, replacement)
+  end
+ 
+  def create_file(file_name, file_content)
+    file_content.gsub!("CUCUMBER_LIB", "'#{cucumber_lib_dir}'") # Some files, such as Rakefiles need to use the lib dir
+    in_current_dir do
+      File.open(file_name, 'w') { |f| f << file_content }
+    end
+  end
+  
+  def create_dir(dir_name)
+    in_current_dir do
+      # create any subdirectories if needed
+      FileUtils.mkdir(dir_name)
+    end
+  end
+  
+  def touch_file(file_name)
+    in_current_dir do
+      FileUtils.touch(file_name)
+    end
+  end
+ 
+  def background_jobs
+    @background_jobs ||= []
+  end
+ 
+  def in_current_dir(&block)
+    Dir.chdir(@current_dir, &block)
+  end
+ 
+  def run(command)
+    stderr_file = Tempfile.new('loris-stderr')
+    stderr_file.close
+    
+    stdout_file = Tempfile.new('loris-stdout')
+    stdout_file.close
+    
+    in_current_dir do
+      `#{command} 1> #{stdout_file.path} 2> #{stderr_file.path}`
+      @last_exit_status = $?.exitstatus
+    end
+    @last_stdout = IO.read(stdout_file.path)
+    @last_stderr = IO.read(stderr_file.path)
+  end
+ 
+  def run_in_background(command)
+    @stderr_file = Tempfile.new('loris-stderr')
+    @stderr_file.close
+
+    @stdout_file = Tempfile.new('loris-stdout')
+    @stdout_file.close
+
+    pid = fork
+    in_current_dir do
+      if pid
+        background_jobs << pid
+      else
+        cmd = "#{command} 1> #{@stdout_file.path} 2> #{@stderr_file.path}"
+        exec cmd
+      end
+    end
+  end
+ 
+  def terminate_background_jobs
+    if @background_jobs
+      @background_jobs.each do |pid|
+        Process.kill(Signal.list['TERM'], pid)
+      end
+    end
+  end
+
+ def get_background_output
+   return IO.read(@stdout_file.path) rescue return ""
+ end
+
+ def get_background_error
+   return IO.read(@stderr_file.path) rescue return ""
+ end
+ 
+end
+ 
+World do
+  CucumberWorld.new
+end
+ 
+Before do
+  FileUtils.rm_rf CucumberWorld.working_dir
+  FileUtils.mkdir CucumberWorld.working_dir
+end
+ 
+After do
+  err = get_background_error
+  if (err != "")
+    puts 'Background process errors:'
+    puts err
+  end  
+  terminate_background_jobs
+end

data/lib/always_continuer.rb

@@ -0,0 +1,7 @@
+class AlwaysContinuer
+  
+  def continue?
+    return true
+  end
+  
+end

data/lib/browser_finder.rb

@@ -0,0 +1,23 @@
+require 'win32/registry'
+
+class BrowserFinder
+  
+  def initialize
+    @ie = '"C:/Program Files/Internet Explorer/iexplore.exe" "%1"'
+  end
+  
+  def getDefault
+    browser = getBrowserFromRegistry()
+    return browser != '' ? browser : @ie
+  end
+  
+  def getBrowserFromRegistry
+    
+      Win32::Registry::HKEY_CLASSES_ROOT.open('http\shell\open\command') do |reg|
+          reg_typ, reg_val = reg.read('')          
+          return reg_val
+      end
+    
+  end
+  
+end

data/lib/file_actioner.rb

@@ -0,0 +1,16 @@
+class FileActioner
+  
+  def initialize(file_finder, task_manager)
+    @file_finder = file_finder
+    @task_manager = task_manager
+  end
+  
+  def run
+    files = @file_finder.find
+    
+    if (files[:filtered] != [])
+      @task_manager.run(files)
+    end
+  end
+  
+end

data/lib/file_finder.rb

@@ -0,0 +1,31 @@
+class FileFinder
+  
+  def initialize(finder, dir)
+    @finder = finder
+    @dir = dir
+    @filters = []
+  end
+  
+  def add_filter(filter)
+    @filters << filter
+  end
+  
+  def find
+    all_files = []
+    filtered_files = []
+
+    @finder.find(@dir) do |path|
+      all_files << path
+      
+      keep = @filters.inject(true) { |k, filter| k && filter.filter(path)  }
+      filtered_files << path if keep
+    end
+    
+    @filters.each do |filter|
+      filter.complete
+    end
+
+    return { :all => all_files, :filtered => filtered_files }
+  end
+
+end

data/lib/filters/ends_with_filter.rb

@@ -0,0 +1,17 @@
+require 'rubygems'
+require 'extensions/string'
+
+class EndsWithFilter
+  
+  def initialize(text)
+    @text = text.downcase
+  end
+  
+  def filter(file_name)
+    return file_name.downcase.ends_with? @text
+  end
+  
+  def complete
+  end
+  
+end

data/lib/filters/extension_filter.rb

@@ -0,0 +1,20 @@
+class ExtensionFilter
+  
+  def initialize(file_class, extension)
+    @file_class = file_class
+    @extension = extension.downcase
+  end
+  
+  def filter(file_name)
+    return file_type(file_name) == @extension
+  end
+
+  # Return the part of the file name string after the last '.'
+  def file_type(file_name)
+    @file_class.extname(file_name).gsub( /^\./, '' ).downcase 
+  end
+  
+  def complete
+  end
+  
+end

data/lib/filters/file_filter.rb

@@ -0,0 +1,14 @@
+class FileFilter
+  
+  def initialize(file_class)
+    @file_class = file_class
+  end
+  
+  def filter(path)
+    return @file_class.file?(path)
+  end
+  
+  def complete
+  end
+  
+end

data/lib/filters/modified_filter.rb

@@ -0,0 +1,21 @@
+class ModifiedFilter
+  
+  def initialize(file_class, last_modified = nil)
+    @file_class = file_class
+    @last_modified = last_modified
+    @modifieds = []
+  end
+  
+  def filter(path)
+    modified = @file_class.mtime(path)
+    @modifieds << modified
+    
+    return @last_modified.nil? || modified > @last_modified
+  end
+  
+  def complete
+    @last_modified = @modifieds.max
+    @modifieds = []
+  end
+  
+end