sproutit-sproutcore 1.0.0.20090407205609

data/spec/buildtasks/manifest/prepare_build_tasks/css_spec.rb

@@ -0,0 +1,87 @@
+require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+
+# This task prepares a single CSS entry for every untagged source entry.
+describe "manifest:prepare_build_tasks:css" do
+  
+  include SC::SpecHelpers
+  include SC::ManifestSpecHelpers
+  
+  before do
+    std_before
+  end
+  
+  def run_task
+    @manifest.prepare!
+    super('manifest:prepare_build_tasks:css')
+  end
+
+  it "should run manifest:prepare_build_tasks:setup as prereq" do
+    should_run('manifest:prepare_build_tasks:setup') { run_task }
+  end
+
+  # This rewriting is done to make sure source entries are disambiguated from
+  # the generated stylesheet.css that will live at the root level
+  it "rewrites all css entries to begin with 'source/...'" do
+    run_task
+    entries = @manifest.entries.select { |e| e.entry_type == :css }
+    entries.each do |entry|
+      %w(filename url build_path).each do |key|
+        entry[key].should =~ /source\//
+      end
+    end
+  end
+
+  it "creates a transform entry for each css entry" do
+    run_task
+
+    # find all original CSS entries...
+    originals = @manifest.entries(:hidden => true).select do |entry|
+      entry.original? && entry.ext == 'css'
+    end
+    originals.size.should > 0 # precondition
+    
+    # transformed entries
+    entries = @manifest.entries.select { |e| e.entry_type == :css }
+    entries.size.should == originals.size #precondition
+    
+    # one transformed entry should exist for each original entry.
+    entries.each do |entry|
+      entry.should be_transform
+      entry.source_entry.should_not be_nil
+      originals.should include(entry.source_entry)
+      originals.delete(entry.source_entry) # so as not to allow doubles
+    end
+    originals.size.should == 0
+  end
+  
+  describe "supports require() and sc_require() statements" do
+    
+    it "adds a entry.required property with empty array of no requires are specified in file"  do
+      run_task
+      entry = @manifest.entry_for('source/no_require.css')
+      entry.required.should == []
+    end
+    
+    it "searches files for require() & sc_requires() statements and adds them to entry.required array -- (also should ignore any ext)" do
+      run_task
+      entry = @manifest.entry_for('source/has_require.css')
+      entry.required.sort.should == ['demo2', 'no_require']
+    end
+  
+  end
+  
+  describe "supports sc_resource() statement" do
+    it "sets entry.resource = 'stylesheet' if no sc_resource statement is found in files" do
+      run_task
+      entry = @manifest.entry_for('source/no_require.css')
+      entry.resource.should == 'stylesheet'
+    end
+    
+    it "searches files for sc_resource() statement and stores last value in entry.resource property" do
+      run_task
+      entry = @manifest.entry_for 'source/sc_resource.css'
+      entry.resource.should == 'bar'
+    end
+  end
+
+end

data/spec/buildtasks/manifest/prepare_build_tasks/html_spec.rb

