houston-core 0.5.0.beta1

data/app/models/ticket_comment.rb

@@ -0,0 +1,21 @@
+class TicketComment
+  
+  def initialize(attributes={})
+    @attributes = attributes
+  end
+  
+  attr_reader :attributes
+  
+  def user
+    attributes[:user]
+  end
+  
+  def remote_id
+    attributes[:remote_id]
+  end
+  
+  def body
+    attributes[:body]
+  end
+  
+end

data/app/models/ticket_committer.rb

@@ -0,0 +1,11 @@
+class TicketCommitter < Struct.new(:name, :email)
+  
+  def tester?
+    false
+  end
+  
+  def to_h
+    { name: name, email: email }
+  end
+  
+end

data/app/models/ticket_tag.rb

@@ -0,0 +1,25 @@
+class TicketTag
+  
+  def initialize(name, color)
+    @name = name
+    @color = color
+  end
+  
+  attr_reader :name, :color
+  
+  def self.from_s(string)
+    name, color = string.scan(/\[([^\]]+)\]\(([a-fA-F0-9]{6})\)/).flatten
+    name = string unless name
+    color = "e4e4e4" unless color
+    new(name, color)
+  end
+  
+  def to_s
+    "[#{name}](#{color})"
+  end
+  
+  def to_h
+    {name: name, color: color}
+  end
+  
+end

data/app/models/user.rb

@@ -0,0 +1,160 @@
+class User < ActiveRecord::Base
+  include Retirement
+  
+  has_many :testing_notes
+  has_many :roles, :dependent => :destroy
+  has_many :credentials, :class_name => "UserCredentials", :dependent => :destroy
+  has_many :consumer_tokens
+  has_many :tickets, foreign_key: "reporter_id"
+  has_and_belongs_to_many :commits
+  belongs_to :current_project, class_name: "Project"
+  
+  devise *Houston.config.devise_configuration
+  
+  default_scope { order("last_name, first_name") }
+  
+  default_value_for :role, Houston.config.default_role
+  
+  validates :first_name, :last_name, :email, :presence => true, :length => {:minimum => 2}
+  validates :role, presence: true, inclusion: {in: Houston.config.roles, message: "%{value} is not one of the configured roles (#{Houston.config.roles.join(", ")})"}
+  validate :all_email_addresses_must_be_unique
+  
+  
+  
+  Houston.config.project_roles.each do |role|
+    method_name = role.downcase.gsub(' ', '_')
+    collection_name = method_name.pluralize
+    
+    class_eval <<-RUBY
+    def self.#{collection_name}
+      Role.#{collection_name}.to_users
+    end
+    RUBY
+  end
+  
+  Houston.config.roles.each do |role|
+    method_name = role.downcase.gsub(' ', '_')
+    collection_name = method_name.pluralize
+    
+    class_eval <<-RUBY
+    def self.#{collection_name}
+      where(role: "#{role}")
+    end
+    
+    def #{method_name}?
+      role == "#{role}"
+    end
+    RUBY
+  end
+  
+  
+  def self.administrators
+    where(administrator: true)
+  end
+  
+  
+  def self.participants
+    Role.participants.to_users
+  end
+  
+  def self.with_primary_email(email)
+    email = email.downcase if email
+    where(email: email)
+  end
+  
+  def self.with_email_address(*email_addresses)
+    email_addresses = email_addresses.flatten.compact
+    return none if email_addresses.none?
+    values = email_addresses.map { |email| connection.quote(email.downcase) }.join(",")
+    where("ARRAY[\"email_addresses\"] && ARRAY[#{values}]")
+  end
+  
+  def self.find_by_email_address(email_address)
+    with_email_address(email_address).first
+  end
+  
+  def self.with_view_option(option, value)
+    where(["view_options->? = ?", option, value])
+  end
+  
+  
+  
+  def email=(value)
+    value = value.downcase if value
+    super(value)
+    self.email_addresses = [email] + alias_emails
+  end
+  
+  def email_addresses
+    super || []
+  end
+  
+  def alias_emails
+    email_addresses - [email]
+  end
+  
+  def alias_emails=(value)
+    self.email_addresses = [email] + Array.wrap(value)
+  end
+  
+  
+  
+  def name
+    "#{first_name} #{last_name}"
+  end
+  
+  def follows?(project)
+    roles.to_projects.member?(project)
+  end
+  
+  def followed_projects
+    roles.to_projects.unretired
+  end
+  
+  def view_options
+    super || {}
+  end
+  
+  
+  
+  # LDAP Overrides
+  # ------------------------------------------------------------------------- #
+  
+  def self.find_ldap_entry(ldap_connection, auth_key_value)
+    filter = Net::LDAP::Filter.eq(Houston::TMI::FIELD_USED_FOR_LDAP_LOGIN, auth_key_value)
+    ldap_connection.ldap.search(filter: filter).first
+  end
+  
+  def self.find_for_ldap_authentication(attributes, entry)
+    email = entry.mail.first.downcase
+    user = where(email: email).first
+    if user && user.username.nil?
+      user.update_column :username, entry[Houston::TMI::FIELD_USED_FOR_LDAP_LOGIN][0].to_s
+    end
+    user
+  end
+  
+  def self.create_from_ldap_entry(attributes, entry)
+    create!(
+      email: entry.mail.first.downcase,
+      username: entry[Houston::TMI::FIELD_USED_FOR_LDAP_LOGIN][0].to_s,
+      password: attributes[:password],
+      first_name: entry.givenname.first,
+      last_name: entry.sn.first )
+  end
+  
+  # ------------------------------------------------------------------------- #
+  
+  
+  
+private
+  
+  def all_email_addresses_must_be_unique
+    email_addresses.each do |email_address|
+      if User.where(User.arel_table[:id].not_eq(id)).with_email_address(email_address).any?
+        errors.add :base, "The email address \"#{email_address}\" is being used"
+      end
+    end
+  end
+  
+end

