xively-rb 0.2.09

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

@@ -0,0 +1,53 @@
+module Xively
+  module Parsers
+    module XML
+      module DatastreamDefaults
+        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?
+            if parsed['eeml']['version'] == '5' || parsed['eeml']['xmlns'] == 'http://www.eeml.org/xsd/005'
+              transform_v1(parsed['eeml']['environment'])
+            else
+              transform_v2(parsed['eeml']['environment'])
+            end
+          rescue MultiXml::ParseError => e
+            raise InvalidXMLError, e.message
+          end
+        end
+
+        private
+
+        # As produced by http://xively.com/api/v2/FEED_ID/datastreams/DATASTREAM_ID.xml
+        def transform_v2(xml)
+          validate_xml(xml)
+          datastream = convert_to_hash(xml['data'])
+          _extract_datastream(datastream).merge({
+            :feed_id => strip(xml,'id'),
+            :feed_creator => strip(xml,'creator')
+          })
+        end
+
+        # As produced by http://xively.com/api/v1/FEED_ID/datastreams/DATASTREAM_ID.xml
+        def transform_v1(xml)
+          validate_xml(xml)
+          datastream = convert_to_hash(xml['data'])
+          _extract_datastream_v1(datastream).merge({
+            :feed_id => strip(xml,'id'),
+            :updated => strip(xml,'updated'),
+            :feed_creator => 'http://www.haque.co.uk'
+          })
+        end
+
+        def validate_xml(xml)
+          raise InvalidXMLError, "Multiple 'data' nodes are not permitted for Datastream level XML" if xml['data'].is_a?(Array)
+          raise InvalidXMLError, "Missing 'data' node from source document" if xml['data'].nil?
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,7 @@
+module Xively
+  module Parsers
+    module XML
+      class InvalidXMLError < Xively::ParserError; end
+    end
+  end
+end

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

