artisan-core 0.0.1

data/lib/artisan/reports/signoff/report.rb

@@ -0,0 +1,120 @@
+require "forwardable"
+require "artisan/stories/story_presenter"
+require "artisan/iterations/iteration_presenter"
+require "artisan/iterations/story_tags"
+
+module Signoff
+  class Report
+    extend Forwardable
+
+    attr_reader :project_name
+    attr_reader :table_data
+
+    def initialize(iteration, project_name, options = {})
+      @iteration = iteration
+      @project_name = project_name
+      @options = options
+      @table_data = {}
+      generate_reporting_variables
+    end
+
+    def_delegators :@iteration, :start_date, :finish_date, :committed_points, :committed_points_at_completion
+
+    def iteration_name
+      return "Iteration #{@iteration.number}"
+    end
+
+    def tables
+      tables = []
+      @options["sections"].each do |key, value|
+        tables << key if value == "1"
+      end
+      return tables
+    end
+
+    def total_billed_points
+      Artisan::Iterations::IterationPresenter.new(@iteration).total_billed_points
+    end
+
+    def team_member_names
+      Artisan::Iterations::IterationPresenter.new(@iteration).team_names
+    end
+
+    def completed
+      report_on(@iteration.stories.select { |story| story.complete? })
+    end
+
+    def features
+      report_on(@iteration.stories.select { |story| !story.nonbillable? })
+    end
+
+    def tasks
+      report_on(@iteration.stories.select { |story| story.nonbillable? })
+    end
+
+    def tag attr
+      report_on(@iteration.stories.select { |story| story.tag_list.include?(attr) })
+    end
+
+    def untagged
+      report_on(@iteration.stories.select { |story| story.tag_list.empty? })
+    end
+
+    def column_widths
+      widths = [60, 280]
+      widths << 100 if show_owner?
+      return widths
+    end
+
+    def column_titles
+      titles = ["Points", "Description"]
+      titles << "Owner" if show_owner?
+      return titles
+    end
+
+    private
+
+    def report_on(stories)
+      data = []
+      total_points = 0
+      stories.each do |story|
+        presenter = Artisan::Stories::StoryPresenter.new(story)
+        row = [story.estimate.to_s, story.name]
+        row << presenter.assigned_user_name if show_owner?
+
+        data << row
+        total_points += story.estimate
+      end
+
+      total_points = total_points.round(2)
+      final_row = [total_points.to_s, ""]
+      final_row << "" if show_owner?
+      data << final_row
+    end
+
+    def show_owner?
+      if !@options["show_owner"].nil?
+        return @options["show_owner"] == "1"
+      end
+      return false
+    end
+
+    def generate_reporting_variables
+      if !@options["sections"].nil?
+        @table_data['completed'] = self.completed if @options["sections"]["Completed"] == "1"
+
+        @table_data['features'] = self.features if @options["sections"]["Features"] == "1"
+
+        @table_data['tasks'] = self.tasks if @options["sections"]["Tasks"] == "1"
+
+        @table_data['untagged'] = self.untagged if @options["sections"]["Untagged"] == "1"
+      end
+
+      Artisan::Iterations::StoryTags.new(@iteration).tags.each { |tag| make_tag_callback(tag) }
+    end
+
+    def make_tag_callback(attr)
+      @table_data[attr.to_s.downcase] = self.tag(attr)
+    end
+  end
+end

data/lib/artisan/reports/velocity_report.rb