data/app/models/user_credentials.rb

@@ -0,0 +1,48 @@
+class UserCredentials < ActiveRecord::Base
+  
+  class MissingCredentials < RuntimeError; end
+  class InsufficientPermissions < RuntimeError; end
+  class InvalidCredentials < RuntimeError; end
+  class AccountLocked < RuntimeError; end
+  
+  encrypt_with_public_key :password, key_pair: Houston.config.keypair
+  
+  validate :test_connection
+  
+  belongs_to :user
+  
+  def self.for(service)
+    credentials = where(service: service).first || (raise MissingCredentials)
+    [credentials.login, credentials.password.decrypt(Houston.config.passphrase)]
+  rescue OpenSSL::PKey::RSAError
+    credentials.delete
+    raise MissingCredentials
+  end
+  
+  
+  
+  def test_connection
+    case service
+    when "Unfuddle" then test_unfuddle_connection
+    when "Github" then test_github_connection
+    else raise NotImplementedError, "The service #{service.inspect} is not recognized"
+    end
+  end
+  
+  def test_github_connection
+    password = self.password.decrypt(Houston.config.passphrase)
+    Octokit::Client.new(login: login, password: password).user
+  rescue Octokit::Forbidden
+    errors.add(:base, "Account locked")
+  rescue Octokit::Unauthorized
+    errors.add(:base, "Invalid credentials")
+  end
+  
+  def test_unfuddle_connection
+    password = self.password.decrypt(Houston.config.passphrase)
+    Unfuddle.with_config(username: login, password: password) { Unfuddle.instance.get("people/current") }
+  rescue Unfuddle::UnauthorizedError
+    errors.add(:base, "Invalid credentials")
+  end
+  
+end

data/app/models/value_statement.rb

@@ -0,0 +1,9 @@
+class ValueStatement < ActiveRecord::Base
+  
+  versioned initial_version: true, dependent: :tracking, only: [:text, :weight]
+  
+  belongs_to :project
+  validates :project_id, :weight, presence: true
+  validates :text, length: 2..36
+  
+end

data/app/presenters/commit_presenter.rb

@@ -0,0 +1,52 @@
+class CommitPresenter
+  include UrlHelper
+  
+  def initialize(commits)
+    @commits = OneOrMany.new(commits)
+  end
+  
+  def as_json(*args)
+    @commits.map(&method(:commit_to_json))
+  end
+  
+  def commit_to_json(commit)
+    hash = {
+      id: commit.id,
+      sha: commit.sha,
+      message: commit.summary,
+      project: commit.project.slug,
+      linkTo: github_commit_url(commit.project, commit.sha), # <-- !todo: more abstract
+      committer: {
+        name: commit.committer,
+        email: commit.committer_email } }
+    
+    release = commit.releases.earliest
+    if release
+      # NB: we want to sort these with TesterNotes
+      #     by the field 'createdAt', so while this
+      #     _actually_ represents 'releasedAt', we'll
+      #     call it 'createdAt' for now.
+      hash[:createdAt] = release.created_at
+      hash[:environment] = release.environment_name
+    end
+    hash
+  end
+  
+  def verbose
+    @commits.map do |commit|
+      commit_to_json(commit).merge({
+        tag: commit.tags.first,
+        hours: commit.hours_worked,
+        tickets: commit.ticket_numbers,
+        unreachable: commit.unreachable,
+        releases: commit.releases.map { |release| {
+          environment: release.environment_name,
+          createdAt: release.created_at } },
+        committers: commit.committers.map { |committer| {
+          id: committer.id,
+          email: committer.email,
+          name: committer.name } } })
+    end
+  end
+  
+end

data/app/presenters/full_ticket_presenter.rb

