rtunesu 0.2.1

data/lib/rtunesu/entity.rb

@@ -0,0 +1,154 @@
+require 'hpricot'
+
+module RTunesU
+  # A Base class reprenseting the various entities seen in iTunes U.  Subclassed into the actual entity classes (Course, Division, Track, etc).  Entity is mostly an object oriented interface to the underlying XML data returned from iTunes U.  Most of attributes of an Entity are read by searching the souce XML returned from iTunes U by the Entity class's implemention of method_missing. 
+  # Attribute of an Entity are written through method missing as well.  Methods that end in '=' will write data that will be saved to iTunes U.
+  # == Reading and Writing Attributes
+  # c = Course.find(12345, rtunes_connection_object) # finds the Course in iTunes U and stores its XML data
+  # c.Handle # finds the <Handle> element in the XML data and returns its value (in this case 12345)
+  # c.Name   # finds the <Name> element in the XML data and returns its value (e.g. 'My Example Course')
+  # c.Name = 'Podcasting: a Revolution' # writes a hash of unsaved data that will be sent to iTunes U.
+  #
+  # == Accessing related entities 
+  # Related Entity objects are accessed with the pluralized form of their class name.  To access a Course's related Group entities, you would use c.Groups. This will return an array of Group objects (or an empty Array object if there are no associated Groups)
+  # You can set the array of associated entities by using the '=' form of the accessor and add anothe element to the end of an array of related entities with '<<'
+  # Examples:
+  # c = Course.find(12345, rtunes_connection_object) # finds the Course in iTunes U and stores its XML data
+  # c.Groups # returns an array of Group entities or an empty array of there are no Group entities
+  # c.Groups = [Group.new(:Name => 'Lectures')] # assigns the Groups related entity array to an existign array (overwriting any local data about Groups)
+  # c.Groups << Group.new(:Name => 'Videos') # Adds the new Group object to the end of hte Groups array
+  # c.Groups.collect {|g| g.Name} # ['Lectures', 'Videos']
+  #
+  # == Notes on arbitrary XML
+  # Because Entity is, at heart, an object oriented wrapper for iTunes U XML data it is possible to add arbitrary (and possibly meaningless or invalidating) data that will be sent to iTunes U.  You should have a solid understanding of how Entites relate in iTunes U to avoind sending bad data.
+  # Examples:
+  # c = Course.find(12345, rtunes_connection_object)
+  # c.Junk = 'some junk xml' 
+  # c.save
+  # # c.save will generate XML that inclucdes 
+  # # <Course>
+  # #   <Junk>some junk xml</Junk>
+  # #   ... some other XML data ...
+  # # </Course>
+  # # this XML may raise errors in iTunes U because it doesn't match valid iTunes U documents
+  class Entity
+    attr_accessor :connection, :attributes, :handle, :parent, :parent_handle, :saved, :source_xml
+    
+    # Creates a new Entity object with attributes based on the hash argument  Some of these attributes are assgined to instance variables of the obect (if there is an attr_accessor for it), the rest will be written to a hash of edits that will be saved to iTunes U using method_missing
+    def initialize(attrs = {})
+      self.attributes = {}
+      attrs.each {|attribute, value| self.send("#{attribute}=", value)}
+    end
+    
+    # Finds a specific entity in iTunes U. To find an entity you will need to know both its type (Course, Group, etc) and handle.  Handles uniquely identify entities in iTunes U and the entity type is used to search the returned XML for the specific entity you are looking for.  For example,
+    # Course.find(123456, rtunes_connection_object)
+    def self.find(handle, connection)
+      entity = self.new(:handle => handle)
+      entity.load_from_xml(connection.process(Document::ShowTree.new(entity).xml))
+      entity
+    end
+        
+    def load_from_xml(xml)
+      self.source_xml = Hpricot.XML(xml).at("//ITunesUResponse//#{self.class_name}//Handle[text()=#{self.handle}]..")
+      raise EntityNotFound if self.source_xml.nil?
+    end
+    
+    # Edits stores the changes made to an entity
+    def edits
+      @edits ||= {}
+    end
+    
+    # Clear the edits and restores the loaded object to its original form
+    def reload
+      self.edits.clear
+    end
+    
+    # Returns the parent of the entity
+    def parent
+      @parent ||= Object.module_eval(self.source_xml.parent.name).new(:source_xml => self.source_xml.parent)
+    rescue
+      nil
+    end
+    
+    def method_missing(method_name, args = nil)
+      # introspect the kind of method call (read one attribute, read an array of related items, write one attribute, write an array of related items)
+      case method_name.to_s.match(/(s)*(=)*$/).captures
+       when [nil, "="] : self.edits[method_name.to_s[0..-2]] = args
+       when ["s", "="] : self.edits[method_name.to_s[0..-2]] = args
+       when [nil, nil] : value_from_edits_or_store(method_name.to_s)
+       when ["s", nil] : value_from_edits_or_store(method_name.to_s, true)
+      end
+    rescue NoMethodError
+      raise NoMethodError, "undefined method '#{method_name}' for #{self.class}"
+    end
+    
+    def value_from_edits_or_store(name, multi = false)
+      if multi
+        begin
+          self.edits[name] || (self.source_xml / name.to_s.chop).collect {|el| Object.module_eval(el.name).new(:source_xml => el)}
+        rescue NoMethodError
+          self.edits[name] = []
+        end
+      else
+        self.edits[name] ||  (self.source_xml % name).innerHTML
+      end
+    end
+
+            
+    # Returns the name of the object's class ignoring namespacing. 
+    # === Use:
+    # course = RTunesU::Course.new
+    # course.class #=> 'RTunesU::Course'
+    # course.class_name #=> 'Course'
+    def class_name
+      self.class.to_s.split(':').last
+    end
+    
+    # Returns the handle of the entitiy's parent.  This can either be set directly as a string or interger or will access the parent entity.  Sometimes you know the parent_handle without the parent object (for example, stored locally from an earlier request). This allows you to add a new Entity to iTunes U without first firing a reques for a prent entity (For example, if your institution places all inside the same Section, you want to add a new Section to your Site, or a new Group to a course tied to your institution's LMS).
+    def parent_handle
+      self.parent ? self.parent.handle : @parent_handle
+    end
+    
+    def to_xml(xml_builder = Builder::XmlMarkup.new)
+      xml_builder.tag!(self.class_name) {
+        self.edits.each {|attribute,edit| edit.is_a?(Array) ? edit.each {|item| item.to_xml(xml_builder)} : xml_builder.tag!(attribute, edit) }
+        # self.edits.each {|attribute| xml_builder.tag!(attribute.to_s.gsub(/\/(.?)/) { "::#{$1.upcase}" }.gsub(/(?:^|_)(.)/) { $1.upcase }, self.attributes[attribute.to_s]) unless self.attributes[attribute.to_s].nil? || self.attributes[attribute.to_s].empty? }
+      }
+    end
+    
+    def update(connection)
+      connection.process(Document::Merge.new(self).xml)
+      self
+    end
+    
+    def create(connection)
+      response = Hpricot.XML(connection.process(Document::Add.new(self).xml))
+      raise Exception, response.at('error').innerHTML if response.at('error')
+      self.handle = response.at('AddedObjectHandle').innerHTML
+      self
+    end
+    
+    # Saves the entity to iTunes U.  Save takes single argument (an iTunes U connection object).  If the entity is unsaved this will create the entity and populate its handle attribte.  If the entity has already been saved it will send the updated data (if any) to iTunes U.
+    def save(connection)
+      saved? ? update(connection) : create(connection)
+    end
+    
+    def saved?
+      self.handle ? true : false
+    end
+    
+    # Deletes the entity from iTunes U.  This cannot be undone.
+    def delete(connection)
+      response = Hpricot.XML(connection.process(Document::Delete.new(self).xml))
+      raise Exception, response.at('error').innerHTML if response.at('error')
+      self.handle = nil
+      self
+    end
+  end
+  
+  class EntityNotFound < Exception
+  end
+  
+  class MissingParent < Exception
+  end
+end