@@ -0,0 +1,175 @@
+require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+
+describe "manifest:prepare_build_tasks:html" do
+  
+  include SC::SpecHelpers
+  include SC::ManifestSpecHelpers
+  
+  before do
+    std_before
+  end
+
+  def run_task
+    @manifest.prepare!
+    super('manifest:prepare_build_tasks:html')
+  end
+
+  it "should run manifest:prepare_build_tasks:setup & strings as prereq" do
+    %w(setup).each do |task_name|
+      should_run("manifest:prepare_build_tasks:#{task_name}") { run_task }
+    end
+  end
+
+  describe "supports sc_resource() statement" do
+    it "sets entry.resource = 'index' if no sc_resource statement is found in files" do
+      run_task
+      entry = entry_for('no_sc_resource.rhtml')
+      entry.resource.should == 'index'
+    end
+    
+    it "searches files for sc_resource() statement and stores last value in entry.resource property" do
+      run_task
+      entry = entry_for 'sc_resource.rhtml'
+      entry.resource.should == 'bar'
+    end
+  end
+
+  describe "annotates entries with render_task" do
+    
+    before do
+      run_task
+    end
+    
+    it "file.erb => render:erubis" do
+      expected = entry_for('file_extension_test.html.erb')
+      expected.render_task.should == "render:erubis"
+    end
+
+    it "file.haml => render:haml" do
+      expected = entry_for('file_extension_test.haml')
+      expected.render_task.should == "render:haml"
+    end
+
+    it "file.rhtml => render:erubis" do
+      expected = entry_for('file_extension_test.rhtml')
+      expected.render_task.should == "render:erubis"
+    end
+
+  end
+  
+  describe "special case handling of index.html for loadable targets" do
+    
+    before do
+      # load application target instead of framework...
+      @target = @project.target_for :contacts
+      @buildfile = @target.buildfile
+      @config = @target.config
+      @manifest = @target.manifest_for(:language => :fr)
+      @target.prepare!
+
+      run_task
+      @index_entry = entry_for 'index.html'
+    end
+    
+    it "applies these rules only to a target that is loadable" do
+      @target.should be_loadable # precondition
+    end
+    
+    # an index.html is always needed for an application to load properly
+    # even if not explicit fragments are present in the app.
+    it "generates an index.html entry even if there are no source html fragments" do
+      @index_entry.should_not be_nil
+      @index_entry.source_entries.size.should == 0 # precondition
+    end
+    
+    it "does not hide the index.html entry" do
+      @index_entry.should_not be_hidden
+    end
+    
+    it "adds the include_required_targets? property to the entry" do
+      @index_entry.should be_include_required_targets
+    end
+    
+    it "marks the target as loadable" do
+      @target.should be_loadable
+    end
+  
+  end
+    
+  describe "special case handling of index.html for frameworks" do
+    
+    before do
+      run_task
+      @index_entry = entry_for 'index.html'
+      @bar_entry = @manifest.entry_for('bar.html')
+    end
+    
+    it "applies these rules only to a target that is not loadable" do
+      @target.should_not be_loadable # precondition
+    end
+    
+    it "hides an index.html entry" do
+      @index_entry.should be_hidden
+    end
+    
+    it "does not add include_required_targets property to entry" do
+      @index_entry.should_not be_include_required_targets
+    end
+    
+    it "should not hide other .html entries if the target is not loadable" do
+      @bar_entry.should_not be_hidden
+    end
+    
+  end
+  
+  describe "combines html entries into one output file per resource" do
+    
+    before do
+      run_task
+      @index_entry = entry_for 'index.html'
+      @bar_entry = @manifest.entry_for('bar.html')
+    end
+    
+    it "should be composite entries" do
+      @index_entry.should be_composite
+      @bar_entry.should be_composite
+    end
+    
+    it "should include any files ending in .rhtml" do
+      expected = entry_for('file_extension_test.rhtml')
+      @index_entry.source_entries.should include(expected)
+    end
+    
+    it "should include any files ending in .erb" do
+      expected = entry_for('file_extension_test.html.erb')
+      @index_entry.source_entries.should include(expected)
+    end
+
+    it "should include any files ending in .haml" do
+      expected = entry_for('file_extension_test.haml')
+      @index_entry.source_entries.should include(expected)
+    end
+
+    it "creates a combined index entry for each resource named in files" do
+      # spot check...
+      @index_entry.source_entries.should include(entry_for('no_sc_resource.rhtml'))
+
+      @bar_entry.source_entries.should include(entry_for('sc_resource.rhtml'))
+    end
+    
+    it "entries have a build_task = build:html" do
+      @index_entry.build_task.should == 'build:html'
+      @bar_entry.build_task.should == 'build:html'
+    end
+    
+    it "hides source entries" do
+      [@index_entry, @bar_entry].each do |entry|
+        entry.source_entries.each do |source_entry|
+          source_entry.should be_hidden
+        end
+      end
+    end
+    
+  end
+
+end

