houston-core 0.5.0.beta1 → 0.5.0

data/app/models/github/pull_request.rb

@@ -3,6 +3,7 @@ module Github
     self.table_name = "pull_requests"
 
     attr_readonly :project_id, :user_id, :repo, :number, :username, :base_ref, :base_sha, :url
+    attr_accessor :actor
 
     belongs_to :project
     belongs_to :user
@@ -10,7 +11,7 @@ module Github
 
     before_validation :associate_project_with_self, if: :repo_changed?
     before_save :associate_user_with_self, if: :username_changed?
-    after_commit :associate_commits_with_self, if: :head_sha_changed?
+    after_commit :associate_commits_with_self, autosave: false
 
     after_destroy { Houston.observer.fire "github:pull:closed", self }
     after_create { Houston.observer.fire "github:pull:opened", self }
@@ -18,6 +19,7 @@ module Github
 
     validates :project_id, :title, :number, :repo, :url, :base_ref, :base_sha, :head_ref, :head_sha,
       presence: true
+    validates :number, uniqueness: { scope: :project_id }
 
     class << self
       def fetch!
@@ -49,7 +51,7 @@ module Github
 
           # Create or Update existing pulls
           expected_pulls.map do |expected_pr|
-            existing_pr = existing_pulls.detect { |existing_pr| 
+            existing_pr = existing_pulls.detect { |existing_pr|
               expected_pr["base"]["repo"]["name"] == existing_pr.repo &&
               expected_pr["number"] == existing_pr.number }
 
@@ -61,19 +63,34 @@ module Github
         end
       end
 
-      def close!(github_pr)
+      def close!(github_pr, options={})
         pr = find_by(
           repo: github_pr["base"]["repo"]["name"],
           number: github_pr["number"])
-        pr.destroy if pr
+        return unless pr
+
+        pr.actor = options[:as]
+        pr.destroy
       end
 
-      def upsert!(github_pr)
+      def upsert!(github_pr, options={})
+        retry_count ||= 0
+        upsert(github_pr).tap do |pr|
+          if pr.valid?
+            pr.actor = options[:as]
+            pr.save
+          end
+        end
+      rescue ActiveRecord::RecordNotUnique
+        retry unless (retry_count += 1) > 1
+        raise
+      end
+
+      def upsert(github_pr)
         Github::PullRequest.find_or_initialize_by(
           repo: github_pr["base"]["repo"]["name"],
           number: github_pr["number"])
           .merge_attributes(github_pr)
-          .tap { |pr| pr.save if pr.valid? }
       end
     end
 
@@ -87,12 +104,18 @@ module Github
       super Array(value).uniq.join("\n")
     end
 
-    def add_label!(label)
-      update_attribute :labels, labels + [label]
+    def add_label!(label, options={})
+      transaction do
+        pr = self.class.lock.find id
+        pr.update_attributes! labels: pr.labels + [label], actor: options[:as]
+      end
     end
 
-    def remove_label!(label)
-      update_attribute :labels, labels - [label]
+    def remove_label!(label, options={})
+      transaction do
+        pr = self.class.lock.find id
+        pr.update_attributes! labels: pr.labels - [label], actor: options[:as]
+      end
     end
 
 
@@ -100,7 +123,7 @@ module Github
     def merge_attributes(pr)
       if new_record?
         self.repo = pr["base"]["repo"]["name"]
-        self.number = pr["number"] 
+        self.number = pr["number"]
         self.username = pr["user"]["login"]
         self.url = pr["html_url"]
         self.base_sha = pr["base"]["sha"]
@@ -126,7 +149,7 @@ module Github
     end
 
     def associate_commits_with_self
-      self.commits = project.commits.between(base_sha, head_sha) if project
+      self.commits = project.commits.between(base_sha, head_sha)
     end
 
   end

data/app/models/github/pull_request_event.rb

@@ -2,13 +2,14 @@ require "github/event"
 
 module Github
   class PullRequestEvent < Event
-    attr_reader :action, :pull_request
+    attr_reader :action, :pull_request, :actor
 
     # https://developer.github.com/v3/activity/events/types/#pullrequestevent
     def initialize(payload)
       super
       @action = payload.fetch "action"
       @pull_request = payload.fetch "pull_request"
+      @actor = payload.fetch("sender", {})["login"]
     end
 
     def process!
@@ -21,21 +22,21 @@ module Github
 
       # Delete pull requests when they are closed
       if action == "closed"
-        PullRequest.close! pull_request
+        PullRequest.close! pull_request, as: actor
         return
       end
 
       # Ensure that we have a record of this open pull request
       # action: labeled, unlabeled, opened, reopened, or synchronized
-      pr = PullRequest.upsert! pull_request
+      pr = PullRequest.upsert! pull_request, as: actor
 
       # The Pull Request may be invalid if it isn't for a
       # project that exists in Houston.
       return unless pr && pr.persisted?
 
       case action
-      when "labeled" then pr.add_label! payload["label"]["name"]
-      when "unlabeled" then pr.remove_label! payload["label"]["name"]
+      when "labeled" then pr.add_label! payload["label"]["name"], as: actor
+      when "unlabeled" then pr.remove_label! payload["label"]["name"], as: actor
       end
     end
 

data/app/models/github_token.rb

@@ -1,8 +1,8 @@
 class GithubToken < Oauth2Token
-  
+
   # skip refresh!
   def ensure_access
     self.class.find_or_create_from_access_token user, self
   end
-  
+
 end

data/app/models/historical_head.rb

@@ -1,5 +1,5 @@
 class HistoricalHead < ActiveRecord::Base
-  
+
   belongs_to :project
-  
+
 end

data/app/models/key_dependency.rb

@@ -1,45 +1,45 @@
 class KeyDependency
-  
-  
+
+
   def initialize(attributes={})
     @slug = attributes[:slug]
     @name = attributes.fetch(:as, @slug.titleize)
     @target_versions = attributes.fetch(:target_versions, []).map(&Gem::Version.method(:new))
   end
-  
-  
-  
+
+
+
   attr_reader :slug, :name, :target_versions
-  
+
   def versions
     @versions ||= KeyDependency.versions_for(self)
   end
-  
+
   def latest_version
     versions.first
   end
-  
+
   def to_s
     slug
   end
-  
-  
-  
+
+
+
   def self.all
     @dependency_versions ||= Houston.config.key_dependencies.map do |dependency|
       KeyDependency.new(dependency)
     end
   end
-  
-  
-  
+
+
+
   def self.versions_for(dependency)
-    
+
     # Right now the only supported dependencies are Ruby Gems
     # In the future, as other kinds of dependencies are supported,
     # we'll support different adapters to fetch their version info
     Rubygems::Gem.new(dependency.slug).versions
   end
-  
-  
+
+
 end

data/app/models/maintenance_light.rb

@@ -1,12 +1,12 @@
 class MaintenanceLight
-  
+
   def initialize(dependency, color, message)
     @version = dependency.version
     @dependency_name = dependency.name
     @color = color
     @message = message
   end
-  
+
   attr_reader :version, :dependency_name, :color, :message
-  
+
 end

data/app/models/measurement.rb

@@ -1,61 +1,61 @@
 class Measurement < ActiveRecord::Base
-  
+
   belongs_to :subject, polymorphic: true
-  
+
   validates :name, :value, :taken_at, presence: true
   validates :name, length: { maximum: 50 }
-  
+
   default_scope -> { order(arel_table[:taken_at].desc) }
-  
+
   class << self
     def take!(attributes)
       required_keys = [:subject_type, :subject_id, :taken_at, :name].freeze
-      
+
       identifying_attributes = attributes.pick(required_keys)
       subject = attributes[:subject]
       identifying_attributes.merge!(subject_type: subject.class.name, subject_id: subject.id) if subject
       identifying_attributes.reverse_merge!(subject_type: nil, subject_id: nil)
-      
+
       required_keys.each do |key|
         raise ArgumentError, "#{key.inspect} is required to take a measurement" unless identifying_attributes.key?(key)
       end
-      
+
       find_or_initialize_by(identifying_attributes).tap do |measurement|
         measurement.value = attributes[:value]
         measurement.save!
       end
     end
-    
+
     def taken_at(time)
       where(taken_at: time)
     end
-    
+
     def taken_on(date)
       where(taken_on: date)
     end
-    
+
     def taken_before(date)
       where(arel_table[:taken_on].lteq(date))
     end
-    
+
     def taken_after(date)
       where(arel_table[:taken_on].gteq(date))
     end
     alias :taken_since :taken_after
-    
+
     def taken_between(date0, date1)
       taken_after(date0).taken_before(date1)
     end
-    
+
     def for(subject)
       return where(subject_type: nil, subject_id: nil) if subject.nil?
       where(subject_type: subject.class.name, subject_id: subject.id)
     end
-    
+
     def global
       self.for(nil)
     end
-    
+
     # Valid identifies for names
     #  - weekly.hours.charged
     #  - weekly.hours.charged.*
@@ -69,21 +69,21 @@ class Measurement < ActiveRecord::Base
         .gsub(/\*$/, "%") }
       where(["name SIMILAR TO ?", "(#{name_patterns.join("|")})"])
     end
