capnotify 0.1.0pre

data/lib/capnotify/plugin.rb

@@ -0,0 +1,121 @@
+require 'capnotify/version'
+require 'pry'
+
+module Capnotify
+  module Plugin
+
+    def print_splash
+      return if fetch(:capnotify_hide_splash, false)
+
+      puts <<-SPLASH
+           __________________
+      - --|\\   Deployment   /|    _____                    __  _ ___
+     - ---| \\   Complete   / |   / ___/__ ____  ___  ___  / /_(_) _/_ __
+    - ----| /\\____________/\\ |  / /__/ _ `/ _ \\/ _ \\/ _ \\/ __/ / _/ // /
+   - -----|/ - Capistrano - \\|  \\___/\\_,_/ .__/_//_/\\___/\\__/_/_/ \\_, /
+  - ------|__________________|          /_/                      /___/
+
+      SPLASH
+    end
+
+    # convenience method for getting the friendly app name
+    # If the stage is specified (the deployment is using multistage), include that.
+    # given that the application is "MyApp" and the stage is "production", this will return "MyApp production"
+    def appname
+      fetch(:capnotify_appname, "")
+    end
+
+    def load_plugin(name, mod)
+      Capistrano.plugin name, mod
+
+      get_plugin(name).init
+    end
+
+    def unload_plugin(name)
+      p = get_plugin(name)
+
+      p.unload if p.respond_to?(:unload)
+      Capistrano.remove_plugin(name)
+    end
+
+    def get_plugin(name)
+      raise "Unknown plugin: #{ name }" unless Capistrano::EXTENSIONS.keys.include?(name)
+      self.send(name)
+    end
+    private :get_plugin
+
+    # template stuff:
+
+    # return the path to the built-in template with the given name
+    def built_in_template_for(template_name)
+      File.join( File.dirname(__FILE__), 'templates', template_name )
+    end
+
+    # given a path to an ERB template, process it with the current binding and return the output.
+    def build_template(template_path)
+      # FIXME: this is called every time build_template is called.
+      # although this is idepodent, it's got room for optimization
+      self.build_components!
+
+      ERB.new( File.open( template_path ).read, nil, '<>' ).result(self.binding)
+    end
+
+    # component stuff
+
+    # returns the capnotify_component_list
+    # this is the underlying mechanism for working with components
+    # append or prepend or insert from here.
+    def components
+      fetch(:capnotify_component_list)
+    end
+
+    # fetch a component given the name
+    # this is most useful for getting a component directly if you want to make modificatins to it
+    def component(name)
+      components.each { |c| return c if c.name == name.to_sym }
+      return nil
+    end
+
+    # insert the given component before the component with `name`
+    # if no component is found with that name, the component will be inserted at the end
+    def insert_component_before(name, component)
+      # iterate over all components, find the component with the given name
+      # once found, insert the given component at that location and return
+      components.each_with_index do |c, i|
+        if c.name == name
+          components.insert(i, component)
+          return
+        end
+      end
+
+      components << component
+    end
+
+    # insert the given component after the component with `name`
+    # if no component is found with that name, the component will be inserted at the end
+    def insert_component_after(name, component)
+      # iterate over all components, find the component with the given name
+      # once found, insert the given component at the following location and return
+      components.each_with_index do |c, i|
+        if c.name == name
+          components.insert(i + 1, component)
+          return
+        end
+      end
+
+      components << component
+    end
+
+    # delete the component with the given name
+    # return the remaining list of components (to enable chaining)
+    def delete_component(name)
+      components.delete_if { |c| c.name == name.to_sym }
+    end
+
+    # build all components
+    def build_components!
+      set :capnotify_component_list, self.components.map { |c| c.build!(self) }
+    end
+
+  end
+end

data/lib/capnotify/templates/_component.html.erb

@@ -0,0 +1,20 @@
+<% if @content.is_a? Hash %>
+<dl>
+<% @content.each do |k,v| %>
+  <dt><%= k %></dt>
+  <dd><%= v %></dd>
+<% end %>
+</dl>
+<% elsif @content.is_a? Array %>
+  <ul>
+  <% @content.each do |row| %>
+    <li>
+      <%= row %>
+    </li>
+  <% end %>
+  </ul>
+<% elsif @content.is_a? String %>
+  <div class="content">
+  <%= @content %>
+  </div>
+<% end %>

data/lib/capnotify/templates/_component.txt.erb

@@ -0,0 +1,11 @@
+<% if @content.is_a? Hash %>
+  <% @content.each do |k,v| %>
+<%= k %>: <%= v %>
+  <% end %>
+<% elsif @content.is_a? Array %>
+  <% @content.each do |row| %>
+<%= row %>
+  <% end %>
+<% elsif @content.is_a? String %>
+  <%= @content %>
+<% end %>

data/lib/capnotify/templates/default_notification.html.erb

@@ -0,0 +1,78 @@
+<html>
+<head>
+  <style>
+    body {
+      font: 12px "Helvetica", "Lucida Grande", "Trebuchet MS", Verdana, sans-serif;
+    }
+    .section h2 {
+      color: #999;
+      margin: 0;
+    }
+
+    .section {
+      margin-bottom: 10px;
+      border-radius: 10px;
+      background-color: #eee;
+
+      padding: 5px 20px;
+    }
+
+    .content {
+      margin-top: 10px;
+      margin-bottom: 10px;
+    }
+
+    dt {
+      width: 15%;
+      margin-right: 10px;
+      display: inline-block;
+      white-space: nowrap;
+
+      clear: both;
+
+      margin-bottom: 5px;
+    }
+
+    dd {
+      width: 65%;
+      display: inline-block;
+      margin-bottom: 5px;
+    }
+
+    dl dt {
+      font-weight: bold;
+    }
+
+
+    #footer {
+      font-size: .75em;
+      text-align: center;
+      margin-top: 20px;
+    }
+
+    <% capnotify.components.each do |component| %>
+      <%= component.custom_css %>
+
+    <% end %>
+
+  </style>
+</head>
+<body>
+
+  <h1>
+    <%= capnotify.appname %> deployment completed!
+  </h1>
+
+  <% capnotify.components.each do |component| %>
+    <div class="<%= component.css_class %>">
+      <h2><%= component.header %></h2>
+
+      <%= component.render_content(:html) %>
+  </div>
+  <% end %>
+
+  <div id="footer">
+    Email generated by <a href="https://github.com/spikegrobstein/capnotify">Capnotify</a>
+  </div>
+</body>
+</html>

data/lib/capnotify/templates/default_notification.txt.erb

@@ -0,0 +1,8 @@
+<%= capnotify.appname %> deployment completed!
+
+<% capnotify.components.each do |component| %>
+--- <%= @header %> ---
+<%= component.render_content(:txt) %>
+<% end %>
+
+Email generated by Capnotify <https://github.com/spikegrobstein/capnotify>

data/lib/capnotify/version.rb

@@ -0,0 +1,3 @@
+module Capnotify
+  VERSION = "0.1.0pre"
+end

data/lib/capnotify.rb

@@ -0,0 +1,132 @@
+require "capnotify/version"
+require 'capnotify/component'
+require 'capnotify/plugin'
+require 'capnotify/plugin/overview'
+require 'capnotify/plugin/details'
+
+module Capnotify
+  def self.load_into(config)
+    config.load do
+      Capistrano.plugin :capnotify, ::Capnotify::Plugin
+
+      def _cset(name, *args, &block)
+        unless exists?(name)
+          set(name, *args, &block)
+        end
+      end
+
+
+      # some configuration
+      _cset :capnotify_deployment_notification_html_template_path, capnotify.built_in_template_for('default_notification.html.erb')
+      _cset :capnotify_deployment_notification_text_template_path, capnotify.built_in_template_for('default_notification.txt.erb')
+
+      # get the name of the user deploying
+      # if using git, this will read that from your git config
+      # otherwise will use the currently logged-in user's name
+      _cset(:deployer_username) do
+        if exists?(:scm) && fetch(:scm).to_sym == :git
+          `git config user.name`.chomp
+        else
+          `whoami`.chomp
+        end
+      end
+
+      # built-in values:
+      set :capnotify_component_list, []
+
+      # override this to change the default behavior for capnotify.appname
+      _cset(:capnotify_appname) do
+        [ fetch(:application, nil), fetch(:stage, nil) ].compact.join(" ")
+      end
+
+      # default messages:
+      # (these can be overridden)
+
+      # short message for the start of running migrations
+      _cset(:capnotify_migrate_start_msg) do
+        "#{ capnotify.appname } migration starting."
+      end
+
+      # short message for the completion of running migrations
+      _cset(:capnotify_migrate_complete_msg) do
+        "#{ capnotify.appname } migration completed."
+      end
+
+      # short message for the start of a deployment
+      _cset(:capnotify_deploy_start_msg) do
+        "#{ capnotify.appname } deployment completed."
+      end
+
+      # short message for the completion of a deployment
+      _cset(:capnotify_deploy_complete_msg) do
+        "#{ capnotify.appname } deployment completed."
+      end
+
+      # short message for putting up a maintenance page
+      _cset(:capnotify_maintenance_up_msg) do
+        "#{ capnotify.appname } maintenance page is now up."
+      end
+
+      # short message for taking down a maintenance page
+      _cset(:capnotify_maintenance_down_msg) do
+        "#{ capnotify.appname } maintenance page has been taken down."
+      end
+
+      # full email message to notify of deployment (html)
+      _cset(:capnotify_deployment_notification_html) do
+        capnotify.build_template( fetch(:capnotify_deployment_notification_html_template_path) )
+      end
+
+      # full email message to notify of deployment (plain text)
+      _cset(:capnotify_deployment_notification_text) do
+        data = capnotify.build_template( fetch(:capnotify_deployment_notification_text_template_path) )
+
+        # clean up the text output (remove leading spaces and more than 2 newlines in a row
+        data.gsub(/^ +/, '').gsub(/\n{3,}/, "\n\n")
+      end
+
+      # before update_code, fetch the current revision
+      # this is needed to ensure that no matter when capnotify fetches the commit logs,
+      # it will have the correct starting point.
+      before 'deploy:update_code' do
+        set :capnotify_previous_revision, fetch(:current_revision, nil) # the revision that's currently deployed at this moment
+      end
+
+      # configure the callbacks
+
+      on(:load) do
+        # deploy start/complete
+        unless fetch(:capnotify_disable_deploy_hooks, false)
+          before('deploy') { trigger :deploy_start }
+          after('deploy')  { trigger :deploy_complete }
+        end
+
+        # migration start/complete
+        unless fetch(:capnotify_disable_migrate_hooks, false)
+          before('deploy:migrate') { trigger :migrate_start }
+          after('deploy:migrate')  { trigger :migrate_complete }
+        end
+
+        # maintenance start/complete
+        unless fetch(:capnotify_disable_maintenance_hooks, false)
+          after('deploy:web:disable') { trigger :maintenance_page_up }
+          after('deploy:web:enable')  { trigger :maintenance_page_down }
+        end
+
+        unless fetch(:capnotify_disable_default_components, false)
+          capnotify.load_plugin :capnotify_overview, Capnotify::Plugin::Overview
+          capnotify.load_plugin :capnotify_details, Capnotify::Plugin::Details
+        end
+
+        capnotify.print_splash
+      end
+
+    end
+  end
+
+end
+
+if Capistrano::Configuration.instance
+  Capnotify.load_into(Capistrano::Configuration.instance)
+end
+

data/spec/capnotify/component_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Capnotify::Component do
+  let(:component) { Capnotify::Component.new(:test_component) }
+
+  context "initialization" do
+
+    it "should set the name to the symbol" do
+      Capnotify::Component.new('new_component').name.should == :new_component
+    end
+
+    it "should set the header if specified" do
+      Capnotify::Component.new('asdf', :header => 'spike').header.should == 'spike'
+    end
+
+    it "should set the css_class if specified" do
+      Capnotify::Component.new('asdf', :css_class => 'great-component').css_class.should == 'great-component'
+    end
+
+    it "should set the css_class to the default 'section' if not specified" do
+      Capnotify::Component.new('asdf').css_class.should == 'section'
+    end
+
+    it "should allow building with a block" do
+      c = Capnotify::Component.new(:test_component) do |c|
+        c.header = 'My Header'
+
+        c.content = {}
+        c.content['this is'] = 'a test'
+      end
+
+      c.builder.should_not be_nil
+      c.header.should be_nil
+
+      c.build!(nil)
+
+      c.header.should == 'My Header'
+      c.builder.should be_nil
+    end
+  end
+
+  context "#render_content" do
+    let(:sample_content) { "This is sample content that just works." }
+
+    before do
+      component.content = sample_content
+    end
+
+    context "when using an existing renderer" do
+
+      it "should render data" do
+        component.renderers[:txt].should_not be_nil
+        component.render_content(:txt).should match(sample_content)
+      end
+
+    end
+
+    context "when a template is missing" do
+
+      it "should raise an error" do
+        component.render_for :txt => 'does_not_exist.erb'
+        expect { component.render_content(:txt) }.to raise_error
+      end
+
+    end
+
+    context "when a template is not defined" do
+
+      it "should return an empty string" do
+        component.renderers[:foo].should be_nil
+        component.render_content(:foo).should == ''
+      end
+
+    end
+
+  end
+
+  context "#template_path_for" do
+
+    it "should raise a TemplateUndefined error if the renderer is not defined" do
+      lambda { component.template_path_for(:foo) }.should raise_error(Capnotify::Component::TemplateUndefined)
+    end
+
+  end
+
+  context "#render_for" do
+
+    it "should add new renderers" do
+      expect { component.render_for :other => 'asdf.erb', :more => 'more.erb' }.to change { component.renderers.keys.count }.by(2)
+    end
+
+    it "should override existing renderers" do
+      expect { component.render_for :html => 'new_html.erb' }.to change { component.renderers.keys.count }.by(0)
+
+      component.renderers[:html].should == 'new_html.erb'
+    end
+
+  end
+
+end