xively-rb 0.2.09

data/lib/xively-rb/client.rb

@@ -0,0 +1,43 @@
+require 'httparty'
+module Xively
+  class Client
+    include HTTParty
+    base_uri 'https://api.xively.com'
+
+    attr_accessor :api_key
+
+    def self.user_agent
+      "xively-rb/#{Xively::VERSION}"
+    end
+
+    def initialize(api_key)
+      @api_key = api_key
+    end
+
+    def get(url, options = {})
+      self.class.get(url, parse_options(options))
+    end
+
+    def delete(url, options = {})
+      self.class.delete(url, parse_options(options))
+    end
+
+    def put(url, options = {})
+      self.class.put(url, parse_options(options))
+    end
+
+    def post(url, options = {})
+      self.class.post(url, parse_options(options))
+    end
+
+    private
+
+    def parse_options(options = {})
+      new_options = options.clone
+      new_options[:headers] ||= {}
+      new_options[:headers].merge!("User-Agent" => self.class.user_agent, "X-ApiKey" => api_key)
+      new_options
+    end
+
+  end
+end

data/lib/xively-rb/datapoint.rb

@@ -0,0 +1,72 @@
+module Xively
+  class Datapoint
+    ALLOWED_KEYS = %w(feed_id datastream_id at value)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+
+    include Xively::Templates::JSON::DatapointDefaults
+    include Xively::Templates::XML::DatapointDefaults
+    include Xively::Templates::CSV::DatapointDefaults
+    include Xively::Parsers::JSON::DatapointDefaults
+    include Xively::Parsers::XML::DatapointDefaults
+
+    # validates_presence_of :datastream_id
+    # validates_presence_of :value
+
+    include Validations
+
+    def valid?
+      pass = true
+      [:datastream_id, :value, :feed_id].each do |attr|
+        if self.send(attr).blank?
+          errors[attr] = ["can't be blank"]
+          pass = false
+        end
+      end
+      return pass
+    end
+
+    def initialize(input = {}, format = nil)
+      raise InvalidFormatError, "Unknown format specified, currently we can only parse JSON or XML." unless [nil,:json,:xml].include?(format)
+      if input.is_a? Hash
+        self.attributes = input
+      elsif format == :json || (format.nil? && input.strip[0...1].to_s == "{")
+        self.attributes = from_json(input)
+      else
+        self.attributes = from_xml(input)
+      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]) }
+      return attributes
+    end
+
+    def as_json(options = {})
+      generate_json(options[:version])
+    end
+
+    def to_json(options = {})
+      MultiJson.dump as_json(options)
+    end
+
+    def to_xml(options = {})
+      generate_xml(options[:version])
+    end
+
+    def to_csv(options = {})
+      generate_csv(options.delete(:version), options)
+    end
+  end
+end
+

data/lib/xively-rb/datastream.rb

