cosm-rb 0.0.1

data/lib/cosm-rb/trigger.rb

@@ -0,0 +1,65 @@
+module Cosm
+  class Trigger
+    ALLOWED_KEYS = %w(threshold_value user notified_at url trigger_type id environment_id stream_id)
+    ALLOWED_KEYS.each { |key| attr_accessor(key.to_sym) }
+
+    include Cosm::Templates::JSON::TriggerDefaults
+    include Cosm::Parsers::JSON::TriggerDefaults
+    include Cosm::Parsers::XML::TriggerDefaults
+
+    # validates_presence_of :url
+    # validates_presence_of :stream_id
+    # validates_presence_of :environment_id
+    # validates_presence_of :user
+
+    include Validations
+
+    def valid?
+      pass = true
+      [:url, :stream_id, :environment_id, :user].each do |attr|
+        if self.send(attr).blank?
+          errors[attr] = ["can't be blank"]
+          pass = false
+        end
+      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)
+      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?
+      ALLOWED_KEYS.each { |key| self.send("#{key}=", input[key]) }
+      return attributes
+    end
+
+    def as_json(options = {})
+      generate_json
+    end
+
+    def to_json(options = {})
+      ::JSON.generate as_json(options)
+    end
+
+
+  end
+end
+
+

data/lib/cosm-rb/validations.rb

@@ -0,0 +1,9 @@
+module Cosm
+  module Validations
+    attr_accessor :errors
+    def errors
+      @errors ||= {}
+    end
+  end
+end
+

data/lib/cosm-rb/version.rb

@@ -0,0 +1,3 @@
+module Cosm #:nodoc:
+  VERSION = '0.0.1'
+end

data/lib/cosm-rb.rb

@@ -0,0 +1,29 @@
+require 'nokogiri'
+require 'yajl/json_gem'
+require 'csv'
+
+$:.unshift(File.dirname(File.expand_path(__FILE__)))
+
+$KCODE = 'u' if RUBY_VERSION.to_f < 1.9
+
+require 'cosm-rb/helpers'
+require 'cosm-rb/base'
+require 'cosm-rb/validations'
+require 'cosm-rb/object_extensions'
+require 'cosm-rb/nil_content'
+require 'cosm-rb/string_extensions'
+require 'cosm-rb/array_extensions'
+require 'cosm-rb/hash_extensions'
+require 'cosm-rb/template'
+require 'cosm-rb/templates/defaults'
+require 'cosm-rb/parsers/defaults'
+require 'cosm-rb/feed'
+require 'cosm-rb/datastream'
+require 'cosm-rb/datapoint'
+require 'cosm-rb/search_result'
+require 'cosm-rb/trigger'
+require 'cosm-rb/key'
+require 'cosm-rb/permission'
+require 'cosm-rb/resource'
+
+require 'cosm-rb/client'

data/spec/cosm-rb/array_extensions_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Array extensions" do
+  it "should ignore array.split calls" do
+    array = ['a', 'b']
+    array.split.should == array
+  end
+end
+

