adafruit-io 1.0.4 → 2.0.0.beta.1

data/adafruit-io.gemspec

@@ -6,7 +6,7 @@ require 'adafruit/io/version'
 Gem::Specification.new do |spec|
   spec.name          = "adafruit-io"
   spec.version       = Adafruit::IO::VERSION
-  spec.authors       = ["Justin Cooper"]
+  spec.authors       = ["Justin Cooper", "Adam Bachman"]
   spec.email         = ["justin@adafruit.com"]
   spec.summary       = %q{Adafruit IO API Client Library}
   spec.description   = %q{API Client Library for the Adafruit IO product}
@@ -22,9 +22,6 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "faraday", "~> 0.8"
   spec.add_dependency "faraday_middleware", "~> 0.9"
-  spec.add_dependency "activemodel",  "~> 4.2"
-  spec.add_dependency "multi_xml", "~> 0.5"
-  spec.add_dependency "addressable", "~> 2.3"
 
   spec.add_development_dependency "bundler", "~> 1.5"
   spec.add_development_dependency "rake", "~> 10.4"

data/lib/adafruit/io.rb

@@ -3,6 +3,5 @@ require "adafruit/io/version"
 
 module Adafruit
   module IO
-
   end
-end
+end

data/lib/adafruit/io/arguments.rb

@@ -0,0 +1,73 @@
+module Adafruit
+  module IO
+    module Arguments
+
+      # Allows us to give a username during client initialization or with a specific method.
+      def extract_username(args)
+        username = @username
+
+        if args.last.is_a?(Hash) && args.last.has_key?(:username)
+          username = args.last.delete(:username)
+        end
+
+        if username.nil?
+          raise "cannot make request when username is nil"
+        end
+
+        [ username, args ]
+      end
+
+      # Allow users to pass a hash with key named 'key' or :key, or just a
+      # plain string to use as a key.
+      #
+      #   client.feed({ key: 'myfeed' })
+      #   client.feed({ 'key' => 'myfeed' })
+      #   client.feed('myfeed')
+      #
+      # Are all equivalent.
+      def get_key_from_arguments(arguments)
+        record_or_key = arguments.shift
+        return nil if record_or_key.nil?
+
+        if record_or_key.is_a?(String)
+          record_or_key
+        elsif record_or_key.is_a?(Hash) && (record_or_key.has_key?('key') || record_or_key.has_key?(:key))
+          record_or_key['key'] || record_or_key[:key]
+        elsif record_or_key.respond_to?(:key)
+          record_or_key.key
+        else
+          raise 'unrecognized object or key value in arguments'
+        end
+      end
+
+      # Same as get_key_from_arguments but looking for id
+      def get_id_from_arguments(arguments)
+        record_or_id = arguments.shift
+        return nil if record_or_id.nil?
+
+        if record_or_id.is_a?(String)
+          record_or_id
+        elsif record_or_id.is_a?(Hash) && (record_or_id.has_key?('id') || record_or_id.has_key?(:id))
+          record_or_id['id'] || record_or_id[:id]
+        elsif record_or_id.respond_to?(:id)
+          record_or_id.id
+        else
+          raise 'unrecognized object or id value in arguments'
+        end
+      end
+
+      # Get a filtered list of parameters from the next argument
+      def get_query_from_arguments(arguments, params)
+        query = {}
+        options = arguments.shift
+        return query if options.nil?
+
+        params.each do |param|
+          query[param] = options[param.to_sym] if options.has_key?(param.to_sym)
+        end
+        query
+      end
+
+    end
+  end
+end

data/lib/adafruit/io/client.rb

@@ -1,60 +1,55 @@
+require 'json'
+require 'uri'
+
 require 'faraday'
 require 'faraday_middleware'
 require 'faraday_middleware/response/mashify'
-require 'json'
-require 'adafruit/io/client/feed'
-require 'adafruit/io/client/group'
+
+require 'adafruit/io/arguments'
+require 'adafruit/io/configurable'
+require 'adafruit/io/request_handler'
+
+require 'adafruit/io/client/feeds'
 require 'adafruit/io/client/data'
-require 'adafruit/io/client/request_handler'
+require 'adafruit/io/client/groups'
 
 module Adafruit
   module IO
     class Client
 
