desmos 0.1.2

data/lib/desmos/utils.rb

@@ -0,0 +1,64 @@
+module Desmos
+  module Utils
+
+    # Taken from Rack::Utils, 1.2.1 to remove Rack dependency.
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
+        '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+      }.tr(' ', '+')
+    end
+    module_function :escape
+
+    # Params are NOT escaped.
+    def traverse_params_hash(hash, result = nil, current_key = nil)
+      result ||= { :files => [], :params => [] }
+    
+      hash.keys.sort { |a, b| a.to_s <=> b.to_s }.collect do |key|
+        new_key = (current_key ? "#{current_key}[#{key}]" : key).to_s
+        case hash[key]
+        when Hash
+          traverse_params_hash(hash[key], result, new_key)
+        when Array
+          array_key = "#{new_key}[]"
+          hash[key].each do |v|
+            result[:params] << [array_key, v.to_s]
+          end
+        when File
+          filename = File.basename(hash[key].path)
+          types = MIME::Types.type_for(filename)
+          result[:files] << [
+            new_key,
+            filename,
+            types.empty? ? 'application/octet-stream' : types[0].to_s,
+            File.expand_path(hash[key].path)
+          ]
+        else
+          result[:params] << [new_key, hash[key].to_s]
+        end
+      end
+      result
+    end
+    module_function :traverse_params_hash
+
+    def traversal_to_param_string(traversal, escape = true)
+      traversal[:params].collect { |param|
+        "#{Desmos::Utils.escape(param[0])}=#{Desmos::Utils.escape(param[1])}"
+      }.join('&')
+    end
+    module_function :traversal_to_param_string
+
+    # Return the bytesize of String; uses String#size under Ruby 1.8 and
+    # String#bytesize under 1.9.
+    if ''.respond_to?(:bytesize)
+      def bytesize(string)
+        string.bytesize
+      end
+    else
+      def bytesize(string)
+        string.size
+      end
+    end
+    module_function :bytesize
+
+  end
+end

data/lib/desmos/whiteboard.rb

@@ -0,0 +1,96 @@
+module Desmos
+  class Whiteboard
+    include RequestSupport
+    attr_accessor :hash, :title, :tutor, :students
+
+    def self.find(hash)
+      new(:hash => hash).get
+    end
+
+    def self.create(options = {})
+      new(options).save
+    end
+
+    def initialize(options = {})
+      @hash       = options[:hash]  # optional: The API will generate this if not provided. Must be unique if provided.
+      @title      = options[:title] # optional
+
+      # optional: Should be a Desmos::Tutor object
+      if options[:tutor] && !(Tutor === options[:tutor])
+        raise ArgumentError, ':tutor option must be either of type Desmos::Tutor or NilClass'
+      end
+      @tutor = options[:tutor]
+
+      # optional: Should be an Array of Desmos::Student objects
+      if options[:students] && (!options[:students].respond_to?(:all?) || !options[:students].all? { |option| Desmos::Student === option })
+        raise ArgumentError, ':students option must be either an Array containing object of type Desmos::Student or NilClass'
+      end
+      @students = options[:students] || []
+    end
+
+    def save
+      parsed_response = request!(:whiteboard, :create, request_options)
+      if parsed_response.fetch(:success) == 'false'
+        raise RequestError, parsed_response[:error_message] unless parsed_response[:error_message] == 'whiteboard already exists'
+      else
+        self.hash = parsed_response.fetch(:hash)
+      end
+      add_tutor
+      add_students
+      self
+    end
+
+    def add_tutor
+      if tutor
+        parsed_response = request!(:whiteboard, :add_user, tutor.request_options.merge(:whiteboard_hash => hash))
+      end
+    end
+
+    def add_students
+      unless students.empty?
+        students.each do |student|
+          add_student(student)
+        end
+      end
+    end
+
+    def add_student(student)
+      parsed_response = request!(:whiteboard, :add_user, student.request_options.merge(:whiteboard_hash => hash))
+    end
+
+    def get
+      parsed_response = request!(:whiteboard, :read, :whiteboard_hash => hash)
+      if parsed_response[:success] == 'false'
+        case parsed_response[:error_message]
+        when 'Whiteboard not found'
+          raise WhiteboardNotFound, "Whiteboard with HASH=#{hash} could not be found"
+        else
+          raise RequestError, parsed_response[:error_message]
+        end
+      else
+        build_from_hash(parsed_response)
+      end
+    end
+
+    def request_options
+      options = {}
+      options.merge!(:hash  => hash)  if hash
+      options.merge!(:title => title) if title
+      if tutor
+        options.merge!(:tutor_name => tutor.name) if tutor.name
+        options.merge!(:tutor_id   => tutor.id)   if tutor.id
+        options.merge!(:tutor_hash => tutor.hash) if tutor.hash
+      end
+      options
+    end
+
+    def build_from_hash(options)
+      self.hash     = options[:hash]
+      self.title    = options[:title]
+      self.tutor    = Tutor.build_from_hash(options[:tutor])
+      self.students = options[:students].collect { |student_attributes| Student.new(student_attributes) }
+      self
+    end
+
+  end
+end

