afterburn 0.0.1

data/lib/afterburn/list_interval_series.rb

@@ -0,0 +1,41 @@
+require 'matrix'
+
+# TODO test
+module Afterburn
+  class ListIntervalSeries
+    def initialize(lists, timestamps)
+      @lists, @timestamps = lists, timestamps
+    end
+
+    # deploy_list_counts + wip_list_counts + completed_list_counts
+    def to_json
+      aggregate(backlog_lists, :name => List::Role::BACKLOG) +
+      map(wip_lists) +
+      aggregate(deployed_lists, :name => List::Role::DEPLOYED)
+    end
+
+    def aggregate(lists, opts = {})
+      vectors = lists.map { |list| list.timestamp_count_vector(@timestamps) }
+      [{ "name" => opts[:name], "data" => vectors.inject(&:+).to_a }]
+    end
+
+    def map(lists)
+      lists.map do |list|
+        { "name" => list.name, "data" => list.timestamp_count_vector(@timestamps).to_a } 
+      end
+    end
+
+    def backlog_lists
+      @lists.select { |list| list.role == List::Role::BACKLOG }
+    end
+
+    def wip_lists
+      @lists.select { |list| list.role == List::Role::WIP }
+    end
+
+    def deployed_lists
+      @lists.select { |list| list.role == List::Role::DEPLOYED }
+    end
+  end
+
+end

data/lib/afterburn/list_metric.rb

@@ -0,0 +1,39 @@
+require 'base64'
+require 'matrix'
+require 'redis/objects'
+
+module Afterburn
+  class ListMetric
+    include Redis::Objects
+
+    attr_reader :timestamp
+    counter :card_count
+
+    def self.for_timestamp(lists, timestamp)
+      lists.map { |list| new(list, timestamp) }      
+    end
+
+    def self.for_list(list, timestamps)
+      timestamps.map { |timestamp| new(list, timestamp) }
+    end
+
+    # TODO test
+    def self.timestamp_count_vector(list, timestamps)
+      Vector[*for_list(list, timestamps).map { |metric| metric.card_count.to_i }]
+    end
+
+    def initialize(list, timestamp = Time.now)
+      @list = list
+      @timestamp = timestamp
+    end
+
+    def id
+      @id ||= Base64.encode64("#{@list.id}:#{@timestamp.to_i}")
+    end
+
+    def count!
+      card_count.incr(@list.card_count)
+    end
+
+  end
+end

data/lib/afterburn/member.rb

@@ -0,0 +1,51 @@
+module Afterburn
+  class Member < TrelloObjectWrapper
+    wrap :member
+
+    set :member_id_set, :global => true
+
+    %w[trello_user_key trello_user_secret trello_app_token].each do |trello_key|
+      value "#{trello_key}_value"
+
+      define_method(trello_key) do
+        send("#{trello_key}_value").value
+      end
+
+      define_method("#{trello_key}=") do |value|
+        send("#{trello_key}_value").value = value
+      end
+    end
+
+    def self.ids
+      member_id_set.members
+    end
+
+    def self.all
+      ids.map { |id| Member.find(id) }
+    end
+
+    def self.first
+      Member.find(ids.first)
+    end
+
+    def self.add_member(member)
+      member_id_set << member.id
+    end
+
+    def self.clear
+      member_id_set.clear
+    end
+
+    def boards
+      trello_member.boards.map { |trello_board| Board.initialize_from_trello_object(trello_board) }
+    end
+
+    def name
+      trello_member.username
+    end
+
+# export TRELLO_USER_KEY=3dca2797d175d70a1252cb502a5e49b9
+# export TRELLO_USER_SECRET=1532c3edcd355ec3bd7767ab0ac4da190351bed6174358139d284f3d67d978df
+# export TRELLO_APP_TOKEN=3aab0899ba564f58c610ce326fbdd3375a206831e7ba68dc95ef3319e90e8170
+  end
+end

data/lib/afterburn/project.rb

