winker 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 6822f9ff1ac2caebfef3e784c0a336fe8a9685bc
+  data.tar.gz: b5a370c52f88f6f953355173f76805a6d3e4ae59
+SHA512:
+  metadata.gz: e0e17eb42a6804a6a7a814e1252bdc9510aa057619361f9d77321bfa9d6152a88cca634a78cf71d8f3161f4843ac583b4b95126887f6ce92c4786a89477cb002
+  data.tar.gz: 0710e4bcb3df3d731deb1634371eb05d5b1975a36946f82dd936aeb50176fbc9242b4dacc75ebd0d112d10959cd919a06e9468ca1a47da4572f3728040fb75b7

data/.gitignore

@@ -0,0 +1,16 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.gems/
+.rbenv-gemsets

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Kelly Mahan
+
+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,169 @@
+# Winker
+
+Winker is a gem written to support the wink api and any other associated platforms.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'winker'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install winker
+
+## Usage
+
+
+    Winker.configure do |wink|
+      wink.client_id     = "******************"
+      wink.client_secret = "******************"
+      wink.access_token  = nil
+      wink.refresh_token = nil
+      wink.username = "email@domain.com"
+      wink.password = "**********"
+      wink.endpoint = "https://winkapi.quirky.com"
+    end
+
+    #retrieve the access_token and refresh_token
+    Winker.authorize
+    
+    #get a list of devices, the hub always seems to be the first device
+    devices = Winker.devices
+    
+    devices.count
+    => 8
+    
+    devices[1].name
+    => "Front porch 1"
+    
+    
+#Device Methods/Attributes
+Some status methods are blocking in the sense that if a status change is sent, such as powering the device on or off, the next time you call powered? it will refresh every 2 seconds until last updated at time is greater than when the status change was called. If 20 seconds pass before an update then the it throws and error that it hasn't received an update. During my testing an update normally took about 4 seconds. But at times would take much longer.
+
+examples
+
+    devices = Winker.devices #returns an array of device objects
+    devices[1].type
+    => "light_bulb"
+    
+Each device has it's own associated type. To make things easier when devices are loaded methods are included to help interact with the device so update(options) doesn't have to be called for every interaction.
+
+##Generic
+
+    refresh
+    #This queries the api to update the device status.
+    #normally device status is cached unless a status update is called on the device
+    #the next time a device status is called a refresh is called first.
+    
+    update(options)
+    #options is a hash with the requested update information
+    #all devices make use of this method
+    #example for powering on a device
+    #update(desired_state: {powered: "true"})
+    #for changing a device name
+    #update(name: "New Device name")
+    #check the api for all updatable information.
+    
+    type
+    #returns the type of device
+    
+    id
+    #returns the id of the device. Used for making api calls for the device
+    
+    updated_at
+    #last time there was an update for the device. Used to tell when a status update has succeeded
+    
+    #method_missing is also used to access the json data directly from the device query
+    #with this you can get other information about the device. Not all devices have the same attributes
+    #example attributes:
+    
+    name
+    manufacturer_device_model
+    manufacturer_device_id
+    device_manufacturer
+    model_name
+    radio_type
+    last_reading
+    ....
+    
+
+##OnOff < Generic
+    on
+    #turns a device on, brightness level is preserved
+    
+    off
+    #turns a device off, brightness level is preserved
+    
+    powered?
+    #checks the powered status of the device, *blocking method
+    
+    on?
+    #alias for powered?
+    
+    off?
+    #!powered?
+
+##LightBulb < OnOff
+    brightness
+    #returns the last brightness level. 0.01 < brightness <= 1
+    #even when the device is powered off the last brightness level is returned
+    #*blocking method
+    
+    brightness=
+    #sets the brightness level and powers on the device if off
+
+##Sensor Pod < Generic
+    temp
+    #returns the current temperature in celcius
+    #TODO return a temp object that defaults to chosen temp scale
+    
+    humidity
+    #returns the current humidity
+
+#Group Methods
+    on
+    #turns all devices in the group on
+    
+    off
+    #turns all devices in the group off
+    
+    brightness=
+    #sets the brightness level for all devices in the group.
+    #I believe a non dimmable device is simply turned on and brightness is ignored.
+    
+    members
+    #returns an array of all devices include in the group.
+    
+    #method_missing is also included to retrieve some attributes
+    name
+    order
+
+#Scene Methods
+    activate
+    #triggers the scene
+    
+    members
+    #returns an array of all devices include in the group.
+    
+    settings
+    #describes the updates that will occur when triggered
+    
+    #method_missing is also included to retrieve some attributes
+    name
+    order    
+
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/winker/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,2 @@
+require "bundler/gem_tasks"
+

