zeus 0.4.6 → 0.10.0.pre

data/lib/zeus/server/stage/error_state.rb

@@ -1,42 +0,0 @@
-module Zeus
-  class Server
-    class Stage
-
-      module ErrorState
-        def handle_load_error(e)
-          errored_file = full_path_of_file_from_error(e)
-
-          # register all the decendent acceptors as stubs with errors
-          register_acceptors_as_errors(e)
-
-          feature_notifier.notify_feature(errored_file)
-          feature_notifier.notify_new_features
-
-          # we do not need to do anything. We wait, until a dependency changes.
-          # At that point, we get killed and restarted.
-          sleep
-        end
-
-        private
-
-        def full_path_of_file_from_error(e)
-          errored_file = e.backtrace[0].scan(/(.+?):\d+:in/)[0][0]
-
-          # handle relative paths
-          unless errored_file =~ /^\//
-            errored_file = File.expand_path(errored_file, Dir.pwd)
-          end
-        end
-
-        def register_acceptors_as_errors(e)
-          descendent_acceptors.each do |acc|
-            acc = acc.extend(Acceptor::ErrorState)
-            acc.error = e
-            acc.run
-          end
-        end
-      end
-
-    end
-  end
-end

data/lib/zeus/server/stage/feature_notifier.rb

@@ -1,38 +0,0 @@
-module Zeus
-  class Server
-    class Stage
-      class FeatureNotifier
-
-        def initialize(server, stage_name)
-          @server = server
-          @stage_name = stage_name
-        end
-
-        def notify_new_features
-          new_features = newly_loaded_features()
-          $previously_loaded_features ||= []
-          $previously_loaded_features |= new_features
-          Thread.new {
-            new_features.each { |f| notify_feature(f) }
-          }
-        end
-
-        def notify_feature(feature)
-          @server.__CHILD__stage_has_feature(@stage_name, feature)
-        end
-
-        private
-
-        def newly_loaded_features
-          old_features = defined?($previously_loaded_features) ? $previously_loaded_features : []
-          ($LOADED_FEATURES + @server.extra_features) - old_features
-        end
-
-      end
-    end
-  end
-end
-
-
-
-

data/lib/zeus/templates/rails.rb

@@ -1,133 +0,0 @@
-require 'socket'
-begin
-  require 'testrbl' # before bundler is setup so it does not need to be in the Gemfile
-rescue LoadError
-end
-
-ROOT_PATH = File.expand_path(Dir.pwd)
-
-Zeus::Server.define! do
-  stage :boot do
-
-    action do
-      ENV_PATH  = File.expand_path('config/environment',  ROOT_PATH)
-      BOOT_PATH = File.expand_path('config/boot',  ROOT_PATH)
-      APP_PATH  = File.expand_path('config/application',  ROOT_PATH)
-
-      require BOOT_PATH
-      require 'rails/all'
-    end
-
-    stage :default_bundle do
-      action { Bundler.require(:default) }
-
-      stage :development_environment do
-        action do
-          Bundler.require(:development)
-          Rails.env = ENV['RAILS_ENV'] = "development"
-          require APP_PATH
-          Rails.application.require_environment!
-        end
-
-        command :generate, :g do
-          begin
-            require 'rails/generators'
-            Rails.application.load_generators
-          rescue LoadError # Rails 3.0 doesn't require this block to be run, but 3.2+ does
-          end
-          require 'rails/commands/generate'
-        end
-
-        command :runner, :r do
-          require 'rails/commands/runner'
-        end
-
-        command :console, :c do
-          require 'rails/commands/console'
-          Rails::Console.start(Rails.application)
-        end
-
-        command :server, :s do
-          require 'rails/commands/server'
-          server = Rails::Server.new
-          Dir.chdir(Rails.application.root)
-          server.start
-        end
-
-        stage :prerake do
-          action do
-            require 'rake'
-            load 'Rakefile'
-          end
-
-          command :rake do
-            Rake.application.run
-          end
-
-        end
-      end
-
-      stage :test_environment do
-        action do
-          Bundler.require(:test)
-
-          Rails.env = ENV['RAILS_ENV'] = 'test'
-          require APP_PATH
-
-          $rails_rake_task = 'yup' # lie to skip eager loading
-          Rails.application.require_environment!
-          $rails_rake_task = nil
-          $LOAD_PATH.unshift(ROOT_PATH) unless $LOAD_PATH.include?(ROOT_PATH)
-
-          if Dir.exist?(ROOT_PATH + "/test")
-            test = File.join(ROOT_PATH, 'test')
-            $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
-          end
-
-          if Dir.exist?(ROOT_PATH + "/spec")
-            spec = File.join(ROOT_PATH, 'spec')
-            $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
-          end
-
-        end
-
-        if Dir.exist?(ROOT_PATH + "/test")
-          stage :test_helper do
-            action { require 'test_helper' }
-
-            command :testrb do
-              argv = ARGV
-
-              # try to find patter by line using testrbl
-              if defined?(Testrbl) && argv.size == 1 and argv.first =~ /^\S+:\d+$/
-                file, line = argv.first.split(':')
-                argv = [file, '-n', "/#{Testrbl.send(:pattern_from_file, File.readlines(file), line)}/"]
-                puts "using -n '#{argv[2]}'" # let users copy/paste or adjust the pattern
-              end
-
-              runner = Test::Unit::AutoRunner.new(true)
-              if runner.process_args(argv)
-                exit runner.run
-              else
-                abort runner.options.banner + " tests..."
-              end
-            end
-          end
-        end
-
-        if Dir.exist?(ROOT_PATH + "/spec")
-          stage :spec_helper do
-            action { require 'spec_helper' }
-
-            command :rspec do
-              exit RSpec::Core::Runner.run(ARGV)
-            end
-          end
-        end
-
-      end
-
-    end
-  end
-end
-