@@ -0,0 +1,83 @@
+module Xively
+  module Parsers
+    module XML
+      module FeedDefaults
+        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?
+            if parsed['eeml']['version'] == '5' || parsed['eeml']['xmlns'] == 'http://www.eeml.org/xsd/005'
+              transform_v1(parsed['eeml']['environment'])
+            else
+              transform_v2(parsed['eeml']['environment'])
+            end
+          rescue MultiXml::ParseError => e
+            raise InvalidXMLError, e.message
+          end
+        end
+
+        private
+
+        # As produced by http://xively.com/api/v2/FEED_ID.xml
+        def transform_v2(xml)
+          location = xml['location'] || {}
+          user = xml['user'] || {}
+          {
+            :title => strip(xml,'title'),
+            :updated => strip(xml,'updated'),
+            :creator => strip(xml,'creator'),
+            :created => strip(xml,'created'),
+            :feed => strip(xml,'feed'),
+            :auto_feed_url => strip(xml,'auto_feed_url'),
+            :status => strip(xml,'status'),
+            :description => strip(xml,'description'),
+            :icon => strip(xml,'icon'),
+            :website => strip(xml,'website'),
+            :email => strip(xml,'email'),
+            :private => strip(xml,'private'),
+            :location_lon => strip(location,'lon'),
+            :location_lat => strip(location,'lat'),
+            :location_ele => strip(location,'ele'),
+            :location_name => strip(location,'name'),
+            :location_domain => strip(location,'domain'),
+            :location_exposure => strip(location,'exposure'),
+            :location_disposition => strip(location,'disposition'),
+            :owner_login => strip(user,'login'),
+            :datastreams => _extract_datastreams(xml['data'])
+          }.merge(sanitised_tags(xml))
+        end
+
+        # As produced by http://xively.com/api/v1/FEED_ID.xml
+        def transform_v1(xml)
+          location = xml['location'] || {}
+          user = xml['user'] || {}
+          {
+            :title => strip(xml,'title'),
+            :updated => strip(xml,'updated'),
+            :creator => 'http://www.haque.co.uk',
+            :created => strip(xml,'created'),
+            :feed => strip(xml,'feed'),
+            :status => strip(xml,'status'),
+            :description => strip(xml,'description'),
+            :icon => strip(xml,'icon'),
+            :website => strip(xml,'website'),
+            :email => strip(xml,'email'),
+            :location_lon => strip(location,'lon'),
+            :location_lat => strip(location,'lat'),
+            :location_ele => strip(location,'ele'),
+            :location_name => strip(location,'name'),
+            :location_domain => strip(location,'domain'),
+            :location_exposure => strip(location,'exposure'),
+            :location_disposition => strip(location,'disposition'),
+            :datastreams => _extract_datastreams_v1(xml['data'])
+          }
+        end
+
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,116 @@
+module Xively
+  module Parsers
+    module XML
+      module Helpers
+
+        private
+
+        def strip(xml, value)
+          if xml.key?(value)
+            xml[value].nil? ? '' : xml[value].strip
+          else
+            nil
+          end
+        end
+
+        def convert_to_hash(val)
+          if val.class == String
+            {'__content__' => val}
+          else
+            val ? val.merge({'__content__' => val['__content__']}) : {}
+          end
+        end
+
+        def convert_to_array(val)
+          if val.is_a?(Hash)
+            val = [val]
+          else
+            [*val]
+          end
+        end
+
+        def _extract_datastreams(xml)
+          return unless xml
+          xml = convert_to_array(xml)
+          xml.collect do |ds|
+            _extract_datastream(ds)
+          end
+        end
+
+
+        def _extract_datastream(xml)
+          current_value = convert_to_hash(xml['current_value'])
+          unit = convert_to_hash(xml['unit'])
+          {
+            :current_value => strip(current_value,'__content__'),
+            :updated => strip(current_value,'at'),
+            :id => strip(xml,'id'),
+            :unit_symbol => strip(unit,'symbol'),
+            :unit_type => strip(unit,'type'),
+            :unit_label => strip(unit,'__content__'),
+            :min_value => strip(xml,'min_value'),
+            :max_value => strip(xml,'max_value'),
+            :datapoints => _extract_datapoints(xml['datapoints'])
+          }.merge(sanitised_tags(xml))
+        end
+
+        def _extract_datastreams_v1(xml)
+          return unless xml
+          xml = convert_to_array(xml)
+          xml.collect do |ds|
+            _extract_datastream_v1(ds)
+          end
+        end
+
+        def _extract_datastream_v1(xml)
+          unit = convert_to_hash(xml['unit'])
+          value = convert_to_hash(xml['value'])
+          {
+            :current_value => strip(value,'__content__'),
+            :id => strip(xml,'id'),
+            :unit_symbol => strip(unit,'symbol'),
+            :unit_type => strip(unit,'type'),
+            :unit_label => strip(unit,'__content__'),
+            :min_value => strip(value,'minValue'),
+            :max_value => strip(value,'maxValue')
+          }.merge(sanitised_tags(xml))
+        end
+
+        def _extract_datapoints(xml)
+          return unless xml
+          value = xml['value']
+          value = convert_to_array(value)
+          value.collect do |dp|
+            _extract_datapoint(dp)
+          end
+        end
+
+        def _extract_datapoint(xml)
+          value = convert_to_hash(xml)
+          {
+            :at => strip(value,'at'),
+            :value => strip(value,'__content__')
+          }
+        end
+
+        def _extract_tags(xml)
+          if xml.class != Array
+            xml = [xml]
+          end
+          if (tags = xml.collect { |t| "#{t}".strip }).any?
+            Xively::CSV.generate_line(tags.delete_if { |v| v.to_s.strip == "" }.sort{ |a,b| a.downcase <=> b.downcase}).strip
+          end
+        end
+
+        # Keep blank tags but delete if value is nil
+        def sanitised_tags(xml)
+          if xml.key?('tag')
+            {:tags => _extract_tags(xml['tag'])}
+          else
+            {}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Xively
+  module Parsers
+    module XML
+      module KeyDefaults
+        def from_xml(xml)
+          begin
+            xml = Nokogiri::XML(xml) do |config|
+              config.strict.nonet
+            end
+            hash = {}
+            hash["id"] = xml.at_xpath("//id").content if xml.at_xpath("//id")
+            hash["expires_at"] = xml.at_xpath("//expires-at").content if xml.at_xpath("//expires-at")
+            hash["key"] = xml.at_xpath("//api-key").content if xml.at_xpath("//api-key")
+            hash["label"] = xml.at_xpath("//label").content if xml.at_xpath("//label")
+            hash["user"] = xml.at_xpath("//user").content if xml.at_xpath("//user")
+            hash["private_access"] = xml.at_xpath("//private-access").content if xml.at_xpath("//private-access")
+
+            hash["permissions"] = xml.xpath("//key/permissions/permission").collect { |permission|
+              access_methods = permission.xpath("access-methods/access-method").collect { |method|
+                method.content.to_s.downcase
+              }
+              resources = permission.xpath("resources/resource").collect { |resource|
+                { "feed_id" => resource.at_xpath("feed-id").content,
+                  "datastream_id" => resource.at_xpath("datastream-id").content,
+                  "datastream_trigger_id" => resource.at_xpath("datastream-trigger-id").content
+                }.delete_if_nil_value
+              }
+              {
+                "referer" => permission.at_xpath("referer").content,
+                "source_ip" => permission.at_xpath("source-ip").content,
+                "private_access" => permission.at_xpath("private-access").content,
+                "access_methods" => access_methods,
+                "resources" => resources
+              }.delete_if_nil_value
+            }
+
+            hash
+          rescue Nokogiri::SyntaxError => e
+            raise InvalidXMLError, e.message
+          end
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,28 @@
+module Xively
+  module Parsers
+    module XML
+      module TriggerDefaults
+        def from_xml(xml)
+          begin
+            xml = Nokogiri::XML(xml) do |config|
+              config.strict.nonet
+            end
+            hash = {}
+            hash["id"] = xml.at_xpath("//id").content if xml.at_xpath("//id")
+            hash["url"] = xml.at_xpath("//url").content if xml.at_xpath("//url")
+            hash["trigger_type"] = xml.at_xpath("//trigger-type").content if xml.at_xpath("//trigger-type")
+            hash["threshold_value"] = xml.at_xpath("//threshold-value").content if xml.at_xpath("//threshold-value")
+            hash["notified_at"] = xml.at_xpath("//notified-at").content if xml.at_xpath("//notified-at")
+            hash["user"] = xml.at_xpath("//user").content if xml.at_xpath("//user")
+            hash["environment_id"] = xml.at_xpath("//environment-id").content if xml.at_xpath("//environment-id")
+            hash["stream_id"] = xml.at_xpath("//stream-id").content if xml.at_xpath("//stream-id")
+            hash
+          rescue Nokogiri::SyntaxError => e
+            raise InvalidXMLError, e.message
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/xively-rb/permission.rb

