limelight 0.5.5-java → 0.6.14-java

data/ruby/lib/limelight/templates/sources/project/Rakefile.template

@@ -0,0 +1,15 @@
+task :spec do
+  system "jruby -S spec spec"
+end
+
+task :features do
+  system "jruby -S cucumber features"
+end
+
+task :all_tests => [:spec, :features] do
+end
+
+desc "Generates the llp for the production."
+task :llp do
+  system "jruby -S limelight pack production -n '!-LLP_NAME-!'"
+end

data/ruby/lib/limelight/templates/sources/project/spec_helper.rb.template

@@ -0,0 +1,12 @@
+require 'rubygems'
+require 'spec'
+require 'limelight/specs/spec_helper'
+
+# Set the Gem home to the frozen gems
+$PRODUCTION_PATH = File.expand_path(File.dirname(__FILE__) + "/../production")
+Gem.use_paths(File.join($PRODUCTION_PATH , "__resources", "gems"), Gem.default_path)
+
+
+Dir.glob(File.join("__resources", "gems", "gems", "**", "lib")).each do |dir|
+  $: << dir
+end

data/ruby/lib/limelight/theater.rb

@@ -0,0 +1,76 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+require 'limelight/limelight_exception'
+require 'thread'
+
+module Limelight
+
+  # A Theater represents a group of Stages.  Productions require a Theater in which to open.
+  #
+  class Theater
+
+    include Java::limelight.model.api.TheaterProxy
+
+    attr_reader :peer #:nodoc:
+
+    def initialize(production, real_theater)
+      @production = production
+      @peer = real_theater
+      @peer.proxy = self
+    end
+
+    # Returns the theater's active stage.  i.e. the stage most recently used.
+    #
+    def active_stage
+      @peer.active_stage
+    end
+
+    # Returns an Array of Stages that belong to this Theater.
+    #
+    def stages
+      stages = []
+      @peer.stages.each { |stage| stages << stage.proxy }
+      return stages
+    end
+
+    # Returns true if the theater has at least one stage
+    #
+    def has_stages?
+      return @peer.has_stages?
+    end
+
+    # Returns the Stage with the spcified name, nil if none exist with the specified name.
+    #
+    def [](stage_name)
+      stage = @peer.get(stage_name)
+      return stage == nil ? nil : stage.proxy
+    end
+
+    # Adds a Stage to the Theater.  Raises an exception is the name of the Stage is duplicated.
+    #
+    def add_stage(name, options = {})
+      stage = build_stage(name, options).proxy
+      @peer.add(stage.peer)
+      return stage
+    end
+
+    # Close this theater.  All stages in this theater will be closed and the active_stage will be nil'ed.
+    #
+    def close
+      @peer.close
+    end
+
+    #TODO MDM - This ia bug waiting to happen.  Need to return the Java peer from this method.
+    def build_stage(name, options) #:nodoc:
+      return Limelight::Stage.new(self, name, options).peer
+    end
+    alias :buildStage :build_stage
+
+    def default_stage
+      @peer.default_stage.proxy
+    end
+
+  end
+
+end

data/{lib → ruby/lib}/limelight/util.rb

@@ -1,5 +1,5 @@
-#- Copyright � 2008-2009 8th Light, Inc. All Rights Reserved.
-#- Limelight and all included source files are distributed under terms of the GNU LGPL.
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
 
 module Limelight
 
@@ -21,11 +21,9 @@ module Limelight
     # Returns true of the file is a directory containing an entry named file_name.
     #
     def self.directory_contains_file(file, file_name)
-      if file.is_a? String
-        return File.directory?(file) && File.exists?(File.join(file, file_name))
-      else
-        return file.isDirectory() && File.exists?(File.join(file.absolute_path, file_name))
-      end
+      fs = Java::limelight.Context.fs
+      dir_path = file.is_a? String ? file : file.path
+      return fs.directory?(dir_path) && fs.exists?(fs.join(dir_path, file_name))
     end
 
     # Removed all methods from a class except instance_eval and methods starting with __.
@@ -33,7 +31,7 @@ module Limelight
     #
     def self.lobotomize(klass)
       klass.methods.each do |method_name|
-        unless method_name[0..1] == "__" || method_name == "instance_eval"
+        unless method_name[0..1] == "__" || method_name == "instance_eval" || method_name == "methods"
           begin
             klass.instance_eval "undef_method :#{method_name}"
           rescue Exception => e
@@ -46,20 +44,3 @@ module Limelight
 
 end
 
-class Module
-
-  def prop_reader(*symbols)
-    symbols.each do |sym|
-      define_method(sym) do
-        return scene.find(sym.to_s)
-#        value = instance_variable_get("@#{sym}")
-#        if value.nil?
-#          value = scene.find(sym.to_s)
-#          instance_variable_set("@#{sym}", value) unless value.nil?
-#        end
-#        return value
-      end
-    end
-  end
-
-end

data/ruby/lib/limelight/util/hashes.rb

@@ -0,0 +1,39 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+require 'limelight/util/map_hash'
+require 'limelight/util/string_hash'
+
+module Limelight
+  module Util
+
+    module Hashes
+
+      def self.for_ruby(hash)
+        if hash.nil?
+          return StringHash.new
+        elsif hash.is_a?(StringHash) || hash.is_a?(MapHash)
+          return hash
+        elsif hash.is_a?(Java::java.util.Map)
+          return MapHash.new(hash)
+        else
+          return StringHash.new.merge!(hash)
+        end
+      end
+
+      def self.for_java(hash)
+        if hash.nil?
+          return StringHash.new
+        elsif hash.is_a?(StringHash) || hash.is_a?(Java::java.util.Map)
+          return hash
+        elsif hash.is_a?(MapHash)
+          return hash.map
+        else
+          return StringHash.new.merge!(hash)
+        end
+      end
+
+    end
+
+  end
+end

