limelight 0.2.1-java → 0.3.0-java

data/spec/java_util_spec.rb

@@ -34,20 +34,4 @@ describe Class do
 
 end
 
-describe String do
-  
-  it "should convert into camel case" do
-    "class_name".camalized.should == "ClassName"
-    "once_upon_a_time".camalized.should == "OnceUponATime"
-    "AbC_eFg_hiJ".camalized.should == "AbcEfgHij"
-    "with spaces".camalized.should == "WithSpaces"
-  end
-  
-  it "should convert into camel case" do
-    "class_name".camalized(:lower).should == "className"
-    "once_upon_a_time".camalized(:lower).should == "onceUponATime"
-    "AbC_eFg_hiJ".camalized(:lower).should == "abcEfgHij"
-    "with spaces".camalized(:lower).should == "withSpaces"
-  end
-  
-end
+

data/spec/main_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'limelight/main'
+
+describe Limelight::Main do
+
+  it "should run the specified command" do
+    command_class = make_mock("command_class")
+    command = make_mock("command")
+
+    Limelight::Commands.should_receive(:[]).with("mock").and_return(command_class)
+    command_class.should_receive(:new).and_return(command)
+    command.should_receive(:run).with(["1", "2", "3"])
+
+    Limelight::Main.run(["mock", "1", "2", "3"])
+  end
+
+end

data/spec/producer_spec.rb

@@ -5,163 +5,173 @@ require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 require 'limelight/producer'
 
 describe Limelight::Producer do
-  
+
   before(:each) do
+    TestDir.clean
     Limelight::Production.clear_index
-    @producer = Limelight::Producer.new("/tmp")
-    @loader = @producer.loader
+    @root_dir = TestDir.path("test_prod")
+    @producer = Limelight::Producer.new(@root_dir)
   end
-  
+
   it "should have loader on creation" do
-    @producer.loader.root.should == "/tmp"
+    @producer.production.root.root.should == @root_dir
   end
-  
+
   it "should take an optional theater on creation" do
     theater = make_mock("theater")
     producer = Limelight::Producer.new("/tmp", theater)
-    
+
     producer.theater.should == theater
   end
-  
+
   it "should build a new theater if none is passing in constructor" do
     @producer.theater.should_not == nil
     @producer.theater.class.should == Limelight::Theater
   end
-  
+
   it "should load props" do
-    @loader.should_receive(:exists?).with("./props.rb").and_return(true)
-    @loader.should_receive(:load).with("./props.rb").and_return("child :id => 321")
-    
-    scene = @producer.load_props(".", :casting_director => make_mock("casting_director", :fill_cast => nil))
+    TestDir.create_file("test_prod/props.rb", "child :id => 321")
+
+    scene = @producer.load_props(:path => TestDir.path("test_prod"), :casting_director => make_mock("casting_director", :fill_cast => nil))
+    scene.illuminate
     scene.children.size.should == 1
     scene.children[0].name.should == "child"
-    scene.children[0].id.should == 321
+    scene.children[0].id.should == "321"
   end
 
   it "should load props even when props.rd doesn't exist." do
-    @loader.should_receive(:exists?).with("./props.rb").and_return(false)
-
-    scene = @producer.load_props(".", :casting_director => make_mock("casting_director", :fill_cast => nil))
+    scene = @producer.load_props(:path => TestDir.path("test_prod"), :casting_director => make_mock("casting_director", :fill_cast => nil))
     scene.children.size.should == 0
   end
 
   it "should load builtin styles" do
-    @loader.should_receive(:exists?).with("./styles.rb").and_return(false)
-
-    styles = @producer.load_styles(".")
+    styles = @producer.load_styles(Limelight::Scene.new())
 
     styles["limelight_builtin_players_combo_box_popup_list"].should_not == nil
   end
-  
+
   it "should load styles" do
+    TestDir.create_file("test_prod/styles.rb", "alpha { width 100 }")
     @producer.builtin_styles = {}
-    @loader.should_receive(:exists?).with("./styles.rb").and_return(true)
-    @loader.should_receive(:load).with("./styles.rb").and_return("alpha { width 100 }")
-    
-    styles = @producer.load_styles(".")
+
+    styles = @producer.load_styles(Limelight::Scene.new(:path => TestDir.path("test_prod")))
     styles.size.should == 1
     styles["alpha"].width.should == "100"
   end
-  
+
   it "should format prop errors well" do
-    @loader.should_receive(:exists?).with("./props.rb").and_return(true)
-    @loader.should_receive(:load).with("./props.rb").and_return("one\n+\nthree")
-    
+    TestDir.create_file("test_prod/props.rb", "one\n+\nthree")
+
     begin