data/spec/cosm-rb/base/instance_methods_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+describe Cosm::Base::InstanceMethods do
+  before(:each) do
+    @feed = Feed.new
+    @feed.updated = Time.parse("20110202")
+    @feed.title = "Feed Title"
+    @feed.private = true
+    @feed.icon = "http://cosm.com/logo.png"
+    @feed.website = "http://cosm.com"
+    @feed.tags = "kittens, sofa, aardvark"
+    @feed.description = "Test feed"
+    @feed.feed = "http://test.host/testfeed.html?random=890299&rand2=91"
+    @feed.email = "abc@example.com"
+    @feed.creator = "http://www.cosm.com"
+    @feed.location_name = "London"
+    @feed.location_disposition = "fixed"
+    @feed.location_domain = "here"
+    @feed.location_ele = "2000"
+    @feed.location_exposure = "naked"
+    @feed.location_lat = 51.5423
+    @feed.location_lon = 3.243
+    @datastream1 = Datastream.new
+    datastream_as_(:hash, :with => {"stream_id" => "0"}, :except => ["datapoints"]).each do |k,v|
+      @datastream1.send("#{k}=", v)
+    end
+    #  @feed.datastreams.create!(datastream_as_(:hash, :with => {"stream_id" => "0"}, :except => ["datapoints"]))
+    @datastream2 = Datastream.new
+    datastream_as_(:hash, :with => {"stream_id" => "two"}, :except => ["datapoints"]).each do |k,v|
+      @datastream2.send("#{k}=", v)
+    end
+    @feed.datastreams = [@datastream1, @datastream2]
+    datapoints = []
+    10.times do
+      datapoint = Datapoint.new
+      datapoint.value = "#{rand(10000)}"
+      datapoint.at = Time.now - rand(10000) * 60
+      datapoints << datapoint
+    end
+    @datastream2.datapoints = datapoints
+  end
+
+  describe "#to_cosm" do
+    it "should return the appropriate Cosm Object" do
+      @feed.to_cosm.should be_kind_of(Cosm::Feed)
+      @datastream1.to_cosm.should be_kind_of(Cosm::Datastream)
+      @datastream2.datapoints.first.to_cosm.should be_kind_of(Cosm::Datapoint)
+    end
+
+    context "Feed" do
+      it "should map the default fields by default" do
+        Cosm::Feed.should_receive(:new).with(@feed.attributes)
+        @feed.to_cosm
+      end
+    end
+
+    context "Datastream" do
+      it "should map the default fields merged with the optionals by default" do
+        Cosm::Datastream.should_receive(:new).with(@datastream2.attributes.merge({"id" => "two"}))
+        @datastream2.to_cosm
+      end
+    end
+
+    context "Datapoint" do
+      it "should map the default fields by default" do
+        Cosm::Datapoint.should_receive(:new).with(@datastream2.datapoints.first.attributes)
+        @datastream2.datapoints.first.to_cosm
+      end
+    end
+  end
+
+  context "custom mappings" do
+    it "should allow custom method mappings" do
+      class CustomFeed
+        extend Cosm::Base
+
+        undef_method :id if method_defined?(:id)
+        attr_accessor :title
+        is_cosm :feed, {:feed => :custom_method}
+
+        def custom_method
+          "I haz customer"
+        end
+      end
+      feed = CustomFeed.new
+      feed.title = "Name"
+      Cosm::Feed.should_receive(:new).with({"feed" => feed.custom_method, "title" => feed.title})
+      feed.to_cosm
+    end
+
+    it "should not rely on datastreams using this gem" do
+      class NewCustomFeed
+        extend Cosm::Base
+
+        attr_accessor :title
+        is_cosm :feed
+
+        def datastreams
+          ["fake datastream"]
+        end
+      end
+
+      feed = NewCustomFeed.new
+      feed.title = "Name"
+      feed.to_cosm
+    end
+  end
+end
+

data/spec/cosm-rb/base_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe Cosm::Base do
+  describe "#is_cosm" do
+    it "should take a class name and a hash of options" do
+      lambda { Feed.is_cosm }.should raise_error(ArgumentError, "wrong number of arguments (0 for 1)")
+      lambda { Feed.is_cosm(:feed, {}, "bogus third arg") }.should raise_error(ArgumentError, "wrong number of arguments (3 for 2)")
+    end
+
+    it "should assign mapping class" do
+      class TestClass
+        extend Cosm::Base
+        is_cosm :datastream
+      end
+      TestClass.cosm_class.should == Cosm::Datastream
+    end
+
+    it "should assign mapping class for datapoints" do
+      class TestClass
+        extend Cosm::Base
+        is_cosm :datapoint
+      end
+      TestClass.cosm_class.should == Cosm::Datapoint
+    end
+
+    it "should not assign mapping class if unrecognized" do
+      class TestClass
+        extend Cosm::Base
+        is_cosm :hero_stream
+      end
+      TestClass.cosm_class.should be_nil
+    end
+
+    it "should assign optional mappings" do
+      class TestClass
+        extend Cosm::Base
+        is_cosm :feed, {:title => :custom_method, :website => :custom_method}
+        def custom_method
+          "Custom title"
+        end
+      end
+      TestClass.cosm_mappings.should == {:title => :custom_method, :website => :custom_method}
+    end
+
+    it "should include our instance methods into a class when we call it" do
+      class TestClass
+        extend Cosm::Base
+      end
+      TestClass.should_receive(:include).with(Cosm::Base::InstanceMethods)
+      class TestClass
+        is_cosm :feed
+      end
+    end
+  end
+end
+

data/spec/cosm-rb/client_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe "Cosm::Client" do
+  it "should have the base uri defined" do
+    Cosm::Client.base_uri.should == 'https://api.cosm.com'
+  end
+end

