houston-core 0.5.0.beta1

data/app/adapters/houston/adapters/error_tracker/errbit_adapter/notice.rb

@@ -0,0 +1,26 @@
+module Houston
+  module Adapters
+    module ErrorTracker
+      class ErrbitAdapter
+        class Notice
+          
+          def initialize(attributes={})
+            @attributes = attributes
+          end
+          
+          attr_reader :attributes
+          
+          
+          def created_at
+            attributes[:created_at]
+          end
+          
+          def app_id
+            attributes[:app_id]
+          end
+          
+        end
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/error_tracker/errbit_adapter/problem.rb

@@ -0,0 +1,98 @@
+module Houston
+  module Adapters
+    module ErrorTracker
+      class ErrbitAdapter
+        class Problem
+          
+          def initialize(attributes={})
+            @attributes = attributes
+          end
+          
+          attr_reader :attributes
+          attr_accessor :err_ids
+          attr_accessor :ticket
+          
+          def id
+            attributes[:id]
+          end
+          
+          def err_ids
+            attributes[:err_ids]
+          end
+          
+          def first_notice_at
+            attributes[:first_notice_at]
+          end
+          
+          def first_notice_commit
+            attributes[:first_notice_commit]
+          end
+          
+          def first_notice_environment
+            attributes[:first_notice_environment]
+          end
+          
+          def last_notice_at
+            attributes[:last_notice_at]
+          end
+          
+          def last_notice_commit
+            attributes[:last_notice_commit]
+          end
+          
+          def last_notice_environment
+            attributes[:last_notice_environment]
+          end
+          
+          def notices_count
+            attributes[:notices_count]
+          end
+          
+          
+          def opened_at
+            attributes[:opened_at]
+          end
+          
+          def resolved_at
+            attributes[:resolved_at]
+          end
+          
+          def resolved?
+            attributes[:resolved]
+          end
+          
+          
+          def app_id
+            attributes[:app_id]
+          end
+          
+          def message
+            attributes[:message]
+          end
+          
+          def where
+            attributes[:where]
+          end
+          
+          def environment
+            attributes[:environment]
+          end
+          
+          def url
+            attributes[:url]
+          end
+          
+          
+          def comments
+            attributes[:comments]
+          end
+          
+          def deleted_at
+            attributes[:deleted_at]
+          end
+          
+        end
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/error_tracker/none_adapter.rb

@@ -0,0 +1,31 @@
+module Houston
+  module Adapters
+    module ErrorTracker
+      class NoneAdapter
+        
+        def self.errors_with_parameters(*args)
+          {}
+        end
+        
+        def self.build(*args)
+          Houston::Adapters::ErrorTracker::NullApp
+        end
+        
+        def self.parameters
+          []
+        end
+        
+        
+        
+        def self.problems_during(*args)
+          []
+        end
+        
+        def self.notices_during(*args)
+          []
+        end
+        
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/error_tracker/null_app.rb

@@ -0,0 +1,40 @@
+module Houston
+  module Adapters
+    module ErrorTracker
+      class NullAppClass
+        
+        
+        # Public API for a ErrorTracker app
+        # ------------------------------------------------------------------------- #
+        
+        def project_url
+        end
+        
+        def error_url(*args)
+        end
+        
+        def problems_during(range)
+          []
+        end
+        
+        def open_problems(params={})
+          []
+        end
+        
+        def resolve!(problem_id, params={})
+        end
+        
+        # ------------------------------------------------------------------------- #
+        
+        
+        def nil?
+          true
+        end
+        
+        
+      end
+      
+      NullApp = NullAppClass.new
+    end
+  end
+end

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

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

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

@@ -0,0 +1,23 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      
+      class Error < StandardError
+        def initialize(original_error)
+          @original_error = original_error
+          super(original_error.message)
+          set_backtrace(original_error.backtrace)
+        end
+        
+        attr_reader :original_error
+      end
+      
+      class ConnectionError < Error
+      end
+      
+      class InvalidQueryError < Error
+      end
+      
+    end
+  end
+end

data/app/adapters/houston/adapters/ticket_tracker/github_adapter.rb

@@ -0,0 +1,27 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      class GithubAdapter
+        
+        class << self
+          
+          def errors_with_parameters(project, repo)
+            {}
+          end
+          
+          def build(project, repo)
+            return Houston::TicketTracker::NullConnection if repo.blank?
+            
+            self::Connection.new(repo)
+          end
+          
+          def parameters
+            [:github_repo]
+          end
+          
+        end
+        
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/ticket_tracker/github_adapter/connection.rb

