scorm 1.0.0

data/lib/scorm.rb

@@ -0,0 +1,5 @@
+module Scorm
+  VERSION = '1.0.0'
+end
+
+require 'scorm/package'

data/lib/scorm/command.rb

@@ -0,0 +1,63 @@
+require 'scorm/commands/base'
+
+Dir["#{File.dirname(__FILE__)}/commands/*.rb"].each { |c| require c }
+
+module Scorm
+  module Command
+    class InvalidCommand < RuntimeError; end
+    class CommandFailed  < RuntimeError; end
+
+    class << self
+      
+      def error(msg)
+        STDERR.puts(msg)
+        exit 1
+      end
+
+      def run(command, args)
+        begin
+          run_internal(command, args.dup)
+        rescue Zip::ZipError => e
+          error e.message
+        rescue InvalidPackage => e
+          error e.message
+        rescue InvalidManifest => e
+          error e.message
+        rescue InvalidCommand
+          error "Unknown command. Run 'scorm help' for usage information."
+        rescue CommandFailed => e
+          error e.message
+        rescue Interrupt => e
+          error "\n[canceled]"
+        end
+      end
+
+      def run_internal(command, args)
+        klass, method = parse(command)
+        runner = klass.new(args)
+        raise InvalidCommand unless runner.respond_to?(method)
+        runner.send(method)
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+          when 1
+            begin
+              return eval("Scorm::Command::#{command.capitalize}"), :index
+            rescue NameError, NoMethodError
+              raise InvalidCommand
+            end
+          when 2
+            begin
+              return Scorm::Command.const_get(parts[0].capitalize), parts[1]
+            rescue NameError
+              raise InvalidCommand
+            end
+          else
+            raise InvalidCommand
+        end
+      end
+    end
+  end
+end

data/lib/scorm/commands/base.rb

@@ -0,0 +1,53 @@
+require 'fileutils'
+
+module Scorm::Command
+  class Base
+    attr_accessor :args
+    attr_reader :autodetected_package
+    
+    def initialize(args)
+      @args = args
+      @autodetected_package = false
+    end
+    
+    def display(msg, newline=true)
+      if newline
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def error(msg)
+      STDERR.puts(msg)
+      exit 1
+    end
+
+    def extract_package(force=true)
+      package = extract_option('--package', false)
+      raise(CommandFailed, "You must specify a package name after --package") if package == false
+      unless package
+        raise(CommandFailed, "No package specified.\nRun this command from package folder or set it adding --package <package name>") if force
+        @autodetected_package = true
+      end
+      package
+    end
+
+    def extract_option(options, default=true)
+      values = options.is_a?(Array) ? options : [options]
+      return unless opt_index = args.select { |a| values.include? a }.first
+      opt_position = args.index(opt_index) + 1
+      if args.size > opt_position && opt_value = args[opt_position]
+        if opt_value.include?('--')
+          opt_value = nil
+        else
+          args.delete_at(opt_position)
+        end
+      end
+      opt_value ||= default
+      args.delete(opt_index)
+      block_given? ? yield(opt_value) : opt_value
+    end
+  end
+end

data/lib/scorm/commands/bundle.rb

@@ -0,0 +1,29 @@
+module Scorm::Command
+  class Bundle < Base
+    def index
+      name = args.shift.strip rescue '.'
+      unless File.exist?(File.join(File.expand_path(name), 'imsmanifest.xml'))
+        raise(CommandFailed, "Invalid package, didn't find any imsmanifest.xml file.")
+      end
+      
+      outname = File.basename(File.expand_path(name)) + '.zip'
+      
+      require 'zip/zip'
+      Zip::ZipFile.open(outname, Zip::ZipFile::CREATE) do |zipfile|
+        Scorm::Package.open(name) do |pkg|
+          Scorm::Manifest::MANIFEST_FILES.each do |file|
+            zipfile.get_output_stream(file) {|f| f.write(pkg.file(file)) }
+            display file
+          end
+          files = pkg.manifest.resources.map {|r| r.files }.flatten.uniq
+          files.each do |file|
+            zipfile.get_output_stream(file) {|f| f.write(pkg.file(file)) }
+            display file
+          end
+        end
+      end
+      
+      display "Created new SCORM package \"#{outname}\"."
+    end
+  end
+end

