diagnostics 0.0.1 → 0.0.2

data/features/step_definitions/aruba.rb

@@ -0,0 +1,5 @@
+require 'aruba'
+
+Then /^the output should contain the table:$/ do |html_table|
+  combined_output.should == html_table.delete(" \n")
+end

data/features/support/env.rb

@@ -0,0 +1,2 @@
+$:.unshift(File.dirname(__FILE__) + '/../../lib')
+require 'diagnostics'

data/lib/diagnostics/check.rb

@@ -0,0 +1,66 @@
+module Diagnostics
+  class Check
+
+    def self.add(name, &block)
+      Diagnostics.checks << check = new(name, &block)
+      check
+    end
+
+    def self.find(name)
+      Diagnostics.checks.select {|c| c.name == name }[0]
+    end
+
+    attr_reader :name
+
+    def initialize(name, &block)
+      @name = name
+      instance_eval(&block) if block
+    end
+
+    def passed(&block)
+      @passed_block = block
+    end
+
+    def warning(&block)
+      @warning_block = block
+    end
+
+    def failed(&block)
+      @failed_block = block
+    end
+
+    def passed?
+      @passed_block_result ||= call_block(@passed_block)
+    end
+
+    def warning?
+      @warning_block_result ||= call_block(@warning_block)
+    end
+
+    def failed?
+      @failed_block_result ||= call_block(@failed_block)
+    end
+
+    def status
+      return :passed  if passed?
+      return :warning if warning?
+      return :failed  if failed?
+      :none
+    end
+
+    def data
+      block_given? ? yield(data_group) : data_group
+    end
+
+  private
+
+    def data_group
+      @data_group ||= DataGroup.new
+    end
+
+    def call_block(block)
+      block ? block.call : false
+    end
+
+  end
+end

data/lib/diagnostics/data/attribute.rb

@@ -0,0 +1,15 @@
+module Diagnostics
+  module Data
+    class Attribute < Struct.new(:name, :value)
+
+      def plain
+        "#{name}: #{value}"
+      end
+
+      def html
+        "<strong>#{name}:</strong> #{value}"
+      end
+
+    end
+  end
+end

data/lib/diagnostics/data/elements.rb

@@ -0,0 +1,40 @@
+module Diagnostics
+  module Data
+    class Elements < Hash
+
+      def initialize
+        self[:attributes] = []
+        self[:lists]      = []
+        self[:texts]      = []
+        self[:tables]     = []
+      end
+
+      def attributes(format)
+        elements(:attributes, format)
+      end
+
+      def lists(format)
+        elements(:lists, format)
+      end
+
+      def texts(format)
+        elements(:texts, format)
+      end
+
+      def tables(format)
+        elements(:tables, format)
+      end
+
+    private
+
+      def elements(key, format)
+        format ? format_elements(key, format) : self[key]
+      end
+
+      def format_elements(key, format)
+        self[key].map(&format)
+      end
+
+    end
+  end
+end

data/lib/diagnostics/data/list.rb

@@ -0,0 +1,15 @@
+module Diagnostics
+  module Data
+    class List < Struct.new(:values)
+
+      def plain
+        values.join("\n")
+      end
+
+      def html
+        values.join('<br />')
+      end
+
+    end
+  end
+end

data/lib/diagnostics/data/table.rb

@@ -0,0 +1,47 @@
+module Diagnostics
+  module Data
+    class Table < Struct.new(:value)
+
+      def html
+        "".tap do |s|
+          s.extend(HTMLMethods)
+
+          s.wrap :table do
+            s.wrap :tr do
+              value.keys.each do |k|
+                s.wrap :th do
+                  s << k.to_s
+                end
+              end
+            end
+            rows.transpose.each do |v|
+              s.wrap :tr do
+                v.each do |td|
+                  s.wrap :td do
+                    s << td.to_s
+                  end
+                end
+              end
+            end
+          end
+        end
+
+      end
+
+      module HTMLMethods
+        def wrap(tag)
+          concat "<#{tag}>"
+          yield if block_given?
+          concat "</#{tag}>"
+        end
+      end
+
+    private
+
+      def rows
+        value.values.map {|v| [v].flatten }
+      end
+
+    end
+  end
+end

data/lib/diagnostics/data/text.rb

@@ -0,0 +1,15 @@
+module Diagnostics
+  module Data
+    class Text < Struct.new(:value)
+
+      def plain
+        value
+      end
+
+      def html
+        "<p>#{value}</p>"
+      end
+
+    end
+  end
+end

data/lib/diagnostics/data_group.rb

@@ -0,0 +1,37 @@
+module Diagnostics
+  class DataGroup
+
+    def elements
+      @elements ||= Data::Elements.new
+    end
+
+    def attributes(format = nil)
+      elements.attributes(format)
+    end
+
+    def lists(format = nil)
+      elements.lists(format)
+    end
+
+    def texts(format = nil)
+      elements.texts(format)
+    end
+
+    def tables(format = nil)
+      elements.tables(format)
+    end
+
+    def []=(key, value)
+      attributes << Data::Attribute.new(key, value)
+    end
+
+    def <<(object)
+      case object
+      when Array  then lists << Data::List.new(object)
+      when String then texts << Data::Text.new(object)
+      when Hash   then tables << Data::Table.new(object)
+      end
+    end
+
+  end
+end

data/lib/diagnostics/methods.rb