@@ -0,0 +1,100 @@
+require 'afterburn'
+require 'redis/objects'
+
+module Afterburn
+  class Project
+    include Redis::Objects
+
+    value :redis_name_value
+    value :enabled_value
+    sorted_set :interval_set
+
+    attr_reader :id
+
+    def self.by_member_name(member_name)
+      Board.fetch_by_member(member_name).map { |board| Project.new(board) }
+    end
+
+    def self.by_member(member)
+      member.boards.map { |board| Project.new(board) }
+    end
+
+    def self.find(id)
+      new(Board.find(id))
+    end
+
+    attr_reader :board
+    def initialize(board)
+      @board = board
+    end
+
+    def id
+      @id ||= @board.id
+    end
+
+    def name=(name)
+      redis_name_value.value = name
+    end
+
+    def name
+      redis_name_value.value || @board.name
+    end
+
+    def enable!
+      enabled_value.value = "1"
+    end
+
+    def disable!
+      enabled_value.value = nil
+    end
+
+    def enable=(enabled)
+      enabled == "1" ? enable! : disable!
+    end
+
+    def enabled?
+      !!enabled_value.value
+    end
+
+    def lists
+      @board.lists
+    end
+
+    # TODO test
+    def record_interval
+      Time.now.tap do |timestamp|
+        interval = BoardInterval.record(@board, timestamp)
+        interval_set[interval.id] = timestamp.to_i
+      end
+    end
+
+    # TODO handle BoardIntervals not found
+    def intervals
+      @intervals ||= BoardInterval.find_all(interval_set.members)
+    end
+
+    def to_json
+      {}.tap do |hash|
+        hash['id'] = id
+        hash['name'] = name
+        hash['categories'] = interval_timestamps.map(&:to_date)
+        hash['series'] = interval_series_json
+      end
+    end
+
+    def interval_timestamps
+      intervals.map(&:timestamp)
+    end
+
+    def interval_series_json
+      ListIntervalSeries.new(lists, interval_timestamps).to_json
+    end
+
+    def update_attributes(attributes)
+      attributes.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+  end
+end

data/lib/afterburn/redis_connection.rb

@@ -0,0 +1,39 @@
+require 'redis'
+
+module Afterburn
+  module RedisConnection
+
+    # Accepts:
+    #   1. A 'hostname:port' String
+    #   2. A 'hostname:port:db' String (to select the Redis db)
+    #   3. A Redis URL String 'redis://host:port'
+    #   4. An instance of `Redis`, `Redis::Client`, `Redis::DistRedis`
+    def redis=(server)
+      case server
+      when String
+        if server =~ /redis\:\/\//
+          redis = Redis.connect(:url => server, :thread_safe => true)
+        else
+          host, port, db = server.split(':')
+          redis = Redis.new(:host => host, :port => port,
+            :thread_safe => true, :db => db)
+        end
+
+        @redis = redis
+      else
+        @redis = server
+      end
+
+      @redis
+    end
+
+    # Returns the current Redis connection. If none has been created, will
+    # create a new one.
+    def redis
+      return @redis if @redis
+      self.redis = Redis.respond_to?(:connect) ? Redis.connect : "localhost:6379"
+      self.redis
+    end
+
+  end
+end

data/lib/afterburn/server.rb