data/lib/scorm/commands/check.rb

@@ -0,0 +1,45 @@
+module Scorm::Command
+  class Check < Base
+    def index
+      package = args.shift.strip rescue ''
+      raise(CommandFailed, "Invalid package.") if package == ''
+
+      Scorm::Package.open(package, :dry_run => true) do |pkg|
+        display "Checking package \"#{File.basename(package)}\""
+        display ""
+        display "== UUID =="
+        display "Identifier: #{pkg.manifest.identifier}"
+        display ""
+        display "== Manifest =="
+        Scorm::Manifest::MANIFEST_FILES.each do |file|
+         if pkg.exists?(file)
+           display "#{file} -> OK"
+          else
+            display "#{file} -> Missing"
+          end
+        end
+        display ""
+        display "== Organizations =="
+        pkg.manifest.organizations.each do |id, organization|
+          if organization == pkg.manifest.default_organization
+            display "#{organization.title} (default)"
+          else
+            display "#{organization.title}"
+          end
+        end
+        display ""
+        display "== Resources =="
+        pkg.manifest.resources.each do |resource|
+          display "#{resource.href} (#{resource.type}, #{resource.scorm_type}):"
+          resource.files.each do |file|
+            if pkg.exists?(file)
+              display "  - #{file} -> OK"
+            else
+              display "  - #{file} -> Missing"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/scorm/commands/create.rb

@@ -0,0 +1,15 @@
+module Scorm::Command
+  class Create < Base
+    def index
+      name = args.shift.strip rescue ''
+      raise(CommandFailed, "Invalid package name.") if name == ''
+
+      FileUtils.mkdir_p(name)
+      Dir.glob(File.join(File.dirname(File.expand_path(__FILE__)), '../../../skeleton/*')).each do |file|
+        FileUtils.cp(file, name)
+        display "#{name}/#{File.basename(file)}"
+      end
+      display "Created new SCORM package \"#{name}\"."
+    end
+  end
+end

data/lib/scorm/commands/extract.rb

@@ -0,0 +1,12 @@
+module Scorm::Command
+  class Extract < Base
+    def index
+      package = args.shift.strip rescue ''
+      raise(CommandFailed, "Invalid package.") if package == ''
+
+      Scorm::Package.open(package) do |pkg|
+        display "Extracted package to #{pkg.path}"
+      end
+    end
+  end
+end

data/lib/scorm/commands/help.rb

@@ -0,0 +1,80 @@
+module Scorm::Command
+  class Help < Base
+    class HelpGroup < Array
+      attr_reader :title
+
+      def initialize(title)
+        @title = title
+      end
+
+      def command(name, description)
+        self << [name, description]
+      end
+
+      def space
+        self << ['', '']
+      end
+    end
+
+    def self.groups
+      @groups ||= []
+    end
+
+    def self.group(title, &block)
+      groups << begin
+        group = HelpGroup.new(title)
+        yield group
+        group
+      end
+    end
+
+    def self.create_default_groups!
+      group 'Commands' do |group|
+        group.command 'help',                         'show this usage'
+        group.command 'version',                      'show the gem version'
+        group.space
+        group.command 'create <name>',                'create a new package skeleton'
+        group.command 'bundle [<path to directory>]', 'creates a package from the current directory'
+        group.command 'check <path to zip file>',     'runs a test suite against your package'
+        group.command 'extract <path to zip file>',   'extracts and checks the specified package'
+      end
+    end
+
+    def index
+      display usage
+    end
+
+    def usage
+      longest_command_length = self.class.groups.map do |group|
+        group.map { |g| g.first.length }
+      end.flatten.max
+
+      self.class.groups.inject(StringIO.new) do |output, group|
+        output.puts "=== %s" % group.title
+        output.puts
+
+        group.each do |command, description|
+          if command.empty?
+            output.puts
+          else
+            output.puts "%-*s # %s" % [longest_command_length, command, description]
+          end
+        end
+
+        output.puts
+        output
+      end.string + <<-EOTXT
+=== Example
+
+ scorm create mypackage
+ cd mypackage
+ scorm check
+ scorm bundle
+ scorm extract mypackage.zip
+
+EOTXT
+    end
+  end
+end
+
+Scorm::Command::Help.create_default_groups!

