afterburn 0.0.1

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2012 YOURNAME
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,3 @@
+= Afterburn
+
+This project rocks and uses MIT-LICENSE.

data/Rakefile

@@ -0,0 +1,49 @@
+#!/usr/bin/env rake
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+begin
+  require 'rdoc/task'
+rescue LoadError
+  require 'rdoc/rdoc'
+  require 'rake/rdoctask'
+  RDoc::Task = Rake::RDocTask
+end
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Afterburn'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+Bundler::GemHelper.install_tasks
+
+load './lib/tasks/afterburn_tasks.rake'
+
+begin
+  require 'rspec/core/rake_task'
+
+  desc "Run specs"
+  RSpec::Core::RakeTask.new do |t|
+    t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+    # Put spec opts in a file named .rspec in root
+  end
+
+  desc "Generate code coverage"
+  RSpec::Core::RakeTask.new(:coverage) do |t|
+    t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec']
+  end
+
+rescue LoadError
+  task :spec do
+    abort "Rspec is not available."
+  end
+end
+
+task :default => :spec

data/bin/burn

@@ -0,0 +1,91 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__) + '/../lib')
+
+require 'afterburn'
+require 'optparse'
+
+config = ENV['AFTERBURNCONFIG'] || './lib/afterburn/server/config/setup.rb'
+load ::File.expand_path(config) if ::File.exists?(config)
+
+parser = OptionParser.new do |opts|
+  opts.banner = "Usage: burn [options] COMMAND"
+
+  opts.separator ""
+  opts.separator "Options:"
+
+  # opts.on("-m", "--members", "List members") do |host|
+  #   Resque.redis = host
+  # end
+
+  # opts.on("-N", "--namespace [NAMESPACE]", "Redis namespace") do |namespace|
+  #   Resque.redis.namespace = namespace
+  # end
+
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+
+  # opts.separator ""
+  # opts.separator "Commands:"
+  # opts.separator "  remove WORKER   Removes a worker"
+  # opts.separator "  kill WORKER     Kills a worker"
+  opts.separator "  list            List current members or projects"
+end
+
+# def kill(worker)
+#   abort "** resque kill WORKER_ID" if worker.nil?
+#   pid = worker.split(':')[1].to_i
+
+#   begin
+#     Process.kill("KILL", pid)
+#     puts "** killed #{worker}"
+#   rescue Errno::ESRCH
+#     puts "** worker #{worker} not running"
+#   end
+
+#   remove worker
+# end
+
+# def remove(worker)
+#   abort "** resque remove WORKER_ID" if worker.nil?
+
+#   Resque.remove_worker(worker)
+#   puts "** removed #{worker}"
+# end
+
+def list(method)
+  if Afterburn.respond_to?("current_#{method}")
+    collection = Afterburn.send("current_#{method}")
+    
+    if collection.any?
+      collection.each do |item|
+        puts item.name
+      end
+    else
+      puts "None"
+    end
+  else
+    puts "#{method} unknown"
+  end
+end
+
+def record
+  Afterburn.current_projects.map(&:record_interval)
+end
+
+parser.parse!
+
+case ARGV[0]
+# when 'kill'
+#   kill ARGV[1]
+# when 'remove'
+#   remove ARGV[1]
+when 'list'
+  list ARGV[1]
+when 'record'
+  record
+else
+  puts parser.help
+end

data/lib/afterburn.rb

@@ -0,0 +1,35 @@
+require 'trello'
+
+module Afterburn
+  autoload :RedisConnection, "afterburn/redis_connection"
+  autoload :Helpers, "afterburn/helpers"
+  autoload :TrelloObjectWrapper, "afterburn/trello_object_wrapper"
+  autoload :Board, "afterburn/board"
+  autoload :Member, "afterburn/member"
+  autoload :List, "afterburn/list"
+  autoload :ListMetric, "afterburn/list_metric"
+  autoload :ListIntervalSeries, "afterburn/list_interval_series"
+  autoload :BoardInterval, "afterburn/board_interval"
+  autoload :Project, "afterburn/project"
+  autoload :Authorization, "afterburn/authorization"
+  autoload :Server, "afterburn/server"
+
+  extend RedisConnection
+  extend self
+
+  def authorize(member_name, &block)
+    Authorization.new(member_name).configure(&block)
+  end
+
+  def current_member
+    @current_member ||= Afterburn::Member.first
+  end
+
+  def current_members
+    Afterburn::Member.all
+  end
+
+  def current_projects
+    current_members.map { |member| Afterburn::Project.by_member(member) }.flatten
+  end
+end

data/lib/afterburn/authorization.rb

@@ -0,0 +1,36 @@
+module Afterburn
+  class Authorization
+    include Trello
+    include Trello::Authorization
+
+    attr_accessor :trello_user_key, :trello_user_secret, :trello_app_token
+
+    def initialize(member_name)
+      @member_name = member_name
+    end
+
+    def configure
+      yield self if block_given?
+      Trello::Authorization.const_set :AuthPolicy, OAuthPolicy
+      OAuthPolicy.consumer_credential = OAuthCredential.new trello_user_key, trello_user_secret
+      OAuthPolicy.token = OAuthCredential.new trello_app_token, nil
+      Afterburn::Member.add_member(member)
+    end
+
+    def trello_user_key
+      @trello_user_key ||= member.trello_user_key
+    end
+
+    def trello_user_secret
+      @trello_user_secret ||= member.trello_user_secret
+    end
+
+    def trello_app_token
+      @trello_app_token ||= member.trello_app_token
+    end
+
+    def member
+      Afterburn::Member.find(@member_name)
+    end
+  end
+end

data/lib/afterburn/board.rb

