sproutit-sproutcore 1.0.0.20090407205609

data/spec/lib/models/hash_struct/method_missing.rb

@@ -0,0 +1,41 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::HashStruct, 'method_missing' do
+
+  before do
+    hash = SC::HashStruct.new :foo => :foo
+  end
+  
+  it "should map hash.foo => hash[:foo]" do
+    hash.foo.should eql(:foo)
+  end
+  
+  it "should map hash.bar = :foo => hash[:bar] = :foo" do
+    hash[:bar].should eql(nil)
+    hash.bar = :foo
+    hash.bar.should eql(:foo)
+    hash[:bar].should eql(:foo)
+  end
+  
+  it "should map hash.foo? => !!hash[:foo]" do
+    hash.foo?.should eql(true)
+    hash.bar = 1
+    hash.bar?.should eql(true)
+    hash.bar = 0
+    hash.bar?.should eql(0)
+  end
+  
+  it "should map hash.undefined_prop? => false" do
+    hash.undefined_prop?.should eql(false) # not defined...
+  end
+  
+  it "should map hash.bar? = :foo to hash[:bar] = !!:foo" do
+    hash.bar? = :foo
+    hash[:bar].should eql(true)
+    hash.bar? = 0
+    hash[:bar].should eql(false)
+  end
+  
+end
+  
+    

data/spec/lib/models/manifest/add_entry_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'add_entry' do
+  
+  include SC::SpecHelpers
+
+  before do
+    @project = empty_project  # no buildfile to avoid running extra code...
+    @project.add_target '/default', :default, :source_root => @project.project_root
+    @target = @project.target_for :default
+    @manifest = @target.manifest_for :language => :en
+  end
+    
+  it "should add a new entry with the passed filename and any other options applied and return it" do
+    entry = @manifest.add_entry 'filename', :extra_option => true
+    entry.kind_of?(SC::ManifestEntry).should be_true
+    entry.filename.should eql('filename')
+    entry.extra_option.should be_true
+  end
+  
+  it "calling with the same options each time should add a new instance" do
+    entry1 = @manifest.add_entry 'filename', :extra_option => true
+    entry2 = @manifest.add_entry 'filename', :extra_option => true
+    entry1.foo = :entry1
+    entry2.foo = :entry2
+    
+    entry1.foo.should eql(:entry1)
+    entry2.foo.should eql(:entry2)
+  end
+  
+  it "should call prepare! on the new entry" do
+    entry = @manifest.add_entry 'filename', :extra_option => true
+    entry.prepared?.should be_true
+  end
+  
+end

data/spec/lib/models/manifest/add_transform_spec.rb