data/spec/buildtasks/manifest/prepare_build_tasks/javascript_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+
+describe "manifest:prepare_build_tasks:javascript" do
+  
+  include SC::SpecHelpers
+  include SC::ManifestSpecHelpers
+  
+  before do
+    std_before
+  end
+
+  def run_task
+    @manifest.prepare!
+    super('manifest:prepare_build_tasks:javascript')
+  end
+
+  it "should run manifest:prepare_build_tasks:setup as prereq" do
+    should_run('manifest:prepare_build_tasks:setup') { run_task }
+  end
+
+  # This rewriting is done to make sure source entries are disambiguated from
+  # the generated javascript.js that will live at the root level
+  it "rewrites all javascript entries to begin with 'source/...'" do
+    run_task
+    entries = @manifest.entries.select { |e| e.entry_type == :javascript }
+    entries.each do |entry|
+      %w(filename url build_path).each do |key|
+        entry[key].should =~ /source\//
+      end
+    end
+  end
+  
+  describe "supports require() and sc_require() statements" do
+    
+    it "adds a entry.required property to entrys with empty array of no requires are specified in file"  do
+      run_task
+      entry = entry_for('source/no_require.js')
+      entry.required.should == []
+    end
+    
+    it "searches files for require() & sc_requires() statements and adds them to entry.required array -- (also should ignore any ext)" do
+      run_task
+      entry = entry_for('source/has_require.js')
+      entry.required.sort.should == ['demo2', 'no_require']
+    end
+  
+  end
+  
+  describe "supports sc_resource() statement" do
+    it "sets entry.resource = 'javascript' if no sc_resource statement is found in files" do
+      run_task
+      entry = entry_for('source/no_require.js')
+      entry.resource.should == 'javascript'
+    end
+    
+    it "searches files for sc_resource() statement and stores last value in entry.resource property" do
+      run_task
+      entry  =entry_for 'source/sc_resource.js'
+      entry.resource.should == 'bar'
+    end
+  end
+  
+
+
+end

data/spec/buildtasks/manifest/prepare_build_tasks/minify_spec.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+
+describe "manifest:prepare_build_tasks:minify" do
+  
+  include SC::SpecHelpers
+  include SC::ManifestSpecHelpers
+  
+  before do
+    std_before
+  end
+
+  def run_task
+    @manifest.prepare!
+    super('manifest:prepare_build_tasks:minify')
+  end
+
+  it "should run setup, javascript, css, and combine as prereq" do
+    %w(setup javascript css sass combine).each do |task_name|  
+      should_run("manifest:prepare_build_tasks:#{task_name}") { run_task }
+    end
+  end
+  
+  describe "minify javascript tasks" do
+    
+    def should_have_minify_javascript_tasks
+      entries = @manifest.entries.select { |e| e.entry_type == :javascript }
+      entries.each do |entry|
+        entry.should be_minified
+        entry.should be_transform
+        entry.source_entry.entry_type.should == :javascript
+      end
+    end
+
+    def should_not_have_minify_javascript_tasks
+      entries = @manifest.entries.select { |e| e.entry_type == :javascript }
+      entries.each do |entry|
+        entry.should_not be_minified
+      end
+    end
+    
+    it "adds task when CONFIG.minify_javascript == true" do
+      @target.config.minify_javascript = true
+      run_task
+      should_have_minify_javascript_tasks
+    end
+
+    it "adds task when CONFIG.minify == true" do
+      @target.config.minify = true
+      @target.config.minify_javascript = nil # assume not defined
+      run_task
+      should_have_minify_javascript_tasks
+    end
+
+    it "does not add task when CONFIG.minify == true but CONFIG.minify_javascript == false" do
+      @target.config.minify = true
+      @target.config.minify_javascript = false
+      run_task
+      should_not_have_minify_javascript_tasks
+    end
+
+    it "does not add task when CONFIG.minify == false and CONFIG.minify_javascript is not defined" do
+      @target.config.minify = false
+      @target.config.minify_javascript = nil
+      run_task
+      should_not_have_minify_javascript_tasks
+    end
+    
+  end
+  
+end

data/spec/buildtasks/manifest/prepare_build_tasks/packed_spec.rb