@@ -0,0 +1,127 @@
+module Xively
+  class Datastream
+    ALLOWED_KEYS = %w(feed_id id feed_creator current_value datapoints max_value min_value tags unit_label unit_symbol unit_type updated datapoints_function)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+    VALID_UNIT_TYPES = %w(basicSI derivedSI conversionBasedUnits derivedUnits contextDependentUnits)
+
+    include Xively::Helpers
+    include Xively::Templates::JSON::DatastreamDefaults
+    include Xively::Templates::XML::DatastreamDefaults
+    include Xively::Templates::CSV::DatastreamDefaults
+    include Xively::Parsers::JSON::DatastreamDefaults
+    include Xively::Parsers::XML::DatastreamDefaults
+    include Xively::Parsers::CSV::DatastreamDefaults
+
+    include Validations
+
+    def valid?
+      pass = true
+      [:id].each do |attr|
+        if self.send(attr).blank?
+          errors[attr] = ["can't be blank"]
+          pass = false
+        end
+      end
+      if !unit_type.blank?
+        if !VALID_UNIT_TYPES.include?(unit_type)
+          errors[:unit_type] = ["is not a valid unit_type (pick one from #{VALID_UNIT_TYPES.join(', ')} or leave blank)"]
+          pass = false
+        end
+      end
+      if current_value && current_value.length > 255
+        errors[:current_value] = ["is too long (maximum is 255 characters)"]
+        pass = false
+      end
+      if tags
+        self.tags = join_tags(self.tags)
+        if tags && tags.length > 255
+          errors[:tags] = ["is too long (maximum is 255 characters)"]
+          pass = false
+        end
+      end
+
+      stream_id_regexp = RUBY_VERSION.to_f >= 1.9 ? /\A[\p{L}\w\-\+\.]+\Z/u : /\A[\w\-\+\.]+\Z/u
+
+      unless self.id =~ stream_id_regexp
+        errors[:id] = ["is invalid"]
+        pass = false
+      end
+      if self.id.blank?
+        errors[:id] = ["can't be blank"]
+        pass = false
+      end
+
+      unless self.feed_id.to_s =~ /\A\d*\Z/
+        errors[:feed_id] = ["is invalid"]
+        pass = false
+      end
+
+      return pass
+    end
+
+    def initialize(input = {}, csv_version = nil, format = nil)
+      raise InvalidFormatError, "Unknown format specified, currently we can only parse JSON, XML or CSV." unless [nil,:json,:xml,:csv].include?(format)
+      if input.is_a? Hash
+        self.attributes = input
+      elsif format == :json || (format.nil? && input.strip[0...1].to_s == "{")
+        self.attributes = from_json(input)
+      elsif format == :xml || (format.nil? && input.strip[0...1].to_s == "<")
+        self.attributes = from_xml(input)
+      else
+        self.attributes = from_csv(input, csv_version)
+      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]) }
+      return attributes
+    end
+
+    def datapoints
+      @datapoints.nil? ? [] : @datapoints
+    end
+
+    def datapoints=(array)
+      return unless array.is_a?(Array)
+      @datapoints = []
+      array.each do |datapoint|
+        if datapoint.is_a?(Datapoint)
+          @datapoints << datapoint
+        elsif datapoint.is_a?(Hash)
+          @datapoints << Datapoint.new(datapoint)
+        end
+      end
+    end
+
+    def as_json(options = {})
+      options[:version] ||= "1.0.0"
+      generate_json(options.delete(:version), options)
+    end
+
+    def to_json(options = {})
+      MultiJson.dump as_json(options)
+    end
+
+    def to_xml(options = {})
+      options[:version] ||= "0.5.1"
+      generate_xml(options.delete(:version), options)
+    end
+
+    def to_csv(options = {})
+      options[:version] ||= "2"
+      generate_csv(options.delete(:version), options)
+    end
+  end
+end
+

data/lib/xively-rb/exceptions.rb

@@ -0,0 +1,5 @@
+module Xively
+  class Error < StandardError; end
+  class InvalidFormatError < Error; end
+  class ParserError < Error; end
+end

data/lib/xively-rb/feed.rb

@@ -0,0 +1,109 @@
+module Xively
+  class Feed
+    # The order of these keys is the order attributes are assigned in. (i.e. id should come before datastreams)
+    ALLOWED_KEYS = %w(id creator owner_login datastreams description email feed icon location_disposition location_domain location_ele location_exposure location_lat location_lon location_name location_waypoints private status tags title updated created website auto_feed_url product_id device_serial csv_version)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+
+    include Xively::Templates::JSON::FeedDefaults
+    include Xively::Templates::XML::FeedDefaults
+    include Xively::Templates::CSV::FeedDefaults
+    include Xively::Parsers::JSON::FeedDefaults
+    include Xively::Parsers::XML::FeedDefaults
+    include Xively::Parsers::CSV::FeedDefaults
+
+    include Validations
+
+    def valid?
+      pass = true
+      if title.blank?
+        errors[:title] = ["can't be blank"]
+        pass = false
+      end
+
+      duplicate_datastream_ids = datastreams.inject({}) {|h,v| h[v.id]=h[v.id].to_i+1; h}.reject{|k,v| v==1}.keys
+      if duplicate_datastream_ids.any?
+        errors[:datastreams] = ["can't have duplicate IDs: #{duplicate_datastream_ids.join(',')}"]
+        pass = false
+      end
+
+      datastreams.each do |ds|
+        unless ds.valid?
+          ds.errors.each { |attr, ds_errors|
+            errors["datastreams_#{attr}".to_sym] = ([*errors["datastreams_#{attr}".to_sym]] | [*ds_errors]).compact
+          }
+          pass = false
+        end
+      end
+
+      return pass
+    end
+
+    def initialize(input = {}, csv_version = nil, format = nil)
+      raise InvalidFormatError, "Unknown format specified, currently we can only parse JSON, XML or CSV." unless [nil,:json,:xml,:csv].include?(format)
+      if input.is_a?(Hash)
+        self.attributes = input
+      elsif format == :json || (format.nil? && input.strip[0...1].to_s == "{")
+        self.attributes = from_json(input)
+      elsif format == :xml || (format.nil? && input.strip[0...5].to_s == "<?xml" || input.strip[0...5].to_s == "<eeml")
+        self.attributes = from_xml(input)
+      else
+        self.attributes = from_csv(input, csv_version)
+      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 datastreams
+      return [] if @datastreams.nil?
+      @datastreams
+    end
+
+    def attributes=(input)
+      return if input.nil?
+      input.deep_stringify_keys!
+      ALLOWED_KEYS.each { |key| self.send("#{key}=", input[key]) }
+      return attributes
+    end
+
+    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)
+        end
+      end
+    end
+
+    def as_json(options = {})
+      options[:version] ||= "1.0.0"
+      generate_json(options.delete(:version), options)
+    end
+
+    def to_json(options = {})
+      MultiJson.dump as_json(options)
+    end
+
+    def to_xml(options = {})
+      options[:version] ||= "0.5.1"
+      generate_xml(options.delete(:version), options)
+    end
+
+    def to_csv(options = {})
+      options[:version] ||= "2"
+      generate_csv(options.delete(:version), options)
+    end
+
+  end
+end
+
+

