zeus-edge 0.12.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in zeus.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Burke Libbey
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,57 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+require 'fileutils'
+require 'pathname'
+
+ROOT_PATH = Pathname.new(File.expand_path("../../", __FILE__))
+RUBYGEM_PATH = Pathname.new(File.expand_path("../", __FILE__))
+
+task build: [:import_externals, :version, :manifest]
+task default: :build
+
+task :import_externals do
+  puts "building rubygem"
+
+  Rake::Task[:clean].invoke
+
+  FileUtils.rm_r(RUBYGEM_PATH + "man") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "build") rescue nil
+
+  # manpages
+  FileUtils.mkdir(RUBYGEM_PATH + "man")
+  FileUtils.cp_r(ROOT_PATH + "man/build", RUBYGEM_PATH + "man")
+
+  # multi-arch binaries
+  FileUtils.cp_r(ROOT_PATH + "build", RUBYGEM_PATH + "build")
+
+  Rake::Task[:manifest].invoke
+  Rake::Task[:build].invoke
+end
+
+task :version do
+  version = File.read('../VERSION').chomp
+  File.open('lib/zeus/version.rb', 'w') { |f| f.puts <<END
+module Zeus
+  VERSION = "#{version}"
+end
+END
+  }
+end
+
+task :manifest do
+  files = `find . -type f | sed 's|^\./||'`.lines.map(&:chomp)
+  exceptions = [
+    /.gitignore$/,
+    /^MANIFEST$/,
+    /^pkg\//,
+  ]
+  files.reject! { |f| exceptions.any? {|ex| f =~ ex }}
+  File.open('MANIFEST', 'w') {|f| f.puts files.join("\n") }
+end
+
+task :clean do
+  FileUtils.rm(RUBYGEM_PATH + "lib/zeus/version.rb") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "man") rescue nil
+  FileUtils.rm_r(RUBYGEM_PATH + "build") rescue nil
+end
+

data/bin/zeus

@@ -0,0 +1,16 @@
+platform = `uname -sm`
+
+exe = case platform
+      when /^Darwin/    ; "zeus-darwin-amd64"
+      when /^Linux.*64/ ; "zeus-linux-amd64"
+      when /^Linux.*/   ; "zeus-linux-386"
+      else
+        puts "Zeus is not supported on your platform."
+        puts "It's not likely to ever be possible on Windows."
+        puts "If you're using another platform that you think should work easily, open an issue at:"
+        puts "https://github.com/burke/zeus/issues"
+        exit 1
+      end
+
+zeusgemdir = File.expand_path("../../", __FILE__)
+exec "#{zeusgemdir}/build/#{exe}", *ARGV

data/ext/inotify-wrapper/extconf.rb

@@ -0,0 +1,24 @@
+if /linux/ =~ RUBY_PLATFORM
+  open("Makefile", "wb") do |f|
+    f.write <<-EOF
+CXX = g++
+CXXFLAGS = -O3 -g -Wall
+
+inotify-wrapper: inotify-wrapper.o
+	$(CXX) $(CXXFLAGS) $< -o $@
+
+%.o: %.cpp
+	$(CXX) $(CXXFLAGS) -c $< -o $@
+
+install:
+	# do nothing
+    EOF
+  end
+else
+  open("Makefile", "wb") do |f|
+    f.write <<-EOF
+install:
+	# do nothing
+    EOF
+  end
+end

data/ext/inotify-wrapper/inotify-wrapper.cpp

@@ -0,0 +1,116 @@
+#include <map>
+#include <string>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/inotify.h>
+
+#include <errno.h>
+
+#define EVENT_SIZE (sizeof (struct inotify_event))
+#define EVENT_BUF_LEN (1024 * (EVENT_SIZE + 16))
+
+using namespace std;
+
+static int _inotify_fd;
+static map<int, string> _WatchedFiles;
+static map<string, bool> _FileIsWatched;
+
+// static int inotifyFlags = IN_ATTRIB | IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF;
+static int inotifyFlags = IN_ATTRIB | IN_MODIFY | IN_MOVE_SELF | IN_DELETE_SELF;
+
+void maybeAddFileToWatchList(string file)
+{
+  if (_FileIsWatched[file]) return;
+
+  int wd = inotify_add_watch(_inotify_fd, file.c_str(), inotifyFlags);
+  int attempts = 0;
+  // Files are momentarily inaccessible when they are rewritten. I couldn't
+  // find a good way to deal with this, so we poll 'deleted' files for 0.25s or so
+  // to see if they reappear.
+  while (wd == -1 && errno == ENOENT) {
+    usleep(10000);
+    wd = inotify_add_watch(_inotify_fd, file.c_str(), inotifyFlags);
+    if (attempts++ == 25) break; // try for at most about a quarter of a second
+  }
+  if (wd != -1) {
+    _WatchedFiles[wd] = file;
+    _FileIsWatched[file] = true;
+  }
+}
+
+// This essentially removes a file from the watchlist then
+// immediately re-adds it. This is because when a file is rewritten,
+// as so many editors love to do, the watchdescriptor no longer refers to
+// the file, so re must re-watch the path.
+void replaceFileInWatchList(int wd, string file)
+{
+  _FileIsWatched.erase(file);
+  _WatchedFiles.erase(wd);
+  inotify_rm_watch(_inotify_fd, wd);
+  maybeAddFileToWatchList(file);
+}
+
+void handleStdin()
+{
+  char line[2048];
+  if (fgets(line, sizeof(line), stdin) == NULL) return;
+  line[strlen(line)-1] = 0;
+
+  maybeAddFileToWatchList(string(line));
+}
+
+void handleInotify()
+{
+  int length;
+  int i = 0;
+  char buffer[EVENT_BUF_LEN];
+  string filename;
+
+  length = read(_inotify_fd, buffer, EVENT_BUF_LEN);
+  if (length < 0) return;
+
+  while (i < length) {
+    struct inotify_event *event = (struct inotify_event *) &buffer[i];
+    string file = _WatchedFiles[event->wd];
+    if (file != "") {
+      printf("%s\n", file.c_str());
+      fflush(stdout);
+      replaceFileInWatchList(event->wd, file);
+    }
+
+    i += EVENT_SIZE + event->len;
+  }
+}
+
+void go()
+{
+  fd_set rfds;
+  int retval;
+
+  for (;;) {
+    FD_ZERO(&rfds);
+    FD_SET(0, &rfds);
+    FD_SET(_inotify_fd, &rfds);
+
+    retval = select(_inotify_fd+1, &rfds, NULL, NULL, NULL);
+
+    if (retval == -1) {
+      // perror("select");
+    } else if (retval) {
+      if (FD_ISSET(0, &rfds))           handleStdin();
+      if (FD_ISSET(_inotify_fd, &rfds)) handleInotify();
+    }
+  }
+}
+
+
+int main(int argc, const char *argv[])
+{
+  _inotify_fd = inotify_init();
+  go();
+}

