sproutit-sproutcore 1.0.20090721145236 → 1.0.20090721145251

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

@@ -1,87 +0,0 @@
-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

@@ -1,175 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,152 +0,0 @@
-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