houston-core 0.5.0.beta1

data/app/models/testing_note.rb

@@ -0,0 +1,64 @@
+class TestingNote < ActiveRecord::Base
+  
+  before_create  :create_ticket_comment!
+  before_update  :update_ticket_comment!
+  before_destroy :destroy_ticket_comment!
+  after_create { Houston.observer.fire "testing_note:create", self }
+  after_update { Houston.observer.fire "testing_note:update", self }
+  after_save   { Houston.observer.fire "testing_note:save", self }
+  
+  belongs_to :user
+  belongs_to :ticket
+  belongs_to :project
+  
+  VERDICTS = %w{works fails badticket none}
+  
+  validates :user, :presence => true
+  validates :ticket, :presence => true
+  validates :project, :presence => true
+  validates :comment, :presence => true, :length => 1..1000
+  validates :verdict, :presence => true, :inclusion => VERDICTS
+  
+  
+  
+  def to_comment
+    TicketComment.new(
+      user: user,
+      body: "**#{verdict}** #{comment}",
+      remote_id: remote_id )
+  end
+  
+  
+  
+  def pass?
+    verdict == "works"
+  end
+  
+  def fail?
+    verdict == "fails"
+  end
+  
+  def first_fail?
+    return false unless fail?
+    first_fail = ticket.testing_notes_since_last_release.where(verdict: "fails").order("created_at ASC").first
+    first_fail == nil || first_fail.id == self.id
+  end
+  
+  
+  
+private
+  
+  def create_ticket_comment!
+    remote_id = ticket.create_comment!(to_comment)
+    self.remote_id = remote_id
+  end
+  
+  def update_ticket_comment!
+    ticket.update_comment!(to_comment)
+  end
+  
+  def destroy_ticket_comment!
+    ticket.destroy_comment!(to_comment)
+  end
+  
+end

data/app/models/ticket.rb