data/lib/winker/api_methods.rb

@@ -0,0 +1,86 @@
+module Winker
+  module ApiMethods
+    def get(path, params = nil)
+      response = super
+      @server_time_dif = Time.parse(response.headers["date"]) - Time.now
+      return response
+    end
+  
+    def put(path, params = nil)
+      response = super
+      @server_time_dif = Time.parse(response.headers["date"]) - Time.now
+      return response
+    end
+  
+    def post(path, params = nil)
+      response = super
+      @server_time_dif = Time.parse(response.headers["date"]) - Time.now
+      return response
+    end
+  
+    def authorize
+      response = post("/oauth2/token", {client_id: Winker.client_id, client_secret: Winker.client_secret, username: Winker.username, password: Winker.password, grant_type: "password"})
+      @access_token = response.body["access_token"]
+      @refresh_token = response.body["refresh_token"]
+      @connection = nil
+      response
+    end
+  
+    def devices
+    
+      response = get("/users/me/wink_devices")
+      Winker::Device.load_devices(parse(response.body).data)
+    end
+  
+    def groups
+      response = get("/users/me/groups")
+      Winker::Group.load_groups(parse(response.body).data)
+    end
+  
+    def icons
+      response = get("/icons")
+      parse(response.body).data
+    end
+  
+    def channels
+      response = get("/channels")
+      parse(response.body).data
+    end
+  
+    def scenes
+      response = get("/users/me/scenes")
+      Winker::Scene.load_scenes(parse(response.body).data)
+    end
+  
+    def get_scene(scene_id)
+      response = get("/scenes/#{scene_id}")
+      parse(response.body).data
+    end
+  
+    # def update_scene(scene_id, options)
+    #   response = put("/scenes/#{scene_id}")
+    #   parse(response.body).data
+    # end
+  
+    def activate_scene(scene_id)
+      response = post("/scenes/#{scene_id}/activate")
+      parse(response.body).data
+    end
+  
+    def get_device(type, id)
+      response = get("/#{type}s/#{id}")
+      parse(response.body).data
+    end
+  
+    def update_device(type, id, options)
+      response = put("/#{type}s/#{id}", options)
+      parse(response.body).data
+    end
+  
+    def update_group(id, options)
+      response = post("/groups/#{id}/activate", options)
+      parse(response.body).data
+    end
+  
+  end
+end

data/lib/winker/connection.rb

@@ -0,0 +1,39 @@
+module Winker
+  module Connection
+    def connection
+      @connection ||= Faraday.new(Winker.endpoint) do |conn|
+        conn.options[:timeout]      = 5
+        conn.options[:open_timeout] = 2
+
+        conn.request  :json
+        conn.response :json, :content_type => /\bjson$/
+
+        conn.authorization :bearer, Winker.access_token if Winker.access_token
+        conn.response :detailed_logger
+
+        conn.adapter Faraday.default_adapter # make requests with Net::HTTP
+      end
+    end
+  
+    def get(path, body = {})
+      body = MultiJson.dump(body) if Hash === body
+      connection.get(path) do |req|
+        req.body = body if body
+      end
+    end
+  
+    def post(path, body = {})
+      body = MultiJson.dump(body) if Hash === body
+      connection.post(path) do |req|
+        req.body = body if body
+      end
+    end
+  
+    def put(path, body = {})
+      body = MultiJson.dump(body) if Hash === body
+      connection.put(path) do |req|
+        req.body = body if body
+      end
+    end
+  end
+end

data/lib/winker/device.rb