@@ -0,0 +1,103 @@
+require 'sinatra/base'
+require 'erb'
+require "rack/csrf"
+require 'afterburn'
+require 'afterburn/version'
+
+module Afterburn
+  class Server < Sinatra::Base
+    dir = File.dirname(File.expand_path(__FILE__))
+
+    set :views,  "#{dir}/server/views"
+    set :public_folder, "#{dir}/server/public"
+    set :static, true
+
+    helpers do
+      include Rack::Utils
+      alias_method :h, :escape_html
+
+      def current_section
+        url_path request.path_info.sub('/','').split('/')[0].downcase
+      end
+
+      def current_page
+        url_path request.path_info.sub('/','')
+      end
+
+      def url_path(*path_parts)
+        [ path_prefix, path_parts ].join("/").squeeze('/')
+      end
+      alias_method :u, :url_path
+
+      def path_prefix
+        request.env['SCRIPT_NAME']
+      end
+
+      def partial(template, local_vars = {})
+        erb(template.to_sym, {:layout => false}, local_vars)
+      end
+
+      def afterburn
+        Afterburn
+      end
+
+      def current_member
+        Afterburn.current_member
+      end
+
+      def current_projects
+        [Afterburn.current_projects.first]
+      end
+
+      def csrf_token
+        Rack::Csrf.csrf_token(env)
+      end
+
+      def csrf_tag
+        Rack::Csrf.csrf_tag(env)
+      end
+
+      def csrt_metatag
+        Rack::Csrf.metatag(env)
+      end
+    end
+
+    def show(page, options = {})
+      response["Cache-Control"] = "max-age=0, private, must-revalidate"
+      begin
+        erb page.to_sym, options
+      rescue Errno::ECONNREFUSED
+        erb :error, {:layout => false}, :error => "Can't connect to Redis! (#{Resque.redis_id})"
+      end
+    end
+
+    get "/" do
+      if current_member
+        show :overview
+      else
+        show :members
+      end
+    end
+
+    post "/members" do
+      member_attrs = params[:member]
+      raise Afterburn::Member.find(member_attrs[:name])
+    end
+
+    get "/projects/:id/edit" do
+      show :edit_project, locals: { project: Afterburn::Project.find(params[:id]) } 
+    end
+
+    post "/projects/:id" do
+      puts params.inspect
+      Project.find(params[:id]).update_attributes(params[:project])
+      redirect "/"
+    end
+
+    put "/lists/:id" do
+      list = Afterburn::List.find(params[:id])
+      list.update_attributes(params[:list])
+      list.to_json
+    end
+  end
+end

data/lib/afterburn/server/config/setup.example.rb

@@ -0,0 +1,12 @@
+#
+# 1. Get your trello key and secret:
+# => https://trello.com/1/appKey/generate.
+# 2. Generate an app token for afterburn:
+# => https://trello.com/1/connect?key=PUBLIC_KEY_FROM_ABOVE&name=MyApp&response_type=token&scope=read,write,account&expiration=never
+# 3. Use the afterburn authorization block in an initializer file
+
+Afterburn.authorize 'rossta' do |auth|
+  auth.trello_user_key = "trello_user_key"
+  auth.trello_user_secret = "trello_user_secret"
+  auth.trello_app_token = "trello_app_token"
+end

data/lib/afterburn/server/config/setup.rb

@@ -0,0 +1,7 @@
+Afterburn.redis = 'redis://localhost:6379'
+
+Afterburn.authorize 'rossta' do |auth|
+  auth.trello_user_key = "3dca2797d175d70a1252cb502a5e49b9"
+  auth.trello_user_secret = "1532c3edcd355ec3bd7767ab0ac4da190351bed6174358139d284f3d67d978df"
+  auth.trello_app_token = "f05683f1c41d6d17e500fcc22c334b3852d34b0fbc0c8d9cf4a4ee011a01ec8c"
+end

data/lib/afterburn/server/public/afterburn.js

@@ -0,0 +1,66 @@
+var Afterburn = {
+  setup: function(projects) {
+    _(projects).each(function(project) {
+      new Afterburn.Chart(project).render();
+    });
+  }
+};
+
+Afterburn.Chart = function(project) {
+  console.log(project);
+  var self = this;
+  self.project = project;
+  self.id = project.id;
+  self.name = project.name;
+};
+
+Afterburn.Chart.prototype = {
+
+  render: function() {
+    var self = this;
+    new Highcharts.Chart({
+      chart: {
+        renderTo: "project_" + self.id,
+        type: 'area'
+      },
+      title: {
+        text: "Cumulative flow diagram for "+self.name+" project"
+      },
+      xAxis: {
+        categories: self.project.categories,
+        tickmarkPlacement: 'on',
+        title: {
+          enabled: false
+        }
+      },
+      yAxis: {
+        title: {
+          text: 'Cards'
+        },
+        labels: {
+          formatter: function() {
+            return this.value;
+          }
+        }
+      },
+      tooltip: {
+        formatter: function() {
+          return ''+
+          this.x +': '+ Highcharts.numberFormat(this.y, 0, ',') +' cards';
+        }
+      },
+      plotOptions: {
+        area: {
+          stacking: 'normal',
+          lineColor: '#666666',
+          lineWidth: 1,
+          marker: {
+            lineWidth: 1,
+            lineColor: '#666666'
+          }
+        }
+      },
+      series: self.project.series
+    });
+  }
+};