@@ -0,0 +1,90 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'add_transform' do
+  
+  include SC::SpecHelpers
+
+  before do
+    @project = empty_project  # no buildfile to avoid running extra code...
+    @project.add_target '/default', :default, :source_root => @project.project_root
+    @target = @project.target_for :default
+    @manifest = @target.manifest_for :language => :en
+    
+    @entry = @manifest.add_entry 'foobar.js', 
+      :build_task => 'build:copy',
+      :source_path => File.join('source', 'foobar.js'),
+      :build_path => File.join('build', 'foobar.js'),
+      :staging_path => File.join('staging', 'foobar.js'),
+      :url => File.join('url', 'foobar.js')
+  end
+  
+  it "should add a composite entry with entry as source" do
+    new_entry = @manifest.add_transform @entry, :build_task => 'foo'
+    new_entry.composite?.should be_true
+    new_entry.source_entries.should == [@entry]
+  end
+  
+  it "copy the filename and build_path if no overrides are passed" do
+    new_entry = @manifest.add_transform @entry
+    new_entry.filename.should == @entry.filename
+    new_entry.build_path.should == @entry.build_path
+  end
+
+  it "uses the filename and build_path in options if passed" do
+    new_entry = @manifest.add_transform @entry, :filename => "foo", :build_path => "bar"
+    new_entry.filename.should == "foo"
+    new_entry.build_path.should == "bar"
+  end
+  
+  it "should unique the staging path each time it is called" do
+    # try once...
+    entry1 = @manifest.add_transform @entry
+    entry1.staging_path.should_not == @entry.staging_path
+    
+    # try again...
+    entry2 = @manifest.add_transform @entry
+    entry2.staging_path.should_not == @entry.staging_path
+    entry2.staging_path.should_not == entry1.staging_path
+    
+    # try chaining...
+    entry3 = @manifest.add_transform entry1
+    entry3.staging_path.should_not == @entry.staging_path
+    entry3.staging_path.should_not == entry1.staging_path
+    entry3.staging_path.should_not == entry2.staging_path    
+  end
+  
+  it "should hide the original entry" do
+    new_entry = @manifest.add_transform @entry, :build_task => 'foo'
+    @entry.should be_hidden
+  end
+  
+  it "should mark the new entry as a transform" do
+    new_entry = @manifest.add_transform @entry, :build_task => 'foo'
+    new_entry.should be_transform
+  end
+  
+  it "swaps extensions in filename, url, build_path, and staging_path if :ext option is provided" do
+    # Check preconditions
+    File.extname(@entry.filename).should == '.js'
+    File.extname(@entry.build_path).should == '.js'
+    File.extname(@entry.url).should == '.js'
+    File.extname(@entry.staging_path).should == '.js'
+
+    # Create new entry
+    new_entry = @manifest.add_transform @entry, :ext => "html"
+
+    File.extname(new_entry.filename).should == '.html'
+    File.extname(new_entry.build_path).should == '.html'
+    File.extname(new_entry.url).should == '.html'
+    File.extname(new_entry.staging_path).should == '.html'
+  end
+  
+  it "rebases the staging path for transform entry to staging_root if original staging_path == source_path" do
+    
+    @entry.staging_path = @entry.source_path
+    @manifest.staging_root = "staging/"
+    new_entry = @manifest.add_transform @entry
+    new_entry.staging_path.should =~ /^staging\//
+  end
+
+end

data/spec/lib/models/manifest/build_spec.rb

@@ -0,0 +1,78 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'build!' do
+  
+  include SC::SpecHelpers
+
+  before do
+    @project = fixture_project(:real_world)
+    
+    ## IMPORTANT: Note the task defined here is assumed by tests below...
+    @project.buildfile.define! do
+      replace_task 'manifest:prepare' do
+        # avoid invoking original machinery...
+      end
+      
+      replace_task 'manifest:build' do
+        MANIFEST.task_did_run = (MANIFEST.task_did_run || 0) + 1
+      end
+      
+      replace_task 'entry:prepare' do
+        # also avoid original machinery...
+      end
+      
+    end
+    
+    @target = @project.target_for :contacts
+    @manifest = @target.manifest_for(:language => :en)
+  end
+
+  it "should return self" do
+    @manifest.build!.should eql(@manifest)
+  end
+  
+  it "should call prepare! then call manifest:build if defined" do
+    @manifest.prepared?.should be_false # check precondition
+    @manifest.build!
+    @manifest.prepared?.should be_true
+
+    @manifest.task_did_run.should eql(1) # ran?
+  end
+  
+  it "should do nothing manifest:build is not defined" do
+    # get an empty project with no build tasks...
+    project = empty_project
+    project.add_target '/default', :default, :source_root => project.project_root
+    target = project.targets['/default']
+    target.buildfile.lookup('manifest:build').should be_nil
+    
+    manifest = target.manifest_for :language => :en
+    lambda { manifest.build! }.should_not raise_error
+  end
+  
+  it "should build only once unless reset_entries! is called" do
+    @manifest.build! # do build once...
+    @manifest.add_entry 'example'  # pretend this happpened during build...
+    @manifest.entries.size.should eql(1) # precondition
+    
+    @manifest.build!
+    @manifest.entries.size.should eql(1) # should NOT be reset.  
+    
+    # reset and try again
+    @manifest.reset_entries!
+    @manifest.build!
+    @manifest.entries.size.should eql(0) # should be reset.  
+     # build! would normally repopulate...
+    
+  end
+  
+  it "should execute manifest:build only one time unless reset" do
+    @manifest.prepared?.should be_false # check precondition
+    @manifest.build!.build! # second time should do nothing
+    @manifest.reset_entries!
+    @manifest.build! # should run since we reset...
+    @manifest.prepared?.should be_true
+    @manifest.task_did_run.should eql(2) # ran only once?
+  end
+  
+end

