blade 0.1.0

data/lib/blade/combined_test_results.rb

@@ -0,0 +1,42 @@
+class Blade::CombinedTestResults
+  attr_reader :sessions, :all_test_results
+
+  def initialize(sessions)
+    @sessions = sessions
+    @all_test_results = sessions.map(&:test_results)
+  end
+
+  def total
+    sum(totals)
+  end
+
+  def lines(type = :results)
+    sessions.flat_map do |session|
+      session.test_results.send(type).map do |line|
+        line.sub(/ok/, "ok [#{session}]")
+      end
+    end
+  end
+
+  def to_s
+    lines = ["1..#{total}"] + lines(:failures) + lines(:passes)
+    lines.join("\n")
+  end
+
+  def failed?
+    statuses.include?("failed")
+  end
+
+  private
+    def sum(values)
+      values.inject(0) { |sum, total| sum + total }
+    end
+
+    def totals
+      all_test_results.map(&:total).compact
+    end
+
+    def statuses
+      all_test_results.map(&:status)
+    end
+end

data/lib/blade/component.rb

@@ -0,0 +1,5 @@
+module Blade::Component
+  def self.included(base)
+    Blade.register_component(base)
+  end
+end

data/lib/blade/interface/ci.rb

@@ -0,0 +1,51 @@
+module Blade::CI
+  extend self
+  include Blade::Component
+
+  def start
+    @completed_sessions = 0
+
+    log "# Running"
+    Blade.subscribe("/results") do |details|
+      process_result(details)
+    end
+  end
+
+  private
+    def process_result(details)
+      if details.has_key?("pass")
+        log details["pass"] ? "." : "F"
+      end
+
+      if details["completed"]
+        process_completion
+      end
+    end
+
+    def process_completion
+      @completed_sessions += 1
+
+      if done?
+        log "\n"
+        display_results_and_exit
+      end
+    end
+
+    def done?
+      @completed_sessions == (Blade.config.expected_sessions || 1)
+    end
+
+    def display_results_and_exit
+      results = Blade::Session.combined_test_results
+      display results
+      exit results.failed? ? 1 : 0
+    end
+
+    def log(message)
+      STDERR.print message.to_s
+    end
+
+    def display(message)
+      STDOUT.puts message.to_s
+    end
+end

data/lib/blade/interface/console.rb

@@ -0,0 +1,125 @@
+require "curses"
+
+module Blade::Console
+  extend self
+  include Blade::Component
+
+  autoload :Tab, "blade/interface/console/tab"
+
+  extend Forwardable
+  def_delegators "Blade::Console", :create_window
+
+  COLOR_NAMES = %w( white yellow green red )
+  PADDING = 1
+
+  def colors
+    @colors ||= OpenStruct.new.tap do |colors|
+      COLOR_NAMES.each do |name|
+        const = Curses.const_get("COLOR_#{name.upcase}")
+        Curses.init_pair(const, const, Curses::COLOR_BLACK)
+        colors[name] = Curses.color_pair(const)
+      end
+    end
+  end
+
+  def create_window(options = {})
+    height = options[:height] || 0
+    width  = options[:width]  || 0
+    top    = options[:top]    || 0
+    left   = options[:left]   || PADDING
+    parent = options[:parent] || Curses.stdscr
+
+    parent.subwin(height, width, top, left)
+  end
+
+  def start
+    run
+    Blade::Assets.watch_logical_paths
+  end
+
+  def stop
+    Curses.close_screen
+  end
+
+  def run
+    start_screen
+    init_windows
+    handle_keys
+    handle_stale_tabs
+
+    Blade.subscribe("/results") do |details|
+      session = Blade::Session.find(details["session_id"])
+
+      if tab = Tab.find(session.id)
+        if details["line"] && tab.active?
+          Tab.content_window.addstr(details["line"] + "\n")
+          Tab.content_window.noutrefresh
+        end
+        tab.draw
+      else
+        tab = Tab.create(id: session.id)
+        tab.activate if Tab.size == 1
+      end
+
+      Curses.doupdate
+    end
+  end
+
+  private
+    def start_screen
+      Curses.init_screen
+      Curses.start_color
+      Curses.noecho
+      Curses.curs_set(0)
+      Curses.stdscr.keypad(true)
+    end
+
+    def init_windows
+      header_window = create_window(height: 3)
+      header_window.attron(Curses::A_BOLD)
+      header_window.addstr "BLADE RUNNER [press 'q' to quit]\n"
+      header_window.attroff(Curses::A_BOLD)
+      header_window.addstr "Open #{Blade.url} to start"
+      header_window.noutrefresh
+
+      Tab.install(top: header_window.maxy)
+
+      Curses.doupdate
+    end
+
+    def handle_keys
+      EM.defer do
+        while ch = Curses.getch
+          case ch
+          when Curses::KEY_LEFT
+            Tab.active.activate_previous
+            Curses.doupdate
+          when Curses::KEY_RIGHT
+            Tab.active.activate_next
+            Curses.doupdate
+          when "q"
+            Blade.stop
+          end
+        end
+      end
+    end
+
+    def handle_stale_tabs
+      Blade.subscribe("/browsers") do |details|
+        if details["message"] = "ping"
+          if tab = Tab.find(details["session_id"])
+            tab.last_ping_at = Time.now
+          end
+        end
+      end
+
+      EM.add_periodic_timer(1) do
+        Tab.stale.each { |t| remove_tab(t) }
+      end
+    end
+
+    def remove_tab(tab)
+      Tab.remove(tab.id)
+      Curses.doupdate
+    end
+end