data/spec/cosm-rb/datapoint_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Cosm::Datapoint do
+
+  it "should have a constant that defines the allowed keys" do
+    Cosm::Datapoint::ALLOWED_KEYS.should == %w(feed_id datastream_id at value)
+  end
+
+  describe "validation" do
+    before(:each) do
+      @datapoint = Cosm::Datapoint.new
+    end
+
+    %w(datastream_id value feed_id).each do |field|
+      it "should require a '#{field}'" do
+        @datapoint.send("#{field}=".to_sym, nil)
+        @datapoint.should_not be_valid
+        @datapoint.errors[field.to_sym].should include("can't be blank")
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "should create a blank slate when passed no arguments" do
+      datapoint = Cosm::Datapoint.new
+      Cosm::Datapoint::ALLOWED_KEYS.each do |attr|
+        datapoint.attributes[attr.to_sym].should be_nil
+      end
+    end
+
+    it "should accept xml" do
+      datapoint = Cosm::Datapoint.new(datapoint_as_(:xml))
+      datapoint.value.should == "2000"
+    end
+
+    it "should accept json" do
+      datapoint = Cosm::Datapoint.new(datapoint_as_(:json))
+      datapoint.value.should == "2000"
+    end
+
+    it "should accept a hash of attributes" do
+      datapoint = Cosm::Datapoint.new(datapoint_as_(:hash))
+      datapoint.value.should == "2000"
+    end
+  end
+
+  describe "#attributes" do
+    it "should return a hash of datapoint properties" do
+      attrs = {}
+      Cosm::Datapoint::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      datapoint = Cosm::Datapoint.new(attrs)
+
+      datapoint.attributes.should == attrs
+    end
+
+    it "should not return nil values" do
+      attrs = {}
+      Cosm::Datapoint::ALLOWED_KEYS.each do |key|
+        attrs[key] = "key #{rand(1000)}"
+      end
+      attrs["created_at"] = nil
+      datapoint = Cosm::Datapoint.new(attrs)
+
+      datapoint.attributes.should_not include("created_at")
+    end
+  end
+
+  describe "#attributes=" do
+    it "should accept and save a hash of datapoint properties" do
+      datapoint = Cosm::Datapoint.new({})
+
+      attrs = {}
+      Cosm::Datapoint::ALLOWED_KEYS.each do |key|
+        value = "key #{rand(1000)}"
+        attrs[key] = value
+        datapoint.should_receive("#{key}=").with(value)
+      end
+      datapoint.attributes=(attrs)
+    end
+  end
+
+  # Provided by Cosm::Templates::DatapointDefaults
+  describe "#generate_json" do
+    it "should take a version and generate the appropriate template" do
+      datapoint = Cosm::Datapoint.new({})
+      Cosm::Template.should_receive(:new).with(datapoint, :json)
+      lambda {datapoint.generate_json}.should raise_error(NoMethodError)
+    end
+  end
+
+  describe "#to_csv" do
+    it "should call the csv generator with default version (nil as there only is one version)" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with(nil, {}).and_return("3")
+      datapoint.to_csv.should == "3"
+    end
+
+    it "should accept optional csv version" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with("1", {}).and_return("34")
+      datapoint.to_csv(:version => "1").should == "34"
+    end
+
+    it "should accept additional options" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_csv).with("1", {:full => true}).and_return("34")
+      datapoint.to_csv(:version => "1", :full => true).should == "34"
+    end
+  end
+
+  describe "#to_xml" do
+
+    it "should call the xml generator with default version (nil as there only is one version)" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_xml).with(nil).and_return("<xml></xml>")
+      datapoint.to_xml.should == "<xml></xml>"
+    end
+
+    it "should accept optional xml version" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_xml).with("5").and_return("<xml></xml>")
+      datapoint.to_xml(:version => "5").should == "<xml></xml>"
+    end
+
+  end
+
+  describe "#as_json" do
+
+    it "should call the json generator with default version (nil as there only is one version)" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_json).with(nil).and_return({"title" => "Environment"})
+      datapoint.as_json.should == {"title" => "Environment"}
+    end
+
+    it "should accept optional json version" do
+      datapoint = Cosm::Datapoint.new({})
+      datapoint.should_receive(:generate_json).with("0.6-alpha").and_return({"title" => "Environment"})
+      datapoint.as_json(:version => "0.6-alpha").should == {"title" => "Environment"}
+    end
+
+  end
+
+  describe "#to_json" do
+    it "should call #as_json" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Cosm::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).with({})
+      datapoint.to_json
+    end
+
+    it "should pass options through to #as_json" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Cosm::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).with({:crazy => "options"})
+      datapoint.to_json({:crazy => "options"})
+    end
+
+    it "should pass the output of #as_json to yajl" do
+      datapoint_hash = {"id" => "env001", "value" => "2344"}
+      datapoint = Cosm::Datapoint.new(datapoint_hash)
+      datapoint.should_receive(:as_json).and_return({:awesome => "hash"})
+      ::JSON.should_receive(:generate).with({:awesome => "hash"})
+      datapoint.to_json
+    end
+  end
+end
+