data/spec/lib/models/manifest/entry_for_spec.rb

@@ -0,0 +1,94 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'entry_for' do
+  
+  include SC::SpecHelpers
+
+  before do
+    @project  = fixture_project :entry_for_project
+    @target   = @project.target_for :test_app
+    @manifest = @target.manifest_for :language => :en
+    @manifest.prepare!
+
+    # manually add some entries for testing...
+    
+    # not hidden -- extra option :foo
+    @manifest.add_entry 'entry.txt', 
+      :hidden => false, 
+      :foo    => :foo, 
+      :item   => :visible_foo
+    
+    # duplicate of above w/ different :foo option
+    @manifest.add_entry 'entry.txt', 
+      :hidden => false, 
+      :foo    => :bar, 
+      :item   => :visible_bar
+    
+    # hidden
+    @manifest.add_entry 'entry.txt', 
+      :hidden => true, 
+      :foo    => :foo, 
+      :item   => :hidden
+      
+    # since we generate the manifest entries manually for testing purposes, 
+    # mark the manifest as built to avoid invoking that machinery...
+    @manifest.instance_variable_set('@is_built', true)
+    
+    # add other targets as well..
+    @shared = @project.target_for(:shared).manifest_for(:language => :en)
+    @shared.prepare!
+    @shared.add_entry 'foobar/fake.png'
+    @shared.instance_variable_set('@is_built', true)
+    
+    @nested = @project.target_for('/test_app/nested').manifest_for(:language => :en)
+    @nested.prepare!
+    @nested.add_entry 'foobar/fake.png'
+    @nested.instance_variable_set('@is_built', true)
+    
+  end
+    
+  it "finds the first visible file matching the filename" do
+    entry = @manifest.entry_for 'entry.txt'
+    entry.should_not be_hidden
+    [:visible_foo, :visible_bar].should include(entry.item) # either one is ok
+  end
+  
+  it "finds the first hidden file matching the filename if :hidden => true is passed" do
+    entry = @manifest.entry_for 'entry.txt', :hidden => true
+    entry.should be_hidden
+    entry.item.should == :hidden
+  end
+    
+  
+  it "finds the first file matching the filename and any additional passed options" do
+    @manifest.entry_for('entry.txt', :foo => :foo).item.should == :visible_foo
+    @manifest.entry_for('entry.txt', :foo => :bar).item.should == :visible_bar
+  end
+  
+  it "requires an exact match on filename" do
+    @manifest.entry_for('entry').should be_nil
+  end
+  
+  it "returns nil if no matching entry could be found" do
+    result = nil
+    result = @manifest.entry_for('imaginary')
+    result.should be_nil # and not return entry
+  end
+  
+  describe "can name entries in other targets by prefixing entry name with target:entry_name" do
+    
+    it "will search another manifest" do
+      entry = @manifest.entry_for('shared:foobar/fake.png')
+      entry.should_not be_nil
+      entry.manifest.should == @shared
+    end
+  
+    it "will search for nested targets relative to current target" do
+      entry = @manifest.entry_for('nested:foobar/fake.png')
+      entry.should_not be_nil
+      entry.manifest.should == @nested
+    end
+    
+  end
+  
+end

data/spec/lib/models/manifest/find_entry.rb