@@ -0,0 +1,22 @@
+module Afterburn
+  class Board < TrelloObjectWrapper
+    wrap :board
+
+    def self.fetch_by_member(member_name)
+      Trello::Member.find(member_name).boards.map { |trello_board| initialize_from_trello_object(trello_board) }
+    end
+
+    def lists
+      @lists ||= trello_lists.map { |trello_list| List.factory(trello_list) }
+    end
+
+    def trello_lists
+      trello_board.lists
+    end
+
+    def name
+      trello_board.name
+    end
+
+  end
+end

data/lib/afterburn/board_interval.rb

@@ -0,0 +1,47 @@
+require "base64"
+require 'redis/objects'
+
+module Afterburn
+  class BoardInterval
+    include Redis::Objects
+
+    attr_reader :board, :timestamp
+
+    def self.find(id)
+      board_id, timestamp_string = Base64.decode64(id).split(":")
+      return nil if board_id.nil?
+      new(Board.find(board_id), Time.at(timestamp_string.to_i))
+    end
+
+    def self.find_all(ids)
+      ids.map { |interval_id| find(interval_id) }.compact
+    end
+
+    # TODO test
+    def self.record(board, timestamp)
+      new(board, timestamp).tap { |board_interval| board_interval.record! }
+    end
+
+    def initialize(board, timestamp = Time.now)
+      @board = board
+      @timestamp = timestamp
+    end
+
+    def id
+      @id ||= Base64.encode64("#{@board.id}:#{@timestamp.to_i}")
+    end
+
+    def list_metrics
+      @list_metrics ||= ListMetric.for_timestamp(@board.lists, timestamp)
+    end
+
+    def record!
+      list_metrics.map(&:count!)
+    end
+
+    def ==(other)
+      self.class == other.class && !other.id.nil? && self.id == other.id
+    end
+
+  end
+end

data/lib/afterburn/engine.rb

@@ -0,0 +1,11 @@
+require 'afterburn'
+
+module Afterburn
+  class Engine < ::Rails::Engine
+    isolate_namespace Afterburn
+
+    initializer 'require_afterburn_server' do
+      require 'afterburn/server'
+    end
+  end
+end

data/lib/afterburn/helpers.rb

@@ -0,0 +1,54 @@
+module Afterburn
+  module Helpers
+
+    def redis
+      Afterburn.redis
+    end
+
+    # Tries to find a constant with the name specified in the argument string:
+    #
+    # constantize("Module") # => Module
+    # constantize("Test::Unit") # => Test::Unit
+    #
+    # The name is assumed to be the one of a top-level constant, no matter
+    # whether it starts with "::" or not. No lexical context is taken into
+    # account:
+    #
+    # C = 'outside'
+    # module M
+    #   C = 'inside'
+    #   C # => 'inside'
+    #   constantize("C") # => 'outside', same as ::C
+    # end
+    #
+    # NameError is raised when the constant is unknown.
+    def constantize(camel_cased_word)
+      camel_cased_word = camel_cased_word.to_s
+
+      if camel_cased_word.include?('-')
+        camel_cased_word = classify(camel_cased_word)
+      end
+
+      names = camel_cased_word.split('::')
+      names.shift if names.empty? || names.first.empty?
+
+      constant = Object
+      names.each do |name|
+        args = Module.method(:const_get).arity != 1 ? [false] : []
+
+        if constant.const_defined?(name, *args)
+          constant = constant.const_get(name)
+        else
+          constant = constant.const_missing(name)
+        end
+      end
+      constant
+    end
+
+
+    def titleize(word)
+      word.gsub(%r{\b('?[a-z])}) { $1.capitalize }
+    end
+
+  end
+end

data/lib/afterburn/list.rb

@@ -0,0 +1,98 @@
+module Afterburn
+  class List < TrelloObjectWrapper
+
+    class UnknownRole < StandardError; end
+    module Role
+      extend self
+      VALID_ROLES = [
+        BACKLOG     = 'backlog',
+        WIP         = 'WIP',      # work in progress
+        DEPLOYED    = 'deployed',
+        IGNORED     = 'ignored'
+      ]
+
+      HISTORICAL = [BACKLOG, DEPLOYED]
+
+      def valid?(role)
+        VALID_ROLES.include?(role)
+      end
+
+      def historical?(role)
+        HISTORICAL.include?(role)
+      end
+    end
+
+    wrap :list
+    value :role_store
+    set :historical_card_id_set
+    set :metric_timestamp_list
+
+    def self.roles
+      Role::VALID_ROLES
+    end
+
+    def self.factory(trello_list)
+      initialize_from_trello_object(trello_list).tap do |list|
+        list.extend(History) if Role.historical?(list.role)
+      end
+    end
+
+    def self.historical(list)
+      HistoricalList.initialize_from_trello_object(list.trello_list)
+    end
+
+    def name
+      trello_list.name
+    end
+
+    def role=(role)
+      raise UnknownRole.new("Tried to set unrecognized '#{role}'") unless Role.valid?(role)
+      role_store.value = role
+    end
+
+    def role
+      role_store.value
+    end
+
+    def trello_cards
+      trello_list.cards
+    end
+
+    def card_count
+      trello_cards.count
+    end
+
+    def timestamp_count_vector(timestamps)
+      ListMetric.timestamp_count_vector(self, timestamps)
+    end
+
+    def update_attributes(attributes)
+      attributes.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    module History
+
+      def card_count
+        update_card_history
+        historical_card_count  
+      end
+
+      def historical_card_ids
+        historical_card_id_set.members
+      end
+
+      def historical_card_count
+        historical_card_id_set.count
+      end
+
+      def update_card_history
+        trello_cards.map(&:id).each { |card_id| historical_card_id_set << card_id }
+      end
+
+    end
+
+  end
+
+end