sproutit-sproutcore 1.0.203 → 1.0.20090721145236

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

data/spec/lib/models/manifest_entry/cacheable_url_spec.rb

@@ -0,0 +1,31 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::ManifestEntry, 'timestamp_url' do
+  
+  include SC::SpecHelpers
+  
+  before do
+    @project = fixture_project(:real_world)
+    @target = @project.target_for :contacts
+    @manifest = @target.manifest_for(:language => :en)
+    
+    # create entry manually to avoid calling prepare
+    @entry = SC::ManifestEntry.new @manifest, 
+      :filename => "filename", 
+      :url => "foo",
+      :source_path => "imaginary" / "path"
+  end
+
+  it "should return url itself if timestamp_url config is false" do
+    @target.config.timestamp_urls = false # preconditon
+    @entry.cacheable_url.should == 'foo'
+  end
+  
+  it "should return url with timestamp token appended as query string if timestamp_url is true" do
+    @target.config.timestamp_urls = true # preconditon
+    @entry.timestamp.should_not be_blank # preconditon
+    @entry.cacheable_url.should == "foo?#{@entry.timestamp}"
+  end
+
+  
+end

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

@@ -0,0 +1,54 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::ManifestEntry, 'prepare!' do
+  
+  include SC::SpecHelpers
+  
+  before do
+    @project = fixture_project(:real_world)
+    @target = @project.target_for :contacts
+    
+    @target.buildfile.define! do
+      replace_task 'entry:prepare' do
+        ENTRY.task_did_run = (ENTRY.task_did_run || 0) + 1
+      end
+    end
+    
+    @manifest = @target.manifest_for(:language => :en)
+    
+    # create entry manually to avoid calling prepare
+    @entry = SC::ManifestEntry.new(@manifest, :filename => "filename")
+  end
+
+  it "should return self" do
+    @entry.prepare!.should eql(@entry)
+  end
+  
+  it "should execute entry:prepare if defined" do
+    @entry.prepared?.should be_false # check precondition
+    @entry.prepare!
+    @entry.prepared?.should be_true
+    @entry.task_did_run.should eql(1) # ran?
+  end
+
+  it "should do nothing if entry: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('entry:prepare').should be_nil
+    manifest = target.manifest_for :language => :en
+    entry = SC::ManifestEntry.new(manifest, :filename => 'filename')
+    lambda { entry.prepare! }.should_not raise_error
+    
+  end
+  
+  it "should execute entry:prepare only once" do
+    @entry.prepared?.should be_false # check precondition
+    @entry.prepare!.prepare!.prepare!
+    @entry.prepared?.should be_true
+    @entry.task_did_run.should eql(1) # ran only once?
+  end
+  
+end

data/spec/lib/models/project/add_target_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'add_target' do
+
+  include SC::SpecHelpers
+
+  before do
+    @project = SC::Project.new fixture_path('buildfiles', 'empty_project')
+  end
+  
+  it "should add a target with the passed name" do
+    @project.add_target :target_name, :target_type
+    target = @project.targets[:target_name]
+    target.should_not be_nil
+    target.target_name.should eql(:target_name)
+    target.target_type.should eql(:target_type)
+  end
+
+  it "should set the target.project automatically" do
+    @project.add_target :target_name, :target_type
+    @project.targets[:target_name].project.should eql(@project)
+  end
+  
+  it "should set any other passed options on the target itself" do
+    @project.add_target :target_name, :target_type, :foo => :foo, :bar => :bar
+    target = @project.targets[:target_name]
+    
+    target.should_not be_nil
+    target.foo.should eql(:foo)
+    target.bar.should eql(:bar)
+  end
+  
+  it "should replace an existing target if defined" do
+    @project.add_target :test1, :dummy
+    target1 = @project.targets[:test1]
+    
+    @project.add_target :test1, :dummy2
+    target2 = @project.targets[:test1]
+    
+    target2.should_not eql(target1)
+    target2.target_type.should eql(:dummy2)
+  end
+
+end

data/spec/lib/models/project/buildfile_spec.rb

