snitcher 0.4.0.rc2 → 0.4.0.rc4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6d59a08f5f3886dc3f7b0aef1943627c22795c2f
-  data.tar.gz: 108054b71ff9b607b91ac3808d01e8c9173b5b0a
+  metadata.gz: 269d8a39f4f95c7cf5d1d574d7e0db92f3ca3d95
+  data.tar.gz: 9b6ce02c920e04cb8e544b0d1b2d0b2510626ca5
 SHA512:
-  metadata.gz: 5fb6accdbc955dd55cf0f1e1a994660557a2425882fe125fa09caa1051510585bc4fea89d4f56bc7588985bf01c487b35b78db8b0b454b5b6c7fe5813786e930
-  data.tar.gz: 3dfdbc8579aac588a50626ed6993bbbf380ca0579c355554a9711fd1d9d0aaa57d84ef03a04f984f1e0e21beccef787e0b7ab2a272f9685461e9a9fac11bd7e2
+  metadata.gz: 394d5c82f089074d385f237da314701ea7cf00a353d2339698f90da97a988a4387c41ce7c422bdfddc42719026b9721c5e737f90ba21379883e4bdb8705571f7
+  data.tar.gz: b9126ddc040154e125d763a13cfef5b09897d916fcb04c49cce36a00af93b1b838dd96bd8bb05e725a8bc15d0dce5baa7f409ef060266ff912f424bacdaaf754

data/.travis.yml

@@ -1,6 +1,3 @@
-branches:
-  only:
-    - master
 language: ruby
 matrix:
   allow_failures:
@@ -17,6 +14,6 @@ rvm:
   - 2.0.0
   - 2.1
   - 2.2
-  - 2.3.0
+  - 2.3
   - jruby
   - ruby-head

data/CHANGELOG.md

@@ -1,5 +1,6 @@
 ## 0.4.0 / TBD
