epall-limelight 0.5.0-java

data/lib/limelight/casting_director.rb

@@ -0,0 +1,112 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'limelight/builtin/players'
+
+module Limelight
+
+  # The CastingDirector is responsible for finding Players for Props within a Production.
+  # Each Producer has an instance of a CastingDirector
+  #
+  # Users of Limelight need not be concerned with this class.
+  #
+  class CastingDirector
+
+    def initialize(loader)
+      @loader = loader
+      @known_players = {}
+    end
+
+    def fill_cast(prop)
+      raise LimelightException.new("Cannot cast a Prop without a Scene.") if prop.scene.nil?
+      cast_default_player(prop)
+      cast_additional_players(prop)
+    end
+
+    private ###############################################
+
+    def cast_default_player(prop)
+      return if prop.name.nil? || prop.name.empty?
+      cast_player(prop, prop.name)
+    end
+
+    def cast_additional_players(prop)
+      return if prop.players.nil? || prop.players.empty?
+      player_names = prop.players.split(/[ ,]/)
+      player_names.each do |player_name|
+        cast_player(prop, player_name)
+      end
+    end
+
+    def cast_player(prop, player_name)      
+      recruiter = Recruiter.new(prop, player_name, @loader)
+      prop.include_player(recruiter.player) if recruiter.player_exists?
+    end
+  end
+
+  class Recruiter
+
+    def initialize(prop, player_name, loader)
+      @prop = prop
+      @cast = prop.scene.cast
+      @player_name = player_name
+      @module_name = player_name.camalized
+      @loader = loader
+    end
+
+    def player
+      return @cast.const_get(@module_name)
+    end
+
+    def player_already_exists?
+      return @cast.const_defined?(@module_name)
+    end
+
+    def player_exists?
+      recruit_player if !player_already_exists?
+      return @cast.const_get(@module_name) != :does_not_exist
+    end
+
+    def recruit_player
+      recruit_custom_player
+      recruit_builtin_player if !player_already_exists?
+      @cast.const_set(@module_name, :does_not_exist) if !player_already_exists?
+    end
+
+    def recruit_custom_player
+      player_filename = locate_player
+      load_player(player_filename) if player_filename
+    end
+
+    def recruit_builtin_player
+      begin
+        return if !Limelight::Builtin::Players.const_defined?(@module_name)
+        @cast.const_set(@module_name, Limelight::Builtin::Players.const_get(@module_name))
+      rescue NameError
+      end
+    end
+
+    private ###############################################
+
+    def locate_player
+      player_filename = File.join(@prop.scene.path.to_s, "players", "#{@player_name}.rb")
+      if !@loader.exists?(player_filename)
+        if @prop.scene.production && @prop.scene.path != @prop.scene.production.path
+          player_filename = File.join(@prop.scene.production.path.to_s, "players", "#{@player_name}.rb")
+          return nil if !@loader.exists?(player_filename)
+        else
+          return nil
+        end
+      end
+      
+      return player_filename
+    end
+
+    def load_player(player_filename)
+      src = IO.read(@loader.path_to(player_filename))
+      @cast.module_eval(src, player_filename)
+    end
+
+  end
+
+end

data/lib/limelight/client/playbills.rb

@@ -0,0 +1,86 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'rexml/document'
+require 'uri'
+require 'net/http'
+
+module Limelight
+  module Client
+
+    class Playbills
+
+      def self.from_xml(xml, uri=nil)
+        playbills = []
+        doc = REXML::Document.new(xml)
+        doc.root.each_element do |playbill_element|
+          playbills << Playbill.from_element(playbill_element, uri)
+        end
+        return playbills
+      end
+
+      def self.from_url(url)
+        uri = URI.parse(url)
+        response = Net::HTTP.get_response(uri)
+        return from_xml(response.body, uri)
+      end
+
+    end
+
+    class Playbill
+
+      def self.from_element(element, uri=nil)
+        playbill = Playbill.new(uri)
+        playbill.populate_from_element(element)
+        return playbill
+      end
+
+      def populate_from_element(element)
+        element.each_element do |element|
+          name = element.name.gsub("-", "_")
+          setter_sym = "#{name}=".to_sym
+          self.send(setter_sym, coerce_value(element))
+        end
+      end
+
+      attr_accessor :author, :created_at, :description, :id, :name, :size, :title, :updated_at, :version, :llp_path, :thumbnail_path
+      attr_reader :uri
+
+      def initialize(uri=nil)
+        @uri = uri
+      end
+
+      def thumbnail
+        return pull(thumbnail_path)
+      end
+
+      def llp
+        return pull(llp_path)
+      end
+
+      private #############################################
+
+      def coerce_value(element)
+        value = element.text
+        type_attribute = element.attribute("type")
+        return value if type_attribute.nil?
+        case type_attribute.value
+        when "datetime"
+          value = DateTime.parse(value)
+        when "integer"
+          value = value.to_i
+        end
+        return value
+      end
+
+      def pull(path)
+        new_uri = uri.dup
+        new_uri.path = path
+        response = Net::HTTP.get_response(new_uri)
+        return response.body
+      end
+
+    end
+
+  end
+end

