scorm 1.0.0

data/lib/scorm/metadata.rb

@@ -0,0 +1,100 @@
+module Scorm
+  
+  # The +Metadata+ class holds meta data associated with a SCORM package in a 
+  # hash like structure. The +Metadata+ class reads a LOM (Learning Object 
+  # Metadata) structure and stores the data in categories. A +Category+ can
+  # contain any number of +DataElement+s. A +DataElement+ behaves just like
+  # a string but can contain the same value in many different languages, 
+  # accessed by the DataElement#value (or DataElement#to_s) method by 
+  # specifying the language code as the first argument.
+  #
+  # Ex.
+  #
+  #   <tt>pkg.manifest.metadata.general.class -> Metadata::Category</tt>
+  #   <tt>pkg.manifest.metadata.general.title.class -> Metadata::DataElement</tt>
+  #   <tt>pkg.manifest.metadata.general.title.value -> 'My course'</tt>
+  #   <tt>pkg.manifest.metadata.general.title.value('sv') -> 'Min kurs'</tt>
+  #
+  class Metadata < Hash
+    
+    def self.from_xml(element)
+      metadata = self.new
+      element.elements.each do |category_el|
+        category = Category.from_xml(category_el)
+        metadata.store(category_el.name.to_s, category)
+      end
+      return metadata
+    end
+    
+    def method_missing(sym)
+      self.fetch(sym.to_s, nil)
+    end
+    
+    class Category < Hash
+      
+      def self.from_xml(element)
+        category = Scorm::Metadata::Category.new
+        element.elements.each do |data_el|
+          category[data_el.name.to_s] = DataElement.from_xml(data_el)
+        end
+        return category
+      end
+      
+      def method_missing(sym, *args)
+        data_element = self.fetch(sym.to_s, nil)
+        if data_element.is_a? DataElement
+          data_element.value(args.first)
+        else
+          data_element
+        end
+      end
+    end
+    
+    class DataElement
+      def initialize(value = '', default_lang = nil)
+        if value.is_a? String
+          @langstrings = Hash.new
+          @langstrings['x-none'] = value
+          @default_lang = 'x-none'
+        elsif value.is_a? Hash
+          @langstrings = value.dup
+          @default_lang = default_lang || 'x-none'
+        end
+      end
+      
+      def self.from_xml(element)
+        if element.elements.size == 0
+          return self.new(element.text.to_s)
+          
+        elsif element.get_elements('value').size != 0
+          value_el = element.get_elements('value').first
+          return self.from_xml(value_el)
+          
+        elsif element.get_elements('langstring').size != 0
+          langstrings = Hash.new
+          default_lang = nil
+          element.each_element('langstring') do |ls|
+            default_lang = ls.attribute('xml:lang').to_s if default_lang.nil?
+            langstrings[ls.attribute('xml:lang').to_s || 'x-none'] = ls.text.to_s
+          end
+          return self.new(langstrings, default_lang)
+          
+        else
+          return Category.from_xml(element)
+          
+        end
+      end
+      
+      def value(lang = nil)
+        if lang.nil?
+          (@langstrings && @default_lang) ? @langstrings[@default_lang] : ''
+        else
+          (@langstrings) ? @langstrings[lang] || '' : ''
+        end
+      end
+      
+      alias :to_s :value
+      alias :to_str :value
+    end
+  end
+end

data/lib/scorm/organization.rb