data/lib/scorm/commands/version.rb

@@ -0,0 +1,7 @@
+module Scorm::Command
+  class Version < Base
+    def index
+      display Scorm::VERSION
+    end
+  end
+end

data/lib/scorm/datatypes.rb

@@ -0,0 +1,57 @@
+module Scorm
+  module Datatypes
+    
+    class Timeinterval
+      def initialize(seconds)
+        @sec = seconds
+      end
+      
+      def self.parse(str)
+        case str
+        when /(\d{2,4}):(\d{2}):(\d{2})/
+          values = str.match(/(\d{2,4}):(\d{2}):(\d{2})/)
+          hour = values[1].to_i
+          minute = values[2].to_i
+          second = values[3].to_i
+        else
+          date, time = str.split('T')
+          if date
+            year = date.match(/([0-9]+Y)/)[1].to_i if date.match(/([0-9]+Y)/)
+            month = date.match(/([0-9]+M)/)[1].to_i if date.match(/([0-9]+M)/)
+            day = date.match(/([0-9]+D)/)[1].to_i if date.match(/([0-9]+D)/)
+          end
+          if time
+            hour = time.match(/([0-9]+H)/)[1].to_i if time.match(/([0-9]+H)/)
+            minute = time.match(/([0-9]+M)/)[1].to_i if time.match(/([0-9]+M)/)
+            second = time.match(/([0-9\.]+S)/)[1].to_f if time.match(/([0-9\.]+S)/)
+          end
+        end
+        year = year || 0
+        month = month || 0
+        day = day || 0
+        hour = hour || 0
+        minute = minute || 0
+        second = second || 0
+        self.new((year*31557600) + (month*2629800) + (day*86400) + (hour*3600) + (minute*60) + second)
+      end
+      
+      def to_i
+        @sec.to_i
+      end
+      
+      def to_f
+        @sec.to_f
+      end
+      
+      def to_s
+        sec = self.to_i
+        hours = (sec/60/60).to_i
+        sec -= hours*60*60
+        min = (sec/60).to_i
+        sec -= min*60
+        return "#{hours}:#{min}:#{sec}"
+      end
+    end
+    
+  end
+end

data/lib/scorm/manifest.rb