data/lib/limelight/commands/command.rb

@@ -0,0 +1,168 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'optparse'
+
+module Limelight
+  module Commands
+
+    LISTING = {}
+
+    class << self
+
+      def [](name) #:nodoc:
+        name = "help" if name.to_s.empty?
+        if LISTING[name].nil?
+          load_command(name)
+        end
+
+        return LISTING[name]
+      end
+
+      def load_command(name)
+        begin
+          name = name.gsub('-', '')
+          require "limelight/commands/#{name}_command"
+        rescue LoadError => e
+        end
+      end
+
+      def output=(value) #:nodoc:
+        @output = value
+      end
+
+      def output  #:nodoc:
+        return @output || $stdout
+      end
+
+    end
+
+    # The base class for all limelight commands.  The following is a list of them all.
+    #
+    #  Usage: limelight <command> [options] [params]
+    #    commands:
+    #    create		Creates the directories and files for a production and/or scene.
+    #    freeze		freeze a gem into a production.
+    #    open		Open a limelight production.
+    #    pack		Pack a limelight production into a .llp file.
+    #
+    class Command
+
+      class << self
+
+        attr_accessor :alias
+
+        # Sets the alias for the derivative command and installs it in the command listing.  All derivative much
+        # call this method exactly once.
+        #
+        def install_as(name)
+          raise "Command already installed: #{name}." if LISTING[name]
+          self.alias = name
+          LISTING[name] = self
+        end
+
+        # Abstract class level methof that returns a string description of the command.  Derivatives should
+        # override this class level method.
+        #
+        def description
+          return "Default Command description"
+        end
+
+      end
+
+      # Flag.  The backtrace on parse errors will be printed if true.
+      #
+      attr_accessor :print_backtrace
+
+      # Runs the command.  This is TemplateMethod.  It will first parse the arguments, then require files, and finally
+      # process the command.  Derivative should not override this method.
+      #
+      def run(args)
+        parse(args)
+        do_requires
+        begin
+          process if !@has_parse_error
+        rescue SystemExit
+          #okay
+        end
+      end
+
+      # Parse the arguments.  All options will be parsed first, then parse_remainder will be called on
+      # remaining args.  Derivative should not override this method.
+      #
+      def parse(args)         
+        begin
+          remainder = options_spec.parse(args)
+          parse_remainder(remainder)
+        rescue SystemExit => e
+          raise e
+        rescue Exception => e
+          @has_parse_error = true
+          parse_error e
+        end
+      end
+
+      protected ###########################################
+
+      def puts(*args) #:nodoc:
+        Commands.output.puts(*args)
+      end
+
+      # Prints an exception that occurs while parsing the arguments.  The usages summary will follow.
+      #
+      def parse_error(exception = nil)
+        if exception
+          puts ""
+          puts "!!! #{exception}"
+          puts exception.backtrace if @print_backtrace
+        end
+        usage
+        exit -1
+      end
+
+      # Prints the usage summary for a command.
+      #
+      def usage
+        puts ""
+        puts "Usage: limelight #{self.class.alias} #{parameter_description}"
+        puts "    #{self.class.description}"
+        puts "    options:"
+        puts options_spec.summarize
+      end
+
+      # Retreives the OptionParser instance for this command.  It will create it if it doesn't exist.
+      #
+      def options_spec
+        if @options_spec.nil?
+          @options_spec = OptionParser.new
+          @options_spec.on("-h", "--help", "Prints this usage summary.") { usage; exit 0 }
+          build_options(@options_spec)
+        end
+        return @options_spec
+      end
+
+      # Abstract method to require any files needed for processing the command.  Derivative should override this
+      # method if they need to require any files.
+      #
+      def do_requires
+        #override me
+      end
+
+      # Abstract method to define the command line options in the OptionParser.  Derivative should override
+      # this method if they offer command line options 
+      #
+      def build_options(spec)
+        #override me
+      end
+
+      # Abstract method to parse command line paramters.  Parameter are those command line arguments listed after
+      # the options.  Derivatives should override this method they take command line paramters.
+      #
+      def parse_remainder(args)
+        #override me
+      end
+
+    end
+
+  end
+end

