tin_can_api 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d896c743e9aa76b46e6e9ae50850de428a5839a6
+  data.tar.gz: 10d4216bb0f21b333a23791c63ff8807f0b95dff
+SHA512:
+  metadata.gz: 236685666c862527a6cd11a365d8f1eef97bf079fbb8cc3b225ec99ce0412561366922ab25bdf0138a01cd29fb267f08c2b113190b71e0c69eedea7b3f482764
+  data.tar.gz: 1ac0a3b83e6aa3fca486a082ada827703db11dc88311eedf17089303388d1c9820a250f5c88590da9661e45fc9889f13cf73c6292afb9b15fa4fca89dc31f7f2

data/.gitignore

@@ -0,0 +1,24 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+
+# RubyMine
+.idea/*
+
+# rvm
+.ruby-version
+.ruby-gemset
+
+
+examples

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--require spec_helper

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in tin_can_api.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Paul Coleman
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,80 @@
+# TinCanApi
+
+A Ruby library for implementing Tin Can API (Experience API).
+
+For more information about the Tin Can API visit:
+
+http://tincanapi.com/
+
+## Warning
+
+Please regard this as alpha software. It was created to solve an urgent problem and has not been fully tested in a live environment.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tin_can_api'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tin_can_api
+
+## Usage
+
+Create a client using basic auth
+```ruby
+client = TinCanApi::Client.new do |c|
+  c.end_point = 'https://some.endpoint.com'
+  c.user_name = 'user'
+  c.password = 'password'
+end
+```
+
+Connect to the 'about' endpoint to get version information
+
+```ruby
+# use the client from above
+response = client.about
+# check if it is successful
+if response.success
+    # access the TinCanApi::About instance
+    response.content
+end
+```
+
+Create a statement
+
+```ruby
+agent = TinCanApi::Agent.new(mbox: 'mailto:info@tincanapi.com')
+verb = TinCanApi::Verb.new(id: 'http://adlnet.gov/expapi/verbs/attempted')
+activity = TinCanApi::Activity.new(id: 'http://pwcoleman.github.com/TinCanRuby')
+
+statement = TinCanApi::Statement.new do |s|
+  s.actor = agent
+  s.verb = verb
+  s.object = activity
+end
+
+response = client.save_statement(statement)
+if response.success
+  # access the statement
+  response.content
+end
+```
+
+For more API calls check out the TinCanApi::Client class
+
+## Contributing
+
+1. Fork it ( https://github.com/pwcoleman/tin_can_api/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+task :console do
+	exec "irb -r tin_can_api -I ./lib"
+end
+
+

data/lib/tin_can_api/about.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module TinCanApi
+  class About
+    attr_accessor :versions, :extensions
+
+    def initialize(options={})
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        @versions = attributes['version'] if attributes['version']
+        @extensions = attributes['extensions'] if attributes['extensions']
+      end
+    end
+  end
+end

data/lib/tin_can_api/activity.rb

@@ -0,0 +1,41 @@
+# encoding: utf-8
+module TinCanApi
+  # Activity model class
+  class Activity
+
+    attr_accessor :object_type, :definition
+    attr_reader :id
+
+    def initialize(options={}, &block)
+      @object_type = 'Activity'
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id =  Addressable::URI.parse(attributes['id']) if attributes['id']
+        self.definition = ActivityDefinition.new(json: attributes['definition'].to_json) if attributes['definition']
+      else
+        self.id = options.fetch(:id, nil)
+        self.definition = options.fetch(:definition, nil)
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def id=(value)
+      if value.is_a?(String)
+        @id = Addressable::URI.parse(value)
+      else
+        @id = value
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['id'] = id.to_s if id
+      node['definition'] = definition.serialize(version) if definition
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/activity_definition.rb

@@ -0,0 +1,139 @@
+# encoding: utf-8
+module TinCanApi
+  # Activity Definition model class
+  class ActivityDefinition
+    include TinCanApi::InteractionType
+
+    attr_accessor :name, :description, :extensions, :interaction_type, :correct_responses_pattern
+    attr_accessor :choices, :scale, :source, :target, :steps
+    attr_reader :type, :more_info
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.type = attributes['type'] if attributes['type']
+        self.more_info = attributes['moreInfo'] if attributes['moreInfo']
+        self.name = attributes['name'] if attributes['name']
+        self.description = attributes['description'] if attributes['description']
+        self.extensions = attributes['extensions'] if attributes['extensions']
+        self.interaction_type = attributes['interactionType'] if attributes['interactionType']
+
+        if attributes['correctResponsesPattern']
+          self.correct_responses_pattern = []
+          attributes['correctResponsesPattern'].each do |pattern|
+            correct_responses_pattern << pattern
+          end
+        end
+
+        if attributes['choices']
+          self.choices = []
+          attributes['choices'].each do |choice|
+            choices << InteractionComponent.new(choice.to_json)
+          end
+        end
+
+        if attributes['scale']
+          self.scale = []
+          attributes['scale'].each do |element|
+            scale << InteractionComponent.new(element.to_json)
+          end
+        end
+
+        if attributes['source']
+          self.source = []
+          attributes['source'].each do |element|
+            source << InteractionComponent.new(element.to_json)
+          end
+        end
+
+        if attributes['target']
+          self.target = []
+          attributes['target'].each do |element|
+            target << InteractionComponent.new(element.to_json)
+          end
+        end
+
+        if attributes['steps']
+          self.steps = []
+          attributes['steps'].each do |element|
+            steps << InteractionComponent.new(element.to_json)
+          end
+        end
+
+      else
+        self.name = options.fetch(:name, nil)
+        self.description = options.fetch(:description, nil)
+        self.extensions = options.fetch(:extensions, nil)
+        self.interaction_type = options.fetch(:interaction_type, nil)
+        self.correct_responses_pattern = options.fetch(:correct_responses_pattern, nil)
+        self.choices = options.fetch(:choices, nil)
+        self.scale = options.fetch(:scale, nil)
+        self.source = options.fetch(:source, nil)
+        self.target = options.fetch(:target, nil)
+        self.type = options.fetch(:type, nil)
+        self.more_info = options.fetch(:more_info, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def type=(value)
+      if value.is_a?(String)
+        @type = Addressable::URI.parse(value)
+      else
+        @type = value
+      end
+    end
+
+    def more_info=(value)
+      if value.is_a?(String)
+        @more_info = Addressable::URI.parse(value)
+      else
+        @more_info = value
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['name'] = name if name
+      node['description'] = description if description
+      node['type'] = type.to_s if type
+      node['moreInfo'] = more_info.to_s if more_info
+      node['extensions'] = extensions if extensions
+      if interaction_type
+        node['interactionType'] = interaction_type.to_s
+        case interaction_type
+          when TinCanApi::InteractionType::CHOICE.to_s, TinCanApi::InteractionType::SEQUENCING.to_s
+            if choices && choices.any?
+              node['choices'] = choices.map {|element| element.serialize(version)}
+            end
+          when TinCanApi::InteractionType::LIKERT.to_s
+            if scale && scale.any?
+              node['scale'] = scale.map {|element| element.serialize(version)}
+            end
+          when TinCanApi::InteractionType::MATCHING.to_s
+            if source && source.any?
+              node['source'] = source.map {|element| element.serialize(version)}
+            end
+            if target && target.any?
+              node['target'] = target.map {|element| element.serialize(version)}
+            end
+          when TinCanApi::InteractionType::PERFORMANCE.to_s
+            if steps && steps.any?
+              node['steps'] = steps.map {|element| element.serialize(version)}
+            end
+        end
+      end
+
+      if correct_responses_pattern && correct_responses_pattern.any?
+        node['correctResponsesPattern'] = correct_responses_pattern.map {|element| element}
+      end
+
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/agent.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'tin_can_api/tcapi_version'
+module TinCanApi
+  # Agent model class
+  class Agent
+
+    attr_accessor :name, :mbox, :mbox_sha1_sum, :open_id, :account, :object_type
+
+    def initialize(options={}, &block)
+      @object_type = 'Agent'
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.name = attributes['name'] if attributes['name']
+        self.mbox = attributes['mbox'] if attributes['mbox']
+        self.mbox_sha1_sum = attributes['mbox_sha1sum'] if attributes['mbox_sha1sum']
+        self.open_id = attributes['openid'] if attributes['openid']
+        self.account = AgentAccount.new(json: attributes['account'].to_json) if attributes['account']
+      else
+        self.name = options.fetch(:name, nil)
+        self.mbox = options.fetch(:mbox, nil)
+        self.mbox_sha1_sum = options.fetch(:mbox_sha1_sum, nil)
+        self.open_id = options.fetch(:open_id, nil)
+        self.account = options.fetch(:account, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['objectType'] = object_type
+      node['name'] = name if name
+      node['mbox'] = mbox if mbox
+      node['mbox_sha1sum'] = mbox_sha1_sum if mbox_sha1_sum
+      node['openid'] = open_id if open_id
+      node['account'] = account.serialize(version) if account
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/agent_account.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'json'
+module TinCanApi
+  # Agent Account model class
+  class AgentAccount
+
+    attr_accessor :home_page, :name
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.name = attributes['name'] if attributes['name']
+        self.home_page = attributes['homePage'] if attributes['homePage']
+      else
+        self.home_page = options.fetch(:home_page, nil)
+        self.name =options.fetch(:name, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['name'] = name if name
+      node['homePage'] = home_page if home_page
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/attachment.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module TinCanApi
+  # Attachment Class
+  class Attachment
+
+    attr_accessor :display, :description, :content_type, :length, :sha2
+    attr_reader :usage_type, :file_url
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.usage_type = attributes['usageType'] if attributes['usageType']
+        self.display = attributes['display'] if attributes['display']
+        self.description = attributes['description'] if attributes['description']
+        self.content_type = attributes['contentType'] if attributes['contentType']
+        self.length = attributes['length'] if attributes['length']
+        self.sha2 = attributes['sha2'] if attributes['sha2']
+        self.file_url = attributes['fileUrl'] if attributes['fileUrl']
+      else
+        self.usage_type = options.fetch(:usage_type, nil)
+        self.display = options.fetch(:display, nil)
+        self.description = options.fetch(:description, nil)
+        self.content_type = options.fetch(:content_type, nil)
+        self.length = options.fetch(:length, nil)
+        self.sha2 = options.fetch(:sha2, nil)
+        self.file_url = options.fetch(:file_url, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def usage_type=(value)
+      if value.is_a?(String)
+        @usage_type = Addressable::URI.parse(value)
+      else
+        @usage_type = value
+      end
+    end
+
+    def file_url=(value)
+      if value.is_a?(String)
+        @file_url = Addressable::URI.parse(value)
+      else
+        @file_url = value
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['usageType'] = usage_type.to_s if usage_type
+      node['display'] = display if display
+      node['description'] = description if description
+      node['contentType'] = content_type if content_type
+      node['length'] = length if length
+      node['sha2'] = sha2 if sha2
+      node['fileUrl'] = file_url.to_s if file_url
+      node
+    end
+
+  end
+end