growthtribe_xapi 0.0.1

data/lib/xapi/agent.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'xapi/tcapi_version'
+module Xapi
+  # 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/xapi/agent_account.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+require 'json'
+module Xapi
+  # Agent Account model class
+  class AgentAccount
+
+    attr_accessor :homePage, :name
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.name = attributes['name'] if attributes['name']
+        self.homePage = attributes['homePage'] if attributes['homePage']
+      else
+        self.homePage = 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'] = homePage if homePage
+      node
+    end
+
+  end
+end

data/lib/xapi/attachment.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+module Xapi
+  # 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

data/lib/xapi/context.rb

@@ -0,0 +1,54 @@
+# encoding: utf-8
+module Xapi
+  # Context Class Description
+  class Context
+
+    attr_accessor :registration, :instructor, :team, :context_activities, :revision
+    attr_accessor :platform, :language, :statement, :extensions
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        self.registration = attributes['registration'] if attributes['registration']
+        self.instructor = Xapi::Agent.new(json: attributes['instructor'].to_json) if attributes['instructor']
+        self.team = Xapi::Team.new(json: attributes['team'].to_json) if attributes['team']
+        self.context_activities = Xapi::ContextActivities.new(json: attributes['contextActivities'].to_json) if attributes['contextActivities']
+        self.revision = attributes['revision'] if attributes['revision']
+        self.platform = attributes['platform'] if attributes['platform']
+        self.language = attributes['language'] if attributes['language']
+        self.statement = Xapi::StatementRef.new(json: attributes['statement'].to_json) if attributes['statement']
+        self.extensions = attributes['extensions'] if attributes['extensions']
+      else
+        self.registration = options.fetch(:registration, nil)
+        self.instructor = options.fetch(:instructor, nil)
+        self.team = options.fetch(:team, nil)
+        self.context_activities = options.fetch(:context_activities, nil)
+        self.revision = options.fetch(:revision, nil)
+        self.platform = options.fetch(:platform, nil)
+        self.language = options.fetch(:language, nil)
+        self.extensions = options.fetch(:extensions, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      node['registration'] = registration if registration
+      node['instructor'] = instructor.serialize(version) if instructor
+      node['team'] = team.serialize(version) if team
+      node['contextActivities'] = context_activities.serialize(version) if context_activities
+      node['revision'] = revision if revision
+      node['platform'] = platform if platform
+      node['language'] = language if language
+      node['statement'] = statement.serialize(version) if statement
+      node['extensions'] = extensions if extensions
+
+      node
+    end
+
+  end
+end

data/lib/xapi/context_activities.rb

@@ -0,0 +1,102 @@
+# encoding: utf-8
+module Xapi
+  # ContextActivities Model class
+  class ContextActivities
+
+    attr_accessor :parent, :grouping, :other, :category
+
+    def initialize(options={}, &block)
+      json = options.fetch(:json, nil)
+      if json
+        attributes = JSON.parse(json)
+        if attributes['parent']
+          if attributes['parent'].is_a?(Array)
+            self.parent = attributes['parent'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.parent = [Activity.new(json: attributes['parent'].to_json)]
+          end
+        end
+
+        if attributes['grouping']
+          if attributes['grouping'].is_a?(Array)
+            self.grouping = attributes['grouping'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.grouping = [Activity.new(json: attributes['grouping'].to_json)]
+          end
+        end
+
+        if attributes['other']
+          if attributes['other'].is_a?(Array)
+            self.other = attributes['other'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.other = [Activity.new(json: attributes['other'].to_json)]
+          end
+        end
+
+        if attributes['category']
+          if attributes['category'].is_a?(Array)
+            self.category = attributes['category'].map {|element| Activity.new(json: element.to_json)}
+          else
+            self.category = [Activity.new(json: attributes['category'].to_json)]
+          end
+        end
+      else
+        self.parent = options.fetch(:parent, nil)
+        self.grouping = options.fetch(:grouping, nil)
+        self.other = options.fetch(:other, nil)
+        self.category = options.fetch(:category, nil)
+
+        if block_given?
+          block[self]
+        end
+      end
+    end
+
+    def serialize(version)
+      node = {}
+      if parent && parent.any?
+        if version == Xapi::TCAPIVersion::V095 && parent.size > 1
+          raise Xapi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (parent)"
+        end
+        if version == Xapi::TCAPIVersion::V095
+          node['parent'] = parent.first.serialize(version)
+        else
+          node['parent'] = parent.map {|element| element.serialize(version)}
+        end
+      end
+
+      if grouping && grouping.any?
+        if version == Xapi::TCAPIVersion::V095 && grouping.size > 1
+          raise Xapi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (grouping)"
+        end
+        if version == Xapi::TCAPIVersion::V095
+          node['grouping'] = grouping.first.serialize(version)
+        else
+          node['grouping'] = grouping.map {|element| element.serialize(version)}
+        end
+      end
+
+      if other && other.any?
+        if version == Xapi::TCAPIVersion::V095 && other.size > 1
+          raise Xapi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support lists of activities (other)"
+        end
+        if version == Xapi::TCAPIVersion::V095
+          node['other'] = other.first.serialize(version)
+        else
+          node['other'] = other.map {|element| element.serialize(version)}
+        end
+      end
+
+      if category && category.any?
+        if version.ordinal >= Xapi::TCAPIVersion::V100.ordinal
+          node['category'] = category.map {|element| element.serialize(version)}
+        else
+          raise Xapi::Errors::IncompatibleTCAPIVersion, "Version #{version.to_s} doesn't support the category context activity"
+        end
+      end
+
+      node
+    end
+
+  end
+end

data/lib/xapi/documents/activity_profile_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Xapi
+  module Documents
+    class ActivityProfileDocument < Document
+
+      attr_accessor :activity
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/xapi/documents/agent_profile_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Xapi
+  module Documents
+    class AgentProfileDocument < Document
+
+      attr_accessor :agent
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/xapi/documents/document.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+module Xapi
+  module Documents
+    class Document
+
+      attr_accessor :id, :etag, :timestamp, :content_type, :content
+
+      def initialize(&block)
+        if block_given?
+          block[self]
+        end
+      end
+
+    end
+  end
+end
+
+require_relative 'activity_profile_document'
+require_relative 'agent_profile_document'
+require_relative 'state_document'

data/lib/xapi/documents/state_document.rb

@@ -0,0 +1,15 @@
+# encoding: utf-8
+module Xapi
+  module Documents
+    class StateDocument < Document
+
+      attr_accessor :activity, :agent, :registration
+
+      def initialize(&block)
+        super(&block)
+      end
+
+    end
+  end
+end
+

data/lib/xapi/enum.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+module Xapi
+  module Enum
+    CONVERT_PROC = Proc.new do
+      @values = constants.sort.collect{|c| const_get(c)}.freeze
+
+      @values.each_with_index do |value, idx|
+        the_symbol = constants.find{|c| const_get(c) == value}
+        sig = class << value ; self end
+        sig.send :define_method, :name, proc{the_symbol}
+        sig.send :define_method, :ordinal, proc{idx}
+
+        if value.is_a? Hash
+          value.each do |k, v|
+            sig.send :define_method, k, (v.is_a?(Proc) ? v : proc{v})
+          end
+        end
+        value.freeze
+      end
+
+      class << self
+        alias :value_of :const_get
+      end
+
+      module_function
+      def each
+        @values.each { |v| yield v }
+      end
+      def values
+        @values
+      end
+      extend Enumerable
+
+      freeze
+    end
+
+    def self.extended extending_obj
+      extending_obj.module_eval &CONVERT_PROC
+    end
+  end
+
+end

data/lib/xapi/errors.rb

@@ -0,0 +1,9 @@
+# encoding: utf-8
+module Xapi
+  module Errors
+
+    # Raised when an incompatible version is used
+    IncompatibleTCAPIVersion = Class.new(StandardError)
+
+  end
+end

data/lib/xapi/group.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+module Xapi
+  # 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