helium-ruby 0.4.0 → 0.5.0

data/docs/top-level-namespace.html

@@ -102,7 +102,7 @@
 </div>
 
       <div id="footer">
-  Generated on Mon Aug 22 15:52:19 2016 by
+  Generated on Wed Aug 24 13:22:50 2016 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
   0.9.3 (ruby-2.3.1).
 </div>

data/lib/helium.rb

@@ -3,6 +3,7 @@ require 'json'
 require 'date'
 
 require "helium/version"
+require "helium/error"
 require "helium/utils"
 require "helium/client"
 require "helium/cursor"

data/lib/helium/client.rb

@@ -17,9 +17,9 @@ module Helium
 
     attr_accessor :api_key
 
-    def initialize(api_key:, debug: false)
-      @api_key = api_key
-      @debug = debug
+    def initialize(opts = {})
+      @api_key = opts.fetch(:api_key)
+      @debug   = opts.fetch(:debug, false)
     end
 
     def inspect

data/lib/helium/client/elements.rb

@@ -2,40 +2,23 @@ module Helium
   class Client
     module Elements
       def elements
-        response = get('/element')
-        elements_data = JSON.parse(response.body)["data"]
-
-        elements = elements_data.map do |element_data|
-          Element.new(client: self, params: element_data)
-        end
-
-        return elements
+        Element.all(client: self)
       end
 
       def element(id)
-        response = get("/element/#{id}")
-        element_data = JSON.parse(response.body)["data"]
-
-        return Element.new(client: self, params: element_data)
+        Element.find(id, client: self)
       end
 
-      def update_element(element, name:)
-        path = "/element/#{element.id}"
-
-        body = {
-          data: {
-            attributes: {
-              name: name
-            },
-            id: element.id,
-            type: "element"
-          }
-        }
+      def element_sensors(element)
+        path = "/element/#{element.id}?include=sensor"
+        response = get(path)
+        sensors_data = JSON.parse(response.body)["included"]
 
-        response = patch(path, body: body)
-        element_data = JSON.parse(response.body)["data"]
+        sensors = sensors_data.map do |sensor|
+          Sensor.new(client: self, params: sensor)
+        end
 
-        return Element.new(client: self, params: element_data)
+        return sensors
       end
     end
   end

data/lib/helium/client/http.rb

@@ -11,28 +11,27 @@ module Helium
         'User-Agent'    => 'helium-ruby'
       }
 
-      def get(path = nil, url: nil, params: {})
-        request = generate_request(path, url: url, method: :get, params: params)
-        run(request)
+      def get(path, opts = {})
+        run(path, :get, opts)
       end
 
-      def paginated_get(path, klass:, params: {})
+      def paginated_get(path, opts = {})
+        klass  = opts.fetch(:klass)
+        params = opts.fetch(:params, {})
+
         Cursor.new(client: self, path: path, klass: klass, params: params)
       end
 
-      def post(path, body: {})
-        request = generate_request(path, method: :post, body: body)
-        run(request)
+      def post(path, opts = {})
+        run(path, :post, opts)
       end
 
-      def patch(path, body: {})
-        request = generate_request(path, method: :patch, body: body)
-        run(request)
+      def patch(path, opts = {})
+        run(path, :patch, opts)
       end
 
       def delete(path)
-        request = generate_request(path, method: :delete)
-        response = run(request)
+        response = run(path, :delete)
         response.code == 204
       end
 
@@ -44,9 +43,24 @@ module Helium
         })
       end
 
