sproutit-sproutcore 1.0.203 → 1.0.20090721145236

data/spec/lib/buildfile/load_spec.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile, 'load' do
+
+  include SC::SpecHelpers
+
+  it "should load the contents of the buildfile as well as imports" do
+    p = fixture_path('buildfiles', 'basic', 'Buildfile')
+    b = SC::Buildfile.load(p)
+    
+    b.should_not be_nil
+    b.invoke(:default)
+    
+    # Found in Buildfile
+    RESULTS[:test_task1].should be_true
+    
+    # Found in import(task_module)
+    RESULTS[:imported_task].should be_true
+  end
+  
+  it "should be able to load the contents of one builfile on top of another" do
+    a = SC::Buildfile.load(fixture_path('buildfiles','installed', 'Buildfile'))
+    b = a.dup.load! fixture_path('buildfiles','basic', 'Buildfile')
+    
+    b.invoke :default
+    
+    # Found in Buildfile
+    RESULTS[:test_task1].should be_true
+    
+    # Found in installed/Buildfile
+    RESULTS[:installed_task].should be_true
+  end
+  
+  it "should store every loaded path in loaded_paths" do
+    ## IMPORTANT! The buildfiles loaded here are not important, but they must
+    ## not contain any 'import' directives or else this test will fail.
+    path1 = fixture_path('buildfiles','installed', 'Buildfile')
+    path2 = fixture_path('buildfiles','installed', 'Buildfile2')
+    
+    a = SC::Buildfile.new
+    a.load! path1
+    a.load! path2
+    
+    a.loaded_paths.size.should eql(2)
+    a.loaded_paths.should include(path1)
+    a.loaded_paths.should include(path2)
+  end
+    
+end

data/spec/lib/buildfile/task/dup_spec.rb

@@ -0,0 +1,55 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+# define a custom subclass of the task to make sure classes are copied
+class CustomTestTask < SC::Buildfile::Task  
+  attr_accessor :test_property
+end
+
+describe SC::Buildfile::Task, 'dup' do
+
+  before do
+    @app = SC::Buildfile.define # used to hook a buildtask 
+    @task = SC::Buildfile::Task.new(:foo, @app)
+  end
+  
+  it "should clone actions and prerequisites" do
+    @app.define! do
+      task :bar => :foo do
+        :test_action
+      end
+    end
+    @task = @app.lookup :bar
+    @task.actions.size.should eql(1) # check precondition
+    @task.prerequisites.size.should eql(1) # check precondition
+    
+    action = @task.actions.first
+    pre = @task.prerequisites.first
+    
+    task2 = @task.dup
+    task2.actions.size.should eql(1)
+    task2.actions.first.should eql(action)
+    
+    task2.prerequisites.size.should eql(1)
+    task2.prerequisites.first.should eql(pre)
+    
+  end
+  
+  it "should take passed application property if defined" do
+    app2 = SC::Buildfile.define
+    task2 = @task.dup(app2)
+    task2.application.should eql(app2)
+  end
+  
+  it "should clone application property is not defined" do
+    @task.dup.application.should eql(@app)
+  end
+  
+  it "should duplicate any ivars from subclasses" do
+    @task = CustomTestTask.new :foo, @app
+    @task.test_property = :bar
+    
+    task2 = @task.dup
+    task2.test_property.should eql(:bar)
+  end
+    
+end

data/spec/lib/buildfile/task_defined_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile, 'task_defined?' do
+
+  it "should return true if the named task is defined" do
+    b = SC::Buildfile.new
+    b.define_task SC::Buildfile::Task, :test  
+    b.task_defined?(:test).should be_true
+  end
+
+  it "should return false if the named task is not defined" do
+    b = SC::Buildfile.new
+    b.task_defined?(:test).should be_false
+  end
+
+end
+  

data/spec/lib/buildfile_commands/build_task_spec.rb

@@ -0,0 +1,19 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile::Commands, 'build_task' do
+
+  it "should add a new task to the buildfile" do
+    b = SC::Buildfile.define do
+      build_task :task1 
+    end
+    b.task_defined?(:task1).should_not be_nil
+  end
+  
+  it "should add a new task with class BuilTask" do
+    b = SC::Buildfile.define do
+      build_task :task1
+    end
+    b.lookup(:task1).class.should eql(SC::Buildfile::BuildTask)
+  end
+
+end

