karl-loris 0.0.5 → 0.0.6

data/.autotest

@@ -0,0 +1,12 @@
+# Automatically reload this config file if it changes
+require 'autotest/restart'
+
+require 'autotest/growl'
+
+Autotest::Growl::hide_label = true
+
+# Use remote notification to avoid problem where notifications sometime don't show
+Autotest::Growl::remote_notification = true
+
+# Don't busy wait on OSX
+# require 'autotest/fsevent'       

data/.gitignore

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

data/TODO

@@ -0,0 +1,21 @@
+* 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)
+
+* Add JS Test Driver support
+
+* Detect file deletion/directory rename
+
+* Deal with filesystem exceptions
+* Deal with task exceptions
+* jspec task (just modified files?)
+* javascript lint task (just modified files?)
+* separate thread (create new and kill old)
+* listen for interrupt
+* detect file deletion
+* rspec task
+* cucumber task
+* Tidy growl windows code

data/VERSION

@@ -0,0 +1 @@
+0.0.6

data/autotest/discover.rb

@@ -0,0 +1,3 @@
+Autotest.add_discovery do
+  "rspec"
+end

data/cucumber.yml

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

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/run.feature

@@ -0,0 +1,37 @@
+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,61 @@
+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 /^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/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/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_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/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/loris.rb

@@ -0,0 +1,108 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'rubygems'
+require 'bind'
+require 'rbconfig'
+require 'find'
+require 'Growl'
+
+
+require 'file_finder'
+require 'poller'
+require 'sleep_waiter'
+require 'always_continuer'
+require 'file_actioner'
+require 'modified_filter'
+require 'file_filter'
+require 'task_manager'
+require 'extension_filter'
+
+require 'outputs/output_collection'
+require 'outputs/shell_output'
+require 'outputs/console_clearing_output' 
+require 'outputs/growl_output'
+
+require 'tasks/list_task'
+require 'tasks/jspec_task'
+require 'tasks/jspec_runner'
+require 'tasks/javascript_lint_task'
+require 'tasks/javascript_lint_runner'
+
+
+include Config
+
+class DebugObserver
+  def update
+    puts '[Poll complete]'
+  end
+end
+
+
+module Loris
+  BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/loris')
+  LIBDIR = File.expand_path(File.dirname(__FILE__) + '/../lib')
+  RUBY_BINARY = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])  
+  
+  module CLI
+    
+    class Main
+    
+      class DummyActioner
+        
+        def initialize(actioner, stream)
+          @actioner = actioner
+          @stream = stream
+        end
+        
+        def run()
+            @actioner.run()
+            @stream.puts '[Poll complete]'
+            @stream.flush
+        end
+        
+      end
+    
+      class << self
+        def execute(args)
+          puts 'Loris is running!'
+
+          debug = args.length > 0
+
+          dir = Dir.pwd
+
+          w = SleepWaiter.new(1)
+          c = AlwaysContinuer.new
+          ff = FileFinder.new(Find, dir)
+          ff.add_filter(FileFilter.new(File))
+          ff.add_filter(ModifiedFilter.new(File))
+
+          oc = OutputCollection.new()
+          oc.add(ShellOutput.new($stdout))
+          oc.add(ConsoleClearingOutput.new())
+
+          if (!debug)
+            oc.add(GrowlOutput.new(Growl))          
+          end
+          
+          tm = TaskManager.new(oc)
+          tm.add(ListTask.new()) if debug
+          tm.add(JavascriptLintTask.new(JavascriptLintRunner.new(dir), dir))
+          tm.add(JSpecTask.new(JSpecRunner.new(dir)))
+
+          a = FileActioner.new(ff, tm)    
+          
+          da = DummyActioner.new(a, $stdout)
+                
+          p = Poller.new(w, c, debug ? da : a)
+          
+          p.start()
+
+        end
+      end    
+
+    end
+    
+  end
+  
+end