@@ -0,0 +1,84 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'entry_for' do
+  
+  include SC::SpecHelpers
+
+  before do
+    @project  = fixture_project :entry_for_project
+    @target   = @project.target_for :test_app
+    @manifest = @target.manifest_for :language => :en
+    @manifest.prepare!
+
+    # manually add some entries for testing...
+
+    # NOTE: the order these entries are added is important to the tests 
+    # below.  See the test descriptions for more info.
+    @manifest.add_entry 'foo'
+    @manifest.add_entry 'images/foo.png'
+    @manifest.add_entry 'images/foo.gif'
+    @manifest.add_entry 'images/sprites/foo.png'
+    @manifest.add_entry 'foo.png'
+    
+    @manifest.add_entry 'bark/bite.png',   :foo => :foo
+    @manifest.add_entry 'bark/bite.png',   :foo => :bar
+    @manifest.add_entry 'hidden/bite.png', :hidden => true
+      
+    # add an entry to shared for one later test also...
+    @shared_man = @project.target_for(:shared).manifest_for(:language => :en)
+    @shared_man.prepare!
+    @shared_man.add_entry 'shared/foo.png'
+  end
+    
+  def should_find(find_str, expected_filename)
+    entry = @manifest.find_entry(find_str)
+    entry.should_not be_nil
+    entry.filename.should == expected_filename
+  end
+  
+  it "matches exact path from url_root" do
+    should_find('images/foo.png', 'images/foo.png')
+  end
+  
+  it "returns first match based on order added, regardless of url depth" do
+    should_find('foo.png', 'images/foo.png')
+  end
+  
+  it "will match any extension if no extension is provided" do
+    should_find('images/sprites/foo', 'images/sprites/foo.png')
+  end
+  
+  it "will match first match if no extension is provided" do
+    should_find('images/foo', 'images/foo.png')
+  end
+
+  it "providing extension can force match" do
+    should_find('foo.gif', 'images/foo.gif')
+  end
+  
+  it "prefers to match files with no extension over those with extension if no ext is provided" do
+    should_find('foo', 'foo')
+  end
+  
+  it "will match only visible unless :hidden => true" do
+    @manifest.find_entry('hidden/bite.png').should be_nil
+    @manifest.find_entry('hidden/bite.png', :hidden => true).should_not be_nil
+  end
+  
+  it "will also match based on additional passed options" do
+    entry = @manifest.find_entry('bark/bite.png', :foo => :bar)
+    entry.should_not be_nil
+    entry.foo.should == :bar
+    
+    entry = @manifest.find_entry('bark/bite.png', :foo => :foo)
+    entry.should_not be_nil
+    entry.foo.should == :foo
+  end
+  
+  it "will search required targets if the requested resource is not found in current manifest" do
+    entry = @manifest.find_entry('shared/foo')
+    entry.should_not be_nil
+    entry.manifest.should == @shared_man # verify came from other manifest...
+  end
+  
+end

data/spec/lib/models/manifest/prepare_spec.rb

@@ -0,0 +1,62 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Manifest, 'prepare!' do
+  
+  include SC::SpecHelpers
+  
+  before do
+    @project = fixture_project(:real_world)
+    @target = @project.target_for :contacts
+    
+    @target.buildfile.define! do
+      
+      replace_task 'target:prepare' do
+        # avoid invoking original machinery...
+      end
+      
+      replace_task 'manifest:prepare' do
+        MANIFEST.task_did_run = (MANIFEST.task_did_run || 0) + 1
+      end
+    end
+    
+    @manifest = @target.manifest_for(:language => :en)
+  end
+
+  it "should return self" do
+    @manifest.prepare!.should eql(@manifest)
+  end
+
+  it "should execure prepare! on target" do
+    @target.prepared?.should be_false
+    @manifest.prepare!
+    @target.prepared?.should be_true
+  end
+  
+  it "should execute manifest:prepare if defined" do
+    @manifest.prepared?.should be_false # check precondition
+    @manifest.prepare!
+    @manifest.prepared?.should be_true
+    @manifest.task_did_run.should eql(1) # ran?
+  end
+
+  it "should do nothing if manifest:prepare is not defined" do
+
+    # get an empty project with no build tasks...
+    project = empty_project
+    project.add_target '/default', :default, :source_root => project.project_root
+    target = project.targets['/default']
+    target.buildfile.lookup('manifest:prepare').should be_nil
+    
+    manifest = target.manifest_for :language => :en
+    lambda { manifest.prepare! }.should_not raise_error
+    
+  end
+  
+  it "should execute manifest:prepare only once" do
+    @manifest.prepared?.should be_false # check precondition
+    @manifest.prepare!.prepare!.prepare!
+    @manifest.prepared?.should be_true
+    @manifest.task_did_run.should eql(1) # ran only once?
+  end
+  
+end