data/spec/lib/buildfile_commands/config_spec.rb

@@ -0,0 +1,97 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+# The config helper can be used in a Buildfile to specify config options
+# targeted at specific bundle names.
+#
+# -- Note that we use the Buildfile.define() method to prepare these tests
+# but you can also use these in Buildfiles using the Buildfile.load() method.
+# The tests for those two method ensure that both approaches are identical.
+#
+describe SC::Buildfile::Commands, 'config' do
+  
+  it "should add the named config to the default mode when first defined" do
+    a = SC::Buildfile.define do 
+      config :test1, :foo => :bar
+    end
+    
+    configs = a.configs
+    
+    configs.all['/test1'].should_not be_nil
+    configs.all['/test1'].foo.should eql(:bar)
+  end
+  
+  it "should merge options when same config is named mode than once" do
+    a = SC::Buildfile.define do
+      config :test1, :test1 => :foo, :test2 => :foo
+      config :test1, :test1 => :bar
+    end
+    
+    configs = a.configs
+    configs.all['/test1'].test1.should eql(:bar)
+    configs.all['/test1'].test2.should eql(:foo)
+  end
+  
+  it "should both accept an options hash, accept a block, or both" do
+    a = SC::Buildfile.define do
+      config :test1, :foo => :bar
+    end
+    
+    b = SC::Buildfile.define do
+      config :test1 do |c|
+        c[:foo] = :bar
+      end
+    end
+    
+    c = SC::Buildfile.define do
+      config :test1, :test1 => :foo, :test2 => :foo do |c|
+        c[:test1] = :bar
+      end
+    end
+    
+    a.configs.all['/test1'].foo.should eql(:bar)
+    b.configs.all['/test1'].foo.should eql(:bar)
+    c.configs.all['/test1'].test1.should eql(:bar)
+    c.configs.all['/test1'].test2.should eql(:foo)
+  end
+  
+  it "should allow OpenStruct-style setting of configs when passed to block" do
+    a = SC::Buildfile.define do
+      config :test1 do |c|
+        c.foo = :bar
+      end
+    end  
+    a.configs.all['/test1'].foo.should eql(:bar)
+  end  
+  
+  it "should merge configs on top of a base buildfile configs without changing the root config" do
+    a = SC::Buildfile.define do
+      config :bundle, :test1 => :foo, :test2 => :foo
+    end
+    
+    b = a.dup.define! do
+      config :bundle, :test1 => :bar
+    end
+    
+    b.configs.all['/bundle'].test1.should eql(:bar)
+    b.configs.all['/bundle'].test2.should eql(:foo)
+                
+    a.configs.all['/bundle'].test1.should eql(:foo)
+    a.configs.all['/bundle'].test2.should eql(:foo)
+  end   
+  
+  it "should store configs inside of a specific mode when specified" do
+    a = SC::Buildfile.define do
+      mode :debug do
+        config :bundle, :foo => :foo
+      end
+      config :bundle, :bar => :bar
+    end
+    
+    a.configs.all['/bundle'].bar.should eql(:bar)
+    a.configs.all['/bundle'].foo.should be_nil
+    
+    a.configs.debug['/bundle'].bar.should be_nil
+    a.configs.debug['/bundle'].foo.should eql(:foo)
+  end
+  
+end

data/spec/lib/buildfile_commands/import_spec.rb

@@ -0,0 +1,17 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile::Commands, 'import' do
+
+  include SC::SpecHelpers
+
+  it "should import any tasks defined by the import" do
+    buildfile1_path = fixture_path('buildfiles', 'installed', 'Buildfile')
+    buildfile2_path = fixture_path('buildfiles', 'installed', 'Buildfile2')
+    b = SC::Buildfile.define do 
+      import buildfile1_path, buildfile2_path
+    end
+    b.task_defined?(:installed_task).should be_true
+    b.task_defined?(:installed_task2).should be_true
+  end
+
+end

data/spec/lib/buildfile_commands/namespace_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile::Commands, 'namespace' do
+
+  it "should define tasks as part of namespace" do
+    b = SC::Buildfile.define do
+      namespace :foo do
+        task :task1 
+      end
+      
+      task :task2
+    end
+    b.task_defined?('foo:task1').should be_true
+    b.task_defined?(:task2).should be_true
+    b.task_defined?('foo:task2').should be_false
+  end
+
+end

data/spec/lib/buildfile_commands/proxies_spec.rb

