limelight 0.2.1-java → 0.3.0-java

data/lib/limelight/commands/freeze_command.rb

@@ -0,0 +1,113 @@
+require 'limelight/commands/command'
+
+module Limelight
+  module Commands
+
+    # Freeze a gem into the production.  Frozen gems are unpacked into the root level gem directory.
+    # Limelight will automatically require a production's frozen gems when loaded.
+    #
+    #  Usage: limelight freeze [options] <gem_name|gem_file>
+    #      freeze a gem into a production.
+    #      options:
+    #      -h, --help                       Prints this usage summary.
+    #      -p, --production=<production>    Specify the production where the gem will be frozen.  Default is '.'.
+    #      -v, --version=<version>          Specify the gem version. Defaults to latest. Ignored if file provided.
+    #
+    class FreezeCommand < Command
+
+      install_as "freeze"
+
+      def self.description #:nodoc:
+        return "freeze a gem into a production."
+      end
+
+      attr_reader :gem_name, :production_path, :gem_version
+
+      def initialize() #:nodoc:
+        @production_path = "."
+#        self.print_backtrace = true
+      end
+
+      def is_gem_file?(name) #:nodoc:
+        return File.extname(name) == ".gem"
+      end
+
+      protected ###########################################
+
+      def process  #:nodoc:
+        check_production_path
+        gem_path = is_gem_file?(@gem_name) ? @gem_name : find_system_gem
+        raise "Gem file does not exist: #{gem_path}" if !File.exists?(gem_path)
+        freeze_gem(gem_path)
+      end
+
+      def parse_remainder(args) #:nodoc:
+        @gem_name = args.shift
+        raise "Gem name paramter missing." if @gem_name.nil?
+      end
+
+      def build_options(spec) #:nodoc:
+        spec.on("-p <production>", "--production=<production>", "Specify the production where the gem will be frozen.  Default is '.'.") { |value| @production_path = value }
+        spec.on("-v <version>", "--version=<version>", "Specify the gem version. Defaults to latest. Ignored if file provided.") { |value| @gem_version = value }
+      end
+
+      def parameter_description #:nodoc:
+        return "[options] <gem_name|gem_file>"
+      end
+
+      def do_requires #:nodoc:
+        require 'limelight/util'
+        require 'limelight/templates/templater'
+        require 'rubygems'
+        require 'rubygems/commands/unpack_command'
+      end
+
+      private #############################################
+
+      def check_production_path
+        if !(Util.is_limelight_production?(@production_path) || Util.is_limelight_scene?(@production_path))
+          raise "The production path '#{@production_path}' doesn't appear to be a Limelight production directory."
+        end
+      end
+
+      def find_system_gem
+        if @gem_version
+          @gem_spec = Gem.cache.find_name(@gem_name, "= #{@gem_version}").first
+          raise "Could not find gem (#{@gem_name}-#{@gem_version})." if @gem_spec.nil?
+        else
+          @gem_spec = Gem.cache.find_name(@gem_name).sort_by { |g| g.version }.last
+          raise "Could not find gem (#{@gem_name})." if @gem_spec.nil?
+        end
+
+        return Gem::Commands::UnpackCommand.new.get_path(@gem_name, @gem_spec.version.version)
+      end
+
+      def freeze_gem(gem_path)
+        @gem_spec = Gem::Format.from_file_by_path(gem_path).spec unless @gem_spec
+        @gem_dir_name = "#{@gem_spec.name}-#{@gem_spec.version}"
+
+        establish_gem_dir
+
+        gem_installer = Gem::Installer.new(gem_path)
+        @templater.logger.log("unpacking gem", @gem_dir_path)
+        gem_installer.unpack(@gem_dir_path)
+
+        install_limelight_hook
+      end
+
+      def establish_gem_dir
+        @templater = Templates::Templater.new(@production_path)
+        @gem_dir_path = File.join(@production_path, "__resources", "gems", @gem_dir_name)
+        raise "The gem (#{@gem_dir_name}) is already frozen." if File.exists?(@gem_dir_path)
+        @templater.directory(File.join("__resources", "gems", @gem_dir_name))
+      end
+
+      def install_limelight_hook
+        tokens = { :GEM_NAME => @gem_dir_name, :PATHS => @gem_spec.require_paths.inspect }
+        @templater.file(File.join("__resources", "gems", @gem_dir_name, "limelight_init.rb"), "freezing/limelight_init.rb.template", tokens)
+      end
+
+    end
+
+  end
+end