data/spec/desmos/configuration_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Desmos::Configuration, '.domain' do
+
+  it 'has a domain attribute, that when set will return the domain' do
+    Desmos::Configuration.should respond_to(:domain)
+    Desmos::Configuration.domain = 'https://example.com'
+    Desmos::Configuration.domain.should eql('https://example.com')
+  end
+
+  it 'raises a ConfigurationError if domain is called without having been set' do
+    Desmos::Configuration.domain = nil
+    lambda { Desmos::Configuration.domain }.should raise_error(Desmos::ConfigurationError, 'Desmos::Configuration.domain is a required configuration value.')
+  end
+
+  it 'adds https:// scheme if none is provided' do
+    Desmos::Configuration.domain = 'something.com'
+    Desmos::Configuration.domain.should eql('https://something.com')
+  end
+
+  it 'converts a regular http:// scheme to https:// if needed' do
+    Desmos::Configuration.domain = 'http://something.com'
+    Desmos::Configuration.domain.should eql('https://something.com')
+  end
+
+end
+
+describe Desmos::Configuration, '.version' do
+
+  it 'has a version attribute, that when set will return the version' do
+    Desmos::Configuration.should respond_to(:version)
+    Desmos::Configuration.version = 'api_v1'
+    Desmos::Configuration.version.should eql('api_v1')
+  end
+
+  it 'raises a ConfigurationError if version is called without having been set' do
+    Desmos::Configuration.version = nil
+    lambda { Desmos::Configuration.version }.should raise_error(Desmos::ConfigurationError, 'Desmos::Configuration.version is a required configuration value.')
+  end
+
+  it "prepends the version with 'api_v' if that part of the string does not exist" do
+    Desmos::Configuration.version = 1
+    Desmos::Configuration.version.should eql('api_v1')
+  end
+
+  it "prepends the version with 'api_v' if that part of the string does not exist" do
+    Desmos::Configuration.version = '1'
+    Desmos::Configuration.version.should eql('api_v1')
+  end
+
+  it "parses out a number if there is one to use as the version" do
+    Desmos::Configuration.version = 'this really 4 should not work'
+    Desmos::Configuration.version.should eql('api_v4')
+  end
+
+end
+
+describe Desmos::Configuration, '.key' do
+
+  it 'has a key attributes, that when set will return the key' do
+    Desmos::Configuration.should respond_to(:key)
+    Desmos::Configuration.key = '133'
+    Desmos::Configuration.key.should eql('133')
+  end
+
+  it 'raises a ConfigurationError if key is called without having been set' do
+    Desmos::Configuration.key = nil
+    lambda { Desmos::Configuration.key }.should raise_error(Desmos::ConfigurationError, 'Desmos::Configuration.key is a required configuration value.')
+  end
+
+  it 'converts whatever is passed in into a String' do
+    Desmos::Configuration.key = 133
+    Desmos::Configuration.key.should eql('133')
+
+    Desmos::Configuration.key = true
+    Desmos::Configuration.key.should eql('true')
+  end
+
+end
+
+describe Desmos::Configuration, '.secret' do
+
+  it 'has a secret attribute, that when set will return the secret' do
+    Desmos::Configuration.should respond_to(:secret)
+    Desmos::Configuration.secret = 'abcde'
+    Desmos::Configuration.secret.should eql('abcde')
+  end
+
+  it 'raises a ConfigurationError is secret is called without having been set' do
+    Desmos::Configuration.secret = nil
+    lambda { Desmos::Configuration.secret }.should raise_error(Desmos::ConfigurationError, 'Desmos::Configuration.secret is a required configuration value.')
+  end
+
+end
+
+describe Desmos::Configuration, '.debug_mode' do
+
+  it 'has a debug_mode attriubute that defaults to false' do
+    Desmos::Configuration.should respond_to(:debug_mode)
+    Desmos::Configuration.debug_mode.should eql(false)
+    Desmos::Configuration.debug_mode = true
+    Desmos::Configuration.debug_mode.should eql(true)
+  end
+
+end

