xively-rb 0.2.09

data/lib/xively-rb/nil_content.rb

@@ -0,0 +1,15 @@
+class NilClass
+  def content
+  end
+
+  def value
+  end
+
+  def iso8601(precision = nil)
+  end
+
+  def empty?
+    true
+  end
+end
+

data/lib/xively-rb/object_extensions.rb

@@ -0,0 +1,6 @@
+class Object
+  def blank?
+    respond_to?(:empty?) ? empty? : !self
+  end
+end
+

data/lib/xively-rb/parsers/csv/datastream_defaults.rb

@@ -0,0 +1,50 @@
+module Xively
+  module Parsers
+    module CSV
+      module DatastreamDefaults
+        def from_csv(csv, csv_version = nil)
+          begin
+            rows = Xively::CSV.parse(csv.strip)
+          rescue Exception => e
+            # this might be a FasterCSV or CSV exception depending on whether
+            # we are running under 1.8.x or 1.9.x
+            raise InvalidCSVError, e.message
+          end
+
+          version = FeedDefaults.detect_version(rows, csv_version)
+
+          raise InvalidCSVError, "CSV is invalid. Submitted data appears to be empty" if rows.nil?
+
+          if version == :v1
+            raise InvalidCSVError, "CSV is invalid. Can only construct a Xively::Datastream object from a single row of data" if rows.size > 1
+            row = rows.first
+            raise InvalidCSVError, "CSV is invalid. Too many fields; must only be a single value" if row.size > 1
+            return { "current_value" => row[0].to_s.strip }
+          else
+            row_sizes = rows.collect { |row| row.size }.uniq
+            raise InvalidCSVError, "CSV is invalid. Too many fields; must only be a single value, or a timestamp and a value" if row_sizes.max > 2
+
+            if rows.size == 1
+              # capture single lines (normal case)
+              row = rows.first
+
+              if row.size == 2
+                return { "updated" => row[0].to_s.strip, "current_value" => row[1].to_s.strip }
+              else
+                return { "current_value" => row[0].to_s.strip }
+              end
+            else
+              # capture multiple lines
+              raise InvalidCSVError, "CSV is invalid. If multiple values are included, then a timestamp and value must be submitted for every row" if row_sizes.min < 2
+
+              return { "datapoints" => rows.collect { |row| { "at" => row[0].to_s.strip, "value" => row[1].to_s.strip } } }
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/csv/feed_defaults.rb

@@ -0,0 +1,97 @@
+module Xively
+  module Parsers
+    module CSV
+      class UnknownVersionError < Xively::ParserError ; end
+      class InvalidCSVError < Xively::ParserError ; end
+
+      module FeedDefaults
+
+        class << self
+          def detect_version(rows, version = nil)
+            return version if version
+            return :v2 if rows.size >= 2
+            return :v1 if rows.size == 1 && rows.first.size != 2
+            raise UnknownVersionError, "CSV Version could not be detected"
+          end
+        end
+
+        def from_csv(csv, csv_version = nil)
+          begin
+            rows = Xively::CSV.parse(csv.strip)
+          rescue Exception => e
+            # this might be a FasterCSV or CSV exception depending on whether
+            # we are running under 1.8.x or 1.9.x
+            raise InvalidCSVError, e.message
+          end
+
+          version = FeedDefaults.detect_version(rows, csv_version)
+
+          hash = Hash.new
+
+          raise InvalidCSVError, "Submitted CSV is empty." if rows.empty?
+
+          if version == :v2
+            hash["datastreams"] = extract_datastreams(rows)
+          elsif version == :v1
+            raise InvalidCSVError, "CSV is invalid. Currently we can only accept CSV for your most recent set of values. You have submitted #{rows.size} rows of data." if rows.size > 1
+            hash["datastreams"] = []
+            rows.first.each_with_index do |current_value, stream_id|
+              hash["datastreams"] << { "id" => stream_id.to_s.strip, "current_value" => current_value.to_s.strip }
+            end
+          end
+          hash["csv_version"] = version
+          hash
+        end
+
+        private
+
+        # This is used by v2 only
+        def extract_datastreams(rows)
+          row_sizes = rows.collect { |row| row.size }.uniq
+          row_ids = rows.collect { |row| row.first.to_s.strip }.uniq
+
+          raise InvalidCSVError, "CSV is invalid. Incorrect number of fields" if row_sizes.max > 3 || row_sizes.min <= 1
+
+          datastream_buckets = {}
+
+          # iterate through each row bucketing by datastream id
+          rows.each do |row|
+            # this splits each row into the id first element, and an array containing the rest of the row
+            id, *rest = *row
+
+            # make empty array if it doesn't exist
+            datastream_buckets[id.to_s.strip] ||= []
+            # add this row to the correct bucketed array
+            datastream_buckets[id.to_s.strip] << rest
+          end
+
+          datastreams = []
+
+          row_ids.each do |datastream_id|
+            datastream_data = datastream_buckets[datastream_id]
+
+            if datastream_data.size == 1
+              # single value for this datastream - current normal
+              data = datastream_data[0]
+              if data.size == 2
+                datastreams << { "id" => datastream_id, "updated" => data[0].to_s.strip, "current_value" => data[1].to_s.strip }
+              else
+                datastreams << { "id" => datastream_id, "current_value" => data[0].to_s.strip }
+              end
+            else
+              # multiple values for this datastream
+              raise InvalidCSVError, "CSV is invalid. If multiple values given they must include a timestamp for all values" if datastream_data.collect { |d| d.size }.min < 2
+
+              datapoints = datastream_data.collect { |datapoint_data| { "at" => datapoint_data[0].to_s.strip, "value" => datapoint_data[1].to_s.strip } }
+
+              datastreams << { "id" => datastream_id, "datapoints" => datapoints }
+            end
+          end
+
+          return datastreams
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/defaults.rb

