honeybadger-api 1.0.0

data/lib/honeybadger-api/environment.rb

@@ -0,0 +1,27 @@
+module Honeybadger
+  module Api
+    class Environment
+
+      attr_reader :id, :name, :project_id, :updated_at, :created_at
+
+      # Public: Build a new instance of Environment
+      #
+      # opts - A Hash of attributes to initialize a Environment
+      #
+      # Returns a new Environment
+      def initialize(opts)
+        @id = opts[:id]
+        @name = opts[:name]
+        @notifications = opts[:notifications]
+        @project_id = opts[:project_id]
+        @updated_at = opts[:updated_at].nil? ? nil : DateTime.parse(opts[:updated_at])
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Whether notification are raised.
+      def notifications?
+        @notifications
+      end
+    end
+  end
+end

data/lib/honeybadger-api/fault.rb

@@ -0,0 +1,63 @@
+module Honeybadger
+  module Api
+    class Fault
+
+      attr_reader :id, :project_id, :klass, :action, :component, :message,
+        :environment, :notices_count, :comments_count, :last_notice_at, :created_at
+
+      # Public: Build a new instance of Fault
+      #
+      # opts - A Hash of attributes to initialize a Fault
+      #
+      # Returns a new Fault
+      def initialize(opts)
+        @id = opts[:id]
+        @project_id = opts[:project_id]
+        @klass = opts[:klass]
+        @action = opts[:action]
+        @component = opts[:component]
+        @message = opts[:message]
+        @environment = opts[:environment]
+        @ignored = opts[:ignored]
+        @resolved = opts[:resolved]
+        @notices_count = opts[:notices_count]
+        @comments_count = opts[:comments_count]
+        @last_notice_at = opts[:last_notice_at].nil? ? nil : DateTime.parse(opts[:last_notice_at])
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Whether tha fault has been marked as ignored.
+      def ignored?
+        @ignored == true
+      end
+
+      # Public: Whether tha fault has been marked as resolved.
+      def resolved?
+        @resolved == true
+      end
+
+      # Public: Find all faults for a given project.
+      def self.all(project_id)
+        path  = "projects/#{project_id}/faults"
+        Honeybadger::Api::Request.all(path, handler)
+      end
+
+      # Public: Paginate all faults for a given project.
+      def self.paginate(project_id, filters = {})
+        path  = "projects/#{project_id}/faults"
+        Honeybadger::Api::Request.paginate(path, handler, filters)
+      end
+
+      # Public: Find a fault for a given project.
+      def self.find(project_id, fault_id)
+        path = "projects/#{project_id}/faults/#{fault_id}"
+        Honeybadger::Api::Request.find(path, handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| Fault.new(response) }
+      end
+    end
+  end
+end

data/lib/honeybadger-api/notice.rb

@@ -0,0 +1,45 @@
+module Honeybadger
+  module Api
+    class Notice
+
+      attr_reader :id, :fault_id, :environment, :message, :request, :created_at
+
+      # Public: Build a new instance of Notice
+      #
+      # opts - A Hash of attributes to initialize a Notice
+      #
+      # Returns a new Notice
+      def initialize(opts)
+        @id = opts[:id]
+        @fault_id = opts[:fault_id]
+        @environment = opts[:environment]
+        @message = opts[:message]
+        @request = opts[:request]
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Find all notices on a fault for a project.
+      def self.all(project_id, fault_id)
+        path = "projects/#{project_id}/faults/#{fault_id}/notices"
+        Honeybadger::Api::Request.all(path, handler)
+      end
+
+      # Public: Paginate all notices on a fault for a project
+      def self.paginate(project_id, fault_id, filters = {})
+        path = "projects/#{project_id}/faults/#{fault_id}/notices"
+        Honeybadger::Api::Request.paginate(path, handler, filters)
+      end
+
+      # Public: Find a notice on a fault for a project.
+      def self.find(project_id, fault_id, notice_id)
+        path = "projects/#{project_id}/faults/#{fault_id}/notices/#{notice_id}"
+        Honeybadger::Api::Request.find(path, handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| Notice.new(response) }
+      end
+    end
+  end
+end

data/lib/honeybadger-api/paginator.rb