@@ -0,0 +1,35 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'buildfile' do
+
+  include SC::SpecHelpers
+
+  it "should return a new, empty buildfile if no Buildfile can be found in the project" do
+    project = SC::Project.new fixture_path('buildfiles', 'empty_project')
+    puts project.buildfile.loaded_paths
+    project.buildfile.loaded_paths.size.should eql(0)
+    project.buildfile.tasks.size.should eql(0)
+  end
+  
+  it "should load a buildfile if one is found in project_root" do
+    project = SC::Project.new fixture_path('buildfiles', 'installed')
+    project.buildfile.loaded_paths.size.should eql(1)
+    project.buildfile.tasks.size.should eql(2)
+  end
+  
+  it "should load all files matching SC.env.buildfile_names" do
+    SC.env.buildfile_names = ['Buildfile', 'Buildfile2']
+    project = SC::Project.new fixture_path('buildfiles', 'installed')
+    project.buildfile.loaded_paths.size.should eql(2)
+    SC.env.delete :buildfile_names
+  end
+
+  it "should merge over top of a parent project buildfile if there is one" do
+    installed = SC::Project.new fixture_path('buildfiles', 'installed')
+    basic = SC::Project.new fixture_path('buildfiles', 'basic'), :parent => installed
+    basic.buildfile.lookup(:installed_task).should_not be_nil
+    basic.buildfile.lookup(:test_task1).should_not be_nil
+  end
+  
+end
+

data/spec/lib/models/project/find_targets_for_spec.rb

@@ -0,0 +1,77 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'find_targets_for' do
+
+  include SC::SpecHelpers
+  
+  # path for a target inside fixtures for this test
+  def target_path(*args)
+    fixture_path(*args.unshift('find_targets'))
+  end
+  
+  # Should be a hash of target type -> array of expected target names
+  def expect_targets(targets, expected_targets = {})
+    known_targets = targets.keys
+    expected_targets.each do | target_type, expected |
+      expected.each do |target_name|
+        target_name = target_name.to_sym
+        known_targets.should include(target_name)
+        targets[target_name].target_type.should eql(target_type)
+        known_targets.delete target_name
+      end
+    end
+  end
+  
+  it "should search recursively for apps, clients, themes, and frameworks dirs with standard options -- also should ignore CaSeOfDir" do
+    
+    project = SC::Project.new(target_path('standard'), :parent => builtin_project)
+
+    # verify preconditions
+    target_types = project.config.target_types
+    target_types.size.should eql(4)
+    target_types[:apps].should eql(:app)
+    target_types[:clients].should eql(:app)
+    target_types[:frameworks].should eql(:framework)
+    target_types[:themes].should eql(:theme)
+    project.config.allow_nested_targets.should be_true
+    
+    # Note, this expectation assumes the fixtures in find_targets/standard has
+    # the following:
+    #  - different cases (see Apps + apps dirs)
+    #  - an apps, clients, and frameworks directory
+    #  - multiple targets in same dir (see framework1, framework2)
+    #  - nesting one type inside another (see app1/framework1, app1/fmwk2)
+    #  - nesting same type inside another (see framework1/framework1)
+    #
+    expect_targets project.targets, 
+      :app => %w(/app1 /client1),
+      :framework => %w(/framework1 /framework2 /app1/framework1 /app1/framework2 /framework1/framework1),
+      :theme => %w(/theme1 /theme2)
+  end
+  
+  it "should find targets based on target_types hash, including overrides in  target Buildfiles" do
+    
+    project = SC::Project.new(target_path('custom'))
+    
+    # NOTE: find_targets_spec/custom/Buildfile defines foo & bar types
+    # custom/foos/custom_foos/Buildfiels overrides.
+    expect_targets project.targets,
+      :foo => %w(/foo1 /custom_foos /custom_foos/foo1 /custom_foos/foo2 /bar1/foo1 /bar1/foo2),
+      :bar => %w(/bar1 /bar1/bar1 /bar1/bar2 /foo1/bar1 /foo1/bar2)
+    
+  end
+  
+  it "should recursively find targets unless allows_nested_targets = false; should respect overrides in Buildfiles" do
+    
+    project = SC::Project.new(target_path('nested'))
+    
+    # NOTE: find_targets_spec/custom/Buildfile defines foo & bar types
+    # custom/foos/custom_foos/Buildfiels overrides.
+    expect_targets project.targets,
+      :app => %w(/app1)
+    project.targets['/app1/nested_app'].should be_nil
+  end
+  
+  
+end
+  

data/spec/lib/models/project/load_nearest_project_spec.rb

@@ -0,0 +1,23 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Project, 'load_nearest_project' do
+  
+  include SC::SpecHelpers
+  
+  it "should find the highest-level directory with a Buildfile" do
+    # Note: since the fixtures live INSIDE the source directory and the 
+    # source directory contains a Buildfile, the _proper_ result here is to 
+    # actually return the top-level directory...
+    project = SC::Project.load_nearest_project fixture_path('buildfiles', 'basic')
+    project.project_root.should eql(fixture_path('..', '..'))
+  end
+  
+  it "should stop if it finds a Buildfile with project! set" do
+    project = SC::Project.load_nearest_project fixture_path('buildfiles', 'project_test', 'not_project', 'child')
+    
+    # The Buildfile at project_test indicates that it is a project -- so it
+    # should stop searching here...
+    project.project_root.should eql(fixture_path('buildfiles', 'project_test'))
+  end
+  
+end