@@ -0,0 +1,15 @@
+require 'xively-rb/parsers/json/feed_defaults'
+require 'xively-rb/parsers/json/search_result_defaults'
+require 'xively-rb/parsers/json/datastream_defaults'
+require 'xively-rb/parsers/json/datapoint_defaults'
+require 'xively-rb/parsers/json/trigger_defaults'
+require 'xively-rb/parsers/json/key_defaults'
+require 'xively-rb/parsers/xml/errors'
+require 'xively-rb/parsers/xml/helpers'
+require 'xively-rb/parsers/xml/feed_defaults'
+require 'xively-rb/parsers/xml/datastream_defaults'
+require 'xively-rb/parsers/xml/datapoint_defaults'
+require 'xively-rb/parsers/xml/trigger_defaults'
+require 'xively-rb/parsers/xml/key_defaults'
+require 'xively-rb/parsers/csv/feed_defaults'
+require 'xively-rb/parsers/csv/datastream_defaults'

data/lib/xively-rb/parsers/json/datapoint_defaults.rb

@@ -0,0 +1,16 @@
+module Xively
+  module Parsers
+    module JSON
+      module DatapointDefaults
+        def from_json(json)
+          begin
+            MultiJson.load(json)
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/json/datastream_defaults.rb

@@ -0,0 +1,58 @@
+module Xively
+  module Parsers
+    module JSON
+      module DatastreamDefaults
+        def from_json(json)
+          begin
+            hash = MultiJson.load(json)
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+          raise InvalidJSONError, "JSON doesn't appear to be a hash" unless hash.is_a?(Hash)
+          case hash['version']
+          when '0.6-alpha'
+            transform_0_6_alpha(hash)
+          when '1.0.0', nil
+            transform_1_0_0(hash)
+          end
+        end
+
+        private
+
+        # As produced by http://xively.com/api/v2/FEED_ID/datastreams/DATASTREAM_ID.json
+        def transform_1_0_0(hash)
+          hash["id"] = hash.delete("id")
+          hash["updated"] = hash.delete("at")
+          hash["current_value"] = hash.delete("current_value")
+          hash["tags"] = join_tags(hash["tags"])
+          if unit = hash.delete('unit')
+            hash['unit_type'] = unit['type']
+            hash['unit_symbol'] = unit['symbol']
+            hash['unit_label'] = unit['label']
+          end
+          hash
+        end
+
+        # As produced by http://xively.com/api/v1/FEED_ID/datastreams/DATASTREAM_ID.json
+        def transform_0_6_alpha(hash)
+          hash["id"] = hash.delete("id")
+          if values = [*hash["values"]].first
+            hash["updated"] = hash["values"].first.delete("recorded_at")
+            hash["current_value"] = hash["values"].first.delete("value")
+            hash["max_value"] = hash["values"].first.delete("max_value")
+            hash["min_value"] = hash["values"].first.delete("min_value")
+          end
+          hash["tags"] = join_tags(hash["tags"])
+          if unit = hash.delete('unit')
+            hash['unit_type'] = unit['type']
+            hash['unit_symbol'] = unit['symbol']
+            hash['unit_label'] = unit['label']
+          end
+          hash
+        end
+
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/json/feed_defaults.rb