@@ -0,0 +1,46 @@
+module Diagnostics
+  module Methods
+
+    DIAGNOSTIC_MESSAGES = {
+      :passed  => 'All Systems Operational',
+      :warning => 'Experiencing Issues',
+      :failed  => 'System Failure',
+      :none    => 'No Diagnostic Checks Run'
+    }
+
+    def diagnostic_checks
+      Diagnostics.checks
+    end
+
+    def diagnostic_check(name, &block)
+      block ? Check.add(name, &block) : Check.find(name)
+    end
+
+    def diagnostic_message
+      case diagnostic_status
+        when :passed  then DIAGNOSTIC_MESSAGES[:passed]
+        when :warning then DIAGNOSTIC_MESSAGES[:warning]
+        when :failed  then DIAGNOSTIC_MESSAGES[:failed]
+        when :none    then DIAGNOSTIC_MESSAGES[:none]
+      end
+    end
+
+    def diagnostic_status
+      return :failed  if diagnostic_statuses.include?(:failed)
+      return :warning if diagnostic_statuses.include?(:warning)
+      return :passed  if diagnostic_statuses.include?(:passed)
+      :none
+    end
+
+  private
+
+    def diagnostic_statuses
+      @diagnostic_statuses ||= diagnostic_checks.map(&:status).uniq
+    end
+
+  end
+end
+
+class Object
+  include Diagnostics::Methods
+end

data/lib/diagnostics/version.rb

@@ -1,3 +1,3 @@
 module Diagnostics
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/rails/init.rb

@@ -0,0 +1 @@
+require 'diagnostics'

data/spec/diagnostics/check_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+module Diagnostics
+  describe Check do
+
+    describe '.add' do
+      it 'adds a check' do
+        described_class.add :foo
+        Diagnostics.should have(1).checks
+      end
+    end
+
+    describe '.find' do
+      let!(:check) { described_class.add :foo }
+
+      it 'finds the check by name' do
+        described_class.find(:foo).should eq(check)
+      end
+    end
+
+    describe 'status predicate methods' do
+      let(:check) do
+        described_class.new(:foo) do |c|
+          c.passed { true }
+          c.warning { false }
+          c.failed { false }
+        end
+      end
+
+      describe '#passed?' do
+        specify { check.should be_passed }
+      end
+
+      describe '#warning?' do
+        specify { check.should_not be_warning }
+      end
+
+      describe '#failed?' do
+        specify { check.should_not be_failed }
+      end
+    end
+
+    describe '#status' do
+      [:passed, :warning, :failed, :none].each do |status|
+        context "with #{status}" do
+          let(:check) { create_check(status) }
+          specify { check.status.should eq(status) }
+        end
+      end
+
+      def create_check(status = nil)
+        described_class.new(:foo) do |c|
+          c.passed  { status == :passed }
+          c.warning { status == :warning }
+          c.failed  { status == :failed }
+        end
+      end
+    end
+
+    describe '#data' do
+      context 'given a block' do
+        it 'yields a DataGroup instance' do
+          described_class.new(:foo).data do |d|
+            d.should be_an_instance_of(Diagnostics::DataGroup)
+          end
+        end
+      end
+
+      context 'given no block' do
+        it 'returns a DataGroup instance' do
+          data = described_class.new(:foo).data
+          data.should be_an_instance_of(Diagnostics::DataGroup)
+        end
+      end
+    end
+
+  end
+end

data/spec/diagnostics/data/attribute_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Diagnostics
+  module Data
+    describe Attribute do
+      let(:attribute) { described_class.new('attr', 'val') }
+
+      describe '#plain' do
+        specify do
+          attribute.plain.should eq('attr: val')
+        end
+      end
+
+      describe '#html' do
+        specify do
+          attribute.html.should eq('<strong>attr:</strong> val')
+        end
+      end
+
+    end
+  end
+end

data/spec/diagnostics/data/list_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+module Diagnostics
+  module Data
+    describe List do
+      let(:list) { described_class.new(['a', 'b', 'c']) }
+
+      describe '#plain' do
+        specify do
+          list.plain.should eq("a\nb\nc")
+        end
+      end
+
+      describe '#html' do
+        specify do
+          list.html.should eq('a<br />b<br />c')
+        end
+      end
+
+    end
+  end
+end

data/spec/diagnostics/data/table_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+module Diagnostics
+  module Data
+    describe Table do
+      describe '#html' do
+
+        specify do
+          described_class.new(
+            { 'heading 1' => [1, 2, 3],
+              'heading 2' => [4, 5, 6],
+              'heading 3' => [7, 8, 9] }
+          ).html.should eq(
+            '<table>' \
+              '<tr>' \
+                '<th>heading 1</th>' \
+                '<th>heading 2</th>' \
+                '<th>heading 3</th>' \
+              '</tr>' \
+              '<tr>' \
+                '<td>1</td>' \
+                '<td>4</td>' \
+                '<td>7</td>' \
+              '</tr>' \
+              '<tr>' \
+                '<td>2</td>' \
+                '<td>5</td>' \
+                '<td>8</td>' \
+              '</tr>' \
+              '<tr>' \
+                '<td>3</td>' \
+                '<td>6</td>' \
+                '<td>9</td>' \
+              '</tr>' \
+            '</table>'
+          )
+        end
+
+        specify do
+          described_class.new(
+            { 'heading 1' => 1,
+              'heading 2' => 2,
+              'heading 3' => 3 }
+          ).html.should eq(
+            '<table>' \
+              '<tr>' \
+                '<th>heading 1</th>' \
+                '<th>heading 2</th>' \
+                '<th>heading 3</th>' \
+              '</tr>' \
+              '<tr>' \
+                '<td>1</td>' \
+                '<td>2</td>' \
+                '<td>3</td>' \
+              '</tr>' \
+            '</table>'
+          )
+        end
+
+      end
+    end
+  end
+end