data/lib/limelight/commands/open_command.rb

@@ -0,0 +1,49 @@
+require 'limelight/commands/command'
+
+module Limelight
+  module Commands
+
+    # See the following usage summary.
+    #
+    #    Usage: limelight open <production_path>
+    #        Open a limelight production.
+    #        options:
+    #        -h, --help                       Prints this usage summary.
+    #
+    class OpenCommand < Command
+
+      install_as "open"
+
+      DEFAULT_PRODUCTION = File.expand_path($LIMELIGHT_HOME + "/productions/startup")
+
+      def initialize
+        self.print_backtrace = true
+      end
+
+      def self.description
+        return "Open a limelight production."
+      end
+
+      protected ###########################################
+
+      def parameter_description
+        return "<production_path>"
+      end
+
+      def do_requires
+        Main.initialize_context
+        require 'limelight/producer'
+      end
+
+      def parse_remainder(args)
+        @production_path = args.shift || DEFAULT_PRODUCTION
+      end
+
+      def process
+        Limelight::Producer.open(@production_path)
+      end
+
+    end
+    
+  end
+end

data/lib/limelight/commands/pack_command.rb

@@ -0,0 +1,45 @@
+#- Copyright 2008 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 usage summary.
+    #
+    #  Usage: limelight pack <production_path>
+    #      Pack a limelight production into a .llp file.
+    #      options:
+    #      -h, --help                       Prints this usage summary.
+    #
+    class PackCommand < Command
+
+      install_as "pack"
+
+      def self.description #:nodoc:
+        return "Pack a limelight production into a .llp file."
+      end
+
+      protected ###########################################
+
+      def parameter_description #:nodoc:
+        return "<production_path>"
+      end
+
+      def parse_remainder(args) #:nodoc:
+        @production_path = args.shift
+        raise "Missing production path" if @production_path.nil?
+      end
+
+      def process #:nodoc:
+        packer = Limelight::Util::Packer.new
+        packer.pack(@production_path)
+      end
+
+    end
+
+  end
+
+
+end

data/lib/limelight/dsl/build_exception.rb

@@ -0,0 +1,51 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+module Limelight
+
+  module DSL
+
+    # An Exception used by many of the DSL Builders.  Allows nice errors messages, with line numbers, to be printed.
+    #
+    class BuildException < Exception
+
+      attr_reader :filename, :line_number
+
+      def initialize(filename, file_contents, e)
+        @filename = filename
+        @file_contents = file_contents
+        @original_exception = e
+        @line_number = find_line_number
+        super(build_error_message)
+        set_backtrace(e.backtrace)
+      end
+
+      def find_line_number
+        lines = [@original_exception.message].concat @original_exception.backtrace
+        line_number = nil
+        lines.each do |line|
+          match = line.match(/\(eval\):(\d+):/)
+          if (match)
+            line_number = match[1].to_i
+            break
+          end
+        end
+        return line_number
+      end
+
+      def build_error_message
+        lines = @file_contents.split("\n")
+        start_line = @line_number - 4 < 0 ? 0 : @line_number - 4
+        end_line = @line_number + 2 >= lines.size ? lines.size - 1: @line_number + 2
+        message = "#{@filename}:#{@line_number}: #{@original_exception.message}"
+        message << "\n\t----- #{@filename} lines #{start_line + 1} - #{end_line + 1} -----"
+        (start_line..end_line).each do |i|
+          message << "\n\t#{i == @line_number - 1 ? "*": " "} #{i+1}: #{lines[i]}"
+        end
+        message << "\n"
+        return message
+      end
+    end
+    
+  end
+end

data/lib/limelight/dsl/menu_bar.rb