-    
+
     def total
       pluck(:value).inject(0) { |sum, value| sum + value.to_d }
     end
-    
+
     def value
       limit(1).pluck(:value)[0]
     end
-    
+
     def mean
       denominator = count
       return nil if denominator.zero?
       total.to_f / denominator
     end
-    
+
     def debug(colored: true)
       format_subject = ->(s) { s.is_a?(User) ? s.first_name : s.is_a?(Project) ? s.slug : "" }
       includes(:subject).reorder("taken_at ASC, subject_type ASC, subject_id ASC, name ASC").map { |m|
@@ -97,14 +97,14 @@ class Measurement < ActiveRecord::Base
         line }.join("\n")
     end
   end
-  
+
   def taken_at=(value)
     super
     self.taken_on = value && value.to_date
   end
-  
+
   def taken_on?(date)
     taken_on == date
   end
-  
+
 end

data/app/models/menu_item.rb

@@ -1,19 +1,19 @@
 class MenuItem
   include ERB::Util
-  
+
   def initialize(name, href)
     @name = name
     @href = href
   end
-  
+
   attr_reader :href
-  
+
   def display
     h @name
   end
-  
+
   def to_html
     "<li><a href=\"#{href}\">#{display}</a></li>".html_safe
   end
-  
+
 end