-      result = @producer.load_props(".", :casting_director => make_mock("casting_director", :fill_cast => nil))
+      result = @producer.load_props(:path => TestDir.path("test_prod"), :casting_director => make_mock("casting_director", :fill_cast => nil))
       result.should == nil # should never perform
-    rescue Limelight::BuildException => e
+    rescue Limelight::DSL::BuildException => e
       e.line_number.should == 3
-      e.filename.should == "./props.rb"
-      e.message.should include("./props.rb:3: undefined method `+@' for ")
+      e.filename.should == TestDir.path("test_prod/props.rb")
+      e.message.should include("/props.rb:3: undefined method `+@' for ")
     end
   end
-  
+
   it "should format styles errors well" do
-    @loader.should_receive(:exists?).with("./styles.rb").and_return(true)
-    @loader.should_receive(:load).with("./styles.rb").and_return("one {}\ntwo {}\n-\nthree {}")
-    
+    TestDir.create_file("test_prod/styles.rb", "one {}\ntwo {}\n-\nthree {}")
+
     begin
-      result = @producer.load_styles(".")
+      result = @producer.load_styles(Limelight::Scene.new(:path => TestDir.path("test_prod")))
       result.should == nil # should never perform
-    rescue Limelight::BuildException => e
+    rescue Limelight::DSL::BuildException => e
       e.line_number.should == 4
-      e.filename.should == "./styles.rb"
-      e.message.should include("./styles.rb:4: undefined method `-@' for #<Java::LimelightStyles::RichStyle:0x")
+      e.filename.should == TestDir.path("test_prod/styles.rb")
+      e.message.should include("/styles.rb:4: undefined method `-@' for #<Java::LimelightStyles::RichStyle:0x")
     end
   end
-  
+
   it "should load a stage when stages.rb exists" do
-    @loader.should_receive(:exists?).with("production.rb").and_return(false)
-    @loader.should_receive(:exists?).with("init.rb").and_return(false)
-    @loader.should_receive(:exists?).with("stages.rb").and_return true
-    @producer.should_receive(:load_stages).and_return([make_mock("stage", :default_scene => "abc", :name => "Default")])
+    TestDir.create_file("test_prod/stages.rb", "stage 'Default' do\n default_scene 'abc'\n end")
     @producer.should_receive(:open_scene).with("abc", anything)
-    
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
     @producer.open
   end
-  
+
   it "should load a scene when stages.rb doesn't exists" do
-    @loader.should_receive(:exists?).with("production.rb").and_return(false)
-    @loader.should_receive(:exists?).with("init.rb").and_return(false)
-    @loader.should_receive(:exists?).with("stages.rb").and_return false
     @producer.should_not_receive(:open_stages)
-    @producer.should_receive(:open_scene).with(".", anything)
-    
+    @producer.should_receive(:open_scene).with(:root, anything)
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
     @producer.open
   end
-  
+
   it "should have one default stage when no stages.rb is provided" do
-    @loader.should_receive(:exists?).with("production.rb").and_return(false)
-    @loader.should_receive(:exists?).with("init.rb").and_return(false)
-    @loader.should_receive(:exists?).with("stages.rb").and_return false
     @producer.stub!(:open_scene)
-    
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
     @producer.open
-    
+
     @producer.theater.stages.size.should == 1
     @producer.theater["Limelight"].should_not == nil
   end
-  
+
+  it "should load a stage but not open it if it has no default scene" do
+    TestDir.create_file("test_prod/stages.rb", "stage 'Default' do\n default_scene 'abc'\n end\n\nstage 'Hidden' do\n default_scene nil\n end")
+    @producer.should_receive(:open_scene).with("abc", anything)
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
+    @producer.open
+  end
+
   it "should open a scene" do
     stage = make_mock("stage")
     scene = make_mock("scene")
+    @producer.should_receive(:load_props).with(:production => @producer.production, :casting_director => anything, :path => TestDir.path("test_prod/name"), :name => "name").and_return(scene)
     @producer.should_receive(:load_styles).and_return("styles")
     @producer.should_receive(:merge_with_root_styles).with("styles")
-    @producer.should_receive(:load_props).with("some path", :styles => "styles", :production => @producer.production, :casting_director => anything, :loader => @loader, :path => "some path").and_return(scene)
+    scene.should_receive(:styles=)
     stage.should_receive(:open).with(scene)
-    
-    @producer.open_scene("some path", stage)
+
+    @producer.open_scene("name", stage)
   end
-  
+
   it "should load empty styles if styles.rb doesn't exist" do
     @producer.builtin_styles = {}
-    @loader.should_receive(:exists?).with("./styles.rb").and_return(false)
-    
-    @producer.load_styles(".").should == {}
+
+    @producer.load_styles(Limelight::Scene.new(:path => TestDir.path("test_prod"))).should == {}
   end
 
   it "should use the ProductionBuilder if production.rb is present" do
