houston-core 0.5.0.beta1

data/app/adapters/houston/adapters/ticket_tracker/unfuddle_adapter/milestone.rb

@@ -0,0 +1,42 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      class UnfuddleAdapter
+        class Milestone
+          
+          
+          def initialize(connection, attributes)
+            @connection       = connection
+            @raw_attributes   = attributes
+            @remote_id        = attributes["id"]
+            @name             = attributes["title"]
+          end
+          
+          attr_reader :raw_attributes,
+                      :remote_id,
+                      :name
+          
+          def attributes
+            { remote_id:      remote_id,
+              name:           name }
+          end
+          
+          
+          def update_name!(name)
+            Houston.benchmark title: "Update Unfuddle Milestone" do
+              milestone = ::Unfuddle::Milestone.new(raw_attributes)
+              milestone.update_attribute("title", name)
+            end
+          end
+          
+          
+        private
+          
+          attr_reader :connection
+          alias :unfuddle :connection
+          
+        end
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/ticket_tracker/unfuddle_adapter/ticket.rb

@@ -0,0 +1,240 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      class UnfuddleAdapter
+        class Ticket
+          
+          
+          
+          def initialize(connection, attributes)
+            @connection       = connection
+            @raw_attributes   = attributes
+            @severity         = get_severity_name(attributes["severity_id"]) if attributes["severity_id"]
+            @component        = get_component_name(attributes["component_id"]) if attributes["component_id"]
+            
+            # required
+            @remote_id        = attributes["id"]
+            @number           = attributes["number"]
+            @summary          = attributes["summary"]
+            @description      = attributes["description"]
+            @reporter_email   = attributes["reporter_email"]
+            @resolution       = attributes["resolution"]
+            @milestone_id     = attributes["milestone_id"]
+            @type             = get_type
+            @created_at       = Time.parse(attributes["created_at"]) if attributes["created_at"]
+            @closed_at        = Time.parse(attributes["closed_on"]) if attributes["closed_on"]
+            
+            # optional
+            @tags             = get_tags
+            @prerequisites    = parse_prerequisites(attributes["associations"])
+            @due_date         = attributes["due_on"]
+          end
+          
+          attr_reader :raw_attributes,
+                      
+                      :remote_id,
+                      :number,
+                      :summary,
+                      :description,
+                      :reporter_email,
+                      :resolution,
+                      :milestone_id,
+                      :type,
+                      :created_at,
+                      :closed_at,
+                      
+                      :tags,
+                      :prerequisites,
+                      :severity,
+                      :component,
+                      :due_date
+          
+          def attributes
+            { remote_id:      remote_id,
+              number:         number,
+              summary:        summary,
+              description:    description,
+              reporter_email: reporter_email,
+              resolution:     resolution,
+              milestone_id:   milestone_id,
+              type:           type,
+              created_at:     created_at,
+              closed_at:      closed_at,
+              
+              tags:           tags,
+              prerequisites:  prerequisites,
+              due_date:       due_date }
+          end
+          
+          
+          
+          def resolve!
+            unless %w{resolved closed}.member? @raw_attributes["status"].to_s.downcase
+              Houston.benchmark title: "Resolve Unfuddle Ticket" do
+                ticket = unfuddle.ticket(remote_id)
+                ticket.update_attributes!("status" => "Resolved", "resolution" => "fixed")
+              end
+            end
+          end
+          
+          def close!
+            Houston.benchmark title: "Close Unfuddle Ticket" do
+              ticket = unfuddle.ticket(remote_id)
+              ticket.update_attributes!("status" => "closed")
+            end
+          end
+          
+          def reopen!
+            unless %w{closed}.member? @raw_attributes["status"].to_s.downcase
+              Houston.benchmark title: "Reopen Unfuddle Ticket" do
+                ticket = unfuddle.ticket(remote_id)
+                ticket.update_attributes!("status" => "Reopened", "resolution" => "")
+              end
+            end
+          end
+          
+          
+          
+          def set_milestone!(milestone_id)
+            Houston.benchmark title: "Update Unfuddle Ticket" do
+              ticket = unfuddle.ticket(remote_id)
+              ticket.update_attribute("milestone_id", milestone_id || 0)
+            end
+          end
+          
+          
+          
+          def create_comment!(comment)
+            Houston.benchmark title: "Create Unfuddle Comment" do
+              unfuddle.as_user(comment.user) do
+                ticket = unfuddle.ticket(remote_id)
+                ticket.create_comment("body" => comment.body).id
+              end
+            end
+          end
+          
+          def update_comment!(comment)
+            Houston.benchmark title: "Update Unfuddle Comment" do
+              unfuddle.as_user(comment.user) do
+                unfuddle_comment = comment(comment.remote_id)
+                return unless unfuddle_comment
+                
+                unfuddle_comment.project_id = unfuddle.project_id
+                unfuddle_comment.update_attributes!("body" => comment.body)
+              end
+            end
+          end
+          
+          def destroy_comment!(comment)
+            Houston.benchmark title: "Destroy Unfuddle Comment" do
+              unfuddle_comment = comment(comment.remote_id)
+              return unless unfuddle_comment
+              
+              unfuddle_comment.project_id = unfuddle.project_id
+              unfuddle_comment.destroy!
+            end
+          end
+          
+          
+          
+          def get_custom_value(custom_field_name)
+            unfuddle_ticket = @raw_attributes
+            
+            retried_once = false
+            begin
+              custom_field_key = custom_field_name.underscore.gsub(/\s/, "_")
+              
+              key = find_in_cache_or_execute(custom_field_key(custom_field_key)) do
+                connection.get_ticket_attribute_for_custom_value_named!(custom_field_name) rescue "undefined"
+              end
+              
+              value_id = unfuddle_ticket[key]
+              return nil if value_id.blank?
+              find_in_cache_or_execute(custom_value_key(custom_field_key, value_id)) do
+                connection.find_custom_field_value_by_id!(custom_field_name, value_id).value
+              end
+            rescue
+              if retried_once
+                raise
+              else
+                
+                # If an error occurred above, it may be because
+                # we cached the wrong value for something.
+                retried_once = true
+                connection.invalidate_cache!("#{custom_field_key}_field", "#{custom_field_key}_value_#{value_id}")
+                retry
+              end
+            end
+          end
+          
+          
+          
+        private
+          
+          attr_reader :connection
+          alias :unfuddle :connection
+          
+          delegate :find_in_cache_or_execute,
+                   :invalidate_cache,
+                   :project_id,
+                   :to => :connection
+          
+          
+          
+          def get_type
+            identify_type_proc = unfuddle.config[:identify_type]
+            identify_type_proc.call(self) if identify_type_proc
+          end
+          
+          def get_tags
+            identify_tags_proc = unfuddle.config[:identify_tags]
+            return [] unless identify_tags_proc
+            identify_tags_proc.call(self)
+          end
+          
+          
+          
+          def parse_prerequisites(associations)
+            Array.wrap(associations)
+              .select { |assocation| assocation["relationship"] == "parent" }
+              .map { |assocation| assocation["ticket"]["number"] }
+          end
+          
+          
+          
+          def get_severity_name(severity_id)
+            severity = unfuddle.severities.find { |severity| severity.id == severity_id }
+            severity && severity.name
+          end
+          
+          def get_component_name(component_id)
+            component = unfuddle.components.find { |component| component.id == component_id }
+            component && component.name
+          end
+          
+          
+          
+          def comment(remote_comment_id)
+            return nil unless remote_comment_id
+            
+            ticket = unfuddle.ticket(remote_id)
+            ticket.comment(remote_comment_id)
+          end
+          
+          
+          
+          def custom_field_key(custom_field_key)
+            "unfuddle/projects/#{project_id}/custom_field/#{custom_field_key}/name"
+          end
+          
+          def custom_value_key(custom_field_key, value_id)
+            "unfuddle/projects/#{project_id}/custom_field/#{custom_field_key}/value/#{value_id}"
+          end
+          
+          
+          
+        end
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/version_control.rb