@@ -0,0 +1,67 @@
+module Xively
+  class Permission
+    ALLOWED_KEYS = %w(label access_methods referer source_ip minimum_interval resources)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+    NESTED_KEYS = %w(resources)
+
+    include Validations
+
+    def valid?
+      pass = true
+      if access_methods.nil? || access_methods.empty?
+        errors[:access_methods] = ["can't be blank"]
+        pass = false
+      end
+
+      resources.each do |resource|
+        unless resource.valid?
+          resource.errors.each do |attr, resource_errors|
+            errors["resources_#{attr}".to_sym] = ([*errors["resources_#{attr}".to_sym]] | [*resource_errors]).compact
+          end
+          pass = false
+        end
+      end
+
+      return pass
+    end
+
+    # Build an instance from a Hash only
+    def initialize(input = {})
+      self.attributes = input
+    end
+
+    def resources
+      return [] if @resources.nil?
+      @resources
+    end
+
+    def resources=(array)
+      return unless array.is_a?(Array)
+      @resources = []
+      array.each do |resource|
+        if resource.is_a?(Resource)
+          @resources << resource
+        elsif resource.is_a?(Hash)
+          @resources << Resource.new(resource)
+        end
+      end
+    end
+
+    def attributes
+      h = {}
+      ALLOWED_KEYS.each do |key|
+        value = self.send(key)
+        h[key] = value unless value.nil?
+      end
+      return h
+    end
+
+    def attributes=(input)
+      return if input.nil?
+      input.deep_stringify_keys!
+      ALLOWED_KEYS.each { |key| self.send("#{key}=", input[key]) }
+      NESTED_KEYS.each { |key| self.send("#{key}=", input["#{key}_attributes"]) unless input["#{key}_attributes"].nil? }
+      return attributes
+    end
+  end
+end

data/lib/xively-rb/resource.rb

@@ -0,0 +1,43 @@
+module Xively
+  class Resource
+    ALLOWED_KEYS = %w(feed_id datastream_id datastream_trigger_id)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+
+    include Validations
+
+    def valid?
+      pass = true
+      if feed_id.blank? && datastream_id.blank? && datastream_trigger_id.blank?
+        errors[:feed_id] = "Must supply at least one of feed_id (optionally with a datastream_id) or datastream_trigger_id"
+        pass = false
+      end
+
+      if feed_id.blank? && !datastream_id.blank?
+        errors[:feed_id] = ["can't be blank if we have supplied a datastream_id"]
+        pass = false
+      end
+
+      return pass
+    end
+
+    def initialize(input = {})
+      self.attributes = input
+    end
+
+    def attributes
+      h = {}
+      ALLOWED_KEYS.each do |key|
+        value = self.send(key)
+        h[key] = value unless value.nil?
+      end
+      return h
+    end
+
+    def attributes=(input)
+      return if input.nil?
+      input.deep_stringify_keys!
+      ALLOWED_KEYS.each { |key| self.send("#{key}=", input[key]) }
+      return attributes
+    end
+  end
+end