data/lib/rtunesu/user.rb

@@ -0,0 +1,26 @@
+module RTunesU
+  # Represents a User for iTunes U authentication.  Requests to iTunes U require User information in a specific format. This class exists to access data in that specific format.  Best combined with a User object from your own authentication or LMS system.
+  # Webservices requests to iTunes U require your institutions administrator credentials
+  # === User
+  # u = RTunesU::User.new('191912121', 'jsmith', 'John Smith', 'jsmith@exmaple.edu')
+  # u.credentials = ['Instructor@urn:mace:example.edu', 'Learner@urn:mace:example.edu']
+  # u.to_identity_string #=> '"John Smith" <jsmith@example.edu> (jsmith) [191912121]'
+  # u.to_credential_string #=> 'Instructor@urn:mace:example.edu;Learner@urn:mace:example.edu'
+  # === Interaction with other classes
+  # a User object is required for creating a Connection object
+  class User
+    attr_accessor :name, :email, :username, :id, :credentials
+    
+    def initialize(id, username, name, email)
+      self.id, self.username, self.name, self.email = id, username, name, email
+    end
+    
+    def to_identity_string
+      '"%s" <%s> (%s) [%s]' % [name, email, username, id]
+    end
+    
+    def to_credential_string
+      self.credentials.join(';')
+    end    
+  end
+end