@@ -0,0 +1,77 @@
+#--
+# TODO: items should be read as an hierarchy.
+#
+# TODO: imsss:sequencing and adlnav:presentation should be parsed and read.
+#
+# TODO: read <item><metadata>...</metadata></item>.
+#++
+
+module Scorm
+  # The +Organization+ class holds data about the organization of a SCORM
+  # package. An organization contains an id, title and any number of +items+.
+  # An +Item+ are (in most cases) the same thing as a SCO (Shareable Content 
+  # Object).
+  class Organization
+    attr_accessor :id
+    attr_accessor :title
+    attr_accessor :items
+    
+    def initialize(id, title, items)
+      raise InvalidManifest, 'missing organization id' if id.nil?
+      @id = id.to_s
+      @title = title.to_s
+      @items = items
+    end
+    
+    def self.from_xml(element)
+      id = element.attribute('identifier').to_s
+      title = element.get_elements('title').first.text.to_s if element.get_elements('title').first
+      items = []
+      REXML::XPath.each(element, 'item') do |item_el|
+        items << Item.from_xml(item_el)
+      end
+      return self.new(id, title, items)
+    end
+    
+    # An item has an id, title, and (in some cases) a parent item. An item is
+    # associated with a resource, which in most cases is a SCO (Shareable 
+    # Content Object) resource.
+    class Item
+      attr_accessor :id
+      attr_accessor :title
+      attr_accessor :isvisible
+      attr_accessor :parameters
+      attr_accessor :resource_id
+      attr_accessor :children
+      attr_accessor :time_limit_action
+      attr_accessor :data_from_lms
+      attr_accessor :completion_threshold
+      
+      def initialize(id, title, isvisible = true, parameters = nil, resource_id = nil, children = nil)
+        @id = id.to_s
+        @title = title.to_s
+        @isvisible = isvisible || true
+        @parameters = parameters
+        @resource_id = resource_id
+        @children = children if children.is_a? Array
+      end
+      
+      def self.from_xml(element)
+        item_id = element.attribute('identifier').to_s
+        item_title = element.get_elements('title').first.text.to_s if element.get_elements('title').first
+        item_isvisible = (element.attribute('isvisible').to_s == 'true')
+        item_parameters = element.attribute('parameters').to_s
+        children = []
+        if element.get_elements('item').empty?
+          resource_id = element.attribute('identifierref').to_s
+        else
+          element.each_element('item') do |item_el|
+            child_item = self.from_xml(item_el)
+            children << child_item
+          end
+        end
+        return self.new(item_id, item_title, item_isvisible, item_parameters, resource_id, children)
+      end
+    end
+  end
+end

data/lib/scorm/package.rb