data/app/models/menu_item_divider.rb

@@ -3,7 +3,7 @@ class MenuItemDivider < MenuItem
   def initialize
     super("", "")
   end
-  
+
   def to_html
     "<li class=\"divider\"></li>"
   end

data/app/models/milestone.rb

@@ -1,106 +1,106 @@
 class Milestone < ActiveRecord::Base
   extend Nosync
-  
+
   belongs_to :project
   has_many :tickets, -> { reorder("NULLIF(tickets.extended_attributes->'milestoneSequence', '')::int") }
-  
+
   versioned only: [:name, :start_date, :end_date, :band, :lanes], class_name: "MilestoneVersion", initial_version: true
-  
+
   default_scope { where(destroyed_at: nil).order(:start_date) }
-  
+
   validates :project_id, presence: true
   validates :name, presence: true, uniqueness: {scope: :project_id}
-  
+
   after_save :propagate_name_change, if: :name_changed?
-  
+
   delegate :ticket_tracker, to: :project
   delegate :nosync?, to: "self.class"
-  
+
   class << self
     def empty
       where(tickets_count: 0)
     end
-    
+
     def populated
       where(arel_table[:tickets_count].gt(0))
     end
-    
+
     def completed
       where(
         arel_table[:tickets_count].gt(0).and(
         arel_table[:closed_tickets_count].eq(arel_table[:tickets_count])))
     end