data/lib/xively-rb/hash_extensions.rb

@@ -0,0 +1,16 @@
+class Hash
+  def delete_if_nil_value
+    delete_if{|k,v| v.nil? || v.blank?}
+  end
+
+  def deep_stringify_keys
+    inject({}) do |options, (key, value)|
+      options[key.to_s] = (value.is_a?(Hash) ? value.deep_stringify_keys : value)
+      options
+    end
+  end
+
+  def deep_stringify_keys!
+    self.replace(self.deep_stringify_keys)
+  end
+end

data/lib/xively-rb/helpers.rb

@@ -0,0 +1,41 @@
+module Xively
+  module Helpers
+    def parse_tag_string(string)
+      return [] if string.blank?
+      string = string.join(',') if string.is_a?(Array)
+      tags = []
+      quoted_mode = false
+      tags << string.chars.reduce("") do |buffer, char|
+        if char == ','
+          if !quoted_mode
+            tags << buffer
+            buffer = ""
+          else
+            buffer << char
+          end
+        elsif char == '"'
+          if buffer.length > 0 && buffer[-1,1] == '\\'
+            buffer[-1] = char
+          else
+            quoted_mode = !quoted_mode
+            buffer << char
+          end
+        else
+          buffer << char
+        end
+        buffer
+      end
+      # strip the tags
+      tags.map { |t|
+        /\A\s*("(.*)"|(.*))\s*\Z/.match(t)
+        $2 || $3.strip
+      }.sort{|a,b| a.downcase <=> b.downcase}
+    end
+
+    def join_tags(tags)
+      return tags unless tags.is_a?(Array)
+      tags.sort{|a,b| a.downcase <=> b.downcase}.join(',')
+    end
+  end
+end
+

data/lib/xively-rb/key.rb

@@ -0,0 +1,99 @@
+module Xively
+  class Key
+    ALLOWED_KEYS = %w(id key label user expires_at permissions private_access)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+    NESTED_KEYS = %w(permissions)
+
+    include Xively::Templates::JSON::KeyDefaults
+    #include Xively::Templates::XML::KeyDefaults
+    include Xively::Parsers::JSON::KeyDefaults
+    include Xively::Parsers::XML::KeyDefaults
+
+    include Validations
+
+    def valid?
+      pass = true
+      [:label, :permissions, :user].each do |attr|
+        if self.send(attr).blank?
+          errors[attr] = ["can't be blank"]
+          pass = false
+        end
+      end
+
+      permissions.each do |permission|
+        unless permission.valid?
+          permission.errors.each do |attr, permission_errors|
+            errors["permissions_#{attr}".to_sym] = ([*errors["permissions_#{attr}".to_sym]] | [*permission_errors]).compact
+          end
+          pass = false
+        end
+      end
+
+      return pass
+    end
+
+    # Build an instance from either a Hash, a JSON string, or an XML document
+    def initialize(input = {}, format = nil)
+      raise InvalidFormatError, "Unknown format specified, currently we can only parse JSON or XML." unless [nil,:json,:xml].include?(format)
+      if input.is_a?(Hash)
+        self.attributes = input
+      elsif format == :json || (format.nil? && input.strip[0...1].to_s == "{")
+        self.attributes = from_json(input)
+      else
+        self.attributes = from_xml(input)
+      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}=".to_sym, input["#{key}_attributes"]) unless input["#{key}_attributes"].nil?
+      }
+      return attributes
+    end
+
+    def as_json(options = nil)
+      generate_json(options || {})
+    end
+
+    def to_json(options = nil)
+      MultiJson.dump(as_json(options))
+    end
+
+    def permissions
+      return [] if @permissions.nil?
+      @permissions
+    end
+
+    def permissions=(array)
+      return unless array.is_a?(Array)
+      @permissions = []
+      array.each do |permission|
+        if permission.is_a?(Permission)
+          @permissions << permission
+        elsif permission.is_a?(Hash)
+          @permissions << Permission.new(permission)
+        end
+      end
+    end
+
+    def private_access?
+      @private_access || false
+    end
+
+    def id
+      @id.nil? ? @key : @id
+    end
+  end
+end