tin_can_api 0.0.1

data/lib/tin_can_api/group.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module TinCanApi
+  # Group model class
+  class Group < Agent
+
+    attr_accessor :members
+
+    def initialize(options={}, &block)
+      super(options, &block)
+
+      @object_type = 'Group'
+      @members = []
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        attributes['member'].each do |member|
+          members << Agent.new(json: member.to_json)
+        end
+      else
+        self.members = options.fetch(:members, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = super(version)
+      if members.any?
+        node['member'] = members.map {|member| member.serialize(version)}
+      end
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/interaction_component.rb

@@ -0,0 +1,32 @@
+# encoding: utf-8
+module TinCanApi
+  # InteractionComponent Class Description
+  class InteractionComponent
+
+    attr_accessor :id, :description
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+        self.description = attributes['description'] if attributes['description']
+      else
+        self.id = options.fetch(:id, nil)
+        self.description = options.fetch(:description, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['id'] = id if id
+      node['description'] = description if description
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/interaction_type.rb

@@ -0,0 +1,58 @@
+# encoding: utf-8
+module TinCanApi
+  # Possible interaction types
+  module InteractionType
+
+    CHOICE = {
+        to_s: 'choice',
+        get_value: proc{'choice'}
+    }
+
+    SEQUENCING = {
+        to_s: 'sequencing',
+        get_value: proc{'sequencing'}
+    }
+
+    LIKERT = {
+        to_s: 'likert',
+        get_value: proc{'likert'}
+    }
+
+    MATCHING = {
+        to_s: 'matching',
+        get_value: proc{'matching'}
+    }
+
+    PERFORMANCE = {
+        to_s: 'performance',
+        get_value: proc{'performance'}
+    }
+
+    TRUE_FALSE = {
+        to_s: 'true-false',
+        get_value: proc{'true-false'}
+    }
+
+    FILL_IN = {
+        to_s: 'fill-in',
+        get_value: proc{'fill-in'}
+    }
+
+    NUMERIC = {
+        to_s: 'numeric',
+        get_value: proc{'numeric'}
+    }
+
+    OTHER = {
+        to_s: 'other',
+        get_value: proc{'other'}
+    }
+
+    def type_by_string(type)
+      values.select{|v| v.to_s == type}.first
+    end
+
+    extend TinCanApi::Enum
+
+  end
+end

data/lib/tin_can_api/lrs_response.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+module TinCanApi
+  class LrsResponse
+    attr_accessor :success, :error_message, :content, :status
+
+    def initialize(&block)
+      if block_given?
+        block[self]
+      end
+    end
+
+
+  end
+end

data/lib/tin_can_api/query_result_format.rb

@@ -0,0 +1,6 @@
+# encoding: utf-8
+module TinCanApi
+  module QueryResultFormat
+
+  end
+end

data/lib/tin_can_api/remote_lrs.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+require 'tin_can_api/tcapi_version'
+module TinCanApi
+  # Class used to communicate with a TCAPI endpoint synchronously
+  class RemoteLRS
+    include TinCanApi::TCAPIVersion
+
+    attr_accessor :end_point, :user_name, :password, :version
+
+    def initialize(version=V101)
+      @version = version
+    end
+
+  end
+end

data/lib/tin_can_api/result.rb

@@ -0,0 +1,45 @@
+# encoding: utf-8
+require 'ruby-duration'
+module TinCanApi
+  # Result Model class
+  class Result
+
+    attr_accessor :score, :success, :completion, :duration, :response, :extensions
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.score = TinCanApi::Score.new(json: attributes['score'].to_json) if attributes['score']
+        self.success = attributes['success'] if attributes['success']
+        self.completion = attributes['completion'] if attributes['completion']
+        self.duration = Duration.new(attributes['duration']) if attributes['duration']
+        self.response = attributes['response'] if attributes['response']
+        self.extensions = attributes['extensions'] if attributes['extensions']
+      else
+        self.score = options.fetch(:score, nil)
+        self.success = options.fetch(:success, nil)
+        self.completion = options.fetch(:completion, nil)
+        self.duration = options.fetch(:duration, nil)
+        self.response = options.fetch(:response, nil)
+        self.extensions = options.fetch(:extensions, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['score'] = score.serialize(version) if score
+      node['success'] = success if success
+      node['completion'] = completion if completion
+      node['duration'] = duration.iso8601 if duration
+      node['response'] = response if response
+      node['extensions'] = extensions if extensions
+
+      node
+    end
+  end
+end

data/lib/tin_can_api/score.rb

@@ -0,0 +1,39 @@
+# encoding: utf-8
+module TinCanApi
+  # Score model class
+  class Score
+
+    attr_accessor :scaled, :raw, :min, :max
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.scaled = attributes['scaled'] if attributes['scaled']
+        self.raw = attributes['raw'] if attributes['raw']
+        self.min = attributes['min'] if attributes['min']
+        self.max = attributes['max'] if attributes['max']
+      else
+        self.scaled = options.fetch(:scaled, nil)
+        self.raw = options.fetch(:raw, nil)
+        self.min = options.fetch(:min, nil)
+        self.max = options.fetch(:max, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+
+    end
+
+    def serialize(version)
+      node = {}
+      node['scaled'] = scaled if scaled
+      node['raw'] = raw if raw
+      node['min'] = min if min
+      node['max'] = max if max
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/statement.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+module TinCanApi
+  # Statement Class
+  class Statement < Statements::StatementsBase
+
+    attr_accessor :id, :stored, :authority, :version, :voided
+
+    def initialize(options={}, &block)
+      super(options, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+        self.stored =  Time.parse(attributes['stored']) if attributes['stored']
+        self.authority = TinCanApi::Agent.new(json: attributes['authority'].to_json) if attributes['authority']
+        self.version = attributes['version'] if attributes['version']
+        self.voided = attributes['voided'] if attributes['voided']
+      else
+        self.id = options.fetch(:id, nil)
+        self.stored = options.fetch(:stored, nil)
+        self.authority = options.fetch(:authority, nil)
+        self.version = options.fetch(:version, nil)
+        self.voided = options.fetch(:voided, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = super(version)
+
+      node['id'] = id if id
+      node['stored'] = stored.strftime('%FT%T%:z') if stored
+      node['authority'] = authority.serialize(version) if authority
+
+      if version == TinCanApi::TCAPIVersion::V095
+        node['voided'] = voided if voided
+      end
+
+      if version.ordinal <= TinCanApi::TCAPIVersion::V100.ordinal
+        node['version'] = version.to_s if version
+      end
+      node
+    end
+
+    def stamp
+      @id = SecureRandom.uuid
+      @timestamp = Time.now
+    end
+  end
+end

data/lib/tin_can_api/statement_ref.rb

@@ -0,0 +1,31 @@
+# encoding: utf-8
+module TinCanApi
+  # StatementRef Class used when referencing another statement from a statement's object property
+  class StatementRef
+
+    attr_accessor :object_type, :id
+
+    def initialize(options={}, &block)
+      @object_type = 'StatementRef'
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+      else
+        self.id = options.fetch(:id, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['id'] = id if id
+      node['objectType'] = object_type
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/statements/statements_base.rb

@@ -0,0 +1,70 @@
+# encoding: utf-8
+module TinCanApi
+  module Statements
+    class StatementsBase
+
+      attr_accessor :actor, :verb, :object, :result, :context, :timestamp, :attachments, :voided
+
+      def initialize(options={}, &block)
+        @attachments = []
+        json = options.fetch(:json, nil)
+        if json
+          attributes = JSON.parse(json)
+          self.actor = TinCanApi::Agent.new(json: attributes['actor'].to_json) if attributes['actor']
+          self.verb = TinCanApi::Verb.new(json: attributes['verb'].to_json) if attributes['verb']
+          object_node = attributes['object']
+          if object_node
+            case object_node['objectType']
+              when 'Group', 'Agent'
+                self.object = TinCanApi::Agent.new(json: object_node.to_json)
+              when 'StatementRef'
+                self.object = TinCanApi::StatementRef.new(json: object_node.to_json)
+              when 'SubStatement'
+                self.object = TinCanApi::SubStatement.new(json: object_node.to_json)
+              else
+                self.object = TinCanApi::Activity.new(json: object_node.to_json)
+            end
+          end
+          self.result = TinCanApi::Result.new(json: attributes['result'].to_json) if attributes['result']
+          self.context = TinCanApi::Context.new(json: attributes['context'].to_json) if attributes['context']
+          self.timestamp = Time.parse(attributes['timestamp']) if attributes['timestamp']
+          self.voided = attributes['voided'] if attributes['voided']
+          if attributes['attachments']
+            attributes['attachments'].each do |attachment|
+              attachments << TinCanApi::Attachment.new(json: attachment.to_json)
+            end
+          end
+        else
+          self.actor = options.fetch(:actor, nil)
+          self.verb = options.fetch(:verb, nil)
+          self.object = options.fetch(:object, nil)
+          self.result = options.fetch(:result, nil)
+          self.context = options.fetch(:context, nil)
+          self.timestamp = options.fetch(:timestamp, nil)
+          self.attachments = options.fetch(:attachments, nil)
+          self.voided = options.fetch(:voided, nil)
+
+          if block_given?
+            block[self]
+          end
+        end
+      end
+
+      def serialize(version)
+        node = {}
+        node['actor'] = actor.serialize(version)
+        node['verb'] = verb.serialize(version)
+        node['object'] = object.serialize(version)
+        node['result'] = result.serialize(version) if result
+        node['context'] = context.serialize(version) if context
+        node['timestamp'] = timestamp.strftime('%FT%T%:z') if timestamp
+        if version.ordinal <= TinCanApi::TCAPIVersion::V100.ordinal
+          if attachments && attachments.any?
+            node['attachments'] = attachments.map {|element| element.serialize(version)}
+          end
+        end
+        node
+      end
+    end
+  end
+end

data/lib/tin_can_api/statements_query.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module TinCanApi
+  class StatementsQuery
+
+    attr_reader :version, :verb_id
+    attr_accessor :agent, :activity_id, :registration, :related_activities, :related_agents
+    attr_accessor :stored_since, :stored_until, :limit, :format, :ascending
+
+    def initialize(&block)
+      self.version = TCAPIVersion::V101
+      if block_given?
+        block[self]
+      end
+    end
+
+    def verb_id=(value)
+      if value.is_a?(Verb)
+        @verb_id = value.id
+      else
+        @verb_id = Addressable::URI.parse(value)
+      end
+    end
+
+    def parameter_map
+      params = {}
+      params['agent'] = agent.serialize(version) if agent
+      params['verb'] = verb_id.to_s if verb_id
+      params['activity'] = activity_id.to_s if activity_id
+      params['registration'] = registration if registration
+      params['related_activities'] = related_activities if related_activities
+      params['related_agents'] = related_agents if related_agents
+      params['since'] = stored_since.strftime('%FT%T%:z') if stored_since
+      params['until'] = stored_until.strftime('%FT%T%:z') if stored_until
+      params['limit'] = limit if limit
+      params['format'] = format if format
+      params['ascending'] = ascending if ascending
+
+      params
+    end
+
+  end
+end

data/lib/tin_can_api/statements_query_v095.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module TinCanApi
+  class StatementsQueryV095
+
+    attr_reader :version, :verb_id
+    attr_accessor :object, :registration, :context, :actor, :stored_since, :stored_until, :limit
+    attr_accessor :authoritative, :sparse, :instructor, :ascending
+
+    def initialize(&block)
+      self.version = TCAPIVersion::V095
+      if block_given?
+        block[self]
+      end
+    end
+
+    def verb_id=(value)
+      if value.is_a?(Verb)
+        @verb_id = value.id
+      else
+        @verb_id = Addressable::URI.parse(value)
+      end
+    end
+
+    def parameter_map
+      params = {}
+      params['verb'] = verb_id.to_s if verb_id
+      params['object'] = object.serialize(version) if object
+      params['registration'] = registration if registration
+      params['context'] = context if context
+      params['actor'] = actor if actor
+      params['since'] = stored_since.strftime('%FT%T%:z') if stored_since
+      params['until'] = stored_until.strftime('%FT%T%:z') if stored_until
+      params['limit'] = limit if limit
+      params['authoritative'] = authoritative if authoritative
+      params['sparse'] = sparse if sparse
+      params['instructor'] = instructor.serialize(version) if instructor
+      params['ascending'] = ascending if ascending
+
+      params
+    end
+  end
+end

data/lib/tin_can_api/statements_result.rb

@@ -0,0 +1,17 @@
+# encoding: utf-8
+module TinCanApi
+  # Statements result model class, returned by LRS calls to get multiple statements
+  class StatementsResult
+
+    attr_accessor :statements, :more_url
+
+    def initialize(options={})
+      json = options.fetch(:json, nil)
+      self.statements = []
+      if json
+        self.statements = json['statements'].map {|statement| Statement.new(json: statement)} if json['statements']
+        self.more_url = json['more'] if json['more']
+      end
+    end
+  end
+end

data/lib/tin_can_api/sub_statement.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+module TinCanApi
+  class SubStatement < Statements::StatementsBase
+
+    attr_accessor :object_type
+
+    def initialize(options={}, &block)
+      @object_type = 'SubStatement'
+      super(options, &block)
+    end
+
+    def serialize(version)
+      node = super(version)
+      node['objectType'] = object_type
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/tcapi_version.rb

@@ -0,0 +1,27 @@
+# encoding: utf-8
+module TinCanApi
+  module TCAPIVersion
+
+    V101 = {
+        to_s: '1.0.1',
+        get_value: proc{'1.0.1'}
+    }
+
+    V100 = {
+        to_s: '1.0.0',
+        get_value: proc{'1.0.0'}
+    }
+
+    V095 = {
+        to_s: '0.95',
+        get_value: proc{'0.95'}
+    }
+
+    def latest_version
+      V101
+    end
+
+    extend TinCanApi::Enum
+
+  end
+end

data/lib/tin_can_api/verb.rb

@@ -0,0 +1,35 @@
+# encoding: utf-8
+module TinCanApi
+  class Verb
+
+    attr_accessor :id, :display
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.id = attributes['id'] if attributes['id']
+        self.display = attributes['display'] if attributes['display']
+      else
+        self.id = options.fetch(:id, nil)
+        self.display = options.fetch(:display, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def id=(value)
+      @id = Addressable::URI.parse(value) if value
+    end
+
+    def serialize(version)
+      node = {}
+      node['id'] = id.to_s if id
+      node['display'] = display if display
+      node
+    end
+
+  end
+end

data/lib/tin_can_api/version.rb

@@ -0,0 +1,4 @@
+# encoding: utf-8
+module TinCanApi
+  VERSION = "0.0.1"
+end

data/lib/tin_can_api.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+require 'tin_can_api/errors'
+require 'tin_can_api/enum'
+require 'tin_can_api/version'
+require 'tin_can_api/interaction_type'
+require 'tin_can_api/about'
+require 'tin_can_api/agent_account'
+require 'tin_can_api/agent'
+require 'tin_can_api/group'
+require 'tin_can_api/verb'
+require 'tin_can_api/interaction_component'
+require 'tin_can_api/documents/document'
+require 'tin_can_api/score'
+require 'tin_can_api/result'
+require 'tin_can_api/attachment'
+require 'tin_can_api/activity_definition'
+require 'tin_can_api/activity'
+require 'tin_can_api/context_activities'
+require 'tin_can_api/context'
+require 'tin_can_api/statements/statements_base'
+require 'tin_can_api/statement'
+require 'tin_can_api/sub_statement'
+require 'tin_can_api/statement_ref'
+require 'tin_can_api/statements_query'
+require 'tin_can_api/statements_query_v095'
+require 'tin_can_api/lrs_response'
+require "tin_can_api/remote_lrs"
+require 'tin_can_api/client'
+
+begin
+  require 'pry'
+rescue LoadError
+end
+
+module TinCanApi
+  # Your code goes here...
+end

data/spec/fixtures/about.json

@@ -0,0 +1,10 @@
+{
+  "extensions" : {
+    "http://id.tincanapi.com/extension/powered-by" : {
+      "name" : "Tin Can Engine",
+      "homePage" : "http://tincanapi.com/lrs-lms/lrs-for-lmss-home/",
+      "version" : "2012.1.0.8c644"
+    }
+  },
+  "version" : [ "0.9", "0.95", "1.0.1" ]
+}

data/spec/fixtures/statement.json

@@ -0,0 +1,33 @@
+{
+  "id": "06a6cbbb-b09c-4618-88a8-e8aa6884ad42",
+  "actor": {
+    "mbox": "mailto:tincanruby@tincanapi.com",
+    "objectType": "Agent"
+  },
+  "verb": {
+    "id": "http://adlnet.gov/expapi/verbs/experienced",
+    "display": {
+      "en-GB": "experienced",
+      "en-US": "experienced"
+    }
+  },
+  "timestamp": "2015-03-27T13:14:42.081Z",
+  "stored": "2015-03-27T13:14:42.081Z",
+  "authority": {
+    "account": {
+      "homePage": "http://example.com/",
+      "name": "ABCDEFGHI"
+    },
+    "objectType": "Agent"
+  },
+  "version": "1.0.1",
+  "object": {
+    "id": "http://tincanapi.com/TinCanRuby/Test/Unit/0",
+    "definition": {
+      "name": {"en-US": "TinCanJava Tests: Unit 0"},
+      "description": {"en-US": "Unit test 0 in the test suite for the Tin Can Ruby library."},
+      "type": "http://id.tincanapi.com/activitytype/unit-test"
+    },
+    "objectType": "Activity"
+  }
+}