@@ -0,0 +1,5 @@
+require File.dirname(__FILE__)
+
+Houston::Adapters.define_adapter_namespace "VersionControl"
+
+require "houston/adapters/version_control/errors"

data/app/adapters/houston/adapters/version_control/commit.rb

@@ -0,0 +1,29 @@
+module Houston
+  module Adapters
+    module VersionControl
+      class Commit
+        
+        def initialize(attributes={})
+          @sha = attributes[:sha]
+          @parent_sha = attributes[:parent_sha]
+          @message = attributes[:message]
+          @authored_at = attributes[:authored_at]
+          @author_name = attributes[:author_name]
+          @author_email = attributes[:author_email]
+          @committed_at = attributes[:committed_at]
+          @committer_name = attributes[:committer_name]
+          @committer_email = attributes[:committer_email]
+        end
+        
+        attr_reader :sha, :parent_sha, :message,
+          :authored_at, :author_name, :author_email,
+          :committed_at, :committer_name, :committer_email
+        
+        def to_s
+          sha[0...7]
+        end
+        
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/version_control/errors.rb

@@ -0,0 +1,37 @@
+module Houston
+  module Adapters
+    module VersionControl
+      
+      class Error < StandardError
+        def initialize(original_error=nil, message=nil)
+          original_error, message = nil, original_error if original_error.is_a?(String)
+          
+          if original_error
+            message ||= original_error.message
+            set_backtrace(original_error.backtrace)
+          end
+          
+          @original_error = original_error
+          @message = message
+          super(message)
+        end
+        
+        attr_accessor :message
+        attr_reader :original_error
+      end
+      
+      class CommitNotFound < Error
+      end
+      
+      class BranchNotFound < Error
+      end
+      
+      class FileNotFound < Error
+      end
+      
+      class InvalidShaError < ArgumentError
+      end
+      
+    end
+  end
+end