data/spec/desmos/request_support_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+
+describe Desmos::RequestSupport, '#request!' do
+
+  before(:each) do
+    class_instance = Class.new
+    class_instance.send(:include, Desmos::RequestSupport)
+    @instance = class_instance.new
+    
+    stub_request(:get, /https\:\/\/api\.tutortrove\.com\/api_v1\/whiteboard\/create/).
+      to_return(:status => 200, :body => "{\"success\": \"true\", \"title\": \"Test Session\", \"hash\": \"abcde\"}")
+  end
+
+  it 'makes a request to the Desmos API with the given object, method, and options and returns a response parsed from JSON' do
+    response = @instance.request!(:whiteboard, :create, { :title => 'Test Session' })
+    response.should eql({
+      :success => 'true',
+      :hash    => 'abcde',
+      :title   => 'Test Session'
+    })
+    assert_requested :get, /https\:\/\/api\.tutortrove\.com\/api_v1\/whiteboard\/create/, :times => 1
+  end
+
+end
+
+describe Desmos::RequestSupport, '#make_request' do
+  
+  before(:each) do
+    class_instance = Class.new
+    class_instance.send(:include, Desmos::RequestSupport)
+    @instance = class_instance.new
+    
+    stub_request(:get, /https\:\/\/api\.tutortrove\.com\/api_v1\/whiteboard\/create/)
+  end
+
+  it 'makes a request to the Desmos API with the given object, method, and options and returns a response from Net::HTTP' do
+    response = @instance.make_request(:whiteboard, :create, { :title => 'Test Session' })
+    response.should be_instance_of(Net::HTTPOK)
+    assert_requested :get, /https\:\/\/api\.tutortrove\.com\/api_v1\/whiteboard\/create/, :times => 1
+  end
+  
+end
+
+describe Desmos::RequestSupport, '#build_uri' do
+  
+  before(:each) do
+    class_instance = Class.new
+    class_instance.send(:include, Desmos::RequestSupport)
+    @instance = class_instance.new
+  end
+
+  it 'builds a uri for the Desmos API from the given object, method, and options and returns the URI object' do
+    uri = @instance.build_uri(:whiteboard, :create, { :title => 'Test Session' })
+    uri.should be_instance_of(URI::HTTPS)
+    uri.path.should eql('/api_v1/whiteboard/create')
+    uri.query.should eql('title=Test+Session')
+    uri.host.should eql(Desmos::Configuration.domain.split('://')[1])
+  end
+  
+end
+
+describe Desmos::RequestSupport, '#build_http' do
+  
+  before(:each) do
+    class_instance = Class.new
+    class_instance.send(:include, Desmos::RequestSupport)
+    @instance = class_instance.new
+  end
+  
+  it 'builds and returns a Net::HTTP instance setup for SSL' do
+    http = @instance.build_http(@instance.build_uri(:whiteboard, :create, { :title => 'Test Session' }))
+    http.should be_instance_of(Net::HTTP)
+  end
+  
+end
+
+describe Desmos::RequestSupport, '#parse_response' do
+  
+  before(:each) do
+    class_instance = Class.new
+    class_instance.send(:include, Desmos::RequestSupport)
+    @instance = class_instance.new
+    
+    stub_request(:get, /https\:\/\/api\.tutortrove\.com\/api_v1\/whiteboard\/create/).
+      to_return(:status => 200, :body => "{\"success\": \"true\", \"title\": \"Test Session\", \"hash\": \"abcde\"}")
+  end
+  
+  it 'parses the JSON response string into a Hash' do
+    response = @instance.make_request(:whiteboard, :create, { :title => 'Test Session', :hash => 'abcde' })
+    parsed_response = @instance.parse_response(response)
+    parsed_response.should be_instance_of(Hash)
+    parsed_response.should eql({
+      :success => 'true',
+      :title   => 'Test Session',
+      :hash    => 'abcde'
+    })
+  end
+  
+end