data/lib/blade/interface/console/tab.rb

@@ -0,0 +1,173 @@
+class Blade::Console::Tab < Blade::Model
+  extend Forwardable
+  def_delegators "Blade::Console", :colors, :create_window
+
+  class << self
+    extend Forwardable
+    def_delegators "Blade::Console", :create_window
+
+    attr_reader :window, :status_window, :content_window
+
+    def install(options = {})
+      top = options[:top]
+      @window = create_window(top: top, height: 3)
+
+      top = @window.begy + @window.maxy + 1
+      @status_window = create_window(top: top, height: 1)
+
+      top = @status_window.begy + @status_window.maxy + 1
+      @content_window = create_window(top: top)
+      @content_window.scrollok(true)
+    end
+
+    def draw
+      window.clear
+      window.noutrefresh
+      all.each(&:draw)
+    end
+
+    def remove(id)
+      tab = find(id)
+      tab.deactivate
+      tab.window.close
+      super
+      draw
+    end
+
+    def active
+      all.detect(&:active?)
+    end
+
+    def stale
+      threshold = Time.now - 2
+      all.select { |t| t.last_ping_at && t.last_ping_at < threshold }
+    end
+  end
+
+  def tabs
+    self.class
+  end
+
+  def height
+    3
+  end
+
+  def width
+    5
+  end
+
+  def top
+    tabs.window.begy
+  end
+
+  def left
+    tabs.window.begx + index * width
+  end
+
+  def window
+    @window ||= create_window(height: height, width: width, top: top, left: left)
+  end
+
+  def draw
+    window.clear
+    active? ? draw_active : draw_inactive
+    window.noutrefresh
+  end
+
+  def draw_active
+    window.addstr "╔═══╗"
+    window.addstr "║ "
+    window.attron(color)
+    window.addstr(dot)
+    window.attroff(color)
+    window.addstr(" ║")
+    window.addstr "╝   ╚"
+  end
+
+  def draw_inactive
+    window.addstr "\n"
+    window.attron(color)
+    window.addstr("  #{dot}\n")
+    window.attroff(color)
+    window.addstr "═════"
+  end
+
+  def dot
+    status == "pending" ? "○" : "●"
+  end
+
+  def index
+    tabs.all.index(self)
+  end
+
+  def session
+    Blade::Session.find(id)
+  end
+
+  def status
+    session.test_results.status
+  end
+
+  def active?
+    active
+  end
+
+  def activate
+    return if active?
+
+    if tab = tabs.active
+      tab.deactivate
+    end
+
+    self.active = true
+    draw
+
+    tabs.status_window.addstr(session.to_s)
+    tabs.status_window.noutrefresh
+
+    tabs.content_window.addstr(session.test_results.to_s)
+    tabs.content_window.noutrefresh
+  end
+
+  def deactivate
+    return unless active?
+
+    self.active = false
+    draw
+
+    tabs.status_window.clear
+    tabs.status_window.noutrefresh
+
+    tabs.content_window.clear
+    tabs.content_window.noutrefresh
+  end
+
+  def activate_next
+    tabs = tabs.all
+
+    if tabs.last == self
+      tabs.first.activate
+    elsif tab = tabs[index + 1]
+      tab.activate
+    end
+  end
+
+  def activate_previous
+    tabs = tabs.all
+
+    if tabs.first == self
+      tabs.last.activate
+    elsif tab = tabs[index - 1]
+      tab.activate
+    end
+  end
+
+  def color
+    case status
+    when "running"  then colors.yellow
+    when "finished" then colors.green
+    when /fail/     then colors.red
+    else                 colors.white
+    end
+  end
+end