@@ -0,0 +1,368 @@
+class Ticket < ActiveRecord::Base
+  extend Nosync
+  
+  self.inheritance_column = nil
+  
+  versioned only: [:summary, :description, :type,
+                   :tags, :antecedents, :prerequisites,
+                   :closed_at, :resolution, :milestone_id]
+  
+  belongs_to :project
+  belongs_to :reporter, class_name: "User"
+  belongs_to :milestone, counter_cache: true
+  has_many :testing_notes
+  has_many :tasks, validate: false
+  has_and_belongs_to_many :releases
+  has_and_belongs_to_many :commits, -> { where(unreachable: false) }
+  has_and_belongs_to_many :released_commits, -> { reachable.released }, class_name: "Commit", association_foreign_key: "commit_id"
+  
+  default_scope { order(:number).where(destroyed_at: nil) }
+  
+  validates :project_id, presence: true
+  validates :summary, presence: true
+  validates :number, presence: true
+  validates :priority, inclusion: { in: %w{low normal high} }
+  validates :type, presence: true, inclusion: { in: Houston.config.ticket_types, message: "\"%{value}\" is unknown. It must be #{Houston.config.ticket_types.to_sentence(last_word_connector: ", or ")}" }
+  validate :must_have_at_least_one_task
+  validates_uniqueness_of :number, scope: :project_id, on: :create
+  
+  before_validation :ensure_that_ticket_has_a_task, on: :create
+  before_save :parse_ticket_description, if: :description_changed?
+  before_save :find_reporter, if: :find_reporter?
+  after_save :propagate_milestone_change, if: :milestone_id_changed?
+  after_save :resolve_antecedents!, if: :just_resolved?
+  after_save :close_antecedents!, if: :just_closed?
+  after_save :updated_milestone_attributes
+  
+  attr_readonly :number, :project_id
+  
+  delegate :testers, :maintainers, :min_passing_verdicts, :ticket_tracker, to: :project
+  delegate :nosync?, to: "self.class"
+  
+  
+  
+  class << self
+    
+    def for_projects(*projects)
+      ids = projects.flatten.map { |project| project.is_a?(Project) ? project.id : project }
+      where(project_id: ids)
+    end
+    alias :for_project :for_projects
+    
+    def mentioned_by_commits(*commits)
+      ids = commits.flatten.map { |commit| commit.is_a?(Commit) ? commit.id : commit }
+      commits_tickets = Arel::Table.new("commits_tickets")
+      where arel_table[:id].in(commits_tickets
+        .where(commits_tickets[:commit_id].in(ids))
+        .project(commits_tickets[:ticket_id]))
+    end
+    
+    def numbered(*numbers)
+      where(number: numbers.flatten.map(&:to_i))
+    end
+    
+    def without(tickets)
+      not_numbered(tickets.map(&:number))
+    end
+    
+    def not_numbered(*numbers)
+      where(arel_table[:number].not_in(numbers.flatten.map(&:to_i)))
+    end
+    
+    def ideas
+      where(type: %w{Feature Enhancement})
+    end
+    
+    def bugs
+      where(type: %w{Bug Chore})
+    end
+    
+    def unresolved
+      unclosed.where(resolution: "")
+    end
+    
+    def resolved
+      where(arel_table[:resolution].not_eq(""))
+    end
+    
+    def fixed
+      where(resolution: "fixed")
+    end
+    
+    def unclosed
+      where(closed_at: nil)
+    end
+    alias :open :unclosed
+    
+    def closed
+      where(arel_table[:closed_at].not_eq(nil))
+    end
+    
+    def created_before(time)
+      where(arel_table[:created_at].lt(time)).reorder(arel_table[:created_at].desc)
+    end
+    
+    def closed_before(time)
+      where(arel_table[:closed_at].lt(time)).reorder(arel_table[:closed_at].desc)
+    end
+    
+    def closed_on(date)
+      where(closed_at: date.to_time.beginning_of_day..date.to_time.end_of_day)
+    end
+    
+    def deployed
+      where(arel_table[:deployment].not_eq(nil))
+    end
+    
+    def deployed_to(environment)
+      where(deployment: environment)
+    end
+    
+    def unreleased
+      where(arel_table[:deployment].not_eq("Production"))
+    end
+    
+    def estimated
+      # !todo: will change: must be defined in terms of tasks
+      where("NULLIF(tickets.extended_attributes->'estimated_effort', '')::numeric > 0")
+    end
+    
+    def unestimated
+      # !todo: will change: must be defined in terms of tasks
+      where("NOT defined(tickets.extended_attributes, 'estimated_effort') OR NULLIF(tickets.extended_attributes->'estimated_effort', '')::numeric <= 0")
+    end
+    
+    def resolve_all!
+      return unless Rails.env.production?
+      all.parallel.each do |ticket|
+        Houston.try 3, exceptions_matching(/connection reset by peer/i) do
+          ticket.resolve!
+        end
+      end
+    end
+    
+  end
+  
+  
+  
+  def due_date
+    extended_attributes["due_date"]
+  end
+  
+  def due_date=(value)
+    extended_attributes["due_date"] = value
+    extended_attributes_will_change!
+  end
+  
+  
+  
+  def reporter_email=(value)
+    value = value.downcase if value
+    super(value)
+  end
+  
+  
+  
+  def committers
+    commits.map { |commit| TicketCommitter.new(commit.committer, commit.committer_email) }.uniq
+  end
+  
+  
+  
+  def ticket_tracker_ticket_url
+    project.ticket_tracker_ticket_url(number)
+  end
+  
+  
+  
+  def unresolved?
+    resolution.blank?
+  end
+  
+  def resolved?
+    !resolution.blank?
+  end
+  
+  def open?
+    closed_at.nil?
+  end
+  
+  def closed?
+    closed_at.present?
+  end
+  
+  def in_development?
+    deployment.blank?
+  end
+  
+  def unreleased?
+    releases.before(reopened_at).empty?
+  end
+  
+  
+  
+  def antecedents
+    (super || []).map { |s| TicketAntecedent.from_s(self, s) }
+  end
+  
+  def antecedents=(antecedents)
+    super Array(antecedents).map(&:to_s)
+  end
+  
+  
+  
+  def tags
+    (super || []).map(&TicketTag.method(:from_s))
+  end
+  
+  def tags=(tags)
+    super (tags || []).map(&:to_s)
+  end
+  
+  
+  
+  def extended_attributes
+    super || (self.extended_attributes = {})
+  end
+  
+  
+  
+  def commit_time
+    @commit_time ||= commits.map(&:committer_hours).compact.sum
+  end
+  
+  def effort
+    @effort ||= tasks.map(&:effort).sum
+  end
+  
+  
+  
+  def create_comment!(comment)
+    remote.create_comment!(comment) if remote.respond_to?(:create_comment!)
+  end
+  
+  def update_comment!(comment)
+    remote.update_comment!(comment) if remote.respond_to?(:update_comment!)
+  end
+  
+  def destroy_comment!(comment)
+    remote.destroy_comment!(comment) if remote.respond_to?(:destroy_comment!)
+  end
+  
+  
+  
+  def released!(release)
+    cache_release_attributes(release)
+    Houston.observer.fire "ticket:release", self, release
+  end
+  
+  def resolve!
+    remote_ticket.resolve! if remote_ticket.respond_to?(:resolve!)
+    update_attribute :resolution, "fixed"
+  end
+  
+  def close!
+    remote_ticket.close! if remote_ticket
+    update_attribute :closed_at, Time.now
+  end
+  
+  def unclose!
+    remote_ticket.reopen! if remote_ticket
+    update_attribute :closed_at, nil
+  end
+  
+  def reopen!
+    return unless resolved?
+    remote_ticket.reopen! if remote_ticket
+
+    update_attributes(
+      resolution: "",
+      closed_at: nil,
+      reopened_at: Time.now, # <-- !todo: get rid of this after introducing tasks
+
+      deployment: nil, # <-- !todo: is this necessary?
+      first_release_at: nil,
+      last_release_at: nil)
+  end
+  
+  
+  
+  def testing_notes_since_last_release
+    last_release_at ? testing_notes.where(["created_at > ?", last_release_at]) : testing_notes
+  end
+  
+  
+  
+  def participants
+    @participants ||= begin              # Participants in a Ticket include:
+      User.unretired.where(id:           #
+        Array(reporter_id) +             #   - its reporter
+        testing_notes.pluck(:user_id) +  #   - anyone who has commented on it
+        releases.pluck(:user_id)) +      #   - anyone who has released it
+        committers                       #   - anyone who has comitted to it
+    end                                  #
+  end
+  
+  
+  
+private
+  
+  def find_reporter?
+    reporter_email_changed? or (reporter_email.present? and reporter_id.nil?)
+  end
+  
+  def find_reporter
+    self.reporter = User.with_email_address(reporter_email).first
+  end
+  
+  def propagate_milestone_change
+    return if nosync?
+    remote_ticket.set_milestone!(milestone && milestone.remote_id) if remote_ticket.respond_to?(:set_milestone!)
+  end
+  
+  def just_resolved?
+    resolution_changed? && resolution_was.blank?
+  end
+  
+  def just_closed?
+    closed_at_changed? && closed_at_was.nil?
+  end
+  
+  def resolve_antecedents!
+    antecedents.each(&:resolve!)
+  end
+  
+  def close_antecedents!
+    antecedents.each(&:close!)
+  end
+  
+  def remote_ticket
+    @remote_ticket ||= ticket_tracker.find_ticket_by_number(number)
+  end
+  alias :remote :remote_ticket
+  
+  def cache_release_attributes(release)
+    attributes = { last_release_at: release.created_at, deployment: release.environment_name }
+    attributes.merge!(first_release_at: release.created_at) if unreleased?
+    update_attributes attributes
+  end
+  
+  def parse_ticket_description
+    Houston.config.parse_ticket_description(self)
+  end
+  
+  def ensure_that_ticket_has_a_task
+    tasks.build if tasks.none?
+  end
+  
+  def must_have_at_least_one_task
+    errors.add :base, "must have at least one task" if tasks.length.zero?
+  end
+  
+  def updated_milestone_attributes
+    return unless milestone_id
+    return unless new_record? or closed_at_changed?
+    milestone.update_closed_tickets_count!
+  end
+  
+end

data/app/models/ticket_antecedent.rb

@@ -0,0 +1,39 @@
+class TicketAntecedent
+  include Comparable
+  
+  def initialize(ticket_or_commit, kind, id)
+    @ticket_or_commit = ticket_or_commit
+    @kind = kind
+    @id = id
+  end
+  
+  attr_reader :ticket_or_commit, :kind, :id
+  delegate :project, to: :ticket_or_commit
+  
+  def self.from_s(ticket, string)
+    new ticket, *string.split(":")
+  end
+  
+  def to_s
+    "#{kind}:#{id}"
+  end
+  
+  def <=>(other)
+    [kind, id] <=> [other.kind, other.id]
+  end
+  
+  
+  
+  def released!(release=nil)
+    Houston.observer.fire "antecedent:#{kind.downcase.underscore}:released", self
+  end
+  
+  def resolve!
+    Houston.observer.fire "antecedent:#{kind.downcase.underscore}:resolved", self
+  end
+  
+  def close!
+    Houston.observer.fire "antecedent:#{kind.downcase.underscore}:closed", self
+  end
+  
+end