@@ -0,0 +1,72 @@
+module Honeybadger
+  module Api
+    class Paginator
+
+      attr_reader :current_page, :total_page_count, :pages
+
+      def initialize(path, filters, handler)
+        @path = path
+        @filters = filters
+        @handler = handler
+
+        @pages = {}
+
+        @filters.merge!({ :page => 1 }) if !@filters.has_key?(:page)
+        response = Honeybadger::Api.client.get(@path, @filters)
+
+        @current_page = response[:current_page]
+        @total_page_count = response[:num_pages]
+
+        @pages[current_page] = response[:results].map do |r|
+          @handler.call(r)
+        end
+      end
+
+      def next?
+        current_page < total_page_count
+      end
+
+      def previous?
+        current_page > 1
+      end
+
+      def next
+        if next?
+          response = Honeybadger::Api.client.get(@path, @filters.merge({:page => current_page + 1}))
+
+          @current_page = response[:current_page]
+          @total_page_count = response[:num_pages]
+
+          @pages[current_page] = response[:results].map do |r|
+            @handler.call(r)
+          end
+
+          @pages[current_page]
+        else
+          nil
+        end
+      end
+
+      def previous
+        if previous?
+          response = Honeybadger::Api.client.get(@path, @filters.merge({:page => current_page - 1}))
+
+          @current_page = response[:current_page]
+          @total_page_count = response[:num_pages]
+
+          @pages[current_page] = response[:results].map do |r|
+            @handler.call(r)
+          end
+
+          @pages[current_page]
+        else
+          nil
+        end
+      end
+
+      def collection
+        @pages.values.flatten
+      end
+    end
+  end
+end

data/lib/honeybadger-api/project.rb

@@ -0,0 +1,71 @@
+module Honeybadger
+  module Api
+    class Project
+
+      attr_reader :id, :name, :owner, :users, :token, :environments,
+        :fault_count, :unresolved_fault_count, :last_notice_at, :created_at
+
+      # Public: Build a new instance of Project
+      #
+      # opts - A Hash of attributes to initialize a Project
+      #
+      # Returns a new Project
+      def initialize(opts)
+        @id = opts[:id]
+        @name = opts[:name]
+        @owner = User.new(opts[:owner][:name], opts[:owner][:email])
+        @users = opts[:users].collect { |user| User.new(user[:name], user[:email]) }
+        @token = opts[:token]
+        @environments = opts[:environments].collect do |env|
+          Environment.new(env)
+        end
+        @active = opts[:active]
+        @disable_public_links = opts[:disable_public_links]
+        @fault_count = opts[:fault_count]
+        @unresolved_fault_count = opts[:unresolved_fault_count]
+        @last_notice_at = opts[:last_notice_at].nil? ? nil : DateTime.parse(opts[:last_notice_at])
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Whether the project is active.
+      def active?
+        @active == true
+      end
+
+      # Public: Whether the project is inactive.
+      def inactive?
+        @active == false
+      end
+
+      # Public: Whether links are public.
+      def public_links?
+        @disable_public_links == false
+      end
+
+      # Public: Whether links are private.
+      def private_links?
+        @disable_public_links == true
+      end
+
+      # Public: Find all of the project.
+      def self.all
+        Honeybadger::Api::Request.all("projects", handler)
+      end
+
+      # Public: Paginate all of the project.
+      def self.paginate(filters = {})
+        Honeybadger::Api::Request.paginate("projects", handler, filters)
+      end
+
+      # Public: Find a project.
+      def self.find(project_id)
+        Honeybadger::Api::Request.find("projects/#{project_id}", handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| Project.new(response) }
+      end
+    end
+  end
+end

data/lib/honeybadger-api/request.rb

@@ -0,0 +1,44 @@
+module Honeybadger
+  module Api
+    class Request
+
+      def initialize(path, handler, filters = {})
+        @path = path
+        @handler = handler
+        @filters = filters
+      end
+
+      def self.all(path, handler)
+        request = Honeybadger::Api::Request.new(path, handler)
+        request.all
+      end
+
+      def all
+        paginator = Honeybadger::Api::Paginator.new(@path, @filters, @handler)
+        while paginator.next?
+          paginator.next
+        end
+        paginator.collection
+      end
+
+      def self.find(path, handler)
+        request = Honeybadger::Api::Request.new(path, handler)
+        request.find
+      end
+
+      def find
+        response = Honeybadger::Api.client.get(@path)
+        @handler.call(response)
+      end
+
+      def self.paginate(path, handler, filters)
+        request = Honeybadger::Api::Request.new(path, handler, filters)
+        request.paginate
+      end
+
+      def paginate
+        Honeybadger::Api::Paginator.new(@path, @filters, @handler)
+      end
+    end
+  end
+end

data/lib/honeybadger-api/team.rb