@@ -0,0 +1,152 @@
+require File.join(File.dirname(__FILE__), %w(.. spec_helper))
+
+# Creates packed combined entries for javascript & css
+describe "manifest:prepare_build_tasks:packed" do
+  
+  include SC::SpecHelpers
+  include SC::ManifestSpecHelpers
+  
+  before do
+    std_before
+  end
+  
+  def run_task
+    # capture any log warnings...
+    @msg = capture('stderr') {
+      @manifest.prepare!
+      super('manifest:prepare_build_tasks:packed')
+    }
+  end
+
+  it "should run setup, combine as prereq" do
+    %w(setup combine).each do |task_name|
+      should_run("manifest:prepare_build_tasks:#{task_name}") { run_task }
+    end
+  end
+
+  it "should not add packed entries for apps" do
+    @target = @project.target_for(:contacts)
+    @target.target_type.should == :app # precondition
+    
+    @manifest = @target.manifest_for(:language => :en)
+    run_task
+    
+    @manifest.entry_for('javascript-packed.js').should be_nil
+    @manifest.entry_for('stylesheet-packed.css').should be_nil
+  end
+  
+  it "should add packed entries for frameworks" do
+    # verify default target is a framework - precondition
+    @target.target_type.should == :framework #precondition
+    run_task
+
+    @manifest.entry_for('javascript-packed.js').should_not be_nil
+  end
+    
+  #######################################
+  # javascript-packed.js support
+  #
+  describe "javascript-packed.js" do
+    
+    before do
+      run_task
+      @entry = entry_for('javascript-packed.js')
+    end
+    
+    it "should generate a javascript-packed.js entry" do
+      @entry.should_not be_nil
+    end
+    
+    it "should include javascript.js entries from all required targets" do
+      @entry.source_entries.size.should > 0
+      @entry.source_entries.each do |entry|
+        entry.filename.should == 'javascript.js'
+      end
+    end
+    
+    it "should include ordered_entries ordered by required target order" do
+      
+      # find targets, sorted by order.  remove any that don't have a 
+      # javascript.js entry.
+      targets = @target.expand_required_targets + [@target]
+      variation = @entry.manifest.variation
+      targets.reject! do |t| 
+        t.manifest_for(variation).build!.entry_for('javascript.js').nil?
+      end
+      
+      @entry.ordered_entries.each do |entry|
+        entry.target.should == targets.shift
+      end
+    end
+    
+    it "should include the actual targets this packed version covers in the targets property (even those w no javascript.js)" do
+      targets = @target.expand_required_targets + [@target]
+      @entry.targets.should == targets
+    end
+    
+    it "should NOT include minified source entries" do
+      @entry.source_entries.each do |entry|
+        entry.should_not be_minified
+      end
+    end
+    
+    it "should be marked as packed" do
+      @entry.should be_packed
+    end
+    
+  end
+
+  #######################################
+   # stylesheet-packed.css support
+   #
+   describe "stylesheet-packed.css" do
+
+     before do
+       run_task
+       @entry = entry_for('stylesheet-packed.css')
+     end
+
+     it "should generate a stylesheet-packed.css entry" do
+       @entry.should_not be_nil
+     end
+
+     it "should include stylesheet.css entries from all required targets" do
+       @entry.source_entries.size.should > 0
+       @entry.source_entries.each do |entry|
+         entry.filename.should == 'stylesheet.css'
+       end
+     end
+
+     it "should include ordered_entries ordered by required target order" do
+
+       # find targets, sorted by order.  remove any that don't have a 
+       # javascript.js entry.
+       targets = @target.expand_required_targets + [@target]
+       variation = @entry.manifest.variation
+       targets.reject! do |t| 
+         t.manifest_for(variation).build!.entry_for('stylesheet.css').nil?
+       end
+
+       @entry.ordered_entries.each do |entry|
+         entry.target.should == targets.shift
+       end
+     end
+
+     it "should include the actual targets this packed version covers in the targets property (even those w no stylesheet.css)" do
+       targets = @target.expand_required_targets + [@target]
+       @entry.targets.should == targets
+     end
+
+     it "should NOT include minified source entries" do
+       @entry.source_entries.each do |entry|
+         entry.should_not be_minified
+       end
+     end
+
+     it "should be marked as packed" do
+       @entry.should be_packed
+     end
+
+   end
+  
+end