-      include Adafruit::IO::Client::RequestHandler
+      include Adafruit::IO::Arguments
+      include Adafruit::IO::Configurable
+      include Adafruit::IO::RequestHandler
 
       def initialize(options)
         @key = options[:key]
-      end
-
-      def get(url, options = {})
-        request :handle_get, url, options
-      end
+        @username = options[:username]
 
-      def post(url, data, options = {})
-        request :handle_post, url, data, options
+        @debug = !!options[:debug]
       end
 
-      def put(url, data, options = {})
-        request :handle_put, url, data, options
-      end
-
-      def delete(url, options = {})
-        request :handle_delete, url
+      # Text representation of the client, masking key
+      #
+      # @return [String]
+      def inspect
+        inspected = super
+        inspected = inspected.gsub! @key, "#{@key[0..3]}#{'*' * (@key.size - 3)}" if @key
+        inspected
       end
 
       def last_response
         @last_response
       end
 
-      def feeds(id_or_key = nil)
-        Adafruit::IO::Feed.new(self, id_or_key)
-      end
-
-      def groups(id_or_key = nil)
-        Adafruit::IO::Group.new(self, id_or_key)
-      end
-
-      def data(feed_id_or_key = nil, id_or_key = nil)
-        Adafruit::IO::Data.new(self, feed_id_or_key, id_or_key)
-      end
+      include Adafruit::IO::Client::Feeds
+      include Adafruit::IO::Client::Data
+      include Adafruit::IO::Client::Groups
 
-  private
+      private
 
       def conn
-        #Faraday.new(:url => 'http://localhost:3002') do |c|
-        if ENV['ADAFRUIT_IO_URL']
-          url = ENV['ADAFRUIT_IO_URL']
+        if api_endpoint
+          url = api_endpoint
         else
           url = 'https://io.adafruit.com'
         end
@@ -65,17 +60,20 @@ module Adafruit
           c.headers['User-Agent'] = "AdafruitIO-Ruby/#{VERSION} (#{RUBY_PLATFORM})"
           c.request :json
 
-          c.response :xml,  :content_type => /\bxml$/
-          #c.response :mashify, :content_type => /\bjson$/
-          #c.response :json
+          # if @debug is true, Faraday will get really noisy when making requests
+          if @debug
+            c.response :logger
+          end
 
           c.use :instrumentation
           c.adapter Faraday.default_adapter
         end
       end
 
-      def request(method, url, data = nil, options = nil)
-        @last_response = send(method, url, data)
+      def api_url(username, *args)
+        to_join = ['api', 'v2', username].concat(args)
+
+        File.join(*to_join)
       end
     end
   end

data/lib/adafruit/io/client/data.rb

@@ -1,70 +1,122 @@
-require 'adafruit/io/client/io_object'
-require 'adafruit/io/client/feed'
-
 module Adafruit
   module IO
-    class Data < IOObject
-      def initialize(client = nil, feed = nil, id_or_key = nil)
-        super(client, id_or_key)
+    class Client
+      module Data
 
-        @feed = feed
-        @base_url = "feeds/#{@feed.id}"
-      end
+        # Add data to a feed.
+        #
+        # Params:
+        #   - feed_key: string
+        #   - value: string or number
+        #   - location (optional): {lat: Number, lon: Number, ele: Number}
+        #   - created_at (optional): iso8601 date time string.
+        #
+        def send_data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          value = arguments.shift
 
-      def create(options = {})
-        response = @client.post "#{@base_url}/data", options
-        return process_response(response)
-      end
+          attrs = {
+            value: value
+          }
+
+          if arguments.size > 0 && arguments.first.is_a?(Hash)
+            location = arguments.shift
+            if location[:lat] && location[:lon]
+              attrs[:lat] = location[:lat]
+              attrs[:lon] = location[:lon]
+              attrs[:ele] = location[:ele]
+            end
+          end
 
-      def retrieve(id_or_key = nil, options = {})
-        if id_or_key
-          @id_or_key = id_or_key
-          response = @client.get "#{@base_url}/data/#{id_or_key}", options
-        else
-          response = @client.get "#{@base_url}/data", options
+          if arguments.size > 0
+            if arguments.first.is_a?(String)
+              created_at = arguments.shift
+              attrs[:created_at] = created_at
+            elsif arguments.first.is_a?(Time)
+              created_at = arguments.shift
+              attrs[:created_at] = created_at.utc.iso8601
+            end
+          end
+
+          post api_url(username, 'feeds', feed_key, 'data'), attrs
         end
 