data/spec/desmos/student_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Desmos::Student, '.new' do
+
+  it 'sets the instance variables for the student' do
+    student = Desmos::Student.new(
+      :id          => 1,
+      :hash        => 'abcde',
+      :name        => 'Test',
+      :last_name   => 'Student',
+      :family_name => 'StudentName',
+      :skype       => 'test_student',
+      :email       => 'test_student@example.com'
+    )
+    student.id.should eql(1)
+    student.hash.should eql('abcde')
+    student.type.should eql('student')
+    student.name.should eql('Test')
+  end
+
+  it 'requires a name attribute' do
+    lambda { Desmos::Student.new(:id => 1) }.should raise_error(ArgumentError, ':name is a required attribute')
+  end
+
+  it 'requires an id attribute' do
+    lambda { Desmos::Student.new(:name => 'test') }.should raise_error(ArgumentError, ':id is a required attribute')
+  end
+
+end
+
+describe Desmos::Student, '.build_from_hash' do
+
+  it 'returns a Desmos::Student object' do
+    student = Desmos::Student.build_from_hash(:id => 1, :name => 'test')
+    student.should be_instance_of(Desmos::Student)
+  end
+
+end

data/spec/desmos/tutor_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Desmos::Tutor, '.new' do
+
+  it 'sets the instance variables for the tutor' do
+    tutor = Desmos::Tutor.new(
+      :id          => 1,
+      :hash        => 'abcde',
+      :name        => 'Test',
+      :last_name   => 'Tutor',
+      :family_name => 'TutorName',
+      :skype       => 'test_tutor',
+      :email       => 'test_tutor@example.com'
+    )
+    tutor.id.should eql(1)
+    tutor.hash.should eql('abcde')
+    tutor.type.should eql('tutor')
+    tutor.name.should eql('Test')
+  end
+
+  it 'requires a name attribute' do
+    lambda { Desmos::Tutor.new(:id => 1) }.should raise_error(ArgumentError, ':name is a required attribute')
+  end
+
+  it 'requires an id attribute' do
+    lambda { Desmos::Tutor.new(:name => 'test') }.should raise_error(ArgumentError, ':id is a required attribute')
+  end
+
+end
+
+describe Desmos::Tutor, '.build_from_hash' do
+
+  it 'returns a Desmos::Tutor object' do
+    tutor = Desmos::Tutor.build_from_hash(:id => 1, :name => 'test')
+    tutor.should be_instance_of(Desmos::Tutor)
+  end
+
+end

data/spec/desmos/user_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Desmos::User, '.new' do
+
+  it 'sets the instance variables for the tutor' do
+    user = Desmos::User.new(
+      :id          => 1,
+      :hash        => 'abcde',
+      :name        => 'Test',
+      :last_name   => 'User',
+      :family_name => 'UserName',
+      :skype       => 'test_user',
+      :email       => 'test_user@example.com'
+    )
+    user.id.should eql(1)
+    user.hash.should eql('abcde')
+    user.type.should eql('user')
+    user.name.should eql('Test')
+  end
+
+  it 'requires a name attribute' do
+    lambda { Desmos::User.new(:id => 1) }.should raise_error(ArgumentError, ':name is a required attribute')
+  end
+
+  it 'requires an id attribute' do
+    lambda { Desmos::User.new(:name => 'test') }.should raise_error(ArgumentError, ':id is a required attribute')
+  end
+
+end
+
+describe Desmos::User, '.build_from_hash' do
+
+  it 'returns a Desmos::User object' do
+    user = Desmos::User.build_from_hash(:id => 1, :name => 'test')
+    user.should be_instance_of(Desmos::User)
+  end
+
+end