@@ -0,0 +1,38 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+# The proxy helper defines proxy settings that can be used with sc-server
+describe SC::Buildfile::Commands, 'proxy' do
+  
+  it "should save the opts for a new proxy" do
+    b = SC::Buildfile.define do
+      proxy '/url', :foo => :bar
+    end
+    b.proxies['/url'].foo.should eql(:bar)
+  end
+
+  it "should save the REPLACE opts for multiple calls to proxy" do
+    b = SC::Buildfile.define do
+      proxy '/url', :test1 => :foo, :test2 => :foo
+      proxy '/url', :test1 => :bar
+    end
+    b.proxies['/url'].test1.should eql(:bar)
+    b.proxies['/url'].test2.should be_nil
+  end
+  
+  it "should merge multiple proxy urls and REPLACE opts for chained files" do
+    a = SC::Buildfile.define do
+      proxy '/url1', :test1 => :foo, :test2 => :foo
+      proxy '/url2', :test1 => :foo
+    end
+    
+    b = a.dup.define! do
+      proxy '/url1', :test1 => :bar
+    end
+    
+    b.proxies['/url1'].test1.should eql(:bar)
+    b.proxies['/url1'].test2.should be_nil
+    b.proxies['/url2'].test1.should eql(:foo)
+  end
+  
+end
+

data/spec/lib/buildfile_commands/replace_task_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile::Commands, 'task' do
+
+  it "should add a new task to the buildfile" do
+    b = SC::Buildfile.define do
+      replace_task :task1 
+    end
+    b.task_defined?(:task1).should_not be_nil
+  end
+  
+  it "should replace an existing task completely if defined" do
+    results = {}
+    b = SC::Buildfile.define do
+      task :task1 do
+        RESULTS[:foo] = :original
+      end
+      
+      replace_task :task1 do
+        RESULTS[:foo] = :replaced
+      end
+    end
+    
+    b.invoke :task1, :results => results
+    
+    results[:foo].should eql(:replaced)
+  end
+
+end

data/spec/lib/buildfile_commands/task_spec.rb

@@ -0,0 +1,36 @@
+require File.join(File.dirname(__FILE__), %w[.. .. spec_helper])
+
+describe SC::Buildfile::Commands, 'task' do
+
+  it "should add a new task to the buildfile" do
+    b = SC::Buildfile.define do
+      task :task1 
+    end
+    b.task_defined?(:task1).should_not be_nil
+  end
+  
+  it "should add a new task with a dependency if specified" do
+    b = SC::Buildfile.define do
+      task :task1 => :task2
+    end
+    b.lookup(:task1).prerequisites.first.should eql('task2')
+  end
+  
+  it "extend an existing task by adding the second action if defined" do
+    results = {}
+    b = SC::Buildfile.define do
+      task :task1 do
+        RESULTS[:foo] = true
+      end
+      
+      task :task1 do
+        RESULTS[:bar] = true
+      end
+    end
+    
+    b.invoke :task1, :results => results
+    results[:foo].should be_true
+    results[:bar].should be_true
+  end
+
+end

data/spec/lib/helpers/packing_optimizer/optimize_spec.rb

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::Target, 'pack optimize !!!' do
+
+  include SC::SpecHelpers
+
+  before do
+   	@project = temp_project :real_world
+    
+  end
+  
+  it "Returns two arrays:  targets that should be loaded packed,  Targets that should be loaded but not packed. In this case it should return one packed and 0 unpacked" do
+	target = @project.target_for 'sproutcore/application'
+	packed, unpacked = SC::Helpers::PackedOptimizer.optimize(target.required_targets)
+	(packed.size + unpacked.size).should eql(1)
+  end
+  
+	
+  it "Returns two arrays:  targets that should be loaded packed,  Targets that should be loaded but not packed. In this case there shouln't be any packed target" do
+	target = @project.target_for 'sproutcore'
+	packed, unpacked = SC::Helpers::PackedOptimizer.optimize(target.required_targets)
+	unpacked.size.should eql(1)
+  end
+
+end
+

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