@@ -0,0 +1,78 @@
+class FullTicketPresenter < TicketPresenter
+
+  def ticket_to_json(ticket)
+    reporter = ticket.reporter
+    super.merge(
+      description: ticket.description,
+      changes: present_versions(ticket.tasks.versions.includes(:versioned) + ticket.versions),
+      tasks: ticket.tasks.map { |task| task.ticket = ticket; {
+        id: task.id,
+        description: task.description,
+        number: task.number,
+        letter: task.letter,
+        effort: task.effort } },
+      reporter: reporter && {
+        email: reporter.email,
+        name: reporter.name })
+  end
+
+private
+
+  def present_versions(versions)
+    versions.sort_by { |version| version.created_at }.reverse.map  { |version| {
+      time: version.created_at,
+      actor: present_version_actor(version.user),
+      description: present_version_description(version)
+    }}
+  end
+
+  def present_version_actor(actor)
+    case actor
+    when User then { name: actor.name, email: actor.email }
+    when String then { name: actor }
+    when nil then { name: "Unknown" }
+    else raise NotImplementedError, "I don't know how to handle an actor of class #{actor.class}"
+    end
+  end
+
+  def present_version_description(version)
+    if version.changes.empty?
+      "<b>added</b> a task: <em>#{version.versioned.letter}. #{version.versioned.description}</em>"
+    else
+      version.changes
+        .map { |attribute, change| present_version_change(version, attribute, change) }
+        .compact
+        .join("<br />")
+    end
+  end
+
+  def present_version_change(version, attribute, change)
+    case attribute
+    when "description" then "changed <b>Description</b>"
+    when "summary" then "changed <b>Summary</b> from <em>#{change[0]}</em> to <em>#{change[1]}</em>"
+    when "closed_at" then
+      if change[0] && !change[1]
+        "<b>reopened</b> the ticket"
+      elsif change[1] && !change[0]
+        "<b>closed</b> the ticket"
+      else
+        nil
+      end
+    when "effort" then
+      if change[0] && change[1]
+        if change[1] > change[0]
+          "increased the <b>Effort</b> of task <b>#{version.versioned.letter}.</b> from <em>#{change[0]}</em> to <em>#{change[1]}</em>"
+        else
+          "decreased the <b>Effort</b> of task <b>#{version.versioned.letter}.</b> from <em>#{change[0]}</em> to <em>#{change[1]}</em>"
+        end
+      elsif change[1]
+        "estimated the <b>Effort</b> of task <b>#{version.versioned.letter}.</b> at <em>#{change[1]}</em>"
+      elsif change[0]
+        "cleared the <b>Effort</b> of task <b>#{version.versioned.letter}.</b></em>"
+      end
+    else
+      "changed <b>#{attribute.titleize}</b>"
+    end
+  end
+
+end

data/app/presenters/one_or_many.rb

@@ -0,0 +1,22 @@
+class OneOrMany < SimpleDelegator
+  
+  delegate :is_a?, to: :__getobj__
+  
+  def map(&block)
+    if __getobj__.respond_to?(:map)
+      __getobj__.map(&block)
+    else
+      yield __getobj__
+    end
+  end
+  
+  def select(&block)
+    if __getobj__.respond_to?(:select)
+      __getobj__.select(&block)
+    else
+      return [] unless yield __getobj__
+      self
+    end
+  end
+  
+end

data/app/presenters/problem_presenter.rb

@@ -0,0 +1,49 @@
+class ProblemPresenter
+  include ActionView::Helpers::DateHelper
+  include CommitHelper
+  
+  attr_reader :project, :problems
+  
+  def initialize(project, problems)
+    @project = project
+    @problems = problems
+  end
+  
+  def as_json(*args)
+    Houston.benchmark "[problem_presenter] Prepare JSON" do
+      @problems.map(&method(:problem_to_json))
+    end
+  end
+  
+  def problem_to_json(problem)
+    { id: problem.id,
+      ticketId: problem.ticket.try(:id),
+      ticketUrl: (@project.ticket_tracker.ticket_url(problem.ticket) if problem.ticket),
+      ticketNumber: problem.ticket.try(:number),
+      token: problem.err_ids.first,
+      url: problem.url,
+      message: problem.message,
+      where: problem.where,
+      noticesCount: problem.notices_count,
+      comments: problem.comments,
+      
+      firstNotice: present_notice(problem.first_notice_at, problem.first_notice_commit, problem.first_notice_environment),
+      lastNotice:  present_notice( problem.last_notice_at,  problem.last_notice_commit,  problem.last_notice_environment) }
+  end
+  
+  def present_notice(time, sha, environment_name)
+    { at: time,
+      ago: distance_of_time_in_words(time, Time.now).gsub("about ", "") + " ago",
+      commit: (format_sha(sha) unless sha.blank?),
+      commitUrl: (project.repo.commit_url(sha) if project.repo.respond_to?(:commit_url)),
+      release: present_release(sha, environment_name) }
+  end
+  
+  def present_release(sha, environment_name)
+    release = @project.releases.where(["LOWER(environment_name) = ?", environment_name.downcase]).find_by_commit1(sha) if environment_name && !sha.blank?
+    { url: "/projects/#{@project.slug}/environments/#{environment_name}/releases/#{release.id}",
+      at: release.created_at.strftime("%b %d"),
+      environment: environment_name.humanize } if release
+  end
+  
+end