@@ -0,0 +1,71 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+module Limelight
+
+  module DSL
+
+    class AnonymousActionListener #:nodoc:
+      include java.awt.event.ActionListener
+
+      def initialize(context, symbol)
+        @context = context
+        @symbol = symbol
+      end
+
+      def actionPerformed(e)
+        method = @context.method(@symbol)
+        method.call
+      end
+    end
+
+    # A class used to build menu bars using a DSL.
+    #
+    #  MenuBar.build(self) do
+    #    menu("File") do
+    #      item("Open", :open_chosen_scene)
+    #      item("Refresh", :reload)
+    #    end
+    #  end
+    #
+    # This example created one menu named 'File' with two menu items: 'Open' and 'Refresh'. The seconds parameter of the
+    # menu items is the symbol of a method on the context that will be invoked when the menu item is selected.
+    #
+    class MenuBar
+
+      def self.build(context, &prop)
+        builder = self.new(context)
+        builder.instance_eval(&prop)
+        return builder.menu_bar
+      end
+
+      attr_reader :menu_bar
+
+      # This builder must be provided with a context.  All menu item actions will be invoked on the context.
+      #
+      def initialize(context)
+        @context = context
+        @menu_bar = javax.swing.JMenuBar.new
+      end
+
+      # Creates a new menu with the provided name
+      #
+      def menu(name)
+        @menu = javax.swing.JMenu.new(name)
+        @menu_bar.add(@menu)
+        yield
+      end
+
+      # Created a new menu item with the provided name.  The symbols paramter is the name of a method on the context
+      # that will be invoked when the item is selected.
+      #
+      def item(name, symbol)
+        menu_item = javax.swing.JMenuItem.new(name)
+        @menu.add(menu_item)
+        menu_item.addActionListener(AnonymousActionListener.new(@context, symbol))
+      end
+
+    end
+    
+  end
+end

data/lib/limelight/dsl/production_builder.rb

@@ -0,0 +1,71 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'limelight/production'
+require 'limelight/limelight_exception'
+require 'limelight/util'
+
+module Limelight
+
+  # A trigger to configure Production objects using the ProductionBuilder DSL.
+  #
+  # See Limelight::ProductionBuilder
+  #
+  def self.build_production(production, &block)
+    builder = DSL::ProductionBuilder.new(production)
+    builder.instance_eval(&block) if block
+    return builder.__production__
+  end
+
+  module DSL
+    # The basis of the DSL for building Style objects.
+    #
+    #  name "Stage Composer"
+    #  attribute :controller
+    #  attribute :inspector
+    #
+    # The above example names the Production 'Stage Composer' and creates two attributes on the Production: 'controller'
+    # and 'inspector'
+    #
+    class ProductionBuilder
+      
+      Limelight::Util.lobotomize(self)
+
+      class << self
+
+        attr_accessor :current_attribute
+
+      end
+
+      attr_reader :__production__
+
+      def initialize(production)
+        @__production__ = production
+      end
+
+      def method_missing(sym, value) #:nodoc:
+        setter_sym = "#{sym}=".to_s
+        raise ProductionBuilderException.new(sym) if !@__production__.respond_to?(setter_sym)
+        @__production__.send(setter_sym, value)
+      end
+
+      # Creates an attribute on the Production
+      #
+      def attribute(sym)
+        ProductionBuilder.current_attribute = sym
+        class << @__production__
+          attr_accessor ProductionBuilder.current_attribute
+        end
+      end
+    end
+
+    # Thrown if there is an error in the ProductionBuilder DSL
+    #
+    class ProductionBuilderException < LimelightException
+      def initialize(name)
+        super("'#{name}' is not a valid production property")
+      end
+    end
+
+  end
+end

data/lib/limelight/dsl/prop_builder.rb

