withings-sdk 0.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bffdaac5113e9b8548d0e9540fed0d105f4fac7f
+  data.tar.gz: 66b5665d6663a342e9b6de3edc8618500e3a8154
+SHA512:
+  metadata.gz: dc2889228ece6b6c4a63c3a90510946558637a54cdce47300d3bd9c0c82bd2cf146e36c0ce0ad0665756890a73165856148e85f76cb80f86ed47211b1d8de52c
+  data.tar.gz: a34bd32aa020683d997ce7d4b19da2da4ff2a40cf853231a1dcd903941546262cc1907616973f10bd1eb52f683e1ef105e6bc23d4dd3f7eb4a417dca7f7f550c

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/.ruby-version
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - 2.1.3
+addons:
+  code_climate:
+    repo_token:
+      secure: "nNf8S+GUM7H0AXyv2dQ2GiDi4qhfLlP7JMXRSL4Bm6MUNPJ5mxRd5cNOdhQaqwcnZXSXkcqr6AEc79XBQBTYWB/o/VAq0yApKw1uvV1g9EQvpGcsSZf6OfcLExCNgZT4chJccfQ+Qd+ToJS6cUF+RY/1RXWfhmaj54DBH2E1lz0="

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+group :test do
+  gem 'codeclimate-test-reporter', require: nil
+  gem 'webmock', '~> 1.2'
+end
+
+# Specify your gem's dependencies in activite.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Paul Osman
+
+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,142 @@
+# Withings API Ruby Gem
+
+[![Build Status](http://img.shields.io/travis/paulosman/withings-sdk.svg)][travis]
+[![Code Climate](https://codeclimate.com/github/paulosman/withings-sdk/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/paulosman/withings-sdk/badges/coverage.svg)][coverage]
+[![Dependency Status](https://gemnasium.com/paulosman/withings-sdk.svg)][gemnasium]
+[![Gem Version](https://badge.fury.io/rb/withings-sdk.svg)][gemversion]
+
+This gem provides access to data collected by [Withings](http://withings.com/) devices through
+their [HTTP API](https://oauth.withings.com/api/doc).
+
+[travis]: https://travis-ci.org/paulosman/withings-sdk
+[codeclimate]: https://codeclimate.com/github/paulosman/withings-sdk
+[coverage]: https://codeclimate.com/github/paulosman/withings-sdk
+[gemnasium]: https://gemnasium.com/paulosman/withings-sdk
+[gemversion]: https://badge.fury.io/rb/withings-sdk
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'withings-sdk'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install withings-sdk
+
+## Usage
+
+### Authorization
+
+Withings uses OAuth 1.0a for API authorization. If you're unfamiliar with OAuth, you can
+[read about it here][bible] or you can [read the full spec][spec] if you're feeling brave.
+
+Before you can make requests to the Withings API, you must first obtain user authorization and
+generate an Access Token. Before you can write an application that uses the Withings API you
+must [register and obtain consumer credentials][register].
+
+The following examples assume you are using a web framework such as [Sinatra][sinatra].
+
+[register]: https://oauth.withings.com/partner/add "Withings Application Registration"
+[bible]: http://oauthbible.com/ "OAuth Bible"
+[spec]: http://oauth.net/core/1.0a/ "OAuth 1.0a Core Spec"
+[sinatra]: http://www.sinatrarb.com/ "Sinatra"
+
+```ruby
+client = WithingsSDK::Client.new({
+  consumer_key: 'YOUR_CONSUMER_KEY',
+  consumer_secret: 'YOUR_CONSUMER_SECRET'
+})
+
+request_token = client.request_token({
+  oauth_callback: 'YOUR_OAUTH_CALLBACK'
+})
+
+authorize_url = client.authorize_url(request_token.token, request_token.secret)
+redirect authorize_url
+```
+
+When the user has finished authorizing your application, they will be redirected
+to the callback URL you specified with the following parameters in the query string:
+```userid```, ```oauth_token``` and ```oauth_verifier```. Store these parameters as
+you'll need them later.
+
+```ruby
+client = WithingsSDK::Client.new({
+  consumer_key: 'YOUR_CONSUMER_KEY',
+  consumer_secret: 'YOUR_CONSUMER_SECRET'
+})
+
+client.access_token(request_token.token, request_token.secret, {
+  oauth_verifier: 'OAUTH_VERIFIER'
+})
+```
+
+## Making Requests
+
+Now that you have an authorized access token, you can create a ```WithingsSDK::Client``` instance:
+
+```ruby
+client = WithingsSDK::Client.new do |config|
+  config.consumer_key        = 'YOUR_CONSUMER_KEY'
+  config.consumer_secret     = 'YOUR_CONSUMER_SECRET'
+  config.token               = 'YOUR_ACCESS_TOKEN'
+  config.secret              = 'YOUR_ACCESS_TOKEN_SECRET'
+end
+```
+
+Now you can make authenticated requests on behalf of a user. For example, to get a list of
+activity measures, you can use the following example:
+
+```ruby
+activities = client.activities(user_id, { startdateymd: '2015-01-01', enddateymd: '2015-02-28' })
+activities.each do |activity|
+  if activity.is_a?(WithingsSDK::Activity)
+    puts "Date: #{activity.date}, Steps: #{activity.steps}"
+  end
+end
+```
+## Dates
+
+Many of the Withings API endpoints accept a date parameter in either YYYY-MM-DD format or as a
+unix epoch. This gem tries to simplify date handling by allowing you to specify either, or a
+```Date``` or ```DateTime``` instance. For example:
+
+```ruby
+client = WithingsSDK::Client.new { options }
+sleep_details = client.sleep_series(user_id, {
+  startdate: DateTime.new(2015, 2, 20, 12, 0, 0),
+  enddate: DateTime.new(2015, 2, 21, 12, 20, 0)
+})
+```
+
+Or equivalently,
+
+```ruby
+client = WithingsSDK::Client.new { options }
+sleep_details = client.sleep_series(user_id, {
+  startdate: '2015-02-20',
+  enddate: '2015-02-21'
+})
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/paulosman/withings-sdk/fork )
+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 a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require 'rspec/core/rake_task'
+require 'bundler/gem_tasks'
+
+# Default directory to look in is `/specs`
+# Run with `rake spec`
+RSpec::Core::RakeTask.new(:spec) do |task|
+  task.rspec_opts = ['--color', '--format', 'documentation']
+end
+
+task :default => :spec
+
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "withings-sdk"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/withings-sdk.rb

@@ -0,0 +1,7 @@
+require 'withings-sdk/version'
+require 'withings-sdk/http/oauth'
+require 'withings-sdk/utils'
+require 'withings-sdk/client'
+
+module WithingsSDK
+end

data/lib/withings-sdk/activity.rb

@@ -0,0 +1,6 @@
+require 'withings-sdk/base'
+
+module WithingsSDK
+  class Activity < Base
+  end
+end

data/lib/withings-sdk/base.rb

@@ -0,0 +1,18 @@
+module WithingsSDK
+  class Base
+    # @return [Hash]
+    attr_reader :attrs
+
+    # Initializes a new object with attributes for the values passed to the constructor.
+    #
+    # @param attrs [Hash]
+    # @return [WithingsSDK::Base]
+    def initialize(attrs = {})
+      @attrs = attrs || {}
+      @attrs.each do |key, value|
+        self.class.class_eval { attr_reader key }
+        instance_variable_set("@#{key}", value)
+      end
+    end
+  end
+end

data/lib/withings-sdk/client.rb

@@ -0,0 +1,222 @@
+require 'withings-sdk/error'
+require 'withings-sdk/http/request'
+require 'withings-sdk/activity'
+require 'withings-sdk/measurement_group'
+require 'withings-sdk/notification'
+require 'withings-sdk/sleep_series'
+require 'withings-sdk/sleep_summary'
+require 'withings-sdk/response'
+
+module WithingsSDK
+  class Client
+    include WithingsSDK::HTTP::OAuthClient
+
+    attr_writer :user_agent
+
+    # Initializes a new Client object used to communicate with the Withings API.
+    #
+    # An authenticated Client can be created with an access token and access token
+    # secret if the user has previously authorized access to their Withings account
+    # and you've stored their access credentials. An unauthenticated Client can be
+    # created that will allow you to initiate the OAuth authorization flow, directing
+    # the user to Withings to authorize access to their account.
+    #
+    # @param options [Hash]
+    # @option options [String] :consumer_key The consumer key (required)
+    # @option options [String] :consumer_secret The consumer secret (required)
+    # @option options [String] :token The access token (if you've stored it)
+    # @option options [String] :secret The access token secret (if you've stored it)
+    #
+    # @example User has not yet authorized access to their Withings account
+    #   client = WithingsSDK::Client.new({ consumer_key: your_key, consumer_secret: your_secret })
+    #
+    # @example User has authorized access to their Withings account
+    #   client = WithingsSDK::Client.new({
+    #     consumer_key: your_key,
+    #     consumer_secret: your_secret,
+    #     token: your_access_token,
+    #     secret: your_access_token_secret
+    #   })
+    #
+    # @example You can also pass parameters as a block
+    #   client = WithingsSDK::Client.new do |config|
+    #     config.consumer_key = your_key
+    #     config.consumer_secret = your_secret
+    #     config.token = token
+    #     config.secret = secret
+    #   end
+    #
+    # @return [WithingsSDK::Client]
+    def initialize(options = {})
+      options.each do |key, value|
+        instance_variable_set("@#{key}", value)
+      end
+
+      yield(self) if block_given?
+
+      unless @token.nil? || @secret.nil?
+        @access_token = existing_access_token(@token, @secret)
+      end
+    end
+
+    # Return the User-Agent string
+    #
+    # @return [String]
+    def user_agent
+      @user_agent ||= "WithingsRubyGem/#{WithingsSDK::VERSION}"
+    end
+
+    # Get a list of activity measures for the specified user
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::Activity>]
+    def activities(user_id, options = {})
+      perform_request(:get, '/v2/measure', WithingsSDK::Activity, 'activities', {
+        action: 'getactivity',
+        userid: user_id
+      }.merge(options))
+    end
+
+    # Get a list of body measurements taken by Withings devices
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::MeasurementGroup>]
+    def body_measurements(user_id, options = {})
+      perform_request(:get, '/measure', WithingsSDK::MeasurementGroup, 'measuregrps', {
+        action: 'getmeas',
+        userid: user_id
+      }.merge(options))
+    end
+
+    # Return a list of weight body measurements
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::Measure::Weight>]
+    def weight(user_id, options = {})
+      groups = body_measurements(user_id, options)
+      weights = []
+      groups.each do |group|
+        group.measures.each do |measure|
+          next if !measure.is_a? WithingsSDK::Measure::Weight
+          weights << WithingsSDK::Measure::Weight.new(measure.attrs.merge('weighed_at' => group.date))
+        end
+      end
+      weights
+    end
+
+    # Get details about a user's sleep
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::Sleep>]
+    def sleep_series(user_id, options = {})
+      perform_request(:get, '/v2/sleep', WithingsSDK::SleepSeries, 'series', {
+        action: 'get',
+        userid: user_id
+      }.merge(options))
+    end
+
+    # Get a summary of a user's night. Includes the total time they slept,
+    # how long it took them to fall asleep, how long it took them to fall
+    # asleep, etc.
+    #
+    # NOTE: user_id isn't actually used in this API call (so I assume it is
+    # derived from the OAuth credentials) but I was uncomfortable introducing
+    # this inconsistency into this gem.
+    #
+    # @param user_id [Intger]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::SleepSummary>]
+    def sleep_summary(user_id, options = {})
+      perform_request(:get, '/v2/sleep', WithingsSDK::SleepSummary, 'series', {
+        action: 'getsummary'
+      }.merge(options))
+    end
+
+    # Register a webhook / notification with the Withings API. This allows
+    # you to be notified when new data is available for a user.
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [WithingsSDK::Response]
+    def create_notification(user_id, options = {})
+      perform_request(:post, '/notify', WithingsSDK::Response, nil, {
+        action: 'subscribe'
+      }.merge(options))
+    end
+
+    # Get information about a specific webhook / notification.
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [WithingsSDK::Notification]
+    def get_notification(user_id, options = {})
+      perform_request(:get, '/notify', WithingsSDK::Notification, nil, {
+        action: 'get'
+      }.merge(options))
+    end
+
+    # Return a list of registered webhooks / notifications.
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [Array<WithingsSDK::Notification>]
+    def list_notifications(user_id, options = {})
+      perform_request(:get, '/notify', WithingsSDK::Notification, 'profiles', {
+        action: 'list'
+      }.merge(options))
+    end
+
+    # Revoke previously subscribed webhook / notification.
+    #
+    # @param user_id [Integer]
+    # @param options [Hash]
+    #
+    # @return [WithingsSDK::Response]
+    def revoke_notification(user_id, options = {})
+      perform_request(:get, '/notify', WithingsSDK::Response, nil, {
+        action: 'revoke'
+      }.merge(options))
+    end
+
+    private
+
+    # Helper function that handles all API requests
+    #
+    # @param http_method [Symbol]
+    # @param path [String]
+    # @param klass [Class]
+    # @param key [String]
+    # @param options [Hash]
+    #
+    # @return [Array<Object>]
+    def perform_request(http_method, path, klass, key, options = {})
+      if @consumer_key.nil? || @consumer_secret.nil?
+        raise WithingsSDK::Error::ClientConfigurationError, "Missing consumer_key or consumer_secret"
+      end
+      options = WithingsSDK::Utils.normalize_date_params(options)
+      request = WithingsSDK::HTTP::Request.new(@access_token, { 'User-Agent' => user_agent })
+      response = request.send(http_method, path, options)
+      if key.nil?
+        klass.new(response)
+      elsif response.has_key? key
+        response[key].collect do |element|
+          klass.new(element)
+        end
+      else
+        [klass.new(response)]
+      end
+    end
+  end
+end

data/lib/withings-sdk/error.rb

@@ -0,0 +1,18 @@
+module WithingsSDK
+  # Custom errors for rescuing from Withings API errors
+  class Error < StandardError
+    # @return [Integer]
+    attr_reader :code
+
+    # Raised when client is misconfigured
+    ClientConfigurationError = Class.new(self)
+
+    # Withings returns 200 for everything, making it difficult to figure out
+    # exactly what went wrong. They also appear to send back fairly arbitrary
+    # codes, for example a response with an HTTP Status Code 200 can contain
+    # a body {"status":503,"error":"Invalid Params"} if OAuth credentials are
+    # incorrect (503 normally indicates that a downstream service is unavailable).
+    # Because of this we just wrap most errors in this class.
+    InvalidResponseError = Class.new(self)
+  end
+end

data/lib/withings-sdk/http/oauth.rb

@@ -0,0 +1,50 @@
+require 'oauth'
+
+module WithingsSDK
+  module HTTP
+    module OAuthClient
+      attr_accessor :consumer_key, :consumer_secret, :token, :secret
+      attr_writer :consumer
+
+      DEFAULT_OPTIONS = {
+        site:              'https://oauth.withings.com',
+        proxy:              nil,
+        request_token_path: '/account/request_token',
+        authorize_path:     '/account/authorize',
+        access_token_path:  '/account/access_token',
+        scheme:             :query_string
+      }
+
+      def request_token(options = {})
+        consumer.get_request_token(options)
+      end
+
+      def authorize_url(token, secret, options = {})
+        request_token = OAuth::RequestToken.new(consumer, token, secret)
+        request_token.authorize_url(options)
+      end
+
+      def access_token(token, secret, options = {})
+        request_token = OAuth::RequestToken.new(consumer, token, secret)
+        @access_token = request_token.get_access_token(options)
+        @token = @access_token.token
+        @secret = @access_token.secret
+        @access_token
+      end
+
+      def existing_access_token(token, secret)
+        OAuth::AccessToken.new(consumer, token, secret)
+      end
+
+      def connected?
+        !@access_token.nil?
+      end
+
+      private
+
+      def consumer
+        @consumer ||= OAuth::Consumer.new(@consumer_key, @consumer_secret, DEFAULT_OPTIONS)
+      end
+    end
+  end
+end

data/lib/withings-sdk/http/request.rb

@@ -0,0 +1,61 @@
+require 'uri'
+require 'json'
+require 'net/http'
+
+module WithingsSDK
+  module HTTP
+    BASE_URI = 'https://wbsapi.withings.net'
+
+    class Request
+      def initialize(access_token, headers)
+        @access_token = access_token
+        @headers = headers
+      end
+
+      def get(path, options = {})
+        request(:get, path, options)
+      end
+
+      def post(path, options = {})
+        request(:post, path, options)
+      end
+
+      protected
+
+      def hash_to_query(hash)
+        return URI.encode(hash.map{|k,v| "#{k}=#{v}"}.join("&"))
+      end
+
+      def request_with_body(method, path, options = {})
+        body = hash_to_query(options)
+        uri  = "#{BASE_URI}#{path}"
+        @access_token.send(method, uri, body, @headers)
+      end
+
+      def request_with_query_string(method, path, options = {})
+        uri = "#{BASE_URI}#{path}?#{hash_to_query(options)}"
+        @access_token.send(method, uri, @headers)
+      end
+
+      def request(method, path, options = {})
+        if [:post, :put].include? method
+          response = request_with_body(method, path, options)
+        else
+          response = request_with_query_string(method, path, options)
+        end
+
+        if response.code.to_i < 200 or response.code.to_i >= 400
+          raise WithingsSDK::Error::ClientConfigurationError, response.body
+        end
+
+        body = JSON.parse(response.body)
+        if body['status'].to_i != 0
+          raise WithingsSDK::Error::InvalidResponseError, "#{body['status']} - #{body['error']}"
+        end
+
+        body['body'] ||= body
+        body['body']
+      end
+    end
+  end
+end

data/lib/withings-sdk/measurement_group.rb

@@ -0,0 +1,31 @@
+require 'withings-sdk/measures'
+
+module WithingsSDK
+  class MeasurementGroup < Base
+    # Types of body measurements collected by Withings devices and supported
+    # by this gem. See http://oauth.withings.com/api/doc#api-Measure-get_measure
+    # for details.
+    TYPES = {
+      1  => WithingsSDK::Measure::Weight,
+      4  => WithingsSDK::Measure::Height,
+      5  => WithingsSDK::Measure::FatFreeMass,
+      6  => WithingsSDK::Measure::FatRatio,
+      8  => WithingsSDK::Measure::FatMassWeight,
+      11 => WithingsSDK::Measure::Pulse
+    }
+
+    # Create a new instance with a collection of measurements of the appropriate
+    # WithingsSDK::Measure type.
+    #
+    # @param attrs [Hash]
+    # @return [WithingsSDK::MeasurementGroup]
+    def initialize(attrs = {})
+      super(attrs)
+      return if attrs['measures'].nil?
+      @measures = attrs['measures'].collect do |measurement|
+        klass = TYPES[measurement['type']]
+        klass.new(measurement) unless klass.nil?
+      end.reject { |obj| obj.nil? }
+    end
+  end
+end

data/lib/withings-sdk/measures.rb

@@ -0,0 +1,44 @@
+module WithingsSDK
+  class Measure < Base
+
+    # Create a new instance.
+    #
+    # The Withings API returns all values as integers with a unit which represents
+    # the power of 10 the value should be multiplied by to get the real value. For
+    # example, value=20 and unit=-1 should be 2.0.
+    #
+    # @param attrs [Hash]
+    # @return [WithingsSDK::Measure]
+    def initialize(attrs = {})
+      super(attrs)
+      @value = value / (10 ** unit.abs).to_f
+    end
+
+    #
+    # Different measurement types
+    #
+
+    Weight = Class.new(self) do |cls|
+      # Return weight measurement in kilograms (default unit)
+      #
+      # @return [Float]
+      def in_kg
+        @value
+      end
+
+      # Return weight measurement in pounds
+      #
+      # @return [Float]
+      def in_lb
+        (@value * 2.20462).round(3)
+      end
+    end
+
+    Height = Class.new(self)
+    Pulse  = Class.new(self)
+
+    FatFreeMass   = Class.new(self)
+    FatMassWeight = Class.new(self)
+    FatRatio      = Class.new(self)
+  end
+end

data/lib/withings-sdk/notification.rb

@@ -0,0 +1,4 @@
+module WithingsSDK
+  class Notification < Base
+  end
+end

data/lib/withings-sdk/response.rb

@@ -0,0 +1,13 @@
+module WithingsSDK
+
+  # A Response is used to represent an empty API response with a status
+  # code and no additional information.
+  class Response
+    # @return [Integer]
+    attr_reader :status
+
+    def initialize(attrs = {})
+      @status = attrs['status'].to_i if attrs.has_key? 'status'
+    end
+  end
+end

data/lib/withings-sdk/sleep_series.rb

@@ -0,0 +1,6 @@
+require 'withings-sdk/base'
+
+module WithingsSDK
+  class SleepSeries < Base
+  end
+end

data/lib/withings-sdk/sleep_summary.rb

@@ -0,0 +1,6 @@
+require 'withings-sdk/base'
+
+module WithingsSDK
+  class SleepSummary < Base
+  end
+end

data/lib/withings-sdk/utils.rb

@@ -0,0 +1,72 @@
+require 'date'
+
+module WithingsSDK
+  module Utils
+
+    def self.normalize_date_params(options)
+      opts = hash_with_string_date_keys(options)
+
+      convert_epoch_date_params!(opts)
+      convert_ymd_date_params!(opts)
+
+      if opts.has_key? 'startdateymd' and !opts.has_key? 'startdate'
+        opts['startdate'] = to_epoch(opts['startdateymd'])
+      end
+      if opts.has_key? 'enddateymd' and !opts.has_key? 'enddate'
+        opts['enddate'] = to_epoch(opts['enddateymd'])
+      end
+
+      opts['startdateymd'] = to_ymd(opts['startdate'])      if opts.has_key? 'startdate'
+      opts['enddateymd']   = to_ymd(opts['enddate'])        if opts.has_key? 'enddate'
+      opts
+    end
+
+    private
+
+    def self.hash_with_string_date_keys(params)
+      p = params.dup
+      date_fields = [:startdateymd, :enddateymd, :startdate, :enddate, :lastupdate]
+      date_fields.each { |key| p[key.to_s] = p.delete(key) if p.has_key? key }
+      p
+    end
+
+    def self.convert_ymd_date_params!(params)
+      ymd_fields = ['startdateymd', 'enddateymd']
+      ymd_fields.each do |key|
+        params[key] = to_ymd(params[key]) if params.has_key? key
+      end
+    end
+
+    def self.convert_epoch_date_params!(params)
+      epoch_fields = ['startdate', 'enddate', 'lastdate', 'date']
+      epoch_fields.each do |key|
+        params[key] = to_epoch(params[key]) if params.has_key? key
+      end
+    end
+
+    def self.to_epoch(d)
+      if d.is_a? Date or d.is_a? DateTime
+        d.strftime('%s').to_i
+      elsif  d =~ /[0-9]{4}-[0-9]{2}-[0-9]{2}/
+        DateTime.strptime(d, '%Y-%m-%d').strftime('%s').to_i
+      else
+        d
+      end
+    end
+
+    def self.to_ymd(d)
+      if d.is_a? Date or d.is_a? DateTime
+        d.strftime('%Y-%m-%d')
+      elsif (d =~ /[0-9]+/) != 0
+        DateTime.strptime(d.to_s, '%s').strftime('%Y-%m-%d')
+      else
+        d
+      end
+    end
+
+    def self.to_ymdhms(d)
+      DateTime.strptime(d.to_s, '%s').strftime('%Y-%m-%d %H:%M:%S')
+    end
+
+  end
+end

data/lib/withings-sdk/version.rb

@@ -0,0 +1,3 @@
+module WithingsSDK
+  VERSION = "0.2.1"
+end

data/withings-sdk.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'withings-sdk/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "withings-sdk"
+  spec.version       = WithingsSDK::VERSION
+  spec.authors       = ["Paul Osman"]
+  spec.email         = ["paul@eval.ca"]
+
+  spec.summary       = 'A Ruby interface to the Withings API.'
+  spec.description   = spec.summary
+  spec.homepage      = 'https://github.com/paulosman/activite'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "oauth", "~> 0.4.7"
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.2"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: withings-sdk
+version: !ruby/object:Gem::Version
+  version: 0.2.1
+platform: ruby
+authors:
+- Paul Osman
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oauth
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.7
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: A Ruby interface to the Withings API.
+email:
+- paul@eval.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- lib/withings-sdk.rb
+- lib/withings-sdk/activity.rb
+- lib/withings-sdk/base.rb
+- lib/withings-sdk/client.rb
+- lib/withings-sdk/error.rb
+- lib/withings-sdk/http/oauth.rb
+- lib/withings-sdk/http/request.rb
+- lib/withings-sdk/measurement_group.rb
+- lib/withings-sdk/measures.rb
+- lib/withings-sdk/notification.rb
+- lib/withings-sdk/response.rb
+- lib/withings-sdk/sleep_series.rb
+- lib/withings-sdk/sleep_summary.rb
+- lib/withings-sdk/utils.rb
+- lib/withings-sdk/version.rb
+- withings-sdk.gemspec
+homepage: https://github.com/paulosman/activite
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5.1
+signing_key: 
+specification_version: 4
+summary: A Ruby interface to the Withings API.
+test_files: []