@@ -0,0 +1,43 @@
+require "artisan/iterations/iteration_point_calculator"
+module Reports
+  class VelocityReport
+    attr_accessor :results, :project, :limit
+
+    def initialize(project)
+      @project = project
+    end
+
+    def generate(criteria = {})
+      @limit = !criteria[:limit].nil? ? criteria[:limit] : @project.iterations.count
+      @results = limited_iterations_by_finish_date
+    end
+
+    def collect_iteration(action)
+      return @results.collect {|iteration| iteration.send(action.to_sym) }.reverse
+    end
+
+    def max_value
+      list = array_to_f(collect_iteration(:committed_points)).concat(completed_points)
+      return list.sort[-1]
+    end
+
+    def collect_dates
+      return @results.collect{|iteration| iteration.finish_date.strftime('%b %d')}.reverse
+    end
+
+    def completed_points
+      return @results.collect {|iteration|  Artisan::Iterations::IterationPointCalculator.new(iteration).completed_points }.reverse
+    end
+
+    private
+
+    def array_to_f(array)
+      return array.map(&:to_f)
+    end
+
+    def limited_iterations_by_finish_date
+      @project.iterations.by_finish_date[0, @limit.to_i]
+    end
+
+  end
+end

data/lib/artisan/repository.rb

@@ -0,0 +1,51 @@
+module Artisan
+  class RecordNotFound < RuntimeError
+    attr_reader :base
+
+    def initialize(base = nil)
+      @base = base
+    end
+  end
+
+  class Repository
+    def self.register_repo(repo)
+      @repo = repo
+    end
+
+    def self.story
+      repo.story
+    end
+
+    def self.project
+      repo.project
+    end
+
+    def self.iteration
+      repo.iteration
+    end
+
+    def self.user
+      repo.user
+    end
+
+    def self.future_user
+      repo.future_user
+    end
+
+    def self.project_configuration
+      repo.project_configuration
+    end
+    
+    def self.change
+      repo.change
+    end
+
+    def self.member
+      repo.member
+    end
+
+    def self.repo
+      @repo
+    end
+  end
+end

data/lib/artisan/stories/pert_calculator.rb

@@ -0,0 +1,62 @@
+class Float
+  def round_to(x)
+    (self/x).round * x
+  end
+end
+
+module Artisan
+  module Stories
+    class PertCalculator
+      attr_reader :story, :estimate_mode
+
+      def initialize(story, estimate_mode = "stddev")
+        @story = story
+        @estimate_mode = estimate_mode
+      end
+
+      def weighted_mean
+        unrounded_weighted_mean.round_to(0.25)
+      end
+
+      def standard_deviation
+        unrounded_standard_deviation.round(2)
+      end
+
+      def variance
+        unrounded_variance.round(2)
+      end
+
+      def estimate
+        mean = unrounded_weighted_mean
+        mean += unrounded_standard_deviation * 2 if @estimate_mode.to_s != "mean"
+        return mean.round_to(0.25)
+      end
+
+      private
+
+      def unrounded_weighted_mean
+        (optimistic.to_f + 4 * realistic.to_f + pessimistic.to_f) / 6
+      end
+
+      def unrounded_standard_deviation
+        (pessimistic.to_f - optimistic.to_f)/6
+      end
+
+      def unrounded_variance
+        unrounded_standard_deviation ** 2
+      end
+
+      def optimistic
+        @story.optimistic
+      end
+
+      def realistic
+        @story.realistic
+      end
+
+      def pessimistic
+        @story.pessimistic
+      end
+    end
+  end
+end

data/lib/artisan/stories/stories_interactor.rb