@@ -0,0 +1,57 @@
+
+require 'winker/devices/device_methods'
+require 'winker/devices/generic_device'
+require 'winker/devices/on_off'
+require 'winker/devices/light_bulb'
+require 'winker/devices/sensor_pod'
+require 'winker/devices/unknown_device'
+require 'winker/devices/hub'
+
+module Winker
+  class Device
+    def self.load_devices(data)
+      data.map{|d| Winker::Device.new(d)}
+    end
+    
+    def initialize(obj_data)
+      @obj_data = obj_data
+      find_type_and_id
+      self.extend(eval("Winker::Devices::#{@type.classify}"))
+    end
+  
+    def method_missing(method_sym, *arguments, &block)
+      if obj_data.respond_to?(method_sym)
+        obj_data.send(method_sym, *arguments, &block)
+      else
+        super
+      end
+    end
+    
+    include Winker::Devices::DeviceMethods
+    include Winker::Devices::GenericDevice
+    include Winker::Devices::OnOff
+    include Winker::Devices::LightBulb
+    include Winker::Devices::SensorPod
+    include Winker::Devices::UnknownDevice
+    include Winker::Devices::Hub
+    # VALID_TYPES=%w{
+    #   sensor_pod
+    #   light_bulb
+    #   garage_door
+    #   binary_switch
+    #   air_conditioner
+    #   propane_tank
+    #   outlet
+    #   powerstrip
+    #   piggy_bank
+    #   eggtray
+    #   cloud_clock
+    #   alarm
+    #   dial
+    #   scene
+    #   robot
+    #   group
+    # }
+    
+  end
+end

data/lib/winker/devices/device_methods.rb

@@ -0,0 +1,42 @@
+module Winker
+  module Devices
+    module DeviceMethods
+      #hub must always be last since the hub_id is listed with every device
+
+      VALID_TYPES = %w{
+        sensor_pod
+        light_bulb
+        unknown_device
+        hub
+      }
+  
+      WAIT_BLOCK_SLEEP = 1
+      WAIT_BLOCK_TIMEOUT = 20.seconds
+  
+  
+      attr_accessor :type, :id, :obj_data, :updated_at
+  
+      def find_type_and_id
+        @type = VALID_TYPES.find{|t| @obj_data.singleton_methods.map(&:to_s).include?("#{t}_id")}
+        @id = @obj_data.send("#{@type}_id")
+        @updated_at = 2.weeks.ago
+      end
+  
+      def wait_for_update(boolean_proc, options = {}, &block)
+        options = {
+          timeout: WAIT_BLOCK_TIMEOUT
+        }.merge(options)
+        start = Time.now
+        until (success = boolean_proc.call) || Time.now > start+options[:timeout]
+          result = yield
+          sleep WAIT_BLOCK_SLEEP
+        end
+        if success
+          return result
+        else
+          raise "Device #{self.type} #{self.name} not updated."
+        end
+      end
+    end
+  end
+end

data/lib/winker/devices/generic_device.rb

@@ -0,0 +1,14 @@
+module Winker
+  module Devices
+    module GenericDevice
+      def refresh
+        @obj_data = Winker.get_device(@type, @id)
+      end
+
+      def update(options)
+        @updated_at = Time.now + Winker.server_time_dif
+        Winker.update_device(@type, @id, options)
+      end
+    end
+  end
+end

data/lib/winker/devices/hub.rb

@@ -0,0 +1,10 @@
+module Winker
+  module Devices
+    module Hub
+
+      def self.extended(obj)
+  
+      end
+    end
+  end
+end

data/lib/winker/devices/light_bulb.rb

@@ -0,0 +1,37 @@
+module Winker
+  module Devices
+    module LightBulb
+      include OnOff
+
+      def updates_finished?
+        check_last_brightness
+        check_last_powered
+        return true
+      end
+  
+      def check_last_brightness
+        wait_for_update( Proc.new{@updated_at < @obj_data.last_reading.brightness_updated_at.to_time}) do
+          self.refresh
+        end
+      end
+
+      def self.extended(obj)
+  
+      end
+
+      def brightness
+        check_last_brightness
+        @obj_data.last_reading.brightness
+      end
+
+      def brightness=(_brightness)
+        #set brightness level
+        if _brightness == 0
+          update(desired_state: {powered: "false", brightness: _brightness})
+        else
+          update(desired_state: {powered: "true", brightness: _brightness})
+        end
+      end
+    end
+  end
+end