data/lib/rtunesu/version.rb

@@ -0,0 +1,9 @@
+module RTunesU
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 2
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/rtunesu.rb

@@ -0,0 +1,25 @@
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require 'multipart'
+
+require 'rtunesu/version'
+require 'rtunesu/connection'
+require 'rtunesu/user'
+require 'rtunesu/document'
+require 'rtunesu/entity'
+require 'rtunesu/entities/course'
+require 'rtunesu/entities/division'
+require 'rtunesu/entities/group'
+require 'rtunesu/entities/permission'
+require 'rtunesu/entities/section'
+require 'rtunesu/entities/site'
+require 'rtunesu/entities/track'
+require 'rtunesu/entities/theme'
+
+module  RTunesU
+  API_URL = 'https://deimos.apple.com/WebObjects/Core.woa/API'
+  API_VERSION = '1.1.1'
+  BROWSE_URL = 'https://deimos.apple.com/WebObjects/Core.woa/Browse'
+  SHOW_TREE_URL = 'https://deimos.apple.com/WebObjects/Core.woa/API/ShowTree'
+end

data/script/console

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+# File: script/console
+irb = RUBY_PLATFORM =~ /(:?mswin|mingw)/ ? 'irb.bat' : 'irb'
+
+libs =  " -r irb/completion"
+# Perhaps use a console_lib to store any extra methods I may want available in the cosole
+# libs << " -r #{File.dirname(__FILE__) + '/../lib/console_lib/console_logger.rb'}"
+libs <<  " -r #{File.dirname(__FILE__) + '/../lib/rtunesu.rb'}"
+puts "Loading rtunesu gem"
+exec "#{irb} #{libs} --simple-prompt"

data/script/destroy

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/destroy'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Destroy.new.run(ARGV)

data/script/generate

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+APP_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+
+begin
+  require 'rubigen'
+rescue LoadError
+  require 'rubygems'
+  require 'rubigen'
+end
+require 'rubigen/scripts/generate'
+
+ARGV.shift if ['--help', '-h'].include?(ARGV[0])
+RubiGen::Base.use_component_sources! [:rubygems, :newgem, :newgem_theme, :test_unit]
+RubiGen::Scripts::Generate.new.run(ARGV)

data/script/txt2html

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+GEM_NAME = 'rtunesu' # what ppl will type to install your gem
+RUBYFORGE_PROJECT = 'rtunesu'
+
+require 'rubygems'
+begin
+  require 'newgem'
+  require 'rubyforge'
+rescue LoadError
+  puts "\n\nGenerating the website requires the newgem RubyGem"
+  puts "Install: gem install newgem\n\n"
+  exit(1)
+end
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + "/../lib/#{GEM_NAME}/version.rb"
+
+version  = RTunesU::VERSION::STRING
+download = "http://rubyforge.org/projects/#{RUBYFORGE_PROJECT}"
+
+def rubyforge_project_id
+  RubyForge.new.autoconfig["group_ids"][RUBYFORGE_PROJECT]
+end
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.join(File.dirname(__FILE__), '/../website/template.html.erb')
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.html.erb] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text_template = fsrc.read
+  body_text = ERB.new(body_text_template).result(binding)
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</\1>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(\d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)