xively-rb-connector 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ea7c9c6444f3e234d46349afce7ce495e7b44b6d
+  data.tar.gz: 9bab33c8f37fa6b4783d77f100ffe665c9a26685
+SHA512:
+  metadata.gz: 13b6b634f4e5d98ed315cabd8989c96ab2779ac798e6d3b96bcc42be27cd7e23d480448b8451cb7c17d1e7bd84b30d01d79aa023bddd4d68f2f3d0a80f3fe358
+  data.tar.gz: 73618b4fb24df88f295708236bc0507509e0bc7fb9c2d437979ee2e9cca37589c9718ffd397e016702dd35c78d80d18a04759a0ba5680aa6bcd384d774589525

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalisation:
+/.bundle/
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+.ruby-version
+.ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/

data/Gemfile

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

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Jordan Duggan
+
+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 @@
+xively-rb-connector
+===================
+
+xively-rb-connector is a ruby gem that provides an interface to [Xively](https://xively.com). It extends Sam Mulube's
+excellent [xively-rb](https://github.com/xively/xively-rb) gem. This gem adds convenience functions such as find_by_id
+lookup functions, datastream compression (only saves datapoints when value changes), a datapoint recording buffer, etc.
+
+[Xively](https://xively.com/whats_xively/) is a public cloud specifically built for the "Internet of Things". With their
+platform, developers can connect physical devices, that produce one or more datastreams, to a managed data store. The
+device's details and datastreams are accessible via key-based access to any service or application that has access to the
+web. Xively provides a fantastic development portal and prototyping accounts are free.
+
+## Requirements
+
+* Ruby 1.9.3 or higher
+* A [Xively account](https://xively.com/signup)
+
+## Contact, feedback and bugs
+
+Please file bugs / issues and feature requests on the [issue tracker](https://github.com/jwtd/xively-rb-connector/issues)
+
+## Install
+
+```
+gem install xively-rb-connector
+```
+
+## Examples
+
+```ruby
+
+require 'xively-rb-connector'
+
+# Xively provides a master api-key and device specific keys. To my knowledge, either can be used here.
+my_api_key = 'XIVELY-ACCOUNT-OR-DEVICE-API-KEY-HERE'
+
+# Each device on Xively gets thier own ID, which is exposed via thier REST API as a "feed"
+feed_id = '123456789'
+
+# Find your device on Xively by its feed_id
+d = XivelyConnector.find_device_by_id(feed_id, my_api_key)
+
+# Access details about the device
+d.id	                # 123456789
+d.feed	                # https://api.xively.com/v2/feeds/123456789.json
+d.auto_feed_url         # https://api.xively.com/v2/feeds/123456789.json
+
+d.title                 # My Meter
+d.device_serial         # FOOBAR123456
+d.description           # The xively on xively.com
+d.tags                  # ["Gas", "Power", "Propane", "Water"]
+d.creator               # https://xively.com/users/foo
+d.email                 # your.email@gmail.com
+d.website               # http://www.your-website.com
+d.icon
+
+d.created               # 2014-01-01 16:36:30 UTC
+d.updated               # 2014-03-31 05:02:25 UTC
+d.private               # true
+d.is_private?           # true
+d.status                # live
+d.is_frozen?            # false
+
+# Access location data directly
+d.has_location?         # true
+d.location_name         # The location name on xively.com
+d.location_domain       # physical
+d.location_lon          # -78.12343456
+d.location_lat          # 35.12343454
+d.location_ele          # 354 feet
+d.location_exposure
+d.location_disposition
+d.location_waypoints
+
+# Or get a structure that has all the location details
+l = d.location          #<OpenStruct name="The location name on xively.com", latitude=35.12343454, longitude=-78.12343456, elevation="354 feet", exposure=nil, disposition=nil, waypoints=nil, domain="physical">
+l.name                  # The location name on xively.com
+l.domain                # physical
+l.longitude             # -78.12343456
+l.latitude              # 35.12343454
+l.elevation             # 354 feet
+l.exposure
+l.disposition
+l.waypoints
+
+# Examine datastreams
+d.datastream_ids          # ["Amperage", "Propane", "Voltage", "Power", "Well"]
+d.datastream_values       # ["Amperage in Amps (A) = 0", "Propane in Cubic Feet (cft) = 0", "Voltage in Volts (V) = 9", "Power in Watts (W) = 0", "Well in Cubic Feet (cft) = 0"]
+d.has_channel?('Voltage') # true
+
+# Access datastreams by channel name using bracket syntax
+d['Voltage']                # <XivelyConnector::Datastream:0x007ff62a137b80>
+d['Voltage'].current_value  # 9
+
+ds = d['Volts']
+ds.id                       # Voltage
+ds.unit_label               # Volts
+ds.unit_symbol              # V
+ds.current_value            # 9
+ds.tags                     # Power
+ds.min_value                # 0.0
+ds.max_value                # 25.0
+
+# Setup my datastream buffer
+ds.only_save_changes = true    # Will only queue a datapoint if its value is different from the previous datapoint's which is also the current_value
+ds.datapoint_buffer_size = 60  # Will auto-save to feed when 60 points are queued
+ds.only_save_changes           # true
+ds.only_saves_changes?         # true
+ds.datapoint_buffer_size       # 60
+
+# Queue new datapoints in a number of ways using the shift operator
+# BigDecimal is used for value comparison so "10" == 10 == 10.0
+
+ds.datapoints.size          # 0
+ds << Xively::Datapoint.new(:value => "10", :at => Time.now,())
+ds << {:at=>':at => Time.now(), :value => "10"}
+ds << "10"
+ds << 10
+ds << 10.0
+ds << 11
+
+# If ds.only_save_changes is true, the commands above only result in two datapoints being queued (because the only unique values recorded were 10 and 11)
+ds.datapoints.size          # 2
+
+# Save datapoints to xively.com
+ds.save_datapoints
+ds.datapoints.size          # 0
+
+```
+
+## Resources
+
+* [Free Xively Developer Account](https://xively.com/signup)
+* [xively-rb](https://github.com/xively/xively-rb)
+* [xively-js](http://xively.github.io/xively-js) is a javascript lib for viewing and charting Xively data
+
+## Special Thanks
+
+* Xively - for an awesome data platform
+* Sam Mulube - for xively-rb
+* Ian Duggan - for introducing me to ruby
+

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/xively-rb-connector/connection.rb

@@ -0,0 +1,39 @@
+require 'xively-rb'
+
+module XivelyConnector
+
+  class Connection < Xively::Client
+    include XivelyConnector::Logging
+
+    format :json
+
+    # Mix in the ability to log
+    include XivelyConnector::Logging
+
+    def initialize(options)
+      @logger = options[:logger] || logger
+      @logger.debug "XivelyConnector::Connection initialize"
+      super(options[:api_key])
+    end
+
+    #Set HTTParty params that we need to set after initialize is called
+    #These params come from @options within initialize and include the following:
+    #:ssl_ca_file - SSL CA File for SSL connections
+    #:format - 'json', 'xml', 'html', etc. || Defaults to 'xml'
+    #:format_header - :format Header string || Defaults to 'application/xml'
+    #:pem_cert - /path/to/a/pem_formatted_certificate.pem for SSL connections
+    #:pem_cert_pass - plaintext password, not recommended!
+    def set_httparty_options(options={})
+      if options[:ssl_ca_file]
+        ssl_ca_file opts[:ssl_ca_file]
+        if options[:pem_cert_pass]
+          pem File.read(options[:pem_cert]), options[:pem_cert_pass]
+        else
+          pem File.read(options[:pem_cert])
+        end
+      end
+    end
+
+  end
+
+end

data/lib/xively-rb-connector/datastream.rb

@@ -0,0 +1,109 @@
+require 'xively-rb'
+require 'json'
+require 'bigdecimal'
+
+module XivelyConnector
+
+  # Extend https://github.com/xively-rb-connector/xively-rb
+  class Datastream < Xively::Datastream
+
+    attr_reader :device
+    attr :datapoint_buffer_size, :only_save_changes
+
+    # Mix in the ability to log
+    include XivelyConnector::Logging
+
+    def initialize(options)
+      @logger = options[:logger] || logger
+      @logger.debug "XivelyConnector::Datastream initialize"
+
+      raise "An instance of XivelyConnector::Device must be provided to create a datastream" unless options[:device]
+      raise "The data block for this datastream is missing" unless options[:data]
+
+      # Capture parent and initialize Xively::Datastream
+      @device = options[:device]
+      data   = options[:data]
+      super(data)
+
+      # Set the default buffer size (1 reading per minute)
+      @datapoint_buffer_size = options[:datapoint_buffer_size] || 60
+      @only_save_changes = options[:only_save_changes] || true
+
+      # Initialize Xively::Datastream's datapoint array to allow shift style loading
+      @datapoints = []
+
+      # Fix the unit attribute assignments
+      @unit_symbol   = data['unit']['symbol']
+      @unit_label    = data['unit']['label']
+
+      # Cast the current value as a BigDecimal for casting strings and comparing to ints and floats
+      @current_value = 0 if current_value.nil?
+
+      @logger.info "Initialized Datastream #{@id} (#{@unit_symbol})"
+
+    end
+
+    # Add a question style accessor to only_save_changes attribute
+    def only_saves_changes?
+      only_save_changes
+    end
+
+    # Have shift operator load the datapoint into the datastream's datapoints array
+    def <<(measurement)
+      # Make sure the value provided is a datapoint
+      datapoint = cast_to_datapoint(measurement)
+
+      # If only_save_changes is true, ignore datapoints whose value is the same as the current value
+      if only_save_changes and BigDecimal.new(datapoint.value) == BigDecimal.new(current_value)
+        @logger.debug "Ignoring datapoint from #{datapoint.at} because value did not change from #{current_value}"
+      else
+        @current_value = datapoint.value
+        datapoints << datapoint
+        @logger.debug "Queuing datapoint from #{datapoint.at} with value #{current_value}"
+      end
+
+      # See if the buffer is full
+      check_datapoints_buffer
+    end
+
+    # Converts a measurement to a Datapoint
+    def cast_to_datapoint(measurement, at=Time.now())
+      @logger.debug "cast_to_datapoint(#{measurement.inspect})"
+      if measurement.is_a?(Xively::Datapoint)
+        return measurement
+      elsif measurement.is_a?(Hash)
+        raise "The datapoint hash does not contain :at" unless measurement[:at]
+        raise "The datapoint hash does not contain :value" unless measurement[:value]
+        return Xively::Datapoint.new(measurement)
+      else
+        return Xively::Datapoint.new(:at => at, :value => measurement.to_s)
+      end
+    end
+
+    # Send the queued datapoints array to Xively
+    def save_datapoints
+      @logger.debug "Saving #{datapoints.size} datapoints to the #{id} datastream"
+      response = XivelyConnector.connection.post("/v2/feeds/#{device.id}/datastreams/#{id}/datapoints",
+                                                  :body => {:datapoints => datapoints}.to_json)
+      # If the response succeeded, clear the datapoint buffer and return the response object
+      if response.success?
+        clear_datapoints_buffer
+        response
+      else
+        logger.error response.response
+        raise response.response
+      end
+    end
+
+    # If the datapoints array has exceeded the datapoint_buffer_size, send them to Xively
+    def check_datapoints_buffer
+      save_datapoints if datapoints.size >= @datapoint_buffer_size
+    end
+
+    # Resets the datapoints
+    def clear_datapoints_buffer
+      @datapoints = []
+    end
+
+  end
+end

data/lib/xively-rb-connector/device.rb

@@ -0,0 +1,130 @@
+require 'xively-rb'
+require 'json'
+require 'ostruct'
+
+
+module XivelyConnector
+
+# Extend https://github.com/xively-rb-connector/xively-rb
+class Device < Xively::Feed
+
+    # Mix in the ability to log
+    include XivelyConnector::Logging
+
+    # Connect to a device by ID
+    def self.find_by_id(id)
+      XivelyConnector.connection.logger.debug "Device.find_by_id(#{id})"
+      response = XivelyConnector.connection.get("/v2/feeds/#{id}.json")
+      if response.success?
+        self.new(:response => response)
+      else
+        logger.error response.response
+        response.response
+      end
+    end
+
+    # Converts the Xively dates to ruby DateTimnes and make the datastreams accessible via hash syntax
+    def initialize(options)
+
+      # Create logger
+      @logger = options[:logger] || logger
+      @logger.debug "XivelyConnector::Device initialize"
+
+      # initialize parent
+      data = options[:response]
+      super(options[:response])
+
+      # Convert date strings to ruby dates
+      @created = Time.iso8601(created) # 2014-03-28T16:36:30.651731Z
+      @updated = Time.iso8601(updated) # 2014-03-28T16:45:05.206472Z
+
+      # xively-rb doesn't set location attributes correctly, so do so here
+      if data['location']
+        loc = data['location']
+        @has_location    = true
+        @location_name   = loc['name'] if
+        @location_domain = loc['domain'] if loc['domain']
+        @location_lon    = loc['lon'] if loc['lon']
+        @location_lat    = loc['lat'] if loc['lat']
+        @location_ele    = loc['ele'] if loc['ele']
+        @location_exposure    = loc['exposure'] if loc['exposure']
+        @location_disposition = loc['disposition'] if loc['disposition']
+        @location_waypoints   = loc['waypoints'] if loc['waypoints']
+      end
+
+      # Setup enhanced datastreams
+      @datastream_ref = {}
+      datastreams.each { |ds| @datastream_ref[ds.id] = ds }
+
+      @logger.info "Initialized Xively Device #{@id} with #{datastreams.size} datastreams"
+
+    end
+
+    # Support bracket notation for retriving data streams
+    def [](channel_id)
+      @datastream_ref[channel_id]
+    end
+
+    # Override the datastreams function so that it creates XivelyConnector::Datastreams which extend the standard one
+    def datastreams=(array)
+      return unless array.is_a?(Array)
+      @datastreams = []
+      array.each do |datastream|
+        if datastream.is_a?(Datastream)
+          @datastreams << datastream
+        elsif datastream.is_a?(Hash)
+          #@datastreams << Datastream.new(datastream)
+          @datastreams << XivelyConnector::Datastream.new(:device => self, :data => datastream)
+        end
+      end
+    end
+
+    # Returns an array of datastream ids which are present on this device
+    def datastream_ids
+      @datastream_ref.keys
+    end
+
+    def datastream_values
+      v = []
+      @datastream_ref.each do |id, ds|
+        v << "#{id} in #{ds.unit_label} (#{ds.unit_symbol}) = #{ds.current_value}"
+      end
+      v
+    end
+
+    def has_datastream?(channel)
+      @datastream_ref.has_key?(channel)
+    end
+
+    def has_channel?(channel)
+      has_datastream?(channel)
+    end
+
+    def is_private?
+      private == 'true'
+    end
+
+    def is_frozen?
+      status == 'frozen'
+    end
+
+    def has_location?
+      @has_location ||= false
+    end
+
+    def location
+      @location ||= OpenStruct.new(
+        :name        => location_name,
+        :latitude    => location_lat,
+        :longitude   => location_lon,
+        :elevation   => location_ele,
+        :exposure    => location_exposure,
+        :disposition => location_disposition,
+        :waypoints   => location_waypoints,
+        :domain      => location_domain
+      )
+    end
+
+  end
+
+end

data/lib/xively-rb-connector/logging.rb

@@ -0,0 +1,25 @@
+require 'log4r'
+include Log4r
+module XivelyConnector
+
+  module Logging
+
+    def logger
+      @logger ||= XivelyConnector::Logging.logger
+    end
+
+    def self.logger
+      @logger ||= self.configure_logger_for(self.class.name)
+    end
+
+    def self.configure_logger_for(classname)
+      l = Logger.new(classname)
+      l.level = ERROR
+      l.trace = false
+      l.add Log4r::Outputter.stderr
+      l
+    end
+
+  end
+
+end

data/lib/xively-rb-connector/version.rb

@@ -0,0 +1,9 @@
+module XivelyConnector
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 1
+    PATCH = 0
+
+    STRING = [MAJOR, MINOR, PATCH].join('.')
+  end
+end

data/lib/xively-rb-connector.rb

@@ -0,0 +1,31 @@
+module XivelyConnector
+
+  @@connection = nil
+
+  # Lookup methods delegate to class methods
+  def self.connection
+    @@connection
+  end
+
+  # Lookup methods delegate to class methods
+  def self.connect(options)
+    raise "A connection can not be established without an :api_key" unless options[:api_key]
+    @@connection = Connection.new(options)
+  end
+
+  # Lookup methods delegate to class methods
+  def self.find_device_by_id(id, api_key=nil)
+    self.connect(:api_key => api_key) unless api_key.nil?
+    Device.find_by_id(id)
+  end
+
+  # Base XivelyConnector exception class
+  class XivelyConnectorError < ::Exception; end
+
+end
+
+require "xively-rb-connector/version"
+require "xively-rb-connector/logging"
+require "xively-rb-connector/connection"
+require "xively-rb-connector/device"
+require "xively-rb-connector/datastream"

data/xively-rb-connector.gemspec

@@ -0,0 +1,39 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'xively-rb-connector/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "xively-rb-connector"
+  spec.version       = XivelyConnector::VERSION::STRING
+  spec.authors       = ["Jordan Duggan"]
+  spec.email         = ["Jordan.Duggan@gmail.com"]
+
+  spec.summary       = %q{Ruby gem that provides a high level interface to Xively}
+  spec.description   = %q{xively-rb-connector is a ruby gem that provides an interface to Xively (https://xively.com). It extends Sam Mulube's
+excellent xively-rb (https://github.com/xively/xively-rb) gem. The xively-rb-connector gem adds convenience functions such as find_by_id
+lookup functions, datastream compression (only saves datapoints when value changes), a datapoint recording buffer, etc.
+
+Xively (https://xively.com/whats_xively) is a public cloud specifically built for the "Internet of Things". With their
+platform, developers can connect physical devices, that produce one or more datastreams, to a managed data store. The
+device's details and datastreams are accessible via key-based access to any service or application that has access to the
+web. Xively provides a fantastic development portal and prototyping accounts are free.}
+
+  spec.homepage      = "https://github.com/jwtd/xively-rb-connector"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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"]
+
+  # Development dependencies
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.2"
+
+  # Runtime dependencies
+  spec.add_runtime_dependency "log4r", "~> 1.1"
+  spec.add_runtime_dependency "xively-rb", "~> 0.2"
+  spec.add_runtime_dependency "bigdecimal", "~> 1.2"
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: xively-rb-connector
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Jordan Duggan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.2'
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: xively-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: bigdecimal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: |-
+  xively-rb-connector is a ruby gem that provides an interface to Xively (https://xively.com). It extends Sam Mulube's
+  excellent xively-rb (https://github.com/xively/xively-rb) gem. The xively-rb-connector gem adds convenience functions such as find_by_id
+  lookup functions, datastream compression (only saves datapoints when value changes), a datapoint recording buffer, etc.
+
+  Xively (https://xively.com/whats_xively) is a public cloud specifically built for the "Internet of Things". With their
+  platform, developers can connect physical devices, that produce one or more datastreams, to a managed data store. The
+  device's details and datastreams are accessible via key-based access to any service or application that has access to the
+  web. Xively provides a fantastic development portal and prototyping accounts are free.
+email:
+- Jordan.Duggan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/xively-rb-connector.rb
+- lib/xively-rb-connector/connection.rb
+- lib/xively-rb-connector/datastream.rb
+- lib/xively-rb-connector/device.rb
+- lib/xively-rb-connector/logging.rb
+- lib/xively-rb-connector/version.rb
+- xively-rb-connector.gemspec
+homepage: https://github.com/jwtd/xively-rb-connector
+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: Ruby gem that provides a high level interface to Xively
+test_files: []