data/app/adapters/houston/adapters/version_control/git_adapter.rb

@@ -0,0 +1,96 @@
+module Houston
+  module Adapters
+    module VersionControl
+      class GitAdapter
+        class << self
+          
+          
+          
+          # Public API for a VersionControl::Adapter
+          # ------------------------------------------------------------------------- #
+          
+          def errors_with_parameters(project, location)
+            location = Addressable::URI.parse(location.to_s)
+            connect_to_repo!(location, project.version_control_temp_path)
+            {}
+          rescue Rugged::RepositoryError, Rugged::OSError, Rugged::SshError
+            Rails.logger.error "#{$!.class.name}: #{$!.message}\n  #{$!.backtrace.take(7).join("\n  ")}"
+            { git_location: ["might not be right. Houston can't seem to connect to it."] }
+          end
+          
+          def build(project, location)
+            connect location, project.version_control_temp_path
+          end
+          
+          def connect(location, temp_path)
+            location = Addressable::URI.parse(location.to_s)
+            return Houston::Adapters::VersionControl::NullRepo if location.blank?
+            
+            connection = connect_to_repo! location, temp_path
+            
+            return self::Repo.new(connection) unless location.absolute?
+            return self::GithubRepo.new(connection, location) if /github/ === location
+            return self::RemoteRepo.new(connection, location)
+          rescue Rugged::RepositoryError, Rugged::OSError, Rugged::SshError
+            Rails.logger.warn "\e[33m[git_adapter] #{$!.class}: #{$!.message}\e[0m"
+            Houston::Adapters::VersionControl::NullRepo
+          end
+          
+          def parameters
+            [:git_location]
+          end
+          
+          # ------------------------------------------------------------------------- #
+          
+          
+          
+          def connect_to_repo!(repo_uri, temp_path)
+            git_path = get_local_path_to_repo(repo_uri, temp_path.to_s)
+            Rugged::Repository.new(git_path)
+          end
+          
+          def get_local_path_to_repo(repo_uri, temp_path)
+            if repo_uri.absolute?
+              clone!(repo_uri, temp_path) unless File.exists?(temp_path)
+              temp_path
+            else
+              repo_uri.to_s
+            end
+          end
+          
+          def clone!(origin_uri, local_path, async: false)
+            if async
+              Houston.async { _clone!(origin_uri, local_path, true) }
+            else
+              _clone!(origin_uri, local_path, false)
+            end
+          end
+          
+          def credentials
+            Rugged::Credentials::SshKey.new(
+              username: SSH_USERNAME,
+              privatekey: SSH_PRIVATEKEY,
+              publickey: SSH_PUBLICKEY)
+          end
+          
+          
+          
+        private
+          
+          def _clone!(origin_uri, local_path, async)
+            Houston.benchmark("[git:clone#{":async" if async}] #{origin_uri} => #{local_path}") do
+              Rugged::Repository.clone_at origin_uri.to_s, local_path.to_s,
+                credentials: GitAdapter.credentials,
+                bare: true
+            end
+          end
+          
+          SSH_USERNAME = "git".freeze
+          SSH_PRIVATEKEY = File.expand_path("~/.ssh/id_rsa").freeze
+          SSH_PUBLICKEY = File.expand_path("~/.ssh/id_rsa.pub").freeze
+          
+        end
+      end
+    end
+  end
+end