@@ -0,0 +1,210 @@
+require 'rubygems'
+require 'zip/zip'
+require 'fileutils'
+require 'open-uri'
+require 'scorm/datatypes'
+require 'scorm/manifest'
+
+module Scorm
+  class InvalidPackage < RuntimeError; end
+  class InvalidManifest < InvalidPackage; end
+  
+  class Package
+    attr_accessor :name       # Name of the package.
+    attr_accessor :manifest   # An instance of +Scorm::Manifest+.
+    attr_accessor :path       # Path to the extracted course.
+    attr_accessor :repository # The directory to which the packages is extracted.
+    attr_accessor :options    # The options hash supplied when opening the package.
+    attr_accessor :package    # The file name of the package file.
+    
+    DEFAULT_LOAD_OPTIONS = { 
+      :strict => false,
+      :dry_run => false, 
+      :cleanup => true,
+      :force_cleanup => false,
+      :name => nil,
+      :repository => nil
+    }
+    
+    def self.set_default_load_options(options = {})
+      DEFAULT_LOAD_OPTIONS.merge!(options)
+    end
+    
+    def self.open(filename, options = {}, &block)
+      Package.new(filename, options, &block)
+    end
+    
+    # This method will load a SCORM package and extract its content to the 
+    # directory specified by the +:repository+ option. The manifest file will be
+    # parsed and made available through the +manifest+ instance variable. This
+    # method should be called with an associated block as it yields the opened
+    # package and then auto-magically closes it when the block has finished. It
+    # will also do any necessary cleanup if an exception occur anywhere in the
+    # block. The available options are:
+    #
+    #   :+strict+:     If +false+ the manifest will be parsed in a nicer way. Default: +true+.
+    #   :+dry_run+:    If +true+ nothing will be written to the file system. Default: +false+.
+    #   :+cleanup+:    If +false+ no cleanup will take place if an error occur. Default: +true+.
+    #   :+name+:       The name to use when extracting the package to the 
+    #                  repository. Default: will use the filename of the package 
+    #                  (minus the .zip extension).
+    #   :+repository+: Path to the course repository. Default: the same directory as the package.
+    #
+    def initialize(filename, options = {}, &block)
+      @options = DEFAULT_LOAD_OPTIONS.merge(options)
+      @package = filename.respond_to?(:path) ? filename.path : filename
+      
+      # Check if package is a directory or a file.
+      if File.directory?(@package)
+        @name = File.basename(@package)
+        @repository = File.dirname(@package)
+        @path = File.expand_path(@package)
+      else
+        i = nil
+        begin
+          # Decide on a name for the package.
+          @name = [(@options[:name] || File.basename(@package, File.extname(@package))), i].flatten.join
+      
+          # Set the path for the extracted package.
+          @repository = @options[:repository] || File.dirname(@package)
+          @path = File.expand_path(File.join(@repository, @name))
+        
+          # First try is nil, subsequent tries sets and increments the value with 
+          # one starting at zero.
+          i = (i || 0) + 1
+
+        # Make sure the generated path is unique.
+        end while File.exists?(@path)
+      end
+      
+      # Extract the package
+      extract!
+                                                        
+      # Detect and read imsmanifest.xml
+      if exists?('imsmanifest.xml')
+        @manifest = Manifest.new(self, file('imsmanifest.xml'))
+      else
+        raise InvalidPackage, "#{File.basename(@package)}: no imsmanifest.xml, maybe not SCORM compatible?"
+      end
+      
+      # Yield to the caller.
+      yield(self)
+      
+      # Make sure the package is closed when the caller has finished reading it.
+      self.close
+
+    # If an exception occur the package is auto-magically closed and any 
+    # residual data deleted in a clean way.
+    rescue Exception => e
+      self.close
+      self.cleanup
+      raise e
+    end
+    
+    # Closes the package.
+    def close
+      @zipfile.close if @zipfile
+      
+      # Make sure the extracted package is deleted if force_cleanup_on_close
+      # is enabled.
+      self.cleanup if @options[:force_cleanup_on_close]
+    end
+    
+    # Cleans up by deleting all extracted files. Called when an error occurs.
+    def cleanup
+      FileUtils.rmtree(@path) if @options[:cleanup] && !@options[:dry_run] && @path && File.exists?(@path) && package?
+    end
+    
+    # Extracts the content of the package to the course repository. This will be
+    # done automatically when opening a package so this method will rarely be
+    # used. If the +dry_run+ option was set to +true+ when the package was
+    # opened nothing will happen. This behavior can be overridden with the
+    # +force+ parameter. 
+    def extract!(force = false)
+      return if @options[:dry_run] && !force
+      
+      # If opening an already extracted package; do nothing.
+      if not package?
+        return
+      end
+      
+      # Create the path to the course
+      FileUtils.mkdir_p(@path)
+      
+      Zip::ZipFile::foreach(@package) do |entry|
+        entry_path = File.join(@path, entry.name)
+        entry_dir = File.dirname(entry_path)
+        FileUtils.mkdir_p(entry_dir) unless File.exists?(entry_dir)
+        entry.extract(entry_path)
+      end
+    end
+    
+    # This will only return +true+ if what was opened was an actual zip file.
+    def package?
+      # If the path to the course in the repository is the same as the path to
+      # the package, we can assume that what was really opened was a directory
+      # in the course repository and therefor not a package.
+      return false if File.extname(@package)
+      return true 
+    end
+    
+    # Reads a file from the package. If the file is not extracted yet (all files
+    # are extracted by default when opening the package) it will be extracted
+    # to the file system and its content returned. If the +dry_run+ option was
+    # set to +true+ when opening the package the file will <em>not</em> be
+    # extracted to the file system, but read directly into memory.
+    def file(filename)
+      if File.exists?(@path)
+        File.read(path_to(filename))
+      else
+        Zip::ZipFile.foreach(@package) do |entry|
+          return entry.get_input_stream {|io| io.read } if entry.name == filename
+        end
+      end
+    end
+    
+    # Returns +true+ if the specified file (or directory) exists in the package.
+    def exists?(filename)
+      if File.exists?(@path)
+        File.exists?(path_to(filename))
+      else
+        Zip::ZipFile::foreach(@package) do |entry|
+          return true if entry.name == filename
+        end
+        false
+      end
+    end
+    
+    # Computes the absolute path to a file in an extracted package given its
+    # relative path. The argument +relative+ can be used to get the path 
+    # relative to the course repository.
+    #
+    # Ex.
+    #    <tt>pkg.path => '/var/lms/courses/MyCourse/'</tt>
+    #    <tt>pkg.course_repository => '/var/lms/courses/'</tt>
+    #    <tt>path_to('images/myimg.jpg') => '/var/lms/courses/MyCourse/images/myimg.jpg'</tt>
+    #    <tt>path_to('images/myimg.jpg', true) => 'MyCourse/images/myimg.jpg'</tt>
+    #
+    def path_to(relative_filename, relative = false)
+      if relative
+        File.join(@name, relative_filename)
+      else
+        File.join(@path, relative_filename)
+      end
+    end
+    
+    # Returns an array with the paths to all the files in the package.
+    def files
+      if File.directory?(@package)
+        Dir.glob(File.join(File.join(File.expand_path(@package), '**'), '*')).reject {|f|
+          File.directory?(f) }.map {|f| f.sub(/^#{File.expand_path(@package)}\/?/, '') }
+      else
+        entries = []
+        Zip::ZipFile::foreach(@package) do |entry|
+          entries << entry.name unless entry.name[-1..-1] == '/'
+        end
+        entries
+      end
+    end
+  end
+end

data/lib/scorm/resource.rb

@@ -0,0 +1,49 @@
+module Scorm
+  
+  # A +Resource+ is a representation/description of an actual resource (image,
+  # sco, pdf, etc...) in a SCORM package.
+  class Resource
+    attr_accessor :id
+    attr_accessor :type
+    attr_accessor :scorm_type
+    attr_accessor :href
+    attr_accessor :metadata
+    attr_accessor :files
+    attr_accessor :dependencies
+    
+    def initialize(id, type, scorm_type, href = nil, metadata = nil, files = nil, dependencies = nil)
+      raise InvalidManifest, 'Missing resource id' if id.nil?
+      raise InvalidManifest, 'Missing resource type' if type.nil?
+      breakpoint if scorm_type.nil?
+      raise InvalidManifest, 'Missing resource scormType' if scorm_type.nil?
+      @id = id.to_s
+      @type = type.to_s
+      @scorm_type = scorm_type.to_s
+      @href = href.to_s || ''
+      @metadata = metadata || Hash.new
+      @files = files || []
+      @dependencies = dependencies || []
+    end
+    
+    def self.from_xml(element)
+      metadata = nil
+      files = []
+      REXML::XPath.each(element, 'file') do |file_el|
+        files << element.attribute('xml:base').to_s + file_el.attribute('href').to_s
+      end
+      dependencies = []
+      REXML::XPath.each(element, 'dependency') do |dep_el|
+        dependencies << dep_el.attribute('identifierref').to_s
+      end
+    
+      res = self.new(
+        element.attribute('identifier'), 
+        element.attribute('type'), 
+        element.attribute('scormType', 'adlcp') || element.attribute('scormtype', 'adlcp'),
+        element.attribute('xml:base').to_s + element.attribute('href').to_s,
+        metadata,
+        files,
+        dependencies)
+    end
+  end
+end

data/skeleton/adlcp_rootv1p2.xsd

@@ -0,0 +1,110 @@
+<?xml version="1.0"?>
+<!-- filename=adlcp_rootv1p2.xsd -->
+<!-- Conforms to w3c http://www.w3.org/TR/xmlschema-1/ 2000-10-24-->
+
+<xsd:schema xmlns="http://www.adlnet.org/xsd/adlcp_rootv1p2"
+            targetNamespace="http://www.adlnet.org/xsd/adlcp_rootv1p2"
+            xmlns:xml="http://www.w3.org/XML/1998/namespace"
+            xmlns:imscp="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+            xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+            elementFormDefault="unqualified"
+            version="ADL Version 1.2">
+
+        <xsd:import namespace="http://www.imsproject.org/xsd/imscp_rootv1p1p2"
+         schemaLocation="imscp_rootv1p1p2.xsd"/>
+
+        <xsd:element name="location" type="locationType"/>
+        <xsd:element name="prerequisites" type="prerequisitesType"/>
+        <xsd:element name="maxtimeallowed" type="maxtimeallowedType"/>
+        <xsd:element name="timelimitaction" type="timelimitactionType"/>
+        <xsd:element name="datafromlms" type="datafromlmsType"/>
+        <xsd:element name="masteryscore" type="masteryscoreType"/>
+
+
+        <xsd:element name="schema" type="newSchemaType"/>
+        <xsd:simpleType name="newSchemaType">
+                <xsd:restriction base="imscp:schemaType">
+                        <xsd:enumeration value="ADL SCORM"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:element name="schemaversion" type="newSchemaversionType"/>
+        <xsd:simpleType name="newSchemaversionType">
+                <xsd:restriction base="imscp:schemaversionType">
+                        <xsd:enumeration value="1.2"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+
+        <xsd:attribute name="scormtype">
+            <xsd:simpleType>
+                <xsd:restriction base="xsd:string">
+                   <xsd:enumeration value="asset"/>
+                   <xsd:enumeration value="sco"/>
+                </xsd:restriction>
+            </xsd:simpleType>
+        </xsd:attribute>
+
+        <xsd:simpleType name="locationType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="2000"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+
+        <xsd:complexType name="prerequisitesType">
+           <xsd:simpleContent>
+              <xsd:extension base="prerequisiteStringType">
+                  <xsd:attributeGroup ref="attr.prerequisitetype"/>
+              </xsd:extension>
+           </xsd:simpleContent>
+        </xsd:complexType>
+
+        <xsd:attributeGroup name="attr.prerequisitetype">
+                <xsd:attribute name="type" use="required">
+                        <xsd:simpleType>
+                                <xsd:restriction base="xsd:string">
+                                   <xsd:enumeration value="aicc_script"/>
+                                </xsd:restriction>
+                        </xsd:simpleType>
+                </xsd:attribute>
+        </xsd:attributeGroup>
+
+        <xsd:simpleType name="maxtimeallowedType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="13"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="timelimitactionType">
+                <xsd:restriction base="stringType">
+                        <xsd:enumeration value="exit,no message"/>
+                        <xsd:enumeration value="exit,message"/>
+                        <xsd:enumeration value="continue,no message"/>
+                        <xsd:enumeration value="continue,message"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="datafromlmsType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="255"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="masteryscoreType">
+                <xsd:restriction base="xsd:string">
+                        <xsd:maxLength value="200"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+        <xsd:simpleType name="stringType">
+                <xsd:restriction base="xsd:string"/>
+        </xsd:simpleType>
+        
+        <xsd:simpleType name="prerequisiteStringType">
+                <xsd:restriction base="xsd:string">
+                   <xsd:maxLength value="200"/>
+                </xsd:restriction>
+        </xsd:simpleType>
+
+</xsd:schema>