-      def generate_request(path = nil, url: nil, method:, params: {}, body: {})
-        path = path.gsub(/^\//, '') if path
-        url ||= "#{PROTOCOL}://#{HOST}/v#{API_VERSION}/#{path}"
+      def run(path, method, opts = {})
+        request = generate_request(path, opts.merge(method: method))
+        response = run_request(request)
+        return response
+      end
+
+      def generate_request(path, opts = {})
+        method = opts.fetch(:method)
+        params = opts.fetch(:params, {})
+        body   = opts.fetch(:body, {})
+
+
+        url = if path =~ /^http/
+          path
+        else
+          path = path.gsub(/^\//, '')
+          "#{PROTOCOL}://#{HOST}/v#{API_VERSION}/#{path}"
+        end
 
         Typhoeus::Request.new(url, {
           method:   method,
@@ -56,19 +70,24 @@ module Helium
         })
       end
 
-      def run(request)
+      def run_request(request)
         request.run()
 
+        response = request.response
+
         if debug?
           method = request.options[:method]
           puts "#{method.upcase} #{request.url} #{request.response.code} #{request.response.total_time}"
           # puts request.response.body
         end
 
-        # TODO error handling
-        # halt(request.response.code, "Helium Get Failed: #{request.response.code.to_s}") unless request.response.code.between?(200,399)\
+        halt(response) unless response.code.between?(200,399)
+
+        return response
+      end
 
-        return request.response
+      def halt(response)
+        raise Helium::Error.from_response(response)
       end
     end
   end

data/lib/helium/client/labels.rb

@@ -2,63 +2,15 @@ module Helium
   class Client
     module Labels
       def labels
-        response = get('/label')
-        labels_data = JSON.parse(response.body)["data"]
-
-        labels = labels_data.map do |label_data|
-          Label.new(client: self, params: label_data)
-        end
-
-        return labels
+        Label.all(client: self)
       end
 
       def label(id)
-        response = get("/label/#{id}")
-        label_data = JSON.parse(response.body)["data"]
-
-        return Label.new(client: self, params: label_data)
-      end
-
-      def new_label(name:)
-        path = "/label"
-
-        body = {
-          data: {
-            attributes: {
-              name: name
-            },
-            type: "label"
-          }
-        }
-
-        response = post(path, body: body)
-        label_data = JSON.parse(response.body)["data"]
-
-        return Label.new(client: self, params: label_data)
+        Label.find(id, client: self)
       end
 
-      def update_label(label, name:)
-        path = "/label/#{label.id}"
-
-        body = {
-          data: {
-            attributes: {
-              name: name
-            },
-            id: label.id,
-            type: "label"
-          }
-        }
-
-        response = patch(path, body: body)
-        label_data = JSON.parse(response.body)["data"]
-
-        return Label.new(client: self, params: label_data)
-      end
-
-      def delete_label(label)
-        path = "/label/#{label.id}"
-        delete(path)
+      def create_label(attributes)
+        Label.create(attributes, client: self)
       end
 
       def label_sensors(label)
@@ -73,7 +25,9 @@ module Helium
         return sensors
       end
 
-      def update_label_sensors(label, sensors: [])
+      def update_label_sensors(label, opts = {})
+        sensors = opts.fetch(:sensors, [])
+
         path = "/label/#{label.id}/relationships/sensor"
 
         sensors = Array(sensors)

data/lib/helium/client/sensors.rb

@@ -2,21 +2,11 @@ module Helium
   class Client
     module Sensors
       def sensors
-        response = get('/sensor')
-        sensors_data = JSON.parse(response.body)["data"]
-
-        sensors = sensors_data.map do |sensor_data|
-          Sensor.new(client: self, params: sensor_data)
-        end
-
-        return sensors
+        Sensor.all(client: self)
       end
 
       def sensor(id)
-        response = get("/sensor/#{id}")
-        sensor_data = JSON.parse(response.body)["data"]
-
-        return Sensor.new(client: self, params: sensor_data)
+        Sensor.find(id, client: self)
       end
 
       def sensor_timeseries(sensor, opts = {})
@@ -29,53 +19,14 @@ module Helium
           "filter[end]"   => datetime_to_iso(opts.fetch(:end_time, nil)),
           "agg[type]"     => opts.fetch(:aggtype),
           "agg[size]"     => opts.fetch(:aggsize)
-        }.delete_if { |key, value| value.to_s.empty? }
+        }.delete_if { |_key, value| value.to_s.empty? }
 
         paginated_get(path, klass: Helium::DataPoint, params: params)
       end
 
