cosm-rb 0.0.1

data/lib/cosm-rb/datastream.rb

@@ -0,0 +1,136 @@
+module Cosm
+  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 Cosm::Helpers
+    include Cosm::Templates::JSON::DatastreamDefaults
+    include Cosm::Templates::XML::DatastreamDefaults
+    include Cosm::Templates::CSV::DatastreamDefaults
+    include Cosm::Parsers::JSON::DatastreamDefaults
+    include Cosm::Parsers::XML::DatastreamDefaults
+    include Cosm::Parsers::CSV::DatastreamDefaults
+
+    include Validations
+    # validate :before, :join_tags
+
+    # validates_presence_of :id
+    # validates_length_of :current_value, :maximum => 255
+    # validates_length_of :tags, :maximum => 255
+    # validates_inclusion_of :unit_type, :in => VALID_UNIT_TYPES,
+    #                                    :allow_nil => true,
+    #                                    :message => "is not a valid unit_type (pick one from #{VALID_UNIT_TYPES} or leave blank)"
+    # validates_format_of :id, :with => /\A[\w\-\+\.]+\Z/
+    #
+
+    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 = {})
+      if input.is_a? Hash
+        self.attributes = input
+      elsif input.strip[0...1].to_s == "{"
+        self.attributes = from_json(input)
+      elsif input.strip[0...1].to_s == "<"
+        self.attributes = from_xml(input)
+      else
+        self.attributes = from_csv(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 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 = {})
+      ::JSON.generate 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/cosm-rb/feed.rb

@@ -0,0 +1,108 @@
+module Cosm
+  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 csv_version)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+
+    include Cosm::Templates::JSON::FeedDefaults
+    include Cosm::Templates::XML::FeedDefaults
+    include Cosm::Templates::CSV::FeedDefaults
+    include Cosm::Parsers::JSON::FeedDefaults
+    include Cosm::Parsers::XML::FeedDefaults
+    include Cosm::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)
+      if input.is_a?(Hash)
+        self.attributes = input
+      elsif input.strip[0...1].to_s == "{"
+        self.attributes = from_json(input)
+      elsif 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 = {})
+      ::JSON.generate 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/cosm-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/cosm-rb/helpers.rb

@@ -0,0 +1,42 @@
+module Cosm
+  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|
+        case char
+        when ','
+          if !quoted_mode
+            tags << buffer
+            buffer = ""
+          else
+            buffer << char
+          end
+        when '"'
+          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/cosm-rb/key.rb

@@ -0,0 +1,98 @@
+module Cosm
+  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 Cosm::Templates::JSON::KeyDefaults
+    #include Cosm::Templates::XML::KeyDefaults
+    include Cosm::Parsers::JSON::KeyDefaults
+    include Cosm::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 = {})
+      if input.is_a?(Hash)
+        self.attributes = input
+      elsif 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)
+      ::JSON.generate 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

data/lib/cosm-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/cosm-rb/object_extensions.rb

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

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

@@ -0,0 +1,12 @@
+module Cosm
+  module Parsers
+    module CSV
+      module DatastreamDefaults
+        def from_csv(csv)
+          {"current_value" => ::CSV.parse(csv.strip).first.first.to_s}
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,38 @@
+module Cosm
+  module Parsers
+    module CSV
+      class UnknownVersionError < StandardError ; end
+      module FeedDefaults
+        def from_csv(csv, csv_version = nil)
+          array = ::CSV.parse(csv.strip)
+          version = detect_version(array, csv_version)
+          hash = Hash.new
+          if version == :v2
+            hash["datastreams"] = array.collect {|row|
+              { "id" => row.first.to_s,
+                "current_value" => row.last.to_s
+              }
+            }
+          elsif version == :v1
+            hash["datastreams"] = []
+            array.first.each_with_index do |current_value, stream_id|
+              hash["datastreams"] << { "id" => stream_id.to_s, "current_value" => current_value }
+            end
+          end
+          hash["csv_version"] = version
+          hash
+        end
+
+        private
+
+        def detect_version(array, version = nil)
+          return version if version
+          return :v2 if array.size >= 2
+          return :v1 if array.size == 1 && array.first.size != 2
+          raise UnknownVersionError, "CSV Version could not be detected"
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,13 @@
+require 'cosm-rb/parsers/json/feed_defaults'
+require 'cosm-rb/parsers/json/search_result_defaults'
+require 'cosm-rb/parsers/json/datastream_defaults'
+require 'cosm-rb/parsers/json/datapoint_defaults'
+require 'cosm-rb/parsers/json/trigger_defaults'
+require 'cosm-rb/parsers/json/key_defaults'
+require 'cosm-rb/parsers/xml/feed_defaults'
+require 'cosm-rb/parsers/xml/datastream_defaults'
+require 'cosm-rb/parsers/xml/datapoint_defaults'
+require 'cosm-rb/parsers/xml/trigger_defaults'
+require 'cosm-rb/parsers/xml/key_defaults'
+require 'cosm-rb/parsers/csv/feed_defaults'
+require 'cosm-rb/parsers/csv/datastream_defaults'

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

@@ -0,0 +1,12 @@
+module Cosm
+  module Parsers
+    module JSON
+      module DatapointDefaults
+        def from_json(json)
+          ::JSON.parse(json)
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,53 @@
+module Cosm
+  module Parsers
+    module JSON
+      module DatastreamDefaults
+        def from_json(json)
+          hash = ::JSON.parse(json)
+          case hash['version']
+          when '1.0.0'
+            transform_1_0_0(hash)
+          when '0.6-alpha', nil
+            transform_0_6_alpha(hash)
+          end
+        end
+
+        private
+
+        # As produced by http://cosm.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"] = hash["tags"].join(',') if 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://cosm.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"] = hash["tags"].join(',') if 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/cosm-rb/parsers/json/feed_defaults.rb

@@ -0,0 +1,103 @@
+module Cosm
+  module Parsers
+    module JSON
+      module FeedDefaults
+
+        include Cosm::Helpers
+
+        def from_json(json)
+          hash = ::JSON.parse(json)
+          case hash['version']
+          when '1.0.0'
+            transform_1_0_0(hash)
+          when '0.6-alpha'
+            transform_0_6_alpha(hash)
+          end
+        end
+
+        private
+
+        # As produced by http://cosm.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://cosm.com/api/v1/FEED_ID.json
+        def transform_0_6_alpha(hash)
+          hash["retrieved_at"] = hash["updated"]
+          hash["state"] = hash["status"]
+          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["values"].first["value"],
+              "min_value" => datastream["values"].first["min_value"],
+              "max_value" => datastream["values"].first["max_value"],
+              "updated" => datastream["values"].first["recorded_at"],
+              "tags" => join_tags(datastream["tags"]),
+            }.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
+          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/cosm-rb/parsers/json/key_defaults.rb

@@ -0,0 +1,15 @@
+module Cosm
+  module Parsers
+    module JSON
+      module KeyDefaults
+        def from_json(json)
+          hash = ::JSON.parse(json)["key"]
+          hash["id"] = hash.delete("id")
+          hash["key"] = hash.delete("api_key")
+          hash
+        end
+      end
+    end
+  end
+end
+