@@ -0,0 +1,155 @@
+#- Copyright 2008 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+
+require 'limelight/prop'
+require 'limelight/scene'
+require 'limelight/dsl/build_exception'
+require 'limelight/util'
+
+module Limelight
+
+  # A trigger to build a Limelight::Scene using the PropBuilder DSL.
+  #
+  # See Limelight::PropBuilder
+  #
+  def self.build_scene(root, options={}, &block)
+    loader = options.delete(:build_loader)
+    instance_variables = options.delete(:instance_variables)
+    root.add_options(options)
+    builder = DSL::PropBuilder.new(root)
+    builder.__install_instance_variables(instance_variables)
+    builder.__loader__ = loader
+    builder.instance_eval(&block) if block
+    return root
+  end
+
+  module DSL
+
+    # The basis of the DSL for building Limelight::Prop objects.
+    #
+    # Sample usage:
+    #
+    #   builder = Limelight::PropBuilder.new(a_prop)
+    #   builder.instance_eval(&block)
+    #
+    # The prop passed into the constructor will be the root of the contructed Prop tree.
+    # The block passed into instance_eval contains the DSL for building props.
+    #
+    # Example block/DSL:
+    #
+    #   parent :id => "the_parent" do
+    #     child_one do
+    #       grand_child_one :id => "gc_1", :styles => "grand_child"
+    #       grand_child_two :id => "gc_2", :styles => "grand_child"
+    #     end
+    #     child_two
+    #   end
+    #
+    # The above example will create a Limelight::Prop named 'parent' and add it to the root prop passed into the builder.
+    # The 'parent' prop will contain two props named 'child_one' and 'child_two'.  'child_one' will contain two props named
+    # 'grand_child_one' and 'grand_child_two'.  'child_two' has no child props nor do 'grand_child_one' or 'grand_child_two'.
+    #
+    # An options Hash may be passed into each prop.  The key, value pairs in the hash will be used to set properties on the prop
+    # when it is added to a Limelight::Scene.
+    #
+    # See Limelight::Prop
+    #
+    class PropBuilder
+
+      alias :__instance_variables :instance_variables
+      alias :__instance_variable_get :instance_variable_get
+      alias :__instance_variable_set :instance_variable_set
+
+      Limelight::Util.lobotomize(self)
+
+      # Returns the root prop either passed in or created by this builder.
+      #
+      attr_reader :__prop__
+      attr_accessor :__loader__
+
+      # Creates a new builder.  If a prop is passed it, it will be the root on which props are created.
+      # If the paramter is a Hash, the Hash will be used to construct a prop that will be used as the root.
+      #
+      def initialize(options)
+        if options.is_a?(Prop)
+          @__prop__ = options
+        else
+          @__prop__ = Prop.new(options)
+        end
+      end
+
+      # Add extra initialization options to the prop currently under construction.
+      #
+      #   tree :id => "stump" do
+      #     __ :height => "100%", :width => "30", :background_color => :brown
+      #     branch :height => "100", :width => "20"
+      #     branch do
+      #       __ :height => "100", :width => "20"
+      #     end
+      #   end
+      #
+      # In the above example, the 'tree' prop has the following initialization options: id, height, width, background_color.
+      # The two 'branch' child props are identical.
+      #
+      def __(options)
+        @__prop__.add_options(options)
+      end
+
+      # Installs props from another file using the prop DSL.  The path will be relative to the
+      # root directory of the current production.
+      #
+      def __install(file, instance_variables = {})
+        raise "Cannot install external props because no loader was provided" if @__loader__.nil?
+        raise "External prop file: '#{file}' doesn't exist" if !@__loader__.exists?(file)
+        content = @__loader__.load(file)
+        begin
+          self.__install_instance_variables(instance_variables)
+          self.instance_eval(content)
+        rescue Exception => e
+          raise BuildException.new(file, content, e)
+        end
+      end
+
+      # Installs instance variables, specified by the passed hash, into the PropBuilder instance.
+      # The following call...
+      #
+      #   __install_instance_variables :one => "1", "two" => "two", :three => 3
+      #
+      # ...will result in the following instance variables.
+      #
+      #   @one   = "1"
+      #   @two   = "2"
+      #   @three = 3
+      #
+      # Instance variables are propogated to nested builders so that they need only be defined
+      # on the top level builder and all children will have access to them.
+      #
+      def __install_instance_variables(instance_variables)
+        return if instance_variables.nil?
+        instance_variables.each_pair do |key, value|
+          name = "@#{key}"
+          __instance_variable_set(name, value)
+        end
+      end
+
+      def __install_instance_variables_from_builder(source) #:nodoc:
+        source.__instance_variables.each do |name|
+          if !__instance_variable_get(name)
+            value = source.__instance_variable_get(name)
+            __instance_variable_set(name, value)
+          end
+        end
+      end
+
+      def method_missing(sym, options={}, &prop) # :nodoc:
+        options[:name] ||= sym.to_s
+        builder = PropBuilder.new(options)
+        builder.__install_instance_variables_from_builder(self)
+        builder.__loader__ = @__loader__
+        builder.instance_eval(&prop) if prop
+        @__prop__.add(builder.__prop__)
+      end
+    end
+
+  end
+end