data/lib/zeus/load_tracking.rb

@@ -0,0 +1,53 @@
+module Zeus
+  class LoadTracking
+    class << self
+
+      def features_loaded_by(&block)
+        old_features = all_features()
+        yield
+        new_features = all_features() - old_features
+        return new_features
+      end
+
+      def add_feature(file)
+        path = if File.exist?(File.expand_path(file))
+          File.expand_path(file)
+        else
+          find_in_load_path(file)
+        end
+        add_extra_feature(path) if path
+      end
+
+      private
+
+      def all_features
+        untracked = defined?($untracked_features) ? $untracked_features : []
+        $LOADED_FEATURES + untracked
+      end
+
+      def add_extra_feature(path)
+        $untracked_features ||= []
+        $untracked_features << path
+      end
+
+      def find_in_load_path(file)
+        $LOAD_PATH.map { |path| "#{path}/#{file}" }.detect{ |file| File.exist? file }
+      end
+    end
+  end
+end
+
+module Kernel
+
+  def load(file, *a)
+    Kernel.load(file, *a)
+  end
+
+  class << self
+    alias_method :__load_without_zeus, :load
+    def load(file, *a)
+      Zeus::LoadTracking.add_feature(file)
+      __load_without_zeus(file, *a)
+    end
+  end
+end

data/lib/zeus/m/test_collection.rb

@@ -0,0 +1,52 @@
+require "forwardable"
+
+module Zeus
+  module M
+    ### Custom wrapper around an array of test methods
+    # In charge of some smart querying, filtering, sorting, etc on the the
+    # test methods
+    class TestCollection
+      include Enumerable
+      extend Forwardable
+      # This should act like an array, so forward some common methods over to the
+      # internal collection
+      def_delegators :@collection, :size, :<<, :each, :empty?
+
+      def initialize(collection = nil)
+        @collection = collection || []
+      end
+
+      # Slice out tests that may be within the given line.
+      # Returns a new TestCollection with the results.
+      def within(line)
+        # Into a new collection, filter only the tests that...
+        self.class.new(select do |test|
+          # are within the given boundary for this method
+          # or include everything if the line given is nil (no line)
+          line.nil? || (test.start_line..test.end_line).include?(line)
+        end)
+      end
+
+      # Used to line up method names in `#sprintf` when `m` aborts
+      def column_size
+        # Boil down the collection of test methods to the name of the method's
+        # size, then find the largest one
+        @column_size ||= map { |test| test.name.to_s.size }.max
+      end
+
+      # Be considerate when printing out tests and pre-sort them by line number
+      def by_line_number(&block)
+        # On each member of the collection, sort by line number and yield
+        # the block into the sorted collection
+        sort_by(&:start_line).each(&block)
+      end
+
+      def contains? test_name
+        @collection.each do |test|
+          return true if test_name.match(test.name)
+        end
+        false
+      end
+    end
+  end
+end

data/lib/zeus/m/test_method.rb

@@ -0,0 +1,35 @@
+module Zeus
+  module M
+    ### Simple data structure for what a test method contains.
+    #
+    # Too lazy to make a class for this when it's really just a bag of data
+    # without any behavior.
+    #
+    # Includes the name of this method, what line on the file it begins on,
+    # and where it ends.
+    class TestMethod < Struct.new(:name, :start_line, :end_line)
+      # Set up a new test method for this test suite class
+      def self.create(suite_class, test_method, find_locations = true)
+        # Hopefully it's been defined as an instance method, so we'll need to
+        # look up the ruby Method instance for it
+        method = suite_class.instance_method(test_method)
+
+        if find_locations
+          # Ruby can find the starting line for us, so pull that out of the array
+          start_line = method.source_location.last
+
+          # Ruby can't find the end line however, and I'm too lazy to write
+          # a parser. Instead, `method_source` adds `Method#source` so we can
+          # deduce this ourselves.
+          #
+          # The end line should be the number of line breaks in the method source,
+          # added to the starting line and subtracted by one.
+          end_line = method.source.split("\n").size + start_line - 1
+        end
+
+        # Shove the given attributes into a new databag
+        new(test_method, start_line, end_line)
+      end
+    end
+  end
+end