data/lib/zeus/ui.rb

@@ -1,57 +0,0 @@
-module Zeus
-  class UI
-
-    def initialize
-      @quiet = false
-      @debug = ENV['DEBUG']
-    end
-
-    def info(msg)
-      tell_me(msg, :magenta) if !@quiet
-    end
-
-    def warn(msg)
-      tell_me(msg, :yellow)
-    end
-
-    def error(msg)
-      tell_me(msg, :red)
-    end
-
-    def debug(msg)
-      tell_me(msg, nil) if debug?
-    end
-
-    def be_quiet!
-      @quiet = true
-    end
-
-    def debug!
-      @debug = true
-    end
-
-    def debug?
-      !!@debug && !@quiet
-    end
-
-    private
-
-    def tell_me(msg, color = nil)
-      puts make_message(msg, color)
-    end
-
-    def make_message(msg, color)
-      msg = case color
-            when :red     ; "\x1b[31m#{msg}\x1b[0m"
-            when :green   ; "\x1b[32m#{msg}\x1b[0m"
-            when :yellow  ; "\x1b[33m#{msg}\x1b[0m"
-            when :magenta ; "\x1b[35m#{msg}\x1b[0m"
-            else          ; msg
-            end
-      msg[-1] == "\n" ? msg : "#{msg}\n"
-    end
-
-
-  end
-
-end

data/lib/zeus/version.rb

@@ -1,3 +0,0 @@
-module Zeus
-  VERSION = "0.4.6"
-end

data/spec/cli_spec.rb