data/lib/blade/model.rb

@@ -0,0 +1,31 @@
+require "securerandom"
+
+class Blade::Model < OpenStruct
+  class << self
+    def models
+      @models ||= {}
+    end
+
+    def create(attributes)
+      attributes[:id] ||= SecureRandom.hex(4)
+      model = new(attributes)
+      models[model.id] = model
+    end
+
+    def find(id)
+      models[id]
+    end
+
+    def remove(id)
+      models.delete(id)
+    end
+
+    def all
+      models.values
+    end
+
+    def size
+      models.size
+    end
+  end
+end

data/lib/blade/rack_adapter.rb

@@ -0,0 +1,81 @@
+class Blade::RackAdapter
+  extend Forwardable
+  def_delegators "Blade::Assets", :environment
+
+  PATH = "/blade"
+  ADAPTER_PATH = PATH + "/adapter"
+  WEBSOCKET_PATH = PATH + "/websocket"
+
+  def initialize(app = nil, options = {})
+    Blade.initialize!
+
+    if app.is_a?(Hash)
+      @options = app
+    else
+      @app, @options = app, options
+    end
+
+    @mount_path = @options[:mount]
+    @mount_path_pattern = /^#{@mount_path}/
+
+    @blade_path_pattern = /^#{PATH}/
+    @adapter_path_pattern = /^#{ADAPTER_PATH}/
+    @websocket_path_pattern = /^#{WEBSOCKET_PATH}/
+  end
+
+  def call(env)
+    unless @mount_path.nil?
+      if env["PATH_INFO"] =~ @mount_path_pattern
+        env["PATH_INFO"].sub!(@mount_path_pattern, "")
+      elsif @app
+        return @app.call(env)
+      end
+    end
+
+    case env["PATH_INFO"]
+    when ""
+      add_forward_slash(env)
+    when "/"
+      env["PATH_INFO"] = "index.html"
+      response = environment(:blade).call(env)
+      response_with_session(response, env)
+    when @websocket_path_pattern
+      bayeux.call(env)
+    when @adapter_path_pattern
+      env["PATH_INFO"].sub!(@adapter_path_pattern, "")
+      environment(:adapter).call(env)
+    when @blade_path_pattern
+      env["PATH_INFO"].sub!(@blade_path_pattern, "")
+      environment(:blade).call(env)
+    else
+      environment(:user).call(env)
+    end
+  end
+
+  private
+    def bayeux
+      @bayeux ||= Faye::RackAdapter.new(mount: WEBSOCKET_PATH, timeout: 25)
+    end
+
+    def add_forward_slash(env)
+      path = @mount_path || env["REQUEST_PATH"] || env["SCRIPT_NAME"]
+      redirect_to(File.join(path.to_s, "/"))
+    end
+
+    def redirect_to(location, status = 301)
+      [status, { Location: location }, []]
+    end
+
+    def response_with_session(response, env)
+      if Blade.running?
+        user_agent = UserAgent.parse(env["HTTP_USER_AGENT"])
+        session = Blade::Session.create(user_agent: user_agent)
+        status, headers, body = response
+        response = Rack::Response.new(body, status, headers)
+        response.set_cookie("blade_session", session.id)
+        response.finish
+      else
+        response
+      end
+    end
+end