@@ -0,0 +1,167 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      class GithubAdapter
+        class Connection
+          
+          def initialize(repo_path)
+            @repo_path = repo_path
+            @config = Houston.config.ticket_tracker_configuration(:github)
+          end
+          
+          
+          
+          # Required API
+          
+          def features
+            [:syncing_tickets, :syncing_milestones]
+          end
+          
+          def build_ticket(attributes)
+            attributes["user"] = {} unless attributes["user"]
+            attributes["user"]["email"] = find_user_email(attributes["user"]["login"])
+            Houston::Adapters::TicketTracker::GithubAdapter::Issue.new(self, attributes)
+          end
+          
+          def create_ticket!(houston_ticket)
+            as_user(houston_ticket.reporter) do
+              attrs = get_attributes_from_type(houston_ticket.type)
+              options = {}
+              options[:labels] = attrs[:labels].join(",") if attrs[:labels]
+              
+              native_ticket = client.create_issue(
+                repo_path,
+                houston_ticket.summary,
+                houston_ticket.description,
+                options )
+              
+              build_ticket(native_ticket)
+            end
+          end
+          
+          def find_ticket_by_number(number)
+            attributes = client.issue(repo_path, number) unless number.blank?
+            build_ticket(attributes) if attributes
+          rescue Octokit::NotFound
+            nil
+          end
+          
+          def find_tickets_numbered(*numbers)
+            numbers = numbers.flatten
+            return [] if numbers.empty?
+            return numbers.map(&method(:find_ticket_by_number)).compact if numbers.length < 5
+            open_tickets.select { |ticket| numbers.member?(ticket.number) }
+          end
+          
+          def all_tickets
+            open_tickets + closed_tickets
+          end
+          
+          def open_tickets
+            build_issues client.list_issues(repo_path, state: "open")
+          end
+          
+          def project_url
+            "https://github.com/#{repo_path}/issues"
+          end
+          
+          def ticket_url(ticket_number)
+            "#{project_url}/#{ticket_number}"
+          end
+          
+          
+          
+          def all_milestones
+            []
+          end
+          
+          def open_milestones
+            []
+          end
+          
+          
+          
+          # Idiomatic API
+          
+          attr_reader :repo_path, :config
+          
+          def client
+            @client ||= Octokit::Client.new(Houston.config.github.pick(:access_token).merge(auto_paginate: true))
+          end
+          
+          def close_issue(number)
+            client.close_issue(repo_path, number)
+          end
+          
+          def reopen_issue(number)
+            client.reopen_issue(repo_path, number)
+          end
+          
+          
+          
+          def as_user(user, &block)
+            current_client = @client
+            begin
+              token = user.consumer_tokens.first
+              # !todo: use a more generic exception?
+              raise Github::Unauthorized unless token
+              @client = Octokit::Client.new(access_token: token.token)
+              yield
+            rescue Octokit::Unauthorized
+              raise Github::Unauthorized, $!.message
+            ensure
+              @client = current_client
+            end
+          end
+          
+          
+          
+        private
+          
+          def find_user_email(user_login)
+            return nil if user_login.nil?
+            find_in_cache_or_execute(user_key(user_login)) do
+              user = client.user user_login
+              user.email if user
+            end
+          end
+          
+          def user_key(user_login)
+            "github/users/#{user_login}"
+          end
+          
+          def find_in_cache_or_execute(key, &block)
+            Rails.cache.fetch(key, &block)
+          end
+          
+          def invalidate_cache!(*keys)
+            keys.each do |key|
+              Rails.cache.delete key
+            end
+          end
+          
+          def get_attributes_from_type(type)
+            attributes_from_type_proc = config[:attributes_from_type]
+            return {} unless attributes_from_type_proc
+            attributes_from_type_proc.call(type)
+          end
+          
+          def closed_tickets
+            build_issues client.list_issues(repo_path, state: "closed")
+          end
+          
+          def build_issues(remote_issues)
+            remote_issues
+              .reject(&method(:pull_request?))
+              .map(&method(:build_ticket))
+          end
+          
+          def pull_request?(issue)
+            !issue.pull_request.nil?
+          end
+          
+        end
+      end
+    end
+  end
+end

data/app/adapters/houston/adapters/ticket_tracker/github_adapter/issue.rb

@@ -0,0 +1,99 @@
+module Houston
+  module Adapters
+    module TicketTracker
+      class GithubAdapter
+        class Issue
+          
+          
+          
+          def initialize(connection, attributes)
+            @connection       = connection
+            @raw_attributes   = attributes
+            
+            # required
+            @remote_id        = attributes["id"]
+            @number           = attributes["number"]
+            @summary          = attributes["title"]
+            @description      = attributes["body"]
+            @reporter_email   = attributes["user"]["email"]
+            @resolution       = ""
+            @milestone_id     = nil
+            @type             = get_type
+            @created_at       = attributes["created_at"] if attributes["created_at"]
+            @closed_at        = attributes["closed_at"] if attributes["closed_at"]
+            
+            # optional
+            @tags             = get_tags
+          end
+          
+          attr_reader :raw_attributes,
+                      
+                      :remote_id,
+                      :number,
+                      :summary,
+                      :description,
+                      :reporter_email,
+                      :resolution,
+                      :milestone_id,
+                      :type,
+                      :tags,
+                      :created_at,
+                      :closed_at
+          
+          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:  [] }
+          end
+          
+          
+          
+          def close!
+            connection.close_issue(number)
+          end
+          
+          def resolve!
+            close!
+          end
+          
+          def reopen!
+            connection.reopen_issue(number)
+          end
+          
+          
+          
+        private
+          
+          attr_reader :connection
+          alias :github :connection
+          
+          def get_type
+            identify_type_proc = github.config[:identify_type]
+            identify_type_proc.call(self) if identify_type_proc
+          end
+          
+          def get_tags
+            identify_tags_proc = github.config[:identify_tags]
+            return Array(attributes["labels"]).map(&method(:tag_from_label)) unless identify_tags_proc
+            identify_tags_proc.call(self)
+          end
+          
+          def tag_from_label(label)
+            TicketTag.new(label["name"], label["color"])
+          end
+          
+        end
+      end
+    end
+  end
+end