zeusd 0.2.5 → 0.3.0

data/README.md

@@ -2,11 +2,12 @@
 
 Zeusd aims to provide greater control and easier scripting of the [Zeus Gem](https://github.com/burke/zeus) via daemonization.
 
-## Feautres
+## Features
 
 * Run the [Zeus Gem](https://github.com/burke/zeus) as a daemon.
-* Optionally block execution until Zeus has finished loaded using the `--block` flag.
+* Block execution until after Zeus has loaded using the `--block` flag.
 * Manage multiple zeusd daemons using the `--cwd` flag.
+* Show or follow the live Status Shart using the `zeusd status` command.
 
 ## Usage
 
@@ -23,6 +24,9 @@ $ zeusd restart [--cwd=/path/to/rails/root]
 
 $ zeusd stop    [--cwd=/path/to/rails/root]
                 [--verbose | -v]
+
+$ zeusd status  [--cwd=/path/to/rails/root]
+                [--follow | -f]
 ```
 
 ### Utility Commands

data/bin/zeusd

@@ -21,12 +21,20 @@ class ZeusdCLI < Thor
     daemon.stop!
   end
 
+  desc "status", "Get the current status."
+  method_option :follow, :type => :boolean, :aliases => :f
+  def status
+    trap("SIGINT") { exit! }
+    queue = daemon.status_queue
+    while output = queue.shift
+      puts output
+    end
+  end
+
   desc "tail", "Tail the daemon's log."
   method_option :follow, :type => :boolean, :aliases => :f
   def tail
-    cmd = "tail#{options[:follow] ? ' -f' : ''} -n 25 #{daemon.log_file.to_path}"
-    puts "\n\n[Zeusd] exec(#{cmd})\n\n"
-    exec(cmd)
+    exec "tail#{options[:follow] ? ' -f' : ''} -n 25 #{daemon.log_file.to_path}"
   end
 
   protected

data/lib/zeusd.rb

@@ -1,6 +1,18 @@
+# Standard Lib
+require 'thread'
+require 'pathname'
+require 'logger'
+require 'json'
+
+# 3rd Party Gems
+require 'childprocess'
+require 'file-tail'
+
+# Components
 require 'zeusd/version'
 require 'zeusd/process'
-require 'zeusd/interpreter'
+require 'zeusd/log'
+require 'zeusd/daemon_tracker'
 require 'zeusd/daemon'
 
 module Zeusd

data/lib/zeusd/daemon.rb

@@ -1,18 +1,10 @@
-require 'thread'
-require 'childprocess'
-require 'pathname'
-require 'file-tail'
-
-require 'zeusd/daemon_logging'
-
 module Zeusd
   class Daemon
-    attr_reader :cwd, :verbose, :interpreter, :child_process
+    attr_reader :cwd, :verbose, :child_process, :status
 
     def initialize(options = {})
-      @cwd         = Pathname.new(options[:cwd] || Dir.pwd).realpath
-      @verbose     = !!options[:verbose]
-      @interpreter = Interpreter.new
+      @cwd     = Pathname.new(options[:cwd] || Dir.pwd).realpath
+      @verbose = !!options[:verbose]
     end
 
     def start!(options = {})
@@ -21,7 +13,7 @@ module Zeusd
       @process = Zeusd::Process.find(child_process.pid)
 
       if options.fetch(:block, false)
-        sleep(0.1) until loaded?
+        sleep(3) until status.finished?
       end
 
       self
@@ -38,35 +30,46 @@ module Zeusd
       process.kill!(:recursive => true, :signal => "KILL", :wait => true)
 
       # Clean up socket file if stil exists
-      (zeus_socket_file.delete rescue nil) if zeus_socket_file.exist?
+      (zeus_socket.delete rescue nil) if zeus_socket.exist?
 
       @process = nil
 
       self
     end
 
-    def processes
-      process ? [process, process.descendants].flatten : []
+    def status_queue
+      queue  = Queue.new
+      status = Log::Status.new(File.new(zeus_log.to_path, 'r'))
+
+      queue << status.to_cli
+      status.on_update {|x| queue << x.to_cli }
+      status.record!
+
+      queue
     end
 
     def process
       @process ||= Process.all.find {|p| !!p.command[/zeus.*start$/] && p.cwd == cwd }
     end
 
-    def loaded?
-      interpreter.complete?
+    def finished?
+      status.finished?
     end
 
-    def zeus_socket_file
+    def zeus_socket
       cwd.join('.zeus.sock')
     end
 
-    def zeus_log_file
+    def zeus_log
       cwd.join('log', 'zeus.log').tap do |path|
         FileUtils.touch(path.to_path)
       end
     end
 
+    def verbose?
+      !!verbose
+    end
+
     def to_json(*args)
       {
         :class   => self.class.name,
@@ -79,9 +82,9 @@ module Zeusd
     protected
 
     def start_child_process!
-      # Truncate and cast to File instance
-      zeus_log_file.open("w") {}
-      std_file = File.new(zeus_log_file, 'w+')
+       # Truncate and cast to File instance
+      zeus_log.open("w") {}
+      std_file = File.new(zeus_log.to_path, 'w+')
       std_file.sync = true
 
       # Prep and Start child process
@@ -93,25 +96,17 @@ module Zeusd
       @child_process.detach    = true
       @child_process.start
 
-      # Start tailing child process output
-      Thread.new do
-        File.open(std_file.to_path) do |log|
-          log.extend(File::Tail)
-          log.interval = 0.1
-          log.backward(100)
-          log.tail do |line|
-            interpreter.translate(line)
-            puts line if verbose
-          end
-        end
+      @status = Log::Status.new(std_file)
+      @status.on_update do |status, line|
+        puts status.to_cli if verbose?
       end
+      @status.record!
 
-      # Block until the first zeus command has been registered
-      sleep 0.1 until interpreter.commands.any?
+      sleep 0.1 until @status.started?
 
       @child_process
     end
 
-    include Zeusd::DaemonLogging
+    include Zeusd::DaemonTracker
   end
 end

data/lib/zeusd/{daemon_logging.rb → daemon_tracker.rb}

@@ -1,8 +1,5 @@
-require 'logger'
-require 'json'
-
 module Zeusd
-  module DaemonLogging
+  module DaemonTracker
 
     def log_file
       cwd.join('log', 'zeusd.log')

data/lib/zeusd/log.rb

@@ -0,0 +1,28 @@
+require 'zeusd/log/last_line_array'
+require 'zeusd/log/line'
+require 'zeusd/log/status'
+require 'zeusd/log/tailer'
+
+module Zeusd
+  module Log
+
+    COLOR_TO_ANSI = {
+      :red     => "\e[31m",
+      :green   => "\e[32m",
+      :yellow  => "\e[33m",
+      :blue    => "\e[34m",
+      :magenta => "\e[35m"
+    }
+
+    STATUS_TO_COLOR = {
+      :ready      => :green,
+      :crashed    => :red,
+      :waiting    => :yellow,
+      :running    => :blue,
+      :connecting => :magenta
+    }
+
+    STATUS_TO_ANSI = Hash[STATUS_TO_COLOR.map{|status, color| [status, COLOR_TO_ANSI[color]]}]
+
+  end
+end

data/lib/zeusd/log/last_line_array.rb

@@ -0,0 +1,21 @@
+require 'forwardable'
+module Zeusd
+  class LastLineArray
+    extend Forwardable
+
+    def_delegators *[:to_a].concat(Array.instance_methods.select{|x| x[/^[a-z]+.*?[^!]{1}$/]} - instance_methods(true))
+
+    def initialize(*args)
+      @hash = Hash[args.zip(args)]
+    end
+
+    def <<(line)
+      @hash[line.id] = line
+    end
+
+    def to_a
+      @hash.values
+    end
+
+  end
+end

data/lib/zeusd/log/line.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+
+require 'zeusd/log/line/base'
+require 'zeusd/log/line/command'
+require 'zeusd/log/line/process'
+require 'zeusd/log/line/update'
+require 'zeusd/log/line/error'
+
+module Zeusd
+  module Log
+    module Line
+
+      class << self
+
+        def create(line)
+          [Command, Process, Update, Error, Base].each do |klass|
+            return klass.new(line) if klass.matches_line?(line)
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/line/base.rb

@@ -0,0 +1,72 @@
+# encoding: utf-8
+module Zeusd
+  module Log
+    module Line
+
+      class Base < String
+
+        def self.matches_line?(line)
+          true
+        end
+
+        def status_substring
+          ansi_color
+        end
+
+        def id
+          self
+        end
+
+        def status?(status)
+          ansi_color_of(status_substring) == Log::STATUS_TO_ANSI[status]
+        end
+
+        def ready?
+          status? :ready
+        end
+
+        def crashed?
+          status? :crashed
+        end
+
+        def waiting?
+          status? :waiting
+        end
+
+        def running?
+          status? :running
+        end
+
+        def connecting?
+          status? :connecting
+        end
+
+        def loading?
+          [:waiting, :connecting, :running].any? {|x| status? x}
+        end
+
+        def done?
+          [:crashed, :ready].any? {|x| status? x}
+        end
+
+        def ansi_color_of(substring)
+          if stop_point = index(substring) + (substring.length - 1)
+            if color_start = rindex(/\e/, stop_point)
+              color_end = index('m', color_start)
+              self[color_start..color_end]
+            end
+          end
+        end
+
+        def ansi_color
+          if self[0] == "\e" && !self.index('m').nil?
+            self[0..self.index('m')]
+          end
+        end
+
+      end
+
+
+    end
+  end
+end

data/lib/zeusd/log/line/command.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Zeusd
+  module Log
+    module Line
+
+      class Command < Base
+        def self.matches_line?(line)
+          line[/^\e.*?zeus\s(.*?)(\s|\e)/]
+        end
+
+        def id
+          name
+        end
+
+        def name
+          self[/^\e.*?zeus\s(.*?)(\s|\e)/, 1]
+        end
+
+        def status_substring
+          name
+        end
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/line/error.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+module Zeusd
+  module Log
+    module Line
+
+      class Error < Base
+
+        def self.matches_line?(line)
+          !!line[0..5]["\e[31m"]
+        end
+
+        def id
+          message
+        end
+
+        alias_method :message, :to_s
+
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/line/process.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+module Zeusd
+  module Log
+    module Line
+
+      class Process < Base
+        def self.matches_line?(line)
+          !!line[/(boot|─)/]
+        end
+
+        def id
+          name
+        end
+
+        def name
+          self[/(\e\[[0-9]{1,2}m)([a-z_]+)/, 2]
+        end
+
+        def status_substring
+          name
+        end
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/line/update.rb

@@ -0,0 +1,21 @@
+# encoding: utf-8
+module Zeusd
+  module Log
+    module Line
+
+      class Update < Base
+
+        attr_reader :time
+
+        def self.matches_line?(line)
+          !!line[/\s=====$/]
+        end
+
+        def time
+          @time ||= Time.parse(self[/UPDATED\s(.*?)\s=/, 1])
+        end
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/status.rb

@@ -0,0 +1,99 @@
+module Zeusd
+  module Log
+
+    class Status
+
+      attr_reader :file, :tailer, :updated_at, :line_print_count
+      attr_reader :errors
+      attr_reader :commands
+      attr_reader :processes
+
+      def initialize(file)
+        @line_print_count = 0
+        @file             = File.new(file)
+        @updated_at       = Time.now
+        @errors           = LastLineArray.new
+        @commands         = LastLineArray.new
+        @processes        = LastLineArray.new
+        @tailer           = Tailer.new(file)
+
+        file.each {|line| process(line)} unless file.size.zero?
+      end
+
+      def record!
+        tailer.on_update {|line| process(line)}
+        tailer.start!
+        self
+      end
+
+      def pause!
+        tailer.stop!
+        self
+      end
+
+      def paused?
+        !tailer.following?
+      end
+
+      def recording?
+        tailer.following?
+      end
+
+      def process(line)
+        line = Line.create(line)
+        case line
+        when Line::Command then @commands << line
+        when Line::Process then @processes << line
+        when Line::Error   then @errors << line
+        end
+        @updated_at = Time.now
+        on_update.call(self, line) if on_update
+      end
+
+      def on_update(&block)
+        @on_update = block if block_given?
+        @on_update
+      end
+
+      def started?
+        commands.any?
+      end
+
+      def finished?
+        return true if errors.any?
+        return true if [commands, processes].map(&:to_a).flatten.all?(&:done?)
+        false
+      end
+
+      def empty?
+        [errors, commands, processes].all?(&:empty?)
+      end
+
+      def to_cli
+        output = [
+          "\e[36mZeusd Status\e[0m - Updated: #{updated_at.to_s}\e[K\e[0m\n",
+          "\e[K\e[0m\n",
+          "Legend: \e[32m[ready] \e[31m[crashed] \e[34m[running] \e[35m[connecting] \e[33m[waiting]\e[K\e[0m\n",
+          "\e[K\e[0m\n",
+          "\e[4mProcess Tree\e[K\e[0m\n",
+          [processes.map(&:to_s)],
+          "\e[K\e[0m\n",
+          "\e[4mCommands\e[K\e[0m\n",
+          [commands.map(&:to_s)],
+        ].tap do |x|
+          if errors.any?
+            x << "\e[K"
+            x << "\e[4mErrors\e[K\e[0m\n"
+            x << errors.map(&:to_s)
+          end
+        end.flatten
+        if line_print_count > 0
+          output = output.unshift("\e[#{line_print_count}A\e[K\e[0m\n")
+        end
+        @line_print_count = output.length
+        output
+      end
+
+    end
+  end
+end

data/lib/zeusd/log/tailer.rb

@@ -0,0 +1,49 @@
+module Zeusd
+  module Log
+    class Tailer
+      attr_reader :file, :lines
+
+      def initialize(file)
+        @file  = file
+        @lines = []
+      end
+
+      def on_update(&block)
+        @on_update = block if block_given?
+        @on_update
+      end
+
+      def following?
+        !!@thread
+      end
+
+      def restart!
+        stop!.start!
+      end
+
+      def start!
+        @thread = Thread.new do
+          File.open(file) do |log|
+            log.extend(File::Tail)
+            log.interval = 0.1
+            log.backward(0)
+            log.tail do |line|
+              @lines << line
+              on_update.call(line) if on_update
+            end
+          end
+        end
+        self
+      end
+
+      def stop!
+        if @thread
+          @thread.terminate
+          @thread = nil
+        end
+        self
+      end
+
+    end
+  end
+end

data/lib/zeusd/version.rb

@@ -1,3 +1,3 @@
 module Zeusd
-  VERSION = "0.2.5"
+  VERSION = "0.3.0"
 end

data/spec/spec_helper.rb

@@ -1,10 +1,14 @@
+# encoding: utf-8
 require 'simplecov'
 SimpleCov.start
 
-require 'zeusd'
+require 'tempfile'
 
-DUMMY_APP_PATH = File.expand_path('../dummy', __FILE__)
+require File.expand_path('../support/helpers.rb', __FILE__)
+require File.expand_path('../support/constants.rb', __FILE__)
 
-RSpec.configure do |config|
+require 'zeusd'
 
+RSpec.configure do |c|
+  c.include Helpers
 end

data/spec/support/constants.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+DUMMY_APP_PATH = File.expand_path('../../dummy', __FILE__)
+
+DUMMY_ZEUS_LOG_PATH = File.expand_path('../dummy_zeus.log', __FILE__)
+
+ZEUS_LOG_LINES = {
+  :commands => [
+    "\e[32mzeus destroy (alias: d)\e[K\e[0m\n",
+    "\e[32mzeus server (alias: s)\e[K\e[0m\n",
+    "\e[32mzeus console (alias: c)\e[K\e[0m\n",
+    "\e[32mzeus dbconsole\e[K\e[0m\n",
+    "\e[32mzeus runner (alias: r)\e[K\e[0m\n",
+    "\e[32mzeus generate (alias: g)\e[K\e[0m\n",
+    "\e[32mzeus rake\e[K\e[0m\n",
+    "\e[32mzeus test (alias: rspec, testrb)\e[K\e[0m\n"
+  ],
+  :processes => [
+    "\e[32mboot\e[K\e[0m\n",
+    "\e[33m└── \e[32mdefault_bundle\e[K\e[0m\n",
+    "\e[33m    \e[33m├── \e[32mdevelopment_environment\e[K\e[0m\n",
+    "\e[33m    \e[33m│   \e[33m└── \e[32mprerake\e[K\e[0m\n",
+    "\e[33m    \e[33m└── \e[32mtest_environment\e[K\e[0m\n",
+    "\e[33m    \e[33m    \e[33m└── \e[32mtest_helper\e[K\e[0m\n"
+  ],
+  :all => [
+    "\e[4m\e[32m[ready] \e[31m[crashed] \e[34m[running] \e[35m[connecting] \e[33m[waiting]\e[K\e[0m\n",
+    "\e[32mboot\e[K\e[0m\n",
+    "\e[33m└── \e[32mdefault_bundle\e[K\e[0m\n",
+    "\e[33m    \e[33m├── \e[32mdevelopment_environment\e[K\e[0m\n",
+    "\e[33m    \e[33m│   \e[33m└── \e[32mprerake\e[K\e[0m\n",
+    "\e[33m    \e[33m└── \e[32mtest_environment\e[K\e[0m\n",
+    "\e[33m    \e[33m    \e[33m└── \e[32mtest_helper\e[K\e[0m\n",
+    "\e[K\n",
+    "\e[4mAvailable Commands: \e[33m[waiting] \e[31m[crashed] \e[32m[ready]\e[K\e[0m\n",
+    "\e[32mzeus destroy (alias: d)\e[K\e[0m\n",
+    "\e[32mzeus server (alias: s)\e[K\e[0m\n",
+    "\e[32mzeus console (alias: c)\e[K\e[0m\n",
+    "\e[32mzeus dbconsole\e[K\e[0m\n",
+    "\e[32mzeus runner (alias: r)\e[K\e[0m\n",
+    "\e[32mzeus generate (alias: g)\e[K\e[0m\n",
+    "\e[32mzeus rake\e[K\e[0m\n",
+    "\e[32mzeus test (alias: rspec, testrb)\e[K\e[0m\n"
+  ]
+}

data/spec/support/helpers.rb

@@ -0,0 +1,12 @@
+module Helpers
+
+  def file_write(file, data, options = {})
+    file.write(data)
+    file.flush
+    file.fsync
+    sleep(0.1)
+    file.rewind if options.fetch(:rewind, false)
+    file
+  end
+
+end

data/spec/zeusd/daemon_spec.rb

@@ -5,27 +5,27 @@ describe Zeusd::Daemon do
   after(:each) { daemon.stop! }
 
   describe ".start!" do
-    subject { daemon.start!(:verbose => true) }
+    subject { daemon.start! }
     it { should be daemon }
-    it { should_not be_loaded }
+    it { should_not be_finished }
 
     describe ":block option" do
       subject { daemon.start!(:block => true) }
-      it { should be_loaded }
+      it { should be_finished }
     end
   end
 
   describe ".stop!" do
     subject { daemon.start!.stop! }
     it { should be daemon }
-    it { should_not be_loaded }
+    it { should_not be_finished }
   end
 
   describe ".restart!" do
     subject { daemon }
     context "when daemon is already running" do
       before { subject.start!.restart!(:block => true) }
-      it { should be_loaded }
+      it { should be_finished }
     end
   end
 

data/spec/zeusd/log/line/base_spec.rb

@@ -0,0 +1,59 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+
+describe Zeusd::Log::Line::Base do
+
+  class ExampleLine < Zeusd::Log::Line::Base
+    def status_substring
+      "example"
+    end
+  end
+
+  RED    = "\e[31m"
+  GREEN  = "\e[32m"
+  YELLOW = "\e[33m"
+
+  let(:line) { Zeusd::Log::Line::Base.new("#{RED}This line starts with red but then#{GREEN}changes to green after a bit") }
+
+
+  describe ".ansi_color" do
+    subject { line.ansi_color }
+    it { should eq RED }
+  end
+
+
+  describe ".ansi_color_of" do
+    context "far from setting of color" do
+      subject { line.ansi_color_of("bit") }
+      it { should eq GREEN }
+    end
+
+    context "near setting of color" do
+      subject { line.ansi_color_of("This") }
+      it { should eq RED }
+    end
+
+    context "color itself" do
+      subject { line.ansi_color_of(GREEN) }
+      it { should eq GREEN }
+    end
+  end
+
+  describe ".status_substring" do
+    subject { line }
+    it { should be_crashed }
+  end
+
+  describe "checking status of substring" do
+    Zeusd::Log::STATUS_TO_ANSI.each do |status, color|
+      context "when in a #{status} state" do
+        subject { ExampleLine.new "#{color}zeus example\e[K\e[0m" }
+        it { should send("be_#{status}") }
+      end
+    end
+  end
+
+end

data/spec/zeusd/log/line/command_spec.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Line::Command do
+
+  NAME = "dbconsole"
+  let(:crashed) { Zeusd::Log::Line::Command.new "\e[31mzeus #{NAME}\e[K\e[0m" }
+  let(:ready)   { Zeusd::Log::Line::Command.new "\e[32mzeus #{NAME}\e[K\e[0m" }
+  let(:waiting) { Zeusd::Log::Line::Command.new "\e[33mzeus #{NAME}\e[K\e[0m" }
+
+  describe ".name" do
+    subject { ready.name }
+    it { should eq NAME }
+  end
+
+  describe "checking status of command" do
+    context ".ready?" do
+      subject { ready }
+      it { should be_ready }
+    end
+    context ".waiting?" do
+      subject { waiting }
+      it { should be_waiting }
+    end
+    context ".crashed?" do
+      subject { crashed }
+      it { should be_crashed }
+    end
+  end
+
+end

data/spec/zeusd/log/line/error_spec.rb

@@ -0,0 +1,16 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Line::Error do
+
+  ERROR_STRING = "\e[31This would be a typical \e[33mZeus\e[31 error to see.\e[0m"
+
+  let(:error) { Zeusd::Log::Line::Error.new ERROR_STRING }
+  describe ".message" do
+    subject { error.message }
+    it { should eq ERROR_STRING }
+  end
+
+end

data/spec/zeusd/log/line/process_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Line::Process do
+
+  let(:crashed)    { Zeusd::Log::Line::Process.new "\e[31mboot\e[K\e[0m" }
+  let(:ready)      { Zeusd::Log::Line::Process.new "\e[32m└── \e[32mdefault_bundle\e[K\e[0m" }
+  let(:waiting)    { Zeusd::Log::Line::Process.new "\e[33m    \e[33m├── \e[33mdevelopment_environment\e[K\e[0m" }
+  let(:running)    { Zeusd::Log::Line::Process.new "\e[34m    \e[34m└── \e[34mtest_environment\e[K\e[0m" }
+  let(:connecting) { Zeusd::Log::Line::Process.new "\e[35m    \e[35m    \e[35m└── \e[35mtest_helper\e[K\e[0m" }
+
+  describe ".name" do
+    context "when deeply nested" do
+      subject { waiting.name }
+      it { should eq "development_environment" }
+    end
+    context "when boot" do
+      subject { crashed.name }
+      it { should eq "boot" }
+    end
+  end
+
+  describe "checking status of command" do
+    context ".ready?" do
+      subject { ready }
+      it { should be_ready }
+    end
+    context ".waiting?" do
+      subject { waiting }
+      it { should be_waiting }
+    end
+    context ".crashed?" do
+      subject { crashed }
+      it { should be_crashed }
+    end
+    context ".running?" do
+      subject { running }
+      it { should be_running }
+    end
+    context ".connecting?" do
+      subject { connecting }
+      it { should be_connecting }
+    end
+  end
+
+end

data/spec/zeusd/log/line/update_spec.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Line::Update do
+
+  let(:update) { Zeusd::Log::Line::Update.new "==== UPDATED Sat Mar  1 00:07:24 EST 2014 =====" }
+
+  describe ".time" do
+    subject { update.time }
+    it { should eq Time.parse("1/3/2014 00:07:24 EST") }
+  end
+
+end

data/spec/zeusd/log/line_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Line do
+
+  describe "determining line type" do
+
+    context "update" do
+      subject { Zeusd::Log::Line.create("==== UPDATED Sat Mar  1 00:07:24 EST 2014 =====") }
+      it { should be_a Zeusd::Log::Line::Update }
+    end
+
+    context "error" do
+      subject { Zeusd::Log::Line.create("\e[31mThis would be a typical zeus error") }
+      it { should be_a Zeusd::Log::Line::Error }
+    end
+
+    context "process" do
+      subject { Zeusd::Log::Line.create("\e[33m    \e[33m└── \e[33mtest_environment\e[K\e[0m") }
+      it { should be_a Zeusd::Log::Line::Process }
+    end
+
+    context "command" do
+      subject { Zeusd::Log::Line.create("\e[33mzeus generate (alias: g)\e[K\e[0m") }
+      it { should be_a Zeusd::Log::Line::Command }
+    end
+
+    context "unknown" do
+      subject { Zeusd::Log::Line.create("!#!@$$@#%$#%%!$43154}") }
+      it { should be_a Zeusd::Log::Line::Base }
+    end
+
+  end
+
+end

data/spec/zeusd/log/status_spec.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Status do
+
+  let(:log_file) { Tempfile.new("Zeusd_Log_Status").tap {|f| f.sync = true} }
+  let(:status) { Zeusd::Log::Status.new(log_file) }
+
+  describe "after initialization" do
+    subject { status }
+    it { should be_paused }
+    its(:tailer) { should be_a Zeusd::Log::Tailer }
+    its(:errors) { should be_empty }
+
+    context "when the log file is empty" do
+      its(:commands)  { should be_empty }
+      its(:processes) { should be_empty }
+    end
+
+    context "when log file has data" do
+      before(:each) { file_write(log_file, ZEUS_LOG_LINES[:all].join, :rewind => true) }
+      its(:commands)  { should_not be_empty }
+      its(:processes) { should_not be_empty }
+    end
+  end
+
+  describe ".process" do
+    subject do
+      lines.each {|line| status.process(line)}
+      status
+    end
+
+    context "command" do
+      let(:lines) { ZEUS_LOG_LINES[:commands] }
+      its(:commands) { should have(lines.length).items }
+    end
+
+    context "process" do
+      let(:lines) { ZEUS_LOG_LINES[:processes] }
+      its(:processes) { have(lines.length).items }
+    end
+  end
+
+  describe "recording" do
+    subject { status.record! }
+    it { should be status }
+    it { should be_recording }
+  end
+
+end

data/spec/zeusd/log/tailer_spec.rb

@@ -0,0 +1,22 @@
+# encoding: utf-8
+
+require 'spec_helper'
+require 'zeusd'
+
+describe Zeusd::Log::Tailer do
+
+  let(:log_file)    { Tempfile.new("Zeusd_Log_Tailer") }
+  let(:tailer)      { Zeusd::Log::Tailer.new(log_file) }
+
+  describe "after initialization" do
+    subject { tailer }
+    it { should_not be_following }
+    it { should respond_to :start! }
+    it { should respond_to :stop! }
+    it { should respond_to :restart! }
+    it { should respond_to :following? }
+    it { should respond_to :lines }
+    it { should respond_to :file }
+  end
+
+end

data/zeusd.gemspec

@@ -21,7 +21,6 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "thor"         , "~> 0.18.1"
   spec.add_runtime_dependency "childprocess" , ">= 0.5.1"
   spec.add_runtime_dependency "file-tail"    , "~> 1.0.12"
-  spec.add_runtime_dependency "hooks"        , "~> 0.3.3"
   spec.add_runtime_dependency "zeus"         , "~> 0.13.3"
 
   spec.add_development_dependency "bundler", "~> 1.3"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeusd
 version: !ruby/object:Gem::Version
-  version: 0.2.5
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-01 00:00:00.000000000 Z
+date: 2014-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -59,22 +59,6 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 1.0.12
-- !ruby/object:Gem::Dependency
-  name: hooks
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.3.3
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ~>
-      - !ruby/object:Gem::Version
-        version: 0.3.3
 - !ruby/object:Gem::Dependency
   name: zeus
   requirement: !ruby/object:Gem::Requirement
@@ -158,8 +142,17 @@ files:
 - bin/zeusd
 - lib/zeusd.rb
 - lib/zeusd/daemon.rb
-- lib/zeusd/daemon_logging.rb
-- lib/zeusd/interpreter.rb
+- lib/zeusd/daemon_tracker.rb
+- lib/zeusd/log.rb
+- lib/zeusd/log/last_line_array.rb
+- lib/zeusd/log/line.rb
+- lib/zeusd/log/line/base.rb
+- lib/zeusd/log/line/command.rb
+- lib/zeusd/log/line/error.rb
+- lib/zeusd/log/line/process.rb
+- lib/zeusd/log/line/update.rb
+- lib/zeusd/log/status.rb
+- lib/zeusd/log/tailer.rb
 - lib/zeusd/process.rb
 - lib/zeusd/version.rb
 - spec/dummy/.gitignore
@@ -213,8 +206,18 @@ files:
 - spec/dummy/vendor/plugins/.gitkeep
 - spec/dummy/zeus.json
 - spec/spec_helper.rb
+- spec/support/constants.rb
 - spec/support/dummy_process.rb
+- spec/support/helpers.rb
 - spec/zeusd/daemon_spec.rb
+- spec/zeusd/log/line/base_spec.rb
+- spec/zeusd/log/line/command_spec.rb
+- spec/zeusd/log/line/error_spec.rb
+- spec/zeusd/log/line/process_spec.rb
+- spec/zeusd/log/line/update_spec.rb
+- spec/zeusd/log/line_spec.rb
+- spec/zeusd/log/status_spec.rb
+- spec/zeusd/log/tailer_spec.rb
 - spec/zeusd/process_spec.rb
 - zeusd.gemspec
 homepage: https://github.com/veloper/zeusd
@@ -232,7 +235,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1735692127611811224
+      hash: -4218968737058463992
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -241,7 +244,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -1735692127611811224
+      hash: -4218968737058463992
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.25
@@ -300,6 +303,16 @@ test_files:
 - spec/dummy/vendor/plugins/.gitkeep
 - spec/dummy/zeus.json
 - spec/spec_helper.rb
+- spec/support/constants.rb
 - spec/support/dummy_process.rb
+- spec/support/helpers.rb
 - spec/zeusd/daemon_spec.rb
+- spec/zeusd/log/line/base_spec.rb
+- spec/zeusd/log/line/command_spec.rb
+- spec/zeusd/log/line/error_spec.rb
+- spec/zeusd/log/line/process_spec.rb
+- spec/zeusd/log/line/update_spec.rb
+- spec/zeusd/log/line_spec.rb
+- spec/zeusd/log/status_spec.rb
+- spec/zeusd/log/tailer_spec.rb
 - spec/zeusd/process_spec.rb

data/lib/zeusd/interpreter.rb

@@ -1,93 +0,0 @@
-module Zeusd
-  class Interpreter
-    STATES = %w[ready crashed running connecting waiting]
-
-    attr_reader :lines
-    attr_reader :state_colors, :commands, :errors
-    attr_reader :last_status
-
-    def initialize(*args)
-      @state_colors = Hash[STATES.zip([nil]*STATES.length)]
-      @commands     = {}
-      @errors       = []
-      @lines        = []
-    end
-
-    def translate(zeus_output)
-      zeus_output.split("\n").map{|x| Line.new(x) }.each do |line|
-        # State Colors
-        if @state_colors.values.any?(&:nil?) && line.state_legend?
-          STATES.each do |state|
-            state_colors[state] = line.color_of(state)
-          end
-        end
-
-        # Errors
-        @errors << line if line.color == state_colors["crashed"]
-
-        # Commands
-        @commands[line.command[:name]] = state_colors.invert[line.command[:color]] if line.command?
-
-        # Add Line
-        @lines << line
-      end
-
-      # Garbage Collection
-      if @lines.length > 100
-        @lines = @lines.last(100)
-      end
-    end
-
-    def complete?
-      return false if errors.any?
-      return true if commands.all? {|command, status| %[crashed ready].include?(status)}
-      false
-    end
-
-    def last_update
-      @lines[@lines.rindex(&:update?)..-1].join("\n").to_s
-    end
-
-    class Line < String
-
-      def update?
-        self =~ /\=\=\=\=$/
-      end
-
-      def command?
-        !!command
-      end
-
-      def command
-        if @match ||= self.match(/^(\e.*?)zeus\s(.*?)(\s|\e)/)
-          { :name => @match[2], :color => @match[1] }
-        end
-      end
-
-      def state_legend?
-        STATES.all?{|state| !!self[state]}
-      end
-
-      def color_of(substring)
-        if stop_point = index(substring) + substring.length
-          if color_start = rindex(/\e/, stop_point)
-            color_end = index('m', color_start)
-            self[color_start..color_end]
-          end
-        end
-      end
-
-      def color
-        if self[0] == "\e" && !self.index('m').nil?
-          self[0..self.index('m')]
-        end
-      end
-
-      def color?
-        !!color
-      end
-
-    end
-
-  end
-end