-      def new_sensor(name:)
-        path = "/sensor"
-
-        body = {
-          data: {
-            attributes: {
-              name: name
-            },
-            type: "sensor"
-          }
-        }
-
-        response = post(path, body: body)
-        sensor_data = JSON.parse(response.body)["data"]
-
-        return Sensor.new(client: self, params: sensor_data)
-      end
-
-      def update_sensor(sensor, name:)
-        path = "/sensor/#{sensor.id}"
-
-        body = {
-          data: {
-            attributes: {
-              name: name
-            },
-            id: sensor.id,
-            type: "sensor"
-          }
-        }
-
-        response = patch(path, body: body)
-        sensor_data = JSON.parse(response.body)["data"]
-
-        return Sensor.new(client: self, params: sensor_data)
+      def create_sensor(attributes)
+        Sensor.create(attributes, client: self)
       end
-
-      def delete_sensor(sensor)
-        path = "/sensor/#{sensor.id}"
-        delete(path)
-      end
-
     end
   end
 end

data/lib/helium/cursor.rb

@@ -2,11 +2,11 @@ module Helium
   class Cursor
     include Enumerable
 
-    def initialize(client:, path:, klass:, params: {})
-      @client = client
-      @path   = path
-      @klass  = klass
-      @params = params
+    def initialize(opts = {})
+      @client = opts.fetch(:client)
+      @path   = opts.fetch(:path)
+      @klass  = opts.fetch(:klass)
+      @params = opts.fetch(:params, {})
 
       @collection = []
       @next_link  = nil
@@ -37,7 +37,7 @@ module Helium
 
     def fetch_next_page
       if @next_link
-        response = @client.get(url: @next_link)
+        response = @client.get(@next_link)
       else
         response = @client.get(@path, params: @params)
       end

data/lib/helium/data_point.rb

@@ -2,12 +2,12 @@ module Helium
   class DataPoint < Resource
     attr_reader :timestamp, :value, :port
 
-    def initialize(client:, params:)
-      super(client: client, params: params)
+    def initialize(opts = {})
+      super(opts)
 
-      @timestamp  = params.dig("attributes", "timestamp")
-      @value      = params.dig("attributes", "value")
-      @port       = params.dig("attributes", "port")
+      @timestamp  = @params.dig("attributes", "timestamp")
+      @value      = @params.dig("attributes", "value")
+      @port       = @params.dig("attributes", "port")
     end
 
     def timestamp

data/lib/helium/element.rb

@@ -2,17 +2,16 @@ module Helium
   class Element < Resource
     attr_reader :name, :mac, :versions
 
-    def initialize(client:, params:)
-      super(client: client, params: params)
+    def initialize(opts = {})
+      super(opts)
 
-      @name     = params.dig("attributes", "name")
-      @mac      = params.dig("meta", "mac")
-      @versions = params.dig("meta", "versions")
+      @name     = @params.dig("attributes", "name")
+      @mac      = @params.dig("meta", "mac")
+      @versions = @params.dig("meta", "versions")
     end
 
-    # TODO these kinds of methods should be generalized into a Resource object
-    def update(name:)
-      @client.update_element(self, name: name)
+    def sensors
+      @client.element_sensors(self)
     end
 
     # TODO can probably generalize this a bit more

data/lib/helium/error.rb

@@ -0,0 +1,28 @@
+module Helium
+  # Custom error class for rescuing from Helium API errors
+  class Error < StandardError
+
+    # Returns the appropriate Helium::Error subclass based on status and
+    # response message
+    #
+    # @param [Typhoeus::Response] response
+    # @return [Helium::Error]
+    def self.from_response(response)
+      status  = response.code
+      message = JSON.parse(response.body)["errors"].first["detail"]
+
+      klass =  case status
+               when 401   then Helium::InvalidApiKey
+               else self
+               end
+
+      klass.new(message)
+    end
+  end
+
+  # Raised on errors in the 400-499 range
+  class ClientError < Error; end
+
+  # Raised when Helium returns a 401 error
+  class InvalidApiKey < ClientError; end
+end

data/lib/helium/label.rb

@@ -2,18 +2,10 @@ module Helium
   class Label < Resource
     attr_reader :name
 
-    def initialize(client:, params:)
-      super(client: client, params: params)
+    def initialize(opts = {})
+      super(opts)
 
-      @name = params.dig("attributes", "name")
-    end
-
-    def update(name:)
-      @client.update_label(self, name: name)
-    end
-
-    def destroy
-      @client.delete_label(self)
+      @name = @params.dig("attributes", "name")
     end
 
     # TODO: would be nice to wrap this in a proxy collection, that way