@@ -0,0 +1,27 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::HashStruct, 'deep_clone' do
+
+  it "should deep_clone any objects that respond to deep_clone" do
+    a = SC::HashStruct.new
+    a[:b] = SC::HashStruct.new :c => :d
+    
+    e = a.deep_clone
+    e[:b][:c] = :f
+    
+    e[:b][:c].should eql(:f)    
+    a[:b][:c].should eql(:d)
+  end
+  
+  it "should clone any objects that respond to clone" do
+    a = SC::HashStruct.new
+    a[:b] = [1,2,3]
+    
+    b = a.deep_clone
+    b[:b][0] = 4
+    
+    a[:b][0].should eql(1)
+    b[:b][0].should eql(4)
+  end
+  
+end

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

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::HashStruct, 'has_options?' do
+  
+  include SC::SpecHelpers
+
+  before do 
+    @hash = SC::HashStruct.new :foo => :foo, :bar => :bar
+  end
+  
+  it "always returns true if passed match is empty or nil" do
+    @hash.has_options?.should be_true
+    @hash.has_options?({}).should be_true
+  end
+  
+  it "returns true if every key/value pair in passed value set matches" do
+    @hash.has_options?(:foo => :foo, :bar => :bar).should be_true
+  end
+  
+  it "returns false if any key/value pair in passed value set does not match" do
+    @hash.has_options?(:foo => :foo, :bar => :no_match).should be_false
+  end
+  
+  it "returns false if any key/value pair does not exist in hash" do
+    @hash.has_options?(:imaginary => true).should be_false
+  end
+  
+  it "returns treats strings + symbols the same for keys" do
+    @hash.has_options?('foo' => :foo, 'bar' => :bar).should be_true
+  end
+  
+end

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

@@ -0,0 +1,64 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::HashStruct, 'hash operations' do
+  
+  include SC::SpecHelpers
+
+  it "should allow arbitrary keys to be set/read using hash methods" do
+    e = SC::HashStruct.new
+    e[:foo] = :bar
+    e[:foo].should eql(:bar)
+  end
+  
+  it "should set any hash options passed to new" do
+    e = SC::HashStruct.new :foo => :bar
+    e[:foo].should eql(:bar)
+  end
+  
+  it "should read any missing methods from the hash" do
+    e = SC::HashStruct.new :foo => :bar
+    e.foo.should eql(:bar)
+  end
+  
+  it "should write missing methods ending in = to the hash" do
+    e = SC::HashStruct.new 
+    e.foo = :bar
+    e[:foo].should eql(:bar)
+  end
+  
+  it "should treat string and hash keys as the same" do
+    e = SC::HashStruct.new
+    e['foo'] = :bar
+    e[:foo].should eql(:bar)
+    
+    e[:foo2] = :bar
+    e['foo2'].should eql(:bar)
+  end
+  
+  it "should convert all keys to symbols (i.e. if you get keys, they will always be symbols)" do
+    e = SC::HashStruct.new
+    e['string'] = :foo
+    e[:symbol] = :foo
+        
+    expected = [:string, :symbol]
+    idx=0
+    e.keys.sort { |a,b| a.to_s <=> b.to_s }.each do |k|
+      k.should eql(expected[idx])
+      idx += 1
+    end
+  end
+  
+  it "should raise error if key cannot be converted to symbol" do
+    a = SC::HashStruct.new
+    
+    # numbers respond to to_sym but return nil
+    lambda { a[1] = :foo }.should raise_error
+    lambda { a[1] }.should raise_error
+    
+    # Object does not respond to to_sym
+    lambda { a[Object.new] = :foo }.should raise_error
+    lambda { a[Object.new] }.should raise_error
+  end
+    
+  
+end

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

@@ -0,0 +1,26 @@
+require File.join(File.dirname(__FILE__), %w[.. .. .. spec_helper])
+
+describe SC::HashStruct, 'merge!' do
+
+  it "should convert all keys to symbols - if symbol and string is passed, they will overrwite" do
+    a = SC::HashStruct.new
+    a.merge! :foo => :bar1, 'foo' => :bar2
+    a.keys.size.should eql(1)
+    a.keys.first.should eql(:foo)
+  end
+  
+  it "should do nothing if we merge self!" do
+    a = SC::HashStruct.new :foo => :bar
+    a.merge! a
+    a[:foo].should eql(:bar)
+    a.keys.size.should eql(1)
+  end
+  
+  it "should do nothing if we merge nil" do
+    a = SC::HashStruct.new :foo => :bar
+    lambda { a.merge! nil }.should_not raise_error
+    a[:foo].should eql(:bar)
+    a.keys.size.should eql(1)
+  end
+  
+end

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