-    @loader.should_receive(:exists?).with("production.rb").and_return(true)
-    @loader.should_receive(:exists?).with("init.rb").and_return(false)
-    @loader.should_receive(:load).with("production.rb").and_return("name 'Fido'")
-    @loader.should_receive(:exists?).with("stages.rb").and_return(false)
+    TestDir.create_file("test_prod/production.rb", "name 'Fido'")
     @producer.stub!(:open_scene)
+    Limelight::Gems.should_receive(:install_gems_in_production)
 
     @producer.open
 
     @producer.production.name.should == "Fido"
   end
-  
+
   it "should load init.rb if it exists" do
-    @loader.should_receive(:exists?).with("production.rb").and_return(true)
-    @loader.should_receive(:exists?).with("init.rb").and_return(true)
-    @loader.should_receive(:load).with("production.rb").and_return("name 'Fido'")
-    @loader.should_receive(:exists?).with("stages.rb").and_return(false)
+    TestDir.create_file("test_prod/production.rb", "name 'Fido'")
+    TestDir.create_file("test_prod/init.rb", "")
+
     @producer.stub!(:open_scene)
-    Kernel.should_receive(:load).with("/tmp/init.rb")
-    
+    Kernel.should_receive(:load).with(TestDir.path("test_prod/init.rb"))
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
     @producer.open
   end
-  
+
+  it "should not load init.rb when told not to" do
+    TestDir.create_file("test_prod/init.rb", "$init_loaded = true")
+    Limelight::Gems.should_receive(:install_gems_in_production)
+
+    $init_loaded = false;
+    @producer.load(:ignore_init => true)
+
+    $init_loaded.should == false;
+  end
+
+  it "should give the same buildin_styles hash twice" do
+    @producer.builtin_styles.should_not be(@producer.builtin_styles)
+    # Try again
+    @producer.builtin_styles.should_not be(@producer.builtin_styles)
+  end
+
 end

data/spec/production_spec.rb

@@ -9,12 +9,15 @@ describe Limelight::Production, "Instance methods" do
   before(:each) do
     @producer = make_mock("producer")
     @theater = make_mock("theater")
-    @production = Limelight::Production.new(@producer, @theater)
+    @production = Limelight::Production.new("/tmp")
+    @production.producer = @producer
+    @production.theater = @theater
   end
   
-  it "should know it producder and theater" do
+  it "should know it path, producer, and theater" do
     @production.producer.should == @producer
     @production.theater.should == @theater
+    @production.path.should == "/tmp"
   end
   
   it "should be indexed" do
@@ -24,10 +27,32 @@ describe Limelight::Production, "Instance methods" do
   it "should raise an error when setting the name to a duplicate name" do
     @production.name = "Bill"
     
-    production = Limelight::Production.new(@producer, @theater)
+    production = Limelight::Production.new("/tmp")
     lambda { production.name = "Bill" }.should raise_error(Limelight::LimelightException, "Production name 'Bill' is already taken")
   end
 
+  it "should know it's init file" do
+    @production.init_file.should == "/tmp/init.rb"
+  end
+
+  it "should know it's stages file" do
+    @production.stages_file.should == "/tmp/stages.rb"
+  end
+
+  it "should know it's styles file" do
+    @production.styles_file.should == "/tmp/styles.rb"
+  end
+
+  it "should know it's gems directory" do
+    @production.gems_directory.should == "/tmp/__resources/gems"
+  end
+
+  it "should provide paths to it's scenes" do
+    @production.scene_directory("one").should == "/tmp/one"
+    @production.scene_directory("two").should == "/tmp/two"
+    @production.scene_directory(:root).should == "/tmp"
+  end
+
 end
 
 describe Limelight::Production, "Class methods" do

data/spec/prop_spec.rb

@@ -3,8 +3,9 @@
 
 require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
 require 'limelight/prop'
-require 'limelight/styles_builder'
+require 'limelight/dsl/styles_builder'
 require 'limelight/scene'
+require 'limelight/production'
 
 describe Limelight::Prop do
 
@@ -12,6 +13,7 @@ describe Limelight::Prop do
     @casting_director = make_mock("casting_director", :fill_cast => nil)
     @scene = Limelight::Scene.new(:casting_director => @casting_director)
     @prop = Limelight::Prop.new(:id => "root", :name => "root_class")
+    @scene.illuminate
     @scene << @prop
   end
 
@@ -47,6 +49,7 @@ describe Limelight::Prop do
   end
   
   it "should have an id" do
+    @prop.illuminate
     @prop.id.should == "root"
   end
   