data/lib/limelight/commands/create_command.rb

@@ -0,0 +1,98 @@
+#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'limelight/commands/command'
+
+module Limelight
+  module Commands
+
+    # See the following usages summary
+    #
+    #  Usage: limelight create [options] <production|scene> <path>
+    #      Creates the directories and files for a production and/or scene.
+    #      options:
+    #      -h, --help                       Prints this usage summary.
+    #      -s, --scene=<name>               Name of scene when creating a production.  Defaults to 'default_scene'.
+    #      -p, --production_path=<path>     Path of production to contain scene.  Defaults to '.'.
+    #      -S, --spec_path=<path>           Path to spec directory, relative to <production_path>.  Defaults to 'spec'.
+    #
+    # Assume you wanted to create a new production named "love_story" containing two scenes, "midnight_romance" and
+    # "happily_ever_after".  The following commands would created all the needed files.
+    #
+    #   $ jruby -S limelight create -s midnight_romance production love_story
+    #   $ jruby -S limelight create -p love_story scene happily_ever_after
+    #
+    class CreateCommand < Command
+
+      install_as "create"
+
+      def self.description #:nodoc:
+        return "Creates the directories and files for a production and/or scene."
+      end
+
+      attr_reader :template_type, :scene_name, :production_path, :spec_path  #:nodoc:
+
+      protected ###########################################
+
+      def initialize #:nodoc:
+        @scene_name = "default_scene"
+        @production_path = "."
+      end
+
+      def process #:nodoc:
+        create_method = "create_#{@template_type}".to_s
+        self.send create_method
+      end
+
+      def parameter_description #:nodoc:
+        return "[options] <production|scene> <path>"
+      end
+
+      def parse_remainder(args) #:nodoc:
+        @template_type = args.shift
+        raise "Missing template type" if @template_type.nil?
+        raise "Unknown template type: #{@template_type}" if !["production", "scene"].include?(@template_type)
+        self.send "parse_#{@template_type}".to_sym, args
+        @spec_path = File.join(@production_path, "spec") unless @spec_path
+      end
+
+      def do_requires #:nodoc:
+        require 'limelight/templates/production_templater'
+        require 'limelight/templates/scene_templater'
+      end
+
+      def build_options(spec) #:nodoc:
+        spec.on("-s <name>", "--scene=<name>", "Name of scene when creating a production.  Defaults to 'default_scene'.") { |value| @scene_name = value}
+        spec.on("-p <path>", "--production_path=<path>", "Path of production to contain scene.  Defaults to '.'.") { |value| @production_path = value}
+        spec.on("-S <path>", "--spec_path=<path>", "Path to spec directory, relative to <production_path>.  Defaults to 'spec'.") { |value| @spec_path = value}
+      end
+
+      private #############################################
+
+      def parse_production(args)
+        @production_path = args.shift
+        raise "Missing production path parameter" if @production_path.nil?
+      end
+
+      def parse_scene(args)
+        @scene_name = args.shift
+        raise "Missing scene name/path parameter" if @scene_name.nil?
+      end
+
+      def create_production
+        Templates::ProductionTemplater.new(options_hash).generate
+        Templates::SceneTemplater.new(options_hash).generate
+      end
+
+      def create_scene
+        Templates::SceneTemplater.new(options_hash).generate
+      end
+
+      def options_hash
+        return {:production_path => @production_path, :scene_path => @scene_name, :spec_path => @spec_path}
+      end
+
+    end
+
+  end
+end