data/lib/winker/devices/on_off.rb

@@ -0,0 +1,37 @@
+module Winker
+  module Devices
+    module OnOff
+      def updates_finished?
+        check_last_powered
+        return true
+      end
+  
+      def check_last_powered
+        wait_for_update( Proc.new{@updated_at < @obj_data.last_reading.powered_updated_at.to_time}) do
+          self.refresh
+        end
+      end
+
+      def powered?
+        check_last_powered
+        @obj_data.last_reading.powered
+      end
+
+      def on
+        #turn on device
+        update(desired_state: {powered: "true"})
+      end
+
+      def off
+        #turn off device
+        update(desired_state: {powered: "false"})
+      end
+
+      def off?
+        !powered?
+      end
+
+      alias on? powered?
+    end
+  end
+end

data/lib/winker/devices/sensor_pod.rb

@@ -0,0 +1,19 @@
+module Winker
+  module Devices
+    module SensorPod
+
+      def self.extended(obj)
+  
+      end
+
+      def temp
+        @obj_data.last_reading.temperature
+      end
+
+      def humidity
+        @obj_data.last_reading.humidity
+      end
+
+    end
+  end
+end

data/lib/winker/devices/unknown_device.rb

@@ -0,0 +1,9 @@
+module Winker
+  module Devices
+    module UnknownDevice
+      def self.extended(obj)
+  
+      end
+    end
+  end
+end

data/lib/winker/float.rb

@@ -0,0 +1,9 @@
+
+class Float
+  def to_time
+    Time.at(self)
+  end
+  def to_date
+    self.to_time.to_date
+  end
+end

data/lib/winker/group.rb

@@ -0,0 +1,51 @@
+module Winker
+    
+  class Group
+    
+    attr_accessor :type, :id, :obj_data
+    
+    def self.load_groups(data)
+      data.map{|d| Winker::Group.new(d)}
+    end
+    
+    def initialize(obj_data)
+      @obj_data = obj_data
+      @id = @obj_data.group_id
+    end
+    
+    def members
+      devices.select{|d| @obj_data.members.map{|m| m[:object_id]}.include?(d.id)}
+    end
+    
+    def on
+      Winker.update_group(@id, {desired_state: {powered: "true"}})
+    end
+    
+    def off
+      Winker.update_group(@id, {desired_state: {powered: "false"}})
+    end
+    
+    
+    def brightness=(_brightness)
+      #set brightness level
+      Winker.update_group(@id, {desired_state: {powered: "true", brightness: _brightness}})
+    end
+  
+    def method_missing(method_sym, *arguments, &block)
+      
+      if obj_data.respond_to?(method_sym)
+        obj_data.send(method_sym, *arguments, &block)
+      else
+        super
+      end
+    end
+    
+    private
+
+    
+    def devices
+      @devices ||= Winker.devices
+    end
+    
+  end
+end

data/lib/winker/scene.rb

@@ -0,0 +1,45 @@
+module Winker
+
+  class Scene
+    
+    attr_accessor :type, :id, :obj_data
+    
+    def self.load_scenes(data)
+      data.map{|s| Winker::Scene.new(s)}
+    end
+    
+    def initialize(obj_data)
+      @obj_data = obj_data
+      @id = @obj_data.scene_id
+    end
+    
+    def members
+      devices.select{|d| @obj_data.members.map{|m| m[:object_id]}.include?(d.id)}
+    end
+    
+    def settings
+      @obj_data.members
+    end
+    
+    def activate
+      Winker.activate_scene(self.id)
+    end
+      
+    def method_missing(method_sym, *arguments, &block)
+      
+      if obj_data.respond_to?(method_sym)
+        obj_data.send(method_sym, *arguments, &block)
+      else
+        super
+      end
+    end
+    
+    private
+
+    
+    def devices
+      @devices ||= Winker.devices
+    end
+    
+  end
+end