@@ -65,14 +68,14 @@ describe Limelight::Prop do
   
   it "should find children by id" do
     build_prop_tree
-    @prop.find("blah").should == nil
-    @prop.find("root").should be(@prop)
-    @prop.find("child1").should be(@child1)
-    @prop.find("child2").should be(@child2)
-    @prop.find("grand_child1").should be(@grand_child1)
-    @prop.find("grand_child2").should be(@grand_child2)
-    @prop.find("grand_child3").should be(@grand_child3)
-    @prop.find("grand_child4").should be(@grand_child4)
+    @scene.find("blah").should == nil
+    @scene.find("root").should be(@prop)
+    @scene.find("child1").should be(@child1)
+    @scene.find("child2").should be(@child2)
+    @scene.find("grand_child1").should be(@grand_child1)
+    @scene.find("grand_child2").should be(@grand_child2)
+    @scene.find("grand_child3").should be(@grand_child3)
+    @scene.find("grand_child4").should be(@grand_child4)
   end
   
   it "should find children by name" do
@@ -110,7 +113,7 @@ describe Limelight::Prop do
     @scene << prop
     
     prop.style.width.should == "100"
-    prop.style.text_color.should == "white"
+    prop.style.text_color.should == "#ffffffff"
     prop.style.background_image.should == "apple.jpg"
   end
   
@@ -138,6 +141,7 @@ describe Limelight::Prop do
     styles = Limelight::build_styles { child { width 123 } }
     scene = Limelight::Scene.new(:casting_director => @casting_director, :styles => styles)
     prop = Limelight::Prop.new(:name => "child")
+    scene.illuminate
     
     scene << prop
     
@@ -218,7 +222,7 @@ describe Limelight::Prop do
   end
   
   it "should make dimensions accessible" do
-    @prop.panel.should_receive(:get_box).and_return("whole area")
+    @prop.panel.should_receive(:get_bounding_box).and_return("whole area")
     @prop.panel.should_receive(:get_box_inside_borders).and_return("area inside borders")
     
     @prop.area.should == "whole area"
@@ -252,8 +256,9 @@ describe Limelight::Prop do
     
     @prop.panel.after_paint_action.should == nil
   end
-  
+
   it "should build children" do
+    @prop.scene.production = Limelight::Production.new("some/path")
     @prop.build do
       one
       two do
@@ -269,13 +274,74 @@ describe Limelight::Prop do
   end
 
   it "should play sound" do
-    loader = make_mock("loader")
-    @scene.loader = loader
-    loader.should_receive(:path_to).with("some.au").and_return("/full/path/to/some.au");
+    production = Limelight::Production.new("/blah")
+    @scene.production = production
+    production.root.should_receive(:path_to).with("some.au").and_return("/full/path/to/some.au");
     @prop.panel.should_receive(:play_sound).with("/full/path/to/some.au");
 
     @prop.play_sound("some.au")
   end
+
+  it "should remember when it has been illuminated" do
+    prop = Limelight::Prop.new
+    prop.illuminated?.should == false
+
+    @scene << prop
+
+    prop.illuminated?.should == true;
+  end
+
+  #TODO remove_all should not remove scrollbars
+
+  describe "events" do
+
+    it "should not accept mouse_clicked events to start with" do
+      @prop.accepts_mouse_clicked().should == false
+      @prop.instance_eval("def mouse_clicked(e); puts 'hi'; end;")
+      @prop.accepts_mouse_clicked().should == true
+    end
+
+    it "should not accept mouse_pressed events to start with" do
+      @prop.accepts_mouse_pressed().should == false
+      @prop.instance_eval("def mouse_pressed(e); puts 'hi'; end;")
+      @prop.accepts_mouse_pressed().should == true
+    end
+
+    it "should not accept mouse_released events to start with" do
+      @prop.accepts_mouse_released().should == false
+      @prop.instance_eval("def mouse_released(e); puts 'hi'; end;")
+      @prop.accepts_mouse_released().should == true
+    end  
+
+  end
+
+  describe "id" do
+
+    it "should index its id when illuminated" do
+      @scene.find("root").should == @prop  
+    end
+
+    it "should unindex ids when removing children" do
+      child = Limelight::Prop.new(:id => "child")
+      @prop << child
+      @scene.find("child").should == child
+
+      @prop.remove(child)
+
+      @scene.find("child").should == nil
+    end
+
+    it "should unindex ids when removing all children" do
+      child1 = Limelight::Prop.new(:id => "child1")
+      child2 = Limelight::Prop.new(:id => "child2")
+      @prop << child1 << child2
+
+      @prop.remove_all
+
+      @scene.find("child1").should == nil
+      @scene.find("child2").should == nil
+    end
+
+  end
   
 end
-