@@ -0,0 +1,154 @@
+require 'rexml/document'
+require 'scorm/metadata'
+require 'scorm/organization'
+require 'scorm/resource'
+
+module Scorm
+  class Manifest
+    
+    # Versions of the SCORM standard that is supported when running in
+    # strict mode. When not running in strict mode, the library will not
+    # care about the version specified in the package manifest and will
+    # simply try its best to parse the information that it finds.
+    SUPPORTED_VERSIONS = ['2004 3rd Edition', 'CAM 1.3', '1.2']
+    
+    # List of XML and XML Schema files that are part of the manifest for
+    # the package.
+    MANIFEST_FILES = %w(imsmanifest.xml adlcp_rootv1p2.xsd ims_xml.xsd
+       imscp_rootv1p1p2.xsd imsmd_rootv1p2p1.xsd)
+    
+    # Files that might be present in a package, but that should not be
+    # interprested as resources. All files starting with a "." (i.e. hidden
+    # files) is also implicitly included in this list.
+    RESOURCES_BLACKLIST = [
+      '__MACOSX', 'desktop.ini', 'Thumbs.db'
+    ].concat(MANIFEST_FILES)
+    
+    attr_accessor :identifier
+    attr_accessor :metadata
+    attr_accessor :organizations
+    attr_accessor :default_organization
+    attr_accessor :resources
+    attr_accessor :base_url
+    attr_accessor :schema
+    attr_accessor :schema_version
+  
+    def initialize(package, manifest_data)
+      @xmldoc = REXML::Document.new(manifest_data)
+    
+      @package = package
+      @metadata = Scorm::Metadata.new
+      @organizations = Hash.new
+      @resources = Hash.new
+      
+      # Manifest identifier
+      @identifier = @xmldoc.root.attribute('identifier').to_s
+    
+      # Read metadata
+      if metadata_el = REXML::XPath.first(@xmldoc.root, '/manifest/metadata')
+        # Read <schema> and <schemaversion>
+        schema_el = REXML::XPath.first(metadata_el, 'schema')
+        schemaversion_el = REXML::XPath.first(metadata_el, 'schemaversion')
+        @schema = schema_el.text.to_s unless schema_el.nil?
+        @schema_version = schemaversion_el.text.to_s unless schemaversion_el.nil?
+        
+        if @package.options[:strict]
+          if (@schema != 'ADL SCORM') || (!SUPPORTED_VERSIONS.include?(@schema_version))
+            raise InvalidManifest, "Sorry, unsupported SCORM-version (#{schema_el.text.to_s} #{schemaversion_el.text.to_s}), try turning strict parsing off."
+          end
+        end
+      
+        # Find a <lom> element...
+        lom_el = nil
+        if adlcp_location = REXML::XPath.first(metadata_el, 'adlcp:location')
+          # Read external metadata file
+          metadata_xmldoc = REXML::Document.new(package.file(adlcp_location.text.to_s))
+          if metadata_xmldoc.nil? || (metadata_xmldoc.root.name != 'lom')
+            raise InvalidManifest, "Invalid external metadata file (#{adlcp_location.text.to_s})."
+          else
+            lom_el = metadata_xmldoc.root
+          end
+        else
+          # Read inline metadata
+          lom_el = REXML::XPath.first(metadata_el, 'lom') ||
+                   REXML::XPath.first(metadata_el, 'lom:lom')
+        end
+      
+        # Read lom metadata
+        if lom_el
+          @metadata = Scorm::Metadata.from_xml(lom_el)
+        end
+      end
+    
+      # Read organizations
+      if organizations_el = REXML::XPath.first(@xmldoc.root, '/manifest/organizations')
+        default_organization_id = organizations_el.attribute('default').to_s
+        REXML::XPath.each(@xmldoc.root, '/manifest/organizations/organization') do |el|
+          org = Scorm::Organization.from_xml(el)
+          @organizations[org.id.to_s] = org
+        end
+        # Set the default organization
+        @default_organization = @organizations[default_organization_id]
+        raise InvalidManifest, "No default organization (#{default_organization_id})." if @default_organization.nil?
+      else
+        raise InvalidManifest, 'Missing organizations element.'
+      end
+    
+      # Read resources
+      REXML::XPath.each(@xmldoc.root, '/manifest/resources/resource') do |el|
+        res = Scorm::Resource.from_xml(el)
+        @resources[res.id] = res
+      end
+      
+      # Read additional resources as assets (this is a fix for packages that
+      # don't correctly specify all resource dependencies in the manifest).
+      @package.files.each do |file|
+        next if File.directory?(file)
+        next if RESOURCES_BLACKLIST.include?(File.basename(file))
+        next if File.basename(file) =~ /^\./
+        next unless self.resources(:with_file => file).empty?
+        next unless self.resources(:href => file).empty?
+        
+        res = Scorm::Resource.new(file, 'webcontent', 'asset', file, nil, [file])
+        @resources[file] = res
+      end
+    
+      # Read (optional) base url for resources
+      resources_el = REXML::XPath.first(@xmldoc.root, '/manifest/resources')
+      @base_url = (resources_el.attribute('xml:base') || '').to_s
+    
+      # Read sub-manifests
+      #REXML::XPath.
+    end
+  
+    def resources(options = nil)
+      if (options.nil?) || (!options.is_a?(Hash))
+        @resources.values
+      else
+        subset = @resources.values
+        if options[:id]
+          subset = subset.find_all {|r| r.id == options[:id].to_s }
+        end
+        if options[:type]
+          subset = subset.find_all {|r| r.type == options[:type].to_s }
+        end
+        if options[:scorm_type]
+          subset = subset.find_all {|r| r.scorm_type == options[:scorm_type].to_s }
+        end
+        if options[:href]
+          subset = subset.find_all {|r| r.href == options[:href].to_s }
+        end
+        if options[:with_file]
+          subset = subset.find_all {|r| r.files.include?(options[:with_file].to_s) }
+        end
+        subset
+      end
+    end
+    
+    def sco(item, attribute = nil)
+      resource = self.resources(:id => item.resource_id).first
+      resource = (resource && resource.scorm_type == 'sco') ? resource : nil
+      return (resource && attribute) ? resource.send(attribute) : resource
+    end
+  end
+end