data/ruby/lib/limelight/util/map_hash.rb

@@ -0,0 +1,191 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+module Limelight
+  module Util
+
+    class MapHash
+
+      include Enumerable
+
+      attr_accessor :default
+      attr_reader :map
+
+      def initialize(map)
+        @map = map
+        @default = nil
+      end
+
+      def []=(key, value)
+        @map.put(desymbolize(key), value)
+      end
+      alias_method :store, :[]=
+
+      def [](key)
+        key = desymbolize(key)
+        return @map.contains_key(key) ? @map.get(key) : @default
+      end
+
+      def ==(other)
+        return false if !other.respond_to?(:to_hash)
+        other = other.to_hash
+        return false if other == nil
+        return false if other.size != @map.size
+        other.each { |key, value| return false if self[key] != value }
+        return true
+      end
+      alias_method :eql?, :==
+
+      def clear
+        @map.clear
+        return self
+      end
+
+      def default_proc
+        return nil
+      end
+
+      def delete(key)
+        return @map.remove(desymbolize(key))
+      end
+
+      def delete_if
+        self.keys.each do |key|
+          value = @map.get(key)
+          @map.remove(key) if yield(key, value)
+        end
+        return self
+      end
+      alias_method :reject!, :delete_if
+
+      def dup
+        return MapHash.new(@map.clone)
+      end
+
+      def each(&block)
+        @map.each &block
+        return self
+      end
+      alias_method :each_pair, :each
+
+      def each_key(&block)
+        @map.key_set.each &block
+        return self
+      end
+
+      def each_value(&block)
+        @map.values.each &block
+        return self
+      end
+
+      def empty?
+        return @map.isEmpty()
+      end
+
+      def fetch(key, option=nil)
+        desymbolized_key = desymbolize(key)
+        return @map.get(desymbolized_key) if @map.contains_key(desymbolized_key)
+        return yield(key) if block_given?
+        return option if option != nil
+        raise IndexError.new("key not found")
+      end
+
+      def has_key?(key)
+        return @map.contains_key(desymbolize(key))
+      end
+      alias_method :key?, :has_key?
+      alias_method :member?, :has_key?
+      alias_method :include?, :has_key?
+
+      def has_value?(value)
+        return @map.contains_value(value)
+      end
+      alias_method :value?, :has_value?
+
+      def index(search_value)
+        @map.each { |key, value| return key if value == search_value }
+        return nil
+      end
+
+      def invert
+        result = dup.clear
+        @map.each { |key, value| result[value] = key }
+        return result
+      end
+
+      def keys
+        result = []
+        @map.key_set.each { |key| result << key}
+        return result
+      end
+
+      def length
+        return @map.size
+      end
+      alias_method :size, :length
+
+      def merge(other, &block)
+        return dup.merge!(other, &block)
+      end
+
+      def merge!(other)
+        other.each do |key, value|
+          key = desymbolize(key)
+          value = yield(key, @map.get(key), value) if(@map.contains_key(key) && block_given?)
+          @map.put(key, value)
+        end
+        return self
+      end
+      alias_method :update, :merge!
+
+      def rehash
+        return self
+      end
+
+      def reject(&block)
+        return dup.reject!(&block)
+      end
+
+      def replace(other)
+        clear
+        return merge!(other)
+      end
+
+      def select
+        results = []
+        @map.each { |key, value| results << [key, value] if yield(key, value) }
+        return results
+      end
+
+      def shift
+        return @default if @map.isEmpty
+        key = keys[0]
+        return [key, @map.remove(key)]
+      end
+
+      def to_hash
+        hash = {}
+        @map.each { |key, value| hash[key] = value }
+        return hash
+      end
+
+      def values
+        result = []
+        @map.values.each { |key| result << key}
+        return result
+      end
+
+      def values_at(*keys)
+        return keys.map { |key| self[key] }
+      end
+
+      private
+
+      def desymbolize(key)
+        return key.is_a?(Symbol) ? key.to_s : key
+      end
+
+    end
+
+  end
+end

data/ruby/lib/limelight/util/string_hash.rb

@@ -0,0 +1,64 @@
+#- Copyright © 2008-2011 8th Light, Inc. All Rights Reserved.
+#- Limelight and all included source files are distributed under terms of the MIT License.
+
+module Limelight
+  module Util
+
+    class StringHash < Hash
+
+      alias_method :put, :[]=
+      alias_method :get, :[]
+
+      def []=(key, value)
+        put(as_string(key), value)
+      end
+
+      def [](key)
+        return get(as_string(key))
+      end
+
+      def update(other)
+        other.each_pair do |key, value|
+          my_value = self[key]
+          if value && block_given?
+            value = yield(key, my_value, value)
+          end
+          self[key] = value
+        end
+        return self
+      end
+      alias_method :merge!, :update
+
+      def merge(other, &block)
+        return dup.merge!(other, &block)
+      end
+
+      def key?(key)
+        return super(as_string(key))
+      end
+
+      def fetch(key, *args)
+        return super(as_string(key), *args)
+      end
+
+      def delete(key)
+        return super(as_string(key))
+      end
+
+      private
+
+      def as_string(key)
+        case key
+          when nil
+            return nil
+          when String
+            return key
+          else
+            return key.to_s
+        end
+      end
+
+    end
+
+  end
+end