@@ -1,95 +0,0 @@
-require 'spec_helper'
-
-module Zeus
-  describe CLI do
-    let(:ui) { stub(debug!: nil) }
-
-    before do
-      Zeus::UI.stub(new: ui)
-    end
-
-    it "fails with unknown command" do
-      ui.should_receive(:error).with(/Could not find task/m)
-      Thrud.should_receive(:exit).with(1).and_raise(SystemExit)
-      begin
-        run_with_args("foo")
-      rescue SystemExit
-      end
-    end
-
-    describe "#help" do
-      it "prints a generic help menu" do
-        ui.should_receive(:info).with(/Global Commands.*zeus help.*show this help menu/m)
-        run_with_args("help")
-      end
-
-      it "prints a usage menu per command" do
-        ui.should_receive(:info).with(/Usage:.*zeus version.*version information/m)
-        run_with_args(["help", "version"])
-      end
-    end
-
-    describe "#start" do
-      it "fails to start the zeus server in a non-rails project without a config" do
-        ui.should_receive(:error).with(/is missing a config file.*rails project.*zeus init/m)
-        run_with_args("start", :exit => 1)
-      end
-
-      it "uses the rails template file if the project is missing a config file but looks like rails"
-      it "prints an error and exits if there is no config file and the project doesn't look like rails"
-    end
-
-    describe "#version" do
-      STRING_INCLUDING_VERSION = %r{#{Regexp.escape Zeus::VERSION}}
-
-      it "prints the version and exits" do
-        ui.should_receive(:info).with(STRING_INCLUDING_VERSION)
-        run_with_args("version")
-      end
-
-      it "has aliases" do
-        ui.should_receive(:info).with(STRING_INCLUDING_VERSION).twice
-        run_with_args("--version")
-        run_with_args("-v")
-      end
-    end
-
-    describe "#init" do
-      it "currently only generates a rails file, even if the project doesn't look like rails" do
-        ui.should_receive(:info).with(/Writing new .zeus.rb/m)
-        run_with_args("init")
-        read(".zeus.rb").should include("config/application")
-      end
-
-      it "prints an error and exits if the project already has a zeus config" do
-        write(".zeus.rb", "FOO")
-        ui.should_receive(:error).with(/.zeus.rb already exists /m)
-        run_with_args("init", :exit => 1)
-        read(".zeus.rb").should == "FOO"
-      end
-    end
-
-    describe "generated tasks" do
-      it "displays generated tasks in the help menu" do
-        ui.should_receive(:info).with(/spec/)
-        run_with_args("help")
-      end
-    end
-
-    private
-
-    def run_with_args(args, options={})
-      ARGV.replace([*args])
-      if options[:exit]
-        Zeus::CLI.any_instance.should_receive(:exit).with(options[:exit]).and_raise(SystemExit)
-        begin
-          Zeus::CLI.start
-        rescue SystemExit
-        end
-      else
-        Zeus::CLI.start
-      end
-    end
-  end
-end
-

data/spec/error_printer_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-require 'stringio'
-
-module Zeus
-  describe ErrorPrinter do
-
-    let(:error) {
-      begin
-        raise
-      rescue => e
-        e
-      end
-    }
-
-    it 'prints an error just like ruby does by default' do
-      io = StringIO.new
-      ErrorPrinter.new(error).write_to(io)
-      io.rewind
-      lines = io.readlines
-      lines[0].should =~ /^[^\s]*error_printer_spec.rb:\d+:in `.+':  \(RuntimeError\)$/
-      lines[1].should =~ /^\tfrom .*\.rb:\d+:in `.*'$/
-      lines.size.should > 5
-    end
-
-  end
-end

data/spec/integration_spec.rb

@@ -1,106 +0,0 @@
-require 'spec_helper'
-
-describe "Integration" do
-  after do
-    kill_all_children
-  end
-
-  context "in a non-rails project with a .zeus.rb" do
-    it "starts the zeus server and responds to commands" do
-      bar_setup("puts 'YES'")
-      start, run = start_and_run("bar")
-      start.should include "spawner `foo`"
-      start.should include "acceptor `bar`"
-      run.should == ["YES\r\n"]
-    end
-
-    it "receives ARGV after command" do
-      bar_setup("puts ARGV.join(', ')")
-      start, run = start_and_run("bar 1 '2 3 4' --123")
-      run.should == ["1, 2 3 4, --123\r\n"]
-    end
-
-    it "cam exist with 0" do
-      bar_setup("exit 0")
-      start_and_run("bar")
-    end
-
-    it "can exist with non-0" do
-      bar_setup("exit 1")
-      start_and_run("bar", :fail => true)
-    end
-
-    it "can run via command alias" do
-      write ".zeus.rb", <<-RUBY
-        Zeus::Server.define! do
-          stage :foo do
-            command :bar, :b do
-              puts "YES"
-            end
-          end
-        end
-      RUBY
-
-      start, run = start_and_run("b")
-      start.should include "spawner `foo`"
-      start.should include "acceptor `bar`"
-      run.should == ["YES\r\n"]
-    end
-  end
-
-  private
-
-  def bar_setup(inner)
-    write ".zeus.rb", <<-RUBY
-      Zeus::Server.define! do
-        stage :foo do
-          command :bar do
-            #{inner}
-          end
-        end
-      end
-    RUBY
-  end
-
-  def zeus(command, options={})
-    command = zeus_command(command)
-    result = `#{command}`
-    raise "FAILED #{command}\n#{result}" if $?.success? == !!options[:fail]
-    result
-  end
-
-  def zeus_command(command)
-    "ruby -I #{root}/lib #{root}/bin/zeus #{command} 2>&1"
-  end
-
-  def record_start(output)
-    IO.popen(zeus_command("start")) do |pipe|
-      while str = pipe.readpartial(100)
-        output << str
-      end rescue EOFError
-    end
-  end
-
-  def start_and_run(commands, options={})
-    start_output = ""
-    t1 = Thread.new { record_start(start_output) }
-    sleep 0.1
-    run_output = [*commands].map{ |cmd| zeus(cmd, options) }
-    sleep 0.2
-    t1.kill
-    [start_output, run_output]
-  end
-
-  def kill_all_children
-    `kill -9 #{child_pids.join(" ")}`
-  end
-
-  def child_pids
-    pid = Process.pid
-    pipe = IO.popen("ps -ef | grep #{pid}")
-    pipe.readlines.map do |line|
-      parts = line.split(/\s+/)
-      parts[2] if parts[3] == pid.to_s and parts[2] != pipe.pid.to_s
-    end.compact
-  end
-end