honeybadger-api 1.0.0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in honeybadger-api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Murray Summers
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,189 @@
+# Honeybadger Read API
+
+A Ruby Library for the [Honeybadger Read API](https://www.honeybadger.io/documentation/read_api) for easily pulling your data out of [Honeybadger](https://www.honeybadger.io/).
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'honeybadger-api'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install honeybadger-api
+
+## Usage
+
+### Introduction
+Firstly require the library:
+
+```
+require 'honeybadger-api'
+```
+
+Then configure your personal API access token. Your personal API access token can be found on your [personal profile page](https://www.honeybadger.io/users/edit):
+
+```
+Honeybadger::Api.configure do |c|
+  c.access_token = 'xxxxxxxxxxxxxxxxxxxx'
+end
+```
+
+After you have setup your API access token you can now make requests.
+
+### Projects
+
+```
+# Find a project
+Honeybadger::Api::Project.find(project_id)
+
+# Find all the projects
+Honeybadger::Api::Project.all
+
+# Retrieve a paginator for projects
+paginator = Honeybadger::Api::Project.paginate
+```
+
+There are several methods that you should be aware of when using the paginator.
+
+```
+# Get a paginator for a resource
+paginator = Honeybadger::Api::Project.paginate
+
+
+# Retrieve a paginator for projects starting at a page
+paginator = Honeybadger::Api::Project.paginate(:page => 5)
+
+# Whether there are any more previous or next pages
+paginator.previous?
+=> true
+paginator.next?
+=> true
+
+# Retrieve the previous or next pages
+paginator.previous
+paginator.next
+
+# Retrieve the current page number
+paginator.current_page
+
+# Retrieve the total number of pages
+paginator.total_page_count
+
+# Return all previously requested pages as a Hash
+paginator.pages
+=> {
+  1 => [
+    #<Honeybadger::Api::Project @id=1, @name="Example">,
+    #<Honeybadger::Api::Project @id=2, @name="Acme">
+  ],
+  2 => [
+    #<Honeybadger::Api::Project @id=3, @name="Website">
+  ]
+}
+
+# Return all previously requested pages as a collection
+paginator.collection
+=> [
+  #<Honeybadger::Api::Project @id=1, @name="Example">,
+  #<Honeybadger::Api::Project @id=2, @name="Acme">,
+  #<Honeybadger::Api::Project @id=3, @name="Website">
+]
+
+```
+
+### Deploys
+
+```
+# Find a deploy
+Honeybadger::Api::Deploy.find(project_id, deploy_id)
+
+# Find all the deploys
+Honeybadger::Api::Deploy.all(project_id)
+
+# Retrieve a paginator for deploys
+Honeybadger::Api::Deploy.paginate(project_id)
+```
+
+### Faults
+```
+# Find a fault
+Honeybadger::Api::Fault.find(project_id, fault_id)
+
+# Find all the faults
+Honeybadger::Api::Fault.all(project_id)
+
+# Retrieve a paginator for faults
+Honeybadger::Api::Fault.paginate(project_id)
+```
+
+### Notices
+```
+# Find a notice
+Honeybadger::Api::Notice.find(project_id, fault_id, notice_id)
+
+# Find all the notices
+Honeybadger::Api::Notice.all(project_id, fault_id)
+
+# Retrieve a paginator for notices
+Honeybadger::Api::Notice.paginate(project_id, fault_id)
+```
+### Comments
+```
+# Find a comment
+Honeybadger::Api::Comment.find(project_id, fault_id, comment_id)
+
+# Find all the comments 
+Honeybadger::Api::Comment.all(project_id, fault_id)
+
+# Retrieve a paginator for comments 
+Honeybadger::Api::Comment.paginate(project_id, fault_id)
+```
+
+### Teams
+```
+# Find a team
+Honeybadger::Api::Team.find(team_id)
+
+# Find all the teams
+Honeybadger::Api::Team.all
+
+# Retrieve a paginator for teams
+Honeybadger::Api::Team.paginate
+
+```
+### Team Members
+```
+# Find a team member
+Honeybadger::Api::TeamMember.find(team_id, team_member_id)
+
+# Find all the team members
+Honeybadger::Api::TeamMember.all(team_id)
+
+# Retrieve a paginator for team members 
+Honeybadger::Api::TeamMember.paginate(team_id)
+```
+
+### Team Invitations
+```
+# Find a team invitation 
+Honeybadger::Api::TeamInvitation.find(team_id, team_invitation_id)
+
+# Find all the team invitations 
+Honeybadger::Api::TeamInvitation.all(team_id)
+
+# Retrieve a paginator for team invitations 
+Honeybadger::Api::TeamInvitation.paginate(team_id)
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/honeybadger-api.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'honeybadger-api/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "honeybadger-api"
+  spec.version       = Honeybadger::Api::VERSION
+  spec.authors       = ["Murray Summers"]
+  spec.email         = ["murray.sum@gmail.com"]
+  spec.summary       = %q{Honeybadger Read API}
+  spec.description   = %q{A Ruby Library for the Honeybadger Read API for easily pulling your data out of Honeybadger}
+  spec.homepage      = "https://github.com/murraysum/honeybadger-api"
+  spec.license       = "MIT"
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'json'
+
+  spec.add_development_dependency 'rspec', '2.14.1'
+  spec.add_development_dependency 'webmock'
+  spec.add_development_dependency 'mocha'
+  spec.add_development_dependency 'factory_girl'
+end

data/lib/honeybadger-api.rb

@@ -0,0 +1,41 @@
+require 'date'
+
+require "honeybadger-api/version"
+require "honeybadger-api/configuration"
+require "honeybadger-api/paginator"
+require "honeybadger-api/request"
+require "honeybadger-api/team"
+require "honeybadger-api/team_member"
+require "honeybadger-api/user"
+require "honeybadger-api/client"
+require "honeybadger-api/deploy"
+require "honeybadger-api/team_invitation"
+require "honeybadger-api/comment"
+require "honeybadger-api/project"
+require "honeybadger-api/fault"
+require "honeybadger-api/notice"
+require "honeybadger-api/environment"
+
+module Honeybadger
+  module Api
+
+    # Public: Configure the HoneyBadger Read API and set
+    # an access token to authenticate.
+    #
+    # Examples:
+    #
+    #  Honeybadger::Api.configure do |c|
+    #    c.access_token = "xxxxxxxxxxxxxxxxxxxx"
+    #  end
+    def self.configure
+      @configuration = Honeybadger::Api::Configuration.new
+      yield @configuration
+    end
+
+    # Public: Query the HoneyBadger Read API directly.
+    def self.client
+      Honeybadger::Api::Client.new(@configuration.access_token)
+    end
+
+  end
+end

data/lib/honeybadger-api/client.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+require 'uri'
+require 'json'
+
+module Honeybadger
+  module Api
+    class Client
+      
+      attr_reader :access_token
+
+      def initialize(access_token)
+        @access_token = access_token
+      end
+
+      def get(path, options = {})
+        response = request(path, options)
+        JSON.parse(response.body, :symbolize_names => true)
+      end
+
+      private
+
+      def request(path, options = {})
+        uri = build_uri(path, options)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+        request = Net::HTTP::Get.new(uri.request_uri)
+
+        response = http.request(request)
+      end
+
+      def build_uri(path, opts)
+        uri = URI.join(host, path)
+        uri.query = build_query(opts)
+        uri
+      end
+
+      def build_query(opts)
+        URI.encode_www_form(opts.merge({:auth_token => access_token}))
+      end
+
+      def host
+        "https://api.honeybadger.io/v1/"
+      end
+    end
+  end
+end

data/lib/honeybadger-api/comment.rb

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

data/lib/honeybadger-api/configuration.rb

@@ -0,0 +1,12 @@
+module Honeybadger
+  module Api
+    class Configuration
+
+      attr_accessor :access_token
+
+      def initialize
+        @access_token = nil
+      end
+    end
+  end
+end

data/lib/honeybadger-api/deploy.rb

@@ -0,0 +1,46 @@
+module Honeybadger
+  module Api
+    class Deploy
+
+      attr_reader :id, :project_id, :repository, :revision, :environment, :local_username, :created_at
+
+      # Public: Build a new instance of Deploy
+      #
+      # opts - A Hash of attributes to initialize a Deploy
+      #
+      # Returns a new Deploy
+      def initialize(opts)
+        @id = opts[:id]
+        @project_id = opts[:project_id]
+        @repository = opts[:repository]
+        @revision = opts[:revision]
+        @environment = opts[:environment]
+        @local_username = opts[:local_username]
+        @created_at = opts[:created_at].nil? ? nil : DateTime.parse(opts[:created_at])
+      end
+
+      # Public: Find all deploys for a given project.
+      def self.all(project_id)
+        path = "projects/#{project_id}/deploys"
+        Honeybadger::Api::Request.all(path, handler)
+      end
+
+      # Public: Paginate all deploys for a given project
+      def self.paginate(project_id, filters = {})
+        path = "projects/#{project_id}/deploys"
+        Honeybadger::Api::Request.paginate(path, handler, filters)
+      end
+
+      # Public: Find a deploy for a given project.
+      def self.find(project_id, deploy_id)
+        path = "projects/#{project_id}/deploys/#{deploy_id}"
+        Honeybadger::Api::Request.find(path, handler)
+      end
+
+      # Internal: The handler used to build objects from API responses.
+      def self.handler
+        Proc.new { |response| Deploy.new(response) }
+      end
+    end
+  end
+end