@@ -0,0 +1,114 @@
+module Xively
+  module Parsers
+    module JSON
+      class InvalidJSONError < Xively::ParserError; end
+      module FeedDefaults
+
+        include Xively::Helpers
+
+        def from_json(json)
+          begin
+            hash = MultiJson.load(json)
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+          raise InvalidJSONError, "JSON doesn't appear to be a hash" unless hash.is_a?(Hash)
+          case hash['version']
+          when '0.6-alpha', '0.6'
+            transform_0_6_alpha(hash)
+          else
+            transform_1_0_0(hash)
+          end
+        end
+
+        private
+
+        # As produced by http://xively.com/api/v2/FEED_ID.json
+        def transform_1_0_0(hash)
+          hash["updated"] = hash["updated"]
+          hash["created"] = hash["created"]
+          hash["status"] = hash["status"]
+          hash["tags"] = join_tags(hash["tags"])
+          hash["datastreams"] = hash["datastreams"].collect do |datastream|
+            unit_hash = {}
+            if unit = datastream.delete('unit')
+              unit_hash['unit_type'] = unit['type']
+              unit_hash['unit_symbol'] = unit['symbol']
+              unit_hash['unit_label'] = unit['label']
+            end
+            {
+              "id" => datastream["id"],
+              "current_value" => datastream["current_value"],
+              "min_value" => datastream["min_value"],
+              "max_value" => datastream["max_value"],
+              "updated" => datastream["at"],
+              "tags" => join_tags(datastream["tags"]),
+              "datapoints" => setup_datapoints(datastream["datapoints"])
+            }.merge(unit_hash)
+          end if hash["datastreams"]
+          if location = hash.delete("location")
+            hash["location_disposition"] = location["disposition"]
+            hash["location_domain"] = location["domain"]
+            hash["location_ele"] = location["ele"]
+            hash["location_exposure"] = location["exposure"]
+            hash["location_lat"] = location["lat"]
+            hash["location_lon"] = location["lon"]
+            hash["location_name"] = location["name"]
+          end
+          if owner = hash.delete("user")
+            hash["owner_login"] = owner["login"]
+          end
+          hash
+        end
+
+        # As produced by http://xively.com/api/v1/FEED_ID.json
+        def transform_0_6_alpha(hash)
+          hash["retrieved_at"] = hash["updated"]
+          hash["state"] = hash["status"]
+          if hash["datastreams"]
+            hash["datastreams"] = hash["datastreams"].collect do |datastream|
+              unit_hash = {}
+              if unit = datastream.delete('unit')
+                unit_hash['unit_type'] = unit['type']
+                unit_hash['unit_symbol'] = unit['symbol']
+                unit_hash['unit_label'] = unit['label']
+              end
+              value_hash = {}
+              if datastream["values"].size >= 1
+                value_hash["current_value"] = datastream["values"].first["value"]
+                value_hash["min_value"] = datastream["values"].first["min_value"]
+                value_hash["max_value"] = datastream["values"].first["max_value"]
+                value_hash["updated"] = datastream["values"].first["recorded_at"]
+              end
+              {
+                "id" => datastream["id"],
+                "tags" => join_tags(datastream["tags"]),
+              }.merge(value_hash).merge(unit_hash)
+            end
+            if location = hash.delete("location")
+              hash["location_disposition"] = location["disposition"]
+              hash["location_domain"] = location["domain"]
+              hash["location_ele"] = location["ele"]
+              hash["location_exposure"] = location["exposure"]
+              hash["location_lat"] = location["lat"]
+              hash["location_lon"] = location["lon"]
+              hash["location_name"] = location["name"]
+            end
+          end
+          hash
+        end
+
+        def setup_datapoints(datapoints)
+          return [] unless datapoints
+          datapoints.collect do |datapoint|
+            {
+              "at" => datapoint["at"],
+              "value" => datapoint["value"]
+            }
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/json/key_defaults.rb

@@ -0,0 +1,20 @@
+module Xively
+  module Parsers
+    module JSON
+      module KeyDefaults
+        def from_json(json)
+          begin
+            hash = MultiJson.load(json)["key"]
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+          raise InvalidJSONError, "JSON doesn't appear to be a hash" unless hash.is_a?(Hash)
+          hash["id"] = hash.delete("id")
+          hash["key"] = hash.delete("api_key")
+          hash
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/json/search_result_defaults.rb

@@ -0,0 +1,24 @@
+module Xively
+  module Parsers
+    module JSON
+      module SearchResultDefaults
+        include FeedDefaults
+
+        def from_json(json)
+          begin
+            hash = MultiJson.load(json)
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+          raise InvalidJSONError, "JSON doesn't appear to be a hash" unless hash.is_a?(Hash)
+
+          hash['results'] = hash['results'].collect do |feed|
+            transform_1_0_0(feed)
+          end
+          hash
+        end
+
+      end
+    end
+  end
+end

data/lib/xively-rb/parsers/json/trigger_defaults.rb

@@ -0,0 +1,16 @@
+module Xively
+  module Parsers
+    module JSON
+      module TriggerDefaults
+        def from_json(json)
+          begin
+            MultiJson.load(json)
+          rescue MultiJson::DecodeError => e
+            raise InvalidJSONError, e.message
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/parsers/xml/datapoint_defaults.rb

@@ -0,0 +1,27 @@
+module Xively
+  module Parsers
+    module XML
+      module DatapointDefaults
+
+        include Xively::Parsers::XML::Helpers
+
+        def from_xml(xml)
+          begin
+            parsed = MultiXml.parse(xml)
+            raise InvalidXMLError, "Missing 'environment' node from base node" if parsed['eeml'].nil? || !parsed['eeml'].key?('environment')
+            return {} if parsed['eeml']['environment'].nil?
+            datastream = parsed['eeml']['environment']['data']
+            raise InvalidXMLError, "Multiple 'data' nodes are not permitted for Datapoint level XML" if datastream.is_a?(Array)
+            datapoint = datastream['datapoints']
+            raise InvalidXMLError, "Multiple 'value' nodes are not permitted for Datapoint level XML" if datapoint.is_a?(Array)
+            _extract_datapoints(datapoint).first
+          rescue MultiXml::ParseError => e
+            raise InvalidXMLError, e.message
+          end
+        end
+
+      end
+    end
+  end
+end
+