-* [FEATURE] Add Snitcher::API for integrating with the DMS API ([[@danabrit](https://github.com/danabrit))
+* [FEATURE] Added Snitcher::API for integrating with the DMS API ([@danabrit](https://github.com/danabrit))
+* [FEATURE] Added Snitcher.snitch! which raises exceptions on errors ([@gaffneyc](https://github.com/gaffneyc))
 
 ## 0.3.2 / 2015-08-13
 * [BUG] Fixed passing messaging during a check-in ([@ryoung](https://github.com/ryoung))

data/README.md

@@ -89,14 +89,15 @@ Returns an array of Snitches.
 
 ### Create a Snitch
 
-Required attributes are name and interval. Optional attributes are notes and
-tags.
+Both `:name` and `:interval` are required. Optional attributes include `:notes`,
+and `:tags`. For a full list see [the API documentation](https://deadmanssnitch.com/docs/api/v1#creating-a-snitch).
 
 ```ruby
-attributes = { "name": "Nightly User Data Backups",
-  "interval": "daily",
-  "notes": "User login and usage data",
-  "tags": ["users", "critical"]
+attributes = {
+  name: "Nightly User Data Backups",
+  interval: "daily",
+  notes: "User login and usage data",
+  tags: ["users", "critical"],
 }
 client.create_snitch(attributes)
 ```
@@ -110,8 +111,8 @@ change. The rest of a Snitch's attributes will remain the same.
 
 ```ruby
 token = "c2354d53d2"
-new_attributes = { "name": "Important Nightly User Data Backups" }
-client.update_snitch(token, new_attributes)
+attrs = { "name": "Important Nightly User Data Backups" }
+client.update_snitch(token, attrs)
 ```
 
 Returns the edited Snitch.
@@ -122,7 +123,7 @@ This function adds tags to a Snitch, retaining whatever tags it already has.
 
 ```ruby
 token = "c2354d53d2"
-tags = ["spring_campaign", "support"]
+tags  = ["spring_campaign", "support"]
 client.add_tags(token, tags)
 ```
 
@@ -140,6 +141,20 @@ client.remove_tag(token, tag)
 
 Returns an array of all of the Snitch's remaining tags.
 
+### Setting the Tags on a Snitch
+
+```ruby
+token = "c2354d53d2"
+client.update_snitch(token, tags: [ "production", "critical" ])
+```
+
+### Removing all Tags from a Snitch
+
+```ruby
+token = "c2354d53d2"
+client.update_snitch(token, tags: [])
+```
+
 ### Pause a Snitch
 
 ```ruby

data/lib/snitcher.rb

@@ -6,7 +6,7 @@ require "snitcher/version"
 module Snitcher
   extend self
 
-  # Check-in to Dead Man's Snitch.
+  # Check-in to Dead Man's Snitch, exceptions are raised on failures.
   #
   # @param token [String] The unique Snitch token to check-in with. This can be
   #   found on the Setup page as the last part of the HTTP check-in url. For
@@ -19,16 +19,13 @@ module Snitcher
   #
   # @option opts [Float, Fixnum] :timeout Number of seconds to wait for a
   #   response from the server. Default is 5 seconds.
-  #   no
   #
   # @example
   #   Snitch.snitch("c2354d53d2")
   #   # => true
   #
-  # @raise [Timeout::Error] if the request took too long and timed out.
-  #
   # @return [Boolean] if the check-in succeeded.
-  def snitch(token, opts = {})
+  def snitch!(token, opts = {})
     uri       = URI.parse(checkin_url(opts, token))
     uri.query = URI.encode_www_form(m: opts[:message]) if opts[:message]
 
@@ -41,7 +38,30 @@ module Snitcher
       response = http.request(request)
       response.is_a?(Net::HTTPSuccess)
     end
-  rescue ::Timeout::Error
+  end
+
+  # Check-in to Dead Man's Snitch.
+  #
+  # @param token [String] The unique Snitch token to check-in with. This can be
+  #   found on the Setup page as the last part of the HTTP check-in url. For
+  #   example, c2354d53d2 is the token in http://nosnch.in/c2354d53d2.
+  #
+  # @param [Hash] opts
+  #
+  # @option opts [String] :message Text message to include with the check-in.
+  #   The message is limited to 256 characters.
+  #
+  # @option opts [Float, Fixnum] :timeout Number of seconds to wait for a
+  #   response from the server. Default is 5 seconds.
+  #
+  # @example
+  #   Snitch.snitch("c2354d53d2")
+  #   # => true
+  #
+  # @return [Boolean] if the check-in succeeded.
+  def snitch(*args)
+    snitch!(*args)
+  rescue StandardError
     false
   end
 

data/lib/snitcher/api/client.rb

@@ -59,22 +59,22 @@ class Snitcher::API::Client
   #
   # @return [Array<Snitcher::API::Snitch>] the snitches on the account.
   def snitches(filters = {})
-    path  = "/v1/snitches"
     query = {}
 
     # Tags allow for labeling Snitches for better categorization. This allows
     # filtering by a set of tags.
-    if filters[:tags]
-      tags = Array(filters[:tags]).flatten
+    if tags = filters[:tags]
+      tags = Array(tags).flatten
       query[:tags] = tags.map(&:strip).compact.uniq.join(",")
     end
 
-    # Only add the query param if any valid filters were given.
-    if query.any?
-      path = "#{path}?#{URI.encode_www_form(query)}"
-    end
+    # JSON array of Snitch attributes
+    response = get("/v1/snitches", query)
 
-    snitch_array(get(path))
+    # Convert the attributes hashes into Objects
+    response.map! do |snitch|
+      Snitcher::API::Snitch.new(snitch)
+    end
   end
 
   # Get a single Snitch by it's unique token.
@@ -126,10 +126,10 @@ class Snitcher::API::Client
   # @raise [Snitcher::API::Error] if any other API errors occur.
   #
   # @return [Snitcher::API::Snitch] the new Snitch.
-  def create_snitch(attributes={})
-    if attributes.has_key?(:interval)
+  def create_snitch(attributes = {})
+    if interval = attributes.delete(:interval)
       type = attributes[:type] ||= {}
-      type[:interval] ||= attributes.delete(:interval)
+      type[:interval] ||= interval
     end
 
     response = post("/v1/snitches", attributes)
@@ -174,14 +174,15 @@ class Snitcher::API::Client
   # @raise [Snitcher::API::Error] if any other API errors occur.
   #
   # Raise Timeout::Error if the API request times out
-  def update_snitch(token, attributes={})
+  def update_snitch(token, attributes = {})
     if attributes.has_key?(:tags)
       attributes[:tags] = [attributes[:tags]].flatten.compact
     end
 
-    if attributes.has_key?(:interval)
+    # Expand the interval key to the full structure required by the API
+    if interval = attributes.delete(:interval)
       type = attributes[:type] ||= {}
-      type[:interval] ||= attributes.delete(:interval)
+      type[:interval] ||= interval
     end
 
     payload = patch("/v1/snitches/#{token}", attributes)
@@ -207,9 +208,8 @@ class Snitcher::API::Client
   # @raise [Snitcher::API::Error] if an API errors occur.
   #
   # @return [Array<String>] full list of tags on the Snitch.
-  def add_tags(token, tags=[])
-    tags = [tags].flatten
-    post("/v1/snitches/#{token}/tags", tags)
+  def add_tags(token, tags = [])
+    post("/v1/snitches/#{token}/tags", Array(tags).flatten)
   end
 
   # Remove a tag from a Snitch.
@@ -227,8 +227,7 @@ class Snitcher::API::Client
   #
   # @return [Array<String>] list of the remaining tags on the Snitch.
   def remove_tag(token, tag)
-    path = "/v1/snitches/#{token}/tags/#{tag}"
-    delete(URI.encode(path))
+    delete("/v1/snitches/#{token}/tags/#{tag}")
   end
 
   # Pauses a Snitch if it can be paused. Snitches can only be paused if their
@@ -279,7 +278,7 @@ class Snitcher::API::Client
     "Snitcher; #{engine}/#{RUBY_VERSION}; #{RUBY_PLATFORM}; v#{::Snitcher::VERSION}"
   end
 
-  def execute_request(request, options={})
+  def execute_request(request)
     http_options = {
       open_timeout: @timeout,
       read_timeout: @timeout,
@@ -295,7 +294,7 @@ class Snitcher::API::Client
       if request.body
         request["Content-Type"] = "application/json"
 
-        # Some trickiery to allow pushing the JSON rendering down as far as
+        # Some trickery to allow pushing the JSON rendering down as far as
         # possible.
         if !request.body.is_a?(String)
           request.body = JSON.generate(request.body)
@@ -326,37 +325,39 @@ class Snitcher::API::Client
     end
   end
 
-  def get(path, options={})
+  def get(path, query = {})
+    path = URI.encode(path)
+
+    # Only add the query param if any valid filters were given.
+    if query.any?
+      path = "#{path}?#{URI.encode_www_form(query)}"
+    end
+
     request = Net::HTTP::Get.new(path)
-    execute_request(request, options)
+    execute_request(request)
   end
 
-  def post(path, data=nil, options={})
+  def post(path, data = nil)
+    path = URI.encode(path)
+
     request = Net::HTTP::Post.new(path)
     request.body = data
 
-    execute_request(request, options)
+    execute_request(request)
   end
 
-  def patch(path, data, options={})
+  def patch(path, data)
+    path = URI.encode(path)
+
     request = Net::HTTP::Patch.new(path)
     request.body = data
 
-    execute_request(request, options)
+    execute_request(request)
   end
 
-  def delete(path, options={})
+  def delete(path)
+    path    = URI.encode(path)
     request = Net::HTTP::Delete.new(path)
-    execute_request(request, options)
-  end
-
-  private
-
-  def snitch_array(json_payload)
-    arr = []
-    json_payload.each do |payload|
-      arr << Snitcher::API::Snitch.new(payload)
-    end
-    arr
+    execute_request(request)
   end
 end

data/lib/snitcher/version.rb

@@ -1,3 +1,3 @@
 module Snitcher
-  VERSION = "0.4.0.rc2"
+  VERSION = "0.4.0.rc4"
 end

data/spec/snitcher_spec.rb

@@ -9,15 +9,15 @@ describe Snitcher do
     stub_request(:get, /nosnch\.in/)
   end
 
-  describe ".snitch" do
+  describe ".snitch!" do
     it "pings DMS with the given token" do
-      Snitcher.snitch(token)
+      Snitcher.snitch!(token)
 
       expect(a_request(:get, "https://nosnch.in/#{token}")).to have_been_made.once
     end
 
     it "includes a custom user-agent" do
-      Snitcher.snitch(token)
+      Snitcher.snitch!(token)
 
       expect(
         a_request(:get, "https://nosnch.in/#{token}").with(
@@ -26,42 +26,48 @@ describe Snitcher do
       ).to have_been_made
     end
 
-    context "when successful" do
-      before do
-        stub_request(:get, "https://nosnch.in/#{token}").to_return(status: 200)
-      end
+    it "returns true when successful" do
+      request = stub_request(:get, "https://nosnch.in/#{token}").to_return(status: 202)
 
-      it "returns true" do
-        expect(Snitcher.snitch(token)).to eq(true)
-      end
+      expect(Snitcher.snitch!(token)).to eq(true)
+      expect(request).to have_been_made.once
     end
 
-    context "when unsuccessful" do
-      before do
-        stub_request(:get, "https://nosnch.in/#{token}").to_return(status: 404)
-      end
+    it "returns false when unsuccessful" do
+      request = stub_request(:get, "https://nosnch.in/#{token}").to_return(status: 404)
 
-      it "returns false" do
-        expect(Snitcher.snitch(token)).to eq(false)
-      end
+      expect(Snitcher.snitch!(token)).to eq(false)
+      expect(request).to have_been_made.once
     end
 
     describe "with message" do
       it "includes the message as a query param" do
-        Snitcher.snitch(token, message: "A thing just happened")
+        Snitcher.snitch!(token, message: "A thing just happened")
 
         expect(a_request(:get, "https://nosnch.in/#{token}?m=A%20thing%20just%20happened")).to have_been_made
       end
     end
 
-    describe "timeout" do
-      before do
-        stub_request(:get, "https://nosnch.in/#{token}").to_raise(::Timeout::Error)
-      end
+    it "raises a Timeout::Error if the request timesout" do
+      stub_request(:get, "https://nosnch.in/#{token}").to_timeout
 
-      it "returns false when timed out" do
-        expect(Snitcher.snitch(token)).to eq(false)
-      end
+      expect { Snitcher.snitch!(token) }.to raise_error(Timeout::Error)
+    end
+  end
+
+  describe ".snitch" do
+    it "returns true on a successfuly check-in" do
+      stub_request(:get, "https://nosnch.in/#{token}").to_return(status: 202)
+
+      result = Snitcher.snitch(token)
+      expect(result).to be(true)
+    end
+
+    it "returns false on a timeout" do
+      stub_request(:get, "https://nosnch.in/#{token}").to_timeout
+
+      result = Snitcher.snitch(token)
+      expect(result).to be(false)
     end
   end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snitcher
 version: !ruby/object:Gem::Version
-  version: 0.4.0.rc2
+  version: 0.4.0.rc4
 platform: ruby
 authors:
 - Collective Idea
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-05-24 00:00:00.000000000 Z
+date: 2016-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler