limelight 0.2.1-java → 0.3.0-java

data/spec/scene_spec.rb

@@ -10,8 +10,9 @@ describe Limelight::Scene do
     @casting_director = make_mock("casting_director", :fill_cast => nil)
     @scene = Limelight::Scene.new(:casting_director => @casting_director)
   end
-  
+
   it "should have a styles hash" do
+    @scene.illuminate
     @scene.styles.should_not == nil
     @scene.styles.size.should == 0
   end
@@ -20,10 +21,11 @@ describe Limelight::Scene do
     @scene.button_groups.should_not == nil
     @scene.button_groups.class.should == Limelight::UI::ButtonGroupCache
   end
-  
+
   it "should pullout sytles and casting_director from options" do
     scene = Limelight::Scene.new(:styles => "styles", :casting_director => @casting_director)
-    
+    scene.illuminate
+
     scene.styles.should == "styles"
     scene.casting_director.should == @casting_director
   end
@@ -31,4 +33,72 @@ describe Limelight::Scene do
   it "should have opened event" do
     @scene.should respond_to(:scene_opened)
   end
+
+  it "should have a cast" do
+    @scene.cast.should_not == nil
+    @scene.cast.is_a?(Module).should == true
+  end
+
+  it "should have a cast" do
+    @scene.cast.should_not == nil
+    @scene.cast.is_a?(Module).should == true
+  end
+
+  it "should have an acceptible path when none is provided" do
+    Limelight::Scene.new().path.should == File.expand_path("")
+  end
+
+  describe Limelight::Scene, "paths" do
+
+    before(:each) do
+      @scene = Limelight::Scene.new(:path => "/tmp")
+    end
+
+    it "should know it's props file" do
+      @scene.props_file.should == "/tmp/props.rb"
+    end
+
+    it "should know it's styles file" do
+      @scene.styles_file.should == "/tmp/styles.rb"
+    end
+
+  end
+
+  describe Limelight::Scene, "Prop Indexing" do
+
+    before(:each) do
+      @scene.illuminate
+    end
+
+    it "should index props" do
+      prop = Limelight::Prop.new(:id => "some_id")
+      @scene << prop
+
+      @scene.find("some_id").should == prop
+    end
+
+    it "should raise error if indexing prop with duplicate id" do
+      prop1 = Limelight::Prop.new(:id => "some_id")
+      prop2 = Limelight::Prop.new(:id => "some_id")
+      @scene << prop1
+
+      lambda { @scene << prop2 }.should raise_error(Limelight::LimelightException, "Duplicate id: some_id")
+    end
+
+    it "should unindex prop" do
+      prop = Limelight::Prop.new(:id => "some_id")
+      @scene << prop
+      @scene.unindex_prop(prop)
+
+      @scene.find("some_id").should == nil
+    end
+
+    it "should convert ids to string when finding" do
+      prop = Limelight::Prop.new(:id => 123)
+      @scene << prop
+
+      @scene.find(123).should == prop
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -6,7 +6,7 @@ require File.expand_path(File.dirname(__FILE__) + "/../lib/init")
 require 'spec'
 
 context = Limelight::Context.instance
-context.frameManager = Java::limelight.ui.model.FrameManager.new
+context.frameManager = Java::limelight.ui.model.AlertFrameManager.new
 
 def make_mock(name, stubs = {})
   the_mock = mock(name)
@@ -19,3 +19,39 @@ class Object
     stubs.each_pair { |key, value| self.stub!(key).and_return(value) }
   end
 end
+
+
+require 'fileutils'
+class TestDir
+
+  class << self
+
+    def root
+      @root = File.expand_path(File.dirname(__FILE__) + "/../etc/tmp") if @filename.nil?
+      return @root
+    end
+
+    def path(path)
+      return File.join(root, path)
+    end
+
+    def clean
+      Dir.entries(root).each do |file|
+        FileUtils.rm_r(File.join(root, file), :force => true) unless (file == '.' || file == '..')
+      end
+    end
+
+    def create_file(path, content)
+      filename =  self.path(path)
+      establish_dir(File.dirname(filename))
+      File.open(filename, 'w') { |file| file.write content }
+    end
+
+    def establish_dir(path)
+      if !File.exists?(path)
+        establish_dir(File.dirname(path))
+        Dir.mkdir(path)
+      end
+    end
+  end
+end

data/spec/stage_spec.rb

@@ -46,7 +46,7 @@ describe Limelight::Stage do
   end
 
   it "should call scene.scene_opened at the end of opening a scene" do
-    scene = make_mock("scene", :visible= => nil)
+    scene = make_mock("scene", :visible= => nil, :illuminate => nil)
     scene.should_receive(:scene_opened)
 
     @__stage__.frame.stub!(:open)
@@ -54,4 +54,13 @@ describe Limelight::Stage do
     @__stage__.open(scene)
   end
 
+  it "should illuminate the scene when opening it" do
+    scene = make_mock("scene", :visible= => nil, :scene_opened => nil)
+    scene.should_receive(:illuminate)
+
+    @__stage__.frame.stub!(:open)
+    @__stage__.stub!(:load_scene)
+    @__stage__.open(scene)
+  end
+
 end

data/spec/string_spec.rb

@@ -0,0 +1,35 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'limelight/string'
+
+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
+
+  it "should underscore a name" do
+    "ClassName".underscored.should == "class_name"
+    "OneTwoThree".underscored.should == "one_two_three"
+    "One".underscored.should == "one"
+  end
+
+  it "should convert a string to title" do
+    "class_name".titleized.should == "Class Name"
+    "once_upon_a_time".titleized.should == "Once Upon A Time"
+    "AbC_eFg_hiJ".titleized.should == "Ab C E Fg Hi J"
+    "with spaces".titleized.should == "With Spaces"
+    "Some Title".titleized.should == "Some Title"
+    "SomeTitle".titleized.should == "Some Title"
+  end
+
+end

data/spec/studio_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path(File.dirname(__FILE__) + "/spec_helper")
+require 'limelight/studio'
+
+describe Limelight::Studio do
+
+  it "should install itsself" do
+    Limelight::Studio.install
+
+    studio = Limelight::Studio.instance
+    Limelight::Context.instance.studio.should == studio 
+  end
+
+
+end

data/spec/styles_spec.rb

@@ -32,5 +32,19 @@ describe Limelight::Styles do
 #    end
 #  end
 
+#  it "should generate code" do
+#    Limelight::Styles::Style::STYLE_LIST.each do |descriptor|
+#      const_name = const_format(descriptor.name)
+#      method_name = method_format(descriptor.name)
+#      spaces = 40 - const_name.length
+#      puts "<tr>"
+#      puts "\t<td>'''#{method_name}'''</td>"
+#      puts "\t<td></td>"
+#      puts "\t<td>#{descriptor.defaultValue}</td>"
+#      puts "\t<td></td>"
+#      puts "</tr>"
+#    end
+#  end
+
 
 end

data/spec/templates/production_templater_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'limelight/templates/production_templater'
+
+describe Limelight::Templates::ProductionTemplater do
+
+  it "should initialize settings" do
+    templater = Limelight::Templates::ProductionTemplater.new("some_production", "default_scene")
+
+    templater.target_root.should == "."
+    templater.source_root.should == Limelight::Templates::Templater.source_dir
+    templater.tokens[:PRODUCTION_NAME].should == "Some Production"
+    templater.tokens[:DEFAULT_SCENE_NAME].should == "default_scene"
+  end
+
+  it "should initialize settings for deep dir name" do
+    templater = Limelight::Templates::ProductionTemplater.new("dir1/dir2/some_production", "default_scene")
+
+    templater.target_root.should == "./dir1/dir2"
+    templater.source_root.should == Limelight::Templates::Templater.source_dir
+    templater.tokens[:PRODUCTION_NAME].should == "Some Production"
+    templater.tokens[:DEFAULT_SCENE_NAME].should == "default_scene"
+  end
+
+  it "should initialize settings for root path" do
+    templater = Limelight::Templates::ProductionTemplater.new("/some_production", "default_scene")
+
+    templater.target_root.should == "/"
+    templater.source_root.should == Limelight::Templates::Templater.source_dir
+    templater.tokens[:PRODUCTION_NAME].should == "Some Production"
+    templater.tokens[:DEFAULT_SCENE_NAME].should == "default_scene"
+  end
+
+  it "should generate files" do
+    templater = Limelight::Templates::ProductionTemplater.new("some_production", "default_scene")
+
+    templater.should_receive(:file).with("some_production/production.rb", "production/production.rb.template", templater.tokens)
+    templater.should_receive(:file).with("some_production/init.rb", "production/init.rb.template", templater.tokens)
+    templater.should_receive(:file).with("some_production/stages.rb", "production/stages.rb.template", templater.tokens)
+    templater.should_receive(:file).with("some_production/styles.rb", "production/styles.rb.template", templater.tokens)
+
+    templater.generate
+  end
+
+end

data/spec/templates/scene_templater_spec.rb

@@ -0,0 +1,25 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'limelight/templates/scene_templater'
+
+describe Limelight::Templates::SceneTemplater do
+
+  it "should initialize" do
+    templater = Limelight::Templates::SceneTemplater.new("prod/some_scene")
+
+    templater.target_root.should == "./prod"
+    templater.source_root.should == Limelight::Templates::Templater.source_dir
+    templater.tokens[:SCENE_NAME].should == "some_scene"
+    templater.tokens[:SCENE_TITLE].should == "Some Scene"
+  end
+
+  it "should generate files" do
+    templater = Limelight::Templates::SceneTemplater.new("prod/some_scene")
+
+    templater.should_receive(:file).with("some_scene/props.rb", "scene/props.rb.template", templater.tokens)
+    templater.should_receive(:file).with("some_scene/styles.rb", "scene/styles.rb.template", templater.tokens)
+    templater.should_receive(:directory).with("some_scene/players")
+
+    templater.generate
+  end
+
+end

data/spec/templates/templater_logger_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'limelight/templates/templater_logger'
+
+describe Limelight::Templates::TemplaterLogger do
+
+  before(:each) do
+    @logger = Limelight::Templates::TemplaterLogger.new
+    @in, @out = IO.pipe
+    @logger.output = @out
+  end
+
+  it "should have standard out as output" do
+    @logger = Limelight::Templates::TemplaterLogger.new
+    @logger.output.should == STDOUT
+  end
+
+  it "should handle creating directories" do
+    @logger.creating_directory("dir1")
+
+    result = @in.readline
+    result.strip.should == "creating directory:  dir1"
+  end
+
+  it "should handle creating files" do
+    @logger.creating_file("file1")
+
+    result = @in.readline
+    result.strip.should == "creating file:       file1"
+  end
+
+  it "should handle file already exists" do
+    @logger.file_already_exists("file1")
+
+    result = @in.readline
+    result.strip.should == "file already exists: file1"
+  end
+
+end

data/spec/templates/templater_spec.rb

@@ -0,0 +1,104 @@
+require File.expand_path(File.dirname(__FILE__) + "/../spec_helper")
+require 'limelight/templates/templater'
+
+describe Limelight::Templates::Templater do
+
+  before(:each) do
+    TestDir.clean
+    @src_dir = File.join(TestDir.root, "src")
+    @logger = make_mock("logger")
+    @templater = Limelight::Templates::Templater.new(TestDir.root, @src_dir)
+    @templater.logger = @logger
+  end
+
+  it "should have a templater logger" do
+    @templater = Limelight::Templates::Templater.new(TestDir.root, @src_dir)
+    @templater.logger.should_not == nil
+    @templater.logger.class.should == Limelight::Templates::TemplaterLogger
+  end
+
+  it "should have a target root and source root directory" do
+    @templater.target_root.should == TestDir.root
+    @templater.source_root.should == @src_dir
+  end
+
+  it "should prefix target root with dot if not absolute" do
+    Limelight::Templates::Templater.clarify("blah").should == "./blah"
+    Limelight::Templates::Templater.clarify("one/two").should == "./one/two"
+    Limelight::Templates::Templater.clarify("/root").should == "/root"
+    Limelight::Templates::Templater.clarify("./blah").should == "./blah"
+    Limelight::Templates::Templater.clarify("../blah").should == "../blah"
+  end
+
+  it "should create a directory" do
+    @logger.should_receive(:creating_directory).with("#{TestDir.root}/blah")
+    
+    @templater.directory "blah"
+
+    File.exists?(File.join(TestDir.root, "blah")).should == true
+  end
+
+  it "should create nested directories" do
+    @logger.should_receive(:creating_directory).with("#{TestDir.root}/dir1")
+    @logger.should_receive(:creating_directory).with("#{TestDir.root}/dir1/dir2")
+
+    @templater.directory "dir1/dir2"
+
+    File.exists?(File.join(TestDir.root, "dir1/dir2")).should == true
+  end
+
+  it "should create files from source" do
+    TestDir.create_file("src/file1.txt", "blah")
+    @logger.should_receive(:creating_file).with("#{TestDir.root}/f1.txt")
+
+    @templater.file "f1.txt", "file1.txt"
+
+    File.exists?(File.join(TestDir.root, "f1.txt")).should == true
+    IO.read(File.join(TestDir.root, "f1.txt")).should == "blah"
+  end
+
+  it "should create files nested in directories" do
+    TestDir.create_file("src/file1.txt", "blah")
+    
+    @logger.should_receive(:creating_directory).with("#{TestDir.root}/dir1")
+    @logger.should_receive(:creating_file).with("#{TestDir.root}/dir1/f1.txt")
+
+    @templater.file "dir1/f1.txt", "file1.txt"
+
+    path = File.join(TestDir.root, "dir1", "f1.txt")
+    File.exists?(path).should == true
+    IO.read(path).should == "blah"
+  end
+
+  it "should skip files that already exist" do
+    TestDir.create_file("src/file1.txt", "blah")
+    TestDir.create_file("f1.txt", "existing content") 
+
+    @logger.should_receive(:file_already_exists).with("#{TestDir.root}/f1.txt")
+
+    @templater.file "f1.txt", "file1.txt"
+
+    IO.read(File.join(TestDir.root, "f1.txt")).should == "existing content"
+  end
+
+  it "should replace one token in files" do
+    TestDir.create_file("src/file1.txt", "abc !-TOKEN1-! 123")
+    @logger.should_receive(:creating_file).with("#{TestDir.root}/f1.txt")
+
+    @templater.file "f1.txt", "file1.txt", :TOKEN1 => "you know me"
+
+    File.exists?(File.join(TestDir.root, "f1.txt")).should == true
+    IO.read(File.join(TestDir.root, "f1.txt")).should == "abc you know me 123"
+  end
+
+  it "should replace multiple tokens in files" do
+    TestDir.create_file("src/file1.txt", "!-TOKEN0-! !-TOKEN1-! !-TOKEN2-!")
+    @logger.should_receive(:creating_file).with("#{TestDir.root}/f1.txt")
+
+    @templater.file "f1.txt", "file1.txt", :TOKEN0 => "1", :TOKEN1 => "2", :TOKEN2 => "3"
+
+    File.exists?(File.join(TestDir.root, "f1.txt")).should == true
+    IO.read(File.join(TestDir.root, "f1.txt")).should == "1 2 3"
+  end
+
+end