@@ -0,0 +1,42 @@
+module Honeybadger
+  module Api
+    class Team
+
+      attr_reader :id, :name, :owner, :team_members, :projects, :created_at
+
+      # Public: Build a new instance of Team
+      #
+      # opts - A Hash of attributes to initialize a Team
+      #
+      # Returns a new Team
+      def initialize(opts)
+        @id = opts[:id]
+        @name = opts[:name]
+        @owner = User.new(opts[:owner][:name], opts[:owner][:email])
+        @team_members = opts[:members].collect { |m| TeamMember.new(m) }
+        @projects = opts[:projects].collect { |p| Project.new(p) }
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Find all of the teams.
+      def self.all
+        Honeybadger::Api::Request.all("teams", handler)
+      end
+
+      # Public: Paginate all of the teams.
+      def self.paginate(filters = {})
+        Honeybadger::Api::Request.paginate("teams", handler, filters)
+      end
+
+      # Public: Find a team.
+      def self.find(team_id)
+        Honeybadger::Api::Request.find("teams/#{team_id}", handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| Team.new(response) }
+      end
+    end
+  end
+end

data/lib/honeybadger-api/team_invitation.rb

@@ -0,0 +1,61 @@
+module Honeybadger
+  module Api
+    class TeamInvitation
+
+      attr_reader :id, :token, :email, :created_by, :accepted_by, :created_at, :accepted_at, :message
+
+      # Public: Build a new instance of TeamInvitation
+      #
+      # opts - A Hash of attributes to initialize a TeamInvitation
+      #
+      # Returns a new TeamInvitation
+      def initialize(opts)
+        @id = opts[:id]
+        @token = opts[:token]
+        @email = opts[:email]
+        if opts[:created_by].nil?
+          @created_by = nil
+        else
+          @created_by = User.new(opts[:created_by][:name], opts[:created_by][:email])
+        end
+        if opts[:accepted_by].nil?
+          @accepted_by = nil
+        else
+          @accepted_by = User.new(opts[:accepted_by][:name], opts[:accepted_by][:email])
+        end
+        @admin = opts[:admin]
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+        @accepted_at = opts[:accepted_at].nil? ? nil : DateTime.parse(opts[:accepted_at])
+        @message = opts[:message]
+      end
+
+      # Public: Whether the invitation was for an admin user.
+      def admin?
+        @admin
+      end
+
+      # Public: Find all team invitations for a team.
+      def self.all(team_id)
+        path = "teams/#{team_id}/team_invitations"
+        Honeybadger::Api::Request.all(path, handler)
+      end
+
+      # Public: Paginate all team invitations for a team.
+      def self.paginate(team_id, filters = {})
+        path = "teams/#{team_id}/team_invitations"
+        Honeybadger::Api::Request.paginate(path, handler, filters)
+      end
+
+      # Public: Find a team invitation for a given team.
+      def self.find(team_id, team_invitation_id)
+        path = "teams/#{team_id}/team_invitations/#{team_invitation_id}"
+        Honeybadger::Api::Request.find(path, handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| TeamInvitation.new(response) }
+      end
+    end
+  end
+end

data/lib/honeybadger-api/team_member.rb

@@ -0,0 +1,58 @@
+module Honeybadger
+  module Api
+    class TeamMember
+
+      attr_reader :id, :admin, :created_at
+
+      # Public: Build a new instance of TeamMember
+      #
+      # opts - A Hash of attributes to initialize a TeamMember
+      #
+      # Returns a new TeamMember
+      def initialize(opts)
+        @id = opts[:id]
+        @user = User.new(opts[:name], opts[:email])
+        @admin = opts[:admin]
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Whether the team member is an admin
+      def admin?
+        @admin
+      end
+
+      # Public: The name of the team member
+      def name
+        @user.name
+      end
+
+      # Public: The email address of the team member
+      def email
+        @user.email
+      end
+
+      # Public: Find all team members for a team.
+      def self.all(team_id)
+        path = "teams/#{team_id}/team_members"
+        Honeybadger::Api::Request.all(path, handler)
+      end
+
+      # Public: Paginate all team members for a team.
+      def self.paginate(team_id, filters = {})
+        path = "teams/#{team_id}/team_members"
+        Honeybadger::Api::Request.paginate(path, handler, filters)
+      end
+
+      # Public: Find a team member for a given team.
+      def self.find(team_id, team_member_id)
+        path = "teams/#{team_id}/team_members/#{team_member_id}"
+        Honeybadger::Api::Request.find(path, handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| TeamMember.new(response) }
+      end
+    end
+  end
+end