data/lib/winker/temperature.rb

@@ -0,0 +1,39 @@
+module Winker
+  #TODO make temperture class for easy conversion between F and C
+  # this is not included in the project at this moment
+  class Temperature < Numeric
+    DEFAULT_SCALE = "f"
+    attr_accessor :reading, :scale, :display_scale
+
+    def initialize(temp, scale = DEFAULT_SCALE, display_scale = DEFAULT_SCALE)
+      @reading = temp
+      @scale = scale
+      @display_scale = display_scale
+    end
+
+    def to_s
+      temp.to_s
+    end
+
+    def to_i
+      temp.to_i
+    end
+
+    def to_f
+      temp.to_f
+    end
+
+    def temp
+      case
+      when scale == display_scale
+        return reading
+      when scale == "f" && display_scale == "c"
+        return (reading - 32) * 5.0 / 9
+      when scale == "c" && display_scale == "f"
+        return (reading * 9.0 / 5) + 32
+      else
+        raise "Doesn't support #{scale} temp scale"
+      end
+    end
+  end
+end

data/lib/winker/version.rb

@@ -0,0 +1,3 @@
+module Winker
+  VERSION = "0.0.1"
+end

data/lib/winker.rb

@@ -0,0 +1,51 @@
+require "winker/version"
+
+
+require 'faraday'
+require 'faraday_middleware'
+require 'faraday/detailed_logger'
+require 'hashie'
+require 'active_support'
+require 'active_support/core_ext'
+require 'multi_json'
+
+
+require 'winker/float'
+require 'winker/device'
+require 'winker/group'
+require 'winker/scene'
+require 'winker/connection'
+require 'winker/api_methods'
+
+module Winker
+
+  module Parser
+    def parse(body)
+      case body
+      when Hash
+        body.each do |k,v|
+          body[k] = parse(v)
+        end
+        OpenStruct.new(body)
+      when Array
+        body.map { |item| parse(item) }
+      else
+        body
+      end
+    end
+  end
+  
+  module Configuration
+    attr_accessor :client_id, :client_secret, :access_token, :refresh_token, :username, :password, :endpoint, :server_time_dif
+
+    def configure
+      yield self
+    end
+  end
+
+  extend Parser
+  extend Configuration
+  extend Connection
+  extend ApiMethods
+  
+end

data/winker.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'winker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "winker"
+  spec.version       = Winker::VERSION
+  spec.authors       = ["Kelly Mahan"]
+  spec.email         = ["kmahan@kmahan.com"]
+  spec.summary       = %q{Winker is a gem written to support the wink api and any other associated platforms.}
+  spec.description   = %q{Winker is a gem written to support the wink api and any other associated platforms.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "faraday", "~> 0.9"
+  spec.add_dependency "faraday_middleware", "~> 0.9"
+  spec.add_dependency "faraday-detailed_logger", "~> 1.0"
+  spec.add_dependency "hashie", "~> 3.4"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "multi_json"
+end

metadata

@@ -0,0 +1,180 @@
+--- !ruby/object:Gem::Specification
+name: winker
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Kelly Mahan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-03-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !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: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday_middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: faraday-detailed_logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: hashie
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Winker is a gem written to support the wink api and any other associated
+  platforms.
+email:
+- kmahan@kmahan.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/winker.rb
+- lib/winker/api_methods.rb
+- lib/winker/connection.rb
+- lib/winker/device.rb
+- lib/winker/devices/device_methods.rb
+- lib/winker/devices/generic_device.rb
+- lib/winker/devices/hub.rb
+- lib/winker/devices/light_bulb.rb
+- lib/winker/devices/on_off.rb
+- lib/winker/devices/sensor_pod.rb
+- lib/winker/devices/unknown_device.rb
+- lib/winker/float.rb
+- lib/winker/group.rb
+- lib/winker/scene.rb
+- lib/winker/temperature.rb
+- lib/winker/version.rb
+- winker.gemspec
+homepage: ''
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Winker is a gem written to support the wink api and any other associated
+  platforms.
+test_files: []