-    
+
     def uncompleted
       where(
         arel_table[:tickets_count].eq(0).or(
         arel_table[:closed_tickets_count].lt(arel_table[:tickets_count])))
     end
     alias :open :uncompleted
-    
+
     def visible
       where(arel_table[:start_date].not_eq(nil)).
       where(arel_table[:end_date].not_eq(nil))
     end
-    
+
     def current
       during(Date.today..Date.today)
     end
-    
+
     def during(range)
       visible
         .where(arel_table[:start_date].lteq(range.end))
         .where(arel_table[:end_date].gteq(range.begin))
     end
-    
+
     def without(milestones)
       without_remote_ids(milestones.map(&:remote_id))
     end
-    
+
     def without_remote_ids(*ids)
       where(arel_table[:remote_id].not_in(ids.flatten.map(&:to_i)))
     end
-    
+
     def remote_id_map
       query = select("remote_id, id").to_sql
       connection.select_rows(query).each_with_object({}) { |(remote_id, id), map| map[remote_id.to_i] = id.to_i }
     end
-    
+
     def id_for_remote_id(remote_id)
       return nil if remote_id.nil? or remote_id == 0
       where(remote_id: remote_id).pluck(:id).first
     end
   end
-  
-  
-  
+
+
+
   def completed?
     tickets_count > 0 && closed_tickets_count == tickets_count
   end
-  
+
   def uncompleted?
     !completed?
   end
-  
+
   def close!
     project.ticket_tracker.close_milestone!(self) if project.ticket_tracker.respond_to?(:close_milestone!)
     touch :completed_at
   end
-  
+
   def remote_milestone
     @remote_milestone ||= ticket_tracker.find_milestone(remote_id) if ticket_tracker.respond_to?(:find_milestone)
   end
   alias :remote :remote_milestone
-  
+
   def update_closed_tickets_count!
     update_column :closed_tickets_count, tickets.closed.count
   end
-  
+
 private
-  
+
   def propagate_name_change
     return if nosync?
     remote_milestone.update_name!(name) if remote_milestone.respond_to?(:update_name!)
   end
-  
+
 end

data/app/models/output_stream.rb

@@ -1,12 +1,12 @@
 require "thread_safe"
 
 class OutputStream
-  
+
   def initialize(deploy)
     @deploy = deploy
     @lines = ThreadSafe::Array.new
   end
-  
+
   def <<(value)
     @lines.push(value)
     begin
@@ -18,9 +18,9 @@ class OutputStream
     end
     self
   end
-  
+
   def to_s
     @lines.join
   end
-  
+
 end

data/app/models/post_receive_payload.rb

@@ -1,30 +1,30 @@
 class PostReceivePayload
-  
+
   def initialize(params)
     parse_params(params)
   end
-  
+
   attr_accessor :agent_email, :commit, :branch
-  
+
   def parsed?
     commit.present?
   end
-  
+
   def parse_params(params)
     (params = MultiJson.load(params["payload"])) if params.key?("payload")
     parse_github_style_params(params) if params
   end
-  
+
   def parse_github_style_params(params)
     self.commit = params["after"]
     self.agent_email = parse_github_style_agent(params["pusher"])
     self.branch = params["ref"].split("/").last if params.key?("ref")
   end
-  
+
   def parse_github_style_agent(pusher)
     return nil unless pusher && pusher.key?("email")
     return pusher["email"] unless pusher.key?("name")
     "#{pusher["name"].inspect} <#{pusher["email"]}>"
   end
-  
+
 end