-        return process_response(response)
-      end
+        # Send a batch of data points.
+        #
+        # Points can either be a list of strings, numbers, or hashes with the
+        # keys [ value, created_at OPTIONAL, lat OPTIONAL, lon OPTIONAL, ele OPTIONAL ]
+        #
+        def send_batch_data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          values = arguments.shift
+
+          if values.nil? || !values.is_a?(Array)
+            raise "expected batch values to be an array"
+          end
 
-      def delete
-        response = @client.delete "#{@base_url}/data/#{self.id}"
-        if response == 200
-          {"delete" => true, "id" => self.id}
-        else
-          {"delete" => false, "id" => self.id}
+          if !values.first.is_a?(Hash)
+            # convert values to hashes with single key: 'value'
+            values = values.map {|val| {value: val}}
+          end
+
+          post api_url(username, 'feeds', feed_key, 'data', 'batch'), data: values
         end
-      end
 
-      def save
-        response = @client.put "#{@base_url}/data/#{self.id}", serialize_params(self)
-        @unsaved_values.clear
+        # Get all data for a feed, may paginate.
+        def data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          query = get_query_from_arguments arguments, %w(start_time end_time limit)
 
-        return process_response(response)
-      end
+          get api_url(username, 'feeds', feed_key, 'data'), query
+        end
 
-      def send_data(data)
-        response = @client.post "#{@base_url}/data/send", {:value => data}
-        return process_response(response)
-      end
+        # Get charting data for a feed.
+        def data_chart(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          query = get_query_from_arguments arguments, %w(start_time end_time limit hours resolution)
 
-      def receive
-        response = @client.get "#{@base_url}/data/last"
-        return process_response(response)
-      end
+          get api_url(username, 'feeds', feed_key, 'data', 'chart'), query
+        end
 
-      def last
-        receive
-      end
+        # Get a single data point.
+        def datum(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          data_id = arguments.shift
 
-      def next
-        response = @client.get "#{@base_url}/data/next"
-        return process_response(response)
-      end
+          get api_url(username, 'feeds', feed_key, 'data', data_id)
+        end
+
+        # Retrieve the next unprocessed data point.
+        def next_data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          get api_url(username, 'feeds', feed_key, 'data', 'next')
+        end
+
+        # Retrieve the previously processed data point. This method does not
+        # move the stream pointer.
+        def prev_data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          get api_url(username, 'feeds', feed_key, 'data', 'prev')
+        end
+
+        # Move the stream processing pointer to and retrieve the last (newest)
+        # data point available.
+        def last_data(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          get api_url(username, 'feeds', feed_key, 'data', 'last')
+        end
 
-      def previous
-        response = @client.get "#{@base_url}/data/previous"
-        return process_response(response)
       end
     end
   end

data/lib/adafruit/io/client/feeds.rb

@@ -0,0 +1,60 @@
+
+module Adafruit
+  module IO
+    class Client
+      module Feeds
+
+        # Get all feeds.
+        def feeds(*args)
+          username, _ = extract_username(args)
+
+          get api_url(username, 'feeds')
+        end
+
+        # Get a feed specified by key
+        def feed(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          get api_url(username, 'feeds', feed_key)
+        end
+
+        # Get a feed along with additional details about the feed. This method
+        # has more to lookup and so is slower than `feed`
+        def feed_details(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          get api_url(username, 'feeds', feed_key, 'details')
+        end
+
+        def create_feed(*args)
+          username, arguments = extract_username(args)
+          feed_attrs = arguments.shift
+
+          post api_url(username, 'feeds'), feed_attrs
+        end
+
+        def delete_feed(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+
+          delete api_url(username, 'feeds', feed_key)
+        end
+
+        def update_feed(*args)
+          username, arguments = extract_username(args)
+          feed_key = get_key_from_arguments(arguments)
+          query = get_query_from_arguments(
+            arguments,
+            %w(name key description unit_type unit_symbol history visibility
+               license status_notify status_timeout)
+          )
+
+          put api_url(username, 'feeds', feed_key), query
+        end
+
+      end
+    end
+  end
+end