@@ -0,0 +1,78 @@
+require "artisan/crud_strategy"
+require 'artisan/activity/story_auditor'
+require "artisan/stories/story_numberer"
+
+module Artisan
+  module Stories
+
+    def self.for(project_id, user = nil)
+      StoriesInteractor.new(project_id, user)
+    end
+
+    class StoriesInteractor
+      def initialize(project_id, user = nil)
+        @project = project_repository.find(project_id)
+        @user = user
+      end
+
+      def create(story_attributes, callbacks)
+        model = repository.create_for_project(@project, story_attributes)
+        set_story_number_for model
+        story = CrudStrategy.create(model, callbacks, repository)
+        Activity::StoryAuditor.created(story.id, @project.id, @user.id, story_attributes)
+        return story
+      end
+
+      def update(number, story_attributes, callbacks)
+        story = find(number)
+        original_attributes = story.attributes
+        story = CrudStrategy.update(story, story_attributes, @user, callbacks)
+
+        Activity::StoryAuditor.updated(story.id, @project.id, @user.id, original_attributes, story_attributes)
+      end
+
+      def delete(number)
+        story = find(number)
+        repository.delete(story)
+        Activity::StoryAuditor.deleted(story.id, @project.id, @user.id)
+      end
+
+      def backlog(filter_tag = nil)
+        backlog_stories = filtered(filter_tag, @project.stories.backlog)
+        return StoryCollection.new(backlog_stories)
+      end
+
+      def completed
+        @project.stories.complete
+      end
+
+      def find_by_iteration(iteration_number)
+        iteration = @project.iterations.find_by_number iteration_number
+        iteration.stories(:include => 'assigned_user')
+      end
+
+      def find(number)
+        repository.find(number, @project)
+      end
+
+    private
+
+      def filtered(filter_tag, stories)
+        return stories if filter_tag.nil?
+        return stories.tagged_with(filter_tag, :on => :tags)
+      end
+
+      def set_story_number_for story
+        story.update_attribute(:number, StoryNumberer.new(@project).next_story_number)
+      end
+
+      def repository
+        Repository.story
+      end
+
+      def project_repository
+        Repository.project
+      end
+    end
+  end
+end

data/lib/artisan/stories/story_collection.rb

@@ -0,0 +1,66 @@
+module Artisan
+  module Stories
+    class StoryCollection
+      include Enumerable
+
+      attr_reader :stories
+      alias :all :stories
+
+      def initialize(stories = [])
+        @stories = stories
+      end
+
+      def billable
+        select {|story| !story.nonbillable?}
+      end
+
+      def billed
+        select{|s| !s.nonbillable? && s.complete?}
+      end
+
+      def completed
+        select(&:complete?)
+      end
+
+      def incomplete
+        reject(&:complete?)
+      end
+
+      def billable_points
+        sum_estimates(billable)
+      end
+
+      def billed_points
+        sum_estimates(billed)
+      end
+
+      def estimated_points
+        sum_estimates(@stories)
+      end
+
+      alias :points :estimated_points
+      alias :total_points :estimated_points
+
+      def completed_points
+        sum_estimates(completed)
+      end
+
+      def all_complete?
+        all?(&:complete?)
+      end
+
+      def each(&block)
+        stories.each { |story| block.call(story) }
+      end
+
+      private
+
+      def sum_estimates(collection)
+        collection.inject(0.0) do |sum, story|
+          sum += story.estimate if story.estimate
+          sum
+        end
+      end
+    end
+  end
+end

data/lib/artisan/stories/story_exporter.rb

@@ -0,0 +1,45 @@
+module Artisan
+  module Stories
+    class StoryExporter
+
+      def initialize(story)
+        @story = story
+      end
+
+      def as_json(story_json = {}, options={})
+        options = {} unless options
+        options = neglect_created_at(options)
+
+        story_json = story_json
+
+        if @story.assigned_user
+          story_json["assigned_user"] = {
+            "full_name"    => @story.assigned_user.full_name,
+            "gravatar_url" => @story.assigned_user.gravatar_url
+          }
+        end
+
+        story_json["assigned_user_options"] = @story.project.users.inject({}) do |collection, user|
+          collection[user.full_name] = user.id
+          collection
+        end if @story.project
+
+        story_json["created_at"] = @story.created_at.strftime("%m/%d/%Y") if !@story.created_at.nil?
+        story_json["creator"] = @story.creator.full_name if @story.creator
+        story_json["tag_list"] = @story.tag_list.join(",")
+        story_json
+      end
+
+      private
+
+      def neglect_created_at(options)
+        if options[:except]
+          options[:except] += [:created_at]
+        else
+          options[:except] = [:created_at]
+        end
+        options
+      end
+    end
+  end
+end