jsus 0.3.6 → 0.4.0

data/spec/jsus/packager_spec.rb

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
 
-describe Jsus::Packager do 
-  let(:simple_source)         { Source.new(:provides => [0], :dependencies => [],  :content => "// simple") }
-  let(:another_simple_source) { Source.new(:provides => [1], :dependencies => [],  :content => "// simple 2") }
-  let(:dependant_source)      { Source.new(:provides => [3], :dependencies => [0], :content => "// simple 3") }
+describe Jsus::Packager do
+  let(:simple_source)         { Jsus::SourceFile.from_file("spec/data/SimpleSources/simple_source_one.js", :namespace => "Test") }
+  let(:another_simple_source) { Jsus::SourceFile.from_file("spec/data/SimpleSources/simple_source_two.js", :namespace => "Test") }
+  let(:dependant_source)      { Jsus::SourceFile.from_file("spec/data/SimpleSources/dependent_source_one.js", :namespace => "Test") }
 
-  let(:simple_package)          { Jsus::Packager.new(simple_source, another_simple_source) }
-  let(:package_with_dependency) { Jsus::Packager.new(dependant_source, simple_source) }
+  let(:simple_package)          { Jsus::Packager.new([simple_source, another_simple_source]) }
+  let(:package_with_dependency) { Jsus::Packager.new([dependant_source, simple_source]) }
 
   before(:each) { cleanup }
   after(:each)  { cleanup }
@@ -20,18 +20,18 @@ describe Jsus::Packager do
   end
 
   describe "#pack" do
-    subject { Jsus::Packager.new(simple_source) }    
+    subject { Jsus::Packager.new(simple_source) }
     it "should concatenate source files" do
-      simple_package.pack.should include(simple_source.content, another_simple_source.content)
+      simple_package.pack.should include(simple_source.source, another_simple_source.source)
     end
 
     it "should output to file if given a filename" do
       simple_package.pack("spec/tmp/test.js")
-      IO.read("spec/tmp/test.js").should include(simple_source.content, another_simple_source.content)
+      IO.read("spec/tmp/test.js").should include(simple_source.source, another_simple_source.source)
     end
 
     it "should resolve dependencies" do
-      package_with_dependency.pack.should == "#{simple_source.content}\n#{dependant_source.content}"
+      package_with_dependency.pack.should == "#{simple_source.source}\n#{dependant_source.source}"
     end
   end
-end
+end

data/spec/jsus/pool_spec.rb

@@ -3,9 +3,9 @@ describe Jsus::Pool do
   let(:input_dir) { "spec/data/ChainDependencies/app/javascripts" }
   let(:packages) {
     [
-      Jsus::Package.new("#{input_dir}/Mash",  :pool => subject),
-      Jsus::Package.new("#{input_dir}/Class", :pool => subject),
-      Jsus::Package.new("#{input_dir}/Hash",  :pool => subject)
+      Jsus::Package.new("#{input_dir}/Mash"),
+      Jsus::Package.new("#{input_dir}/Class"),
+      Jsus::Package.new("#{input_dir}/Hash")
     ]
   }
 
@@ -34,7 +34,7 @@ describe Jsus::Pool do
 
       it "should add all the source files to pool" do
         subject.should have_exactly(3).sources
-        subject.sources.map {|s| s.provides_names }.flatten.should include("Mash/Mash", "Hash/Hash", "Class/Class")
+        subject.sources.map {|s| s.provides.map {|tag| tag.to_s } }.flatten.should include("Mash/Mash", "Hash/Hash", "Class/Class")
       end
 
       it "should keep track of extensions" do
@@ -56,9 +56,7 @@ describe Jsus::Pool do
 
 
   describe "#lookup" do
-    before(:each) do
-      packages.each {|package| subject << package.source_files }
-    end
+    before(:each) { packages.each {|package| subject << package} }
 
     it "should find a source file providing given full name" do
       subject.lookup("Class/Class").should == sources[1]
@@ -71,13 +69,6 @@ describe Jsus::Pool do
     it "should allow tags" do
       subject.lookup(Jsus::Tag["Class/Class"]).should == sources[1]
     end
-
-    it "should return replacements whenever possible" do
-      pkg = Jsus::Package.new("spec/data/ClassReplacement",  :pool => subject)
-      subject << pkg.source_files
-      subject.lookup("Class/Class").should == pkg.source_files[0]
-      subject.lookup(Jsus::Tag["Class/Class"]).should == pkg.source_files[0]
-    end
   end
 
   describe "#lookup_direct_dependencies" do
@@ -104,8 +95,8 @@ describe Jsus::Pool do
     end
 
     it "should return a container with files and dependencies" do
-      subject.lookup_dependencies("Mash/Mash").should == [sources[1], sources[2]]
-      subject.lookup_dependencies(Jsus::Tag["Mash/Mash"]).should == [sources[1], sources[2]]
+      subject.lookup_dependencies("Mash/Mash").should =~ [sources[1], sources[2]]
+      subject.lookup_dependencies(Jsus::Tag["Mash/Mash"]).should =~ [sources[1], sources[2]]
     end
 
     it "should return empty array if pool doesn't contain given source" do
@@ -117,7 +108,7 @@ describe Jsus::Pool do
       let(:input_dir) { "spec/data/DependenciesWildcards/app/javascripts" }
 
       it "should support wildcards" do
-        subject.lookup_dependencies("Mash/Mash").should == [sources[1], sources[2]]
+        subject.lookup_dependencies("Mash/Mash").should =~ [sources[1], sources[2]]
       end
     end
   end
@@ -136,14 +127,14 @@ describe Jsus::Pool do
     let(:input_dir) { "spec/data/Extensions/app/javascripts" }
     subject { Jsus::Pool.new(input_dir) }
 
-    it "should return empty array if there's not a single extension for given tag" do
-      subject.lookup_extensions("Core/WTF").should be_empty
-      subject.lookup_extensions(Jsus::Tag["Core/WTF"]).should be_empty
+    it "should return empty array if there's not a single extension for given file" do
+      source = Jsus::SourceFile.from_file("spec/data/test_source_one.js", :namespace => "Test")
+      subject.lookup_extensions(source).should be_empty
     end
 
     it "should return an array with extensions if there are extensions for given tag" do
-      subject.lookup_extensions("Core/Class").should have_exactly(1).item
-      subject.lookup_extensions(Jsus::Tag["Core/Class"]).should have_exactly(1).item
+      source = subject.lookup("Core/Class")
+      subject.lookup_extensions(source).should_not be_empty
     end
   end
 

data/spec/jsus/source_file_spec.rb

@@ -4,57 +4,49 @@ require 'spec_helper'
 describe Jsus::SourceFile do
   before(:each) { cleanup }
   after(:all) { cleanup }
-  let(:package) { Package.new(:name => "Core") }
-  subject { Jsus::SourceFile.from_file("spec/data/OutsideDependencies/app/javascripts/Core/Source/Class/Class.Extras.js", :package => package) }
+  let(:filename) { "spec/data/OutsideDependencies/app/javascripts/Core/Source/Class/Class.Extras.js" }
+  subject { Jsus::SourceFile.from_file(filename) }
   context "initialization" do
     context "from file" do
       subject { Jsus::SourceFile.from_file('spec/data/test_source_one.js') }
-      it "should parse json header" do
-        subject.dependencies_names.should == ["Class"]
-        subject.provides_names.should == ["Color"]
-        subject.description.should == "A library to work with colors"
-      end
 
       it "should set filename field to expanded file name" do
         subject.filename.should == File.expand_path("spec/data/test_source_one.js")
       end
 
-      it "should set original_content to file content" do
-        subject.original_content.should == File.read(subject.filename)
+      it "should set original_source to file content" do
+        subject.original_source.should == File.read(subject.filename)
       end
 
-      context "when format is invalid" do
-        it "should raise error" do
-          lambda { Jsus::SourceFile.from_file('spec/data/bad_test_source_one.js') }.should raise_error
-          lambda { Jsus::SourceFile.from_file('spec/data/bad_test_source_two.js') }.should raise_error
-        end
+      it "should parse the header" do
+        subject.header["license"].should     == "MIT-style license"
+        subject.header["description"].should == "A library to work with colors"
       end
 
-      context "when file does not exist" do
-        it "should raise error" do
-          lambda { Jsus::SourceFile.from_file('spec/data/non-existant-file.js') }.should raise_error
+      context "when that file is problematic" do
+        before(:each) { Jsus.logger.level = Logger::FATAL }
+        after(:each) { Jsus.logger.level = Logger::WARN }
+        context "when format is invalid" do
+          it "should raise error" do
+            lambda { Jsus::SourceFile.from_file('spec/data/bad_test_source_one.js') }.should raise_error
+            lambda { Jsus::SourceFile.from_file('spec/data/bad_test_source_two.js') }.should raise_error
+          end
         end
-      end
 
-      context "when some error happens" do
-        it "should raise error" do
-          YAML.stub!(:load) { raise "Could not parse the file!" }
-          lambda { subject }.should raise_error(RuntimeError, /spec\/data\/test_source_one\.js/)
+        context "when file does not exist" do
+          it "should raise error" do
+            lambda { Jsus::SourceFile.from_file('spec/data/non-existant-file.js') }.should raise_error
+          end
+        end
+
+        context "when some error happens" do
+          it "should raise error and mention filename" do
+            YAML.stub!(:load) { raise "Could not parse the file!" }
+            lambda { subject }.should raise_error(RuntimeError, %r{spec/data/test_source_one\.js})
+          end
         end
-      end
-    end
 
-    it "should set all available fields from constructor" do
-      source = Jsus::SourceFile.new(:package           => package,
-                                    :content           => subject.content,
-                                    :filename          => subject.filename,
-                                    :relative_filename => subject.relative_filename,
-                                    :header            => subject.header)
-      source.package.should           == package
-      source.content.should           == subject.content
-      source.filename.should          == subject.filename
-      source.relative_filename.should == subject.relative_filename
-      source.header.should            == subject.header
+      end
     end
 
     it "should not break on unicode files" do
@@ -69,6 +61,24 @@ describe Jsus::SourceFile do
       source.header["authors"][1].should == "Sebastian Markbåge"
     end
 
+    it "should parse 'requires', 'provides', 'extends' and 'replaces' fields of the header" do
+      subject.requires.should == [Jsus::Tag["Class"]]
+      subject.provides.should =~ [Jsus::Tag["Chain"], Jsus::Tag["Events"], Jsus::Tag["Options"]]
+      subject.replaces.should be_nil
+      subject.extends.should be_nil
+    end
+
+    it "should use assigned namespace for internal dependencies" do
+      subject = described_class.from_file(filename, :namespace => "Core")
+      subject.requires.should == [Jsus::Tag["Core/Class"]]
+      subject.provides.should == [Jsus::Tag["Core/Chain"], Jsus::Tag["Core/Events"], Jsus::Tag["Core/Options"]]
+    end
+
+    it "should accept namespace in options" do
+      described_class.from_file("spec/data/test_source_one.js").namespace.should                       == nil
+      described_class.from_file("spec/data/test_source_one.js", :namespace => "Core").namespace.should == "Core"
+    end
+
     if defined?(Encoding) && Encoding.respond_to?(:default_external)
       it "should not break on unicode files even when external encoding is set to non-utf" do
         old_external = Encoding.default_external
@@ -81,146 +91,6 @@ describe Jsus::SourceFile do
     end
   end
 
-  context "when no package set, " do
-    subject { Jsus::SourceFile.from_file("spec/data/test_source_one.js") }
-    describe "#package" do
-      it "should return nil" do
-        subject.package.should be_nil
-      end
-    end
-
-    describe "#provides_names" do
-      it "should return names without leading slash in both forms" do
-        subject.provides_names.should == ["Color"]
-        subject.provides_names(:short => true).should == ["Color"]
-      end
-    end
-
-    describe "#dependencies_names" do
-      it "should return names without leading slash in both forms" do
-        subject.dependencies_names.should == ["Class"]
-        subject.dependencies_names(:short => true).should == ["Class"]
-      end
-    end
-
-    describe "#external_dependencies" do
-      it "should be empty" do
-        subject.external_dependencies.should be_empty
-      end
-    end
-
-    describe "#external_dependencies_names" do
-      it "should be empty" do
-        subject.external_dependencies_names.should be_empty
-      end
-    end
-  end
-
-  context "when it is in package, " do
-    let(:package) { Jsus::Package.new("spec/data/ExternalDependencies/app/javascripts/Orwik") }
-    subject { package.source_files[0] }
-    describe "#package" do
-      it "should return the package" do
-        subject.package.should == package
-      end
-    end
-
-    describe "#provides_names" do
-      it "should prepend package name by default and when explicitly asked for long form" do
-        subject.provides_names.should == ["Orwik/Test"]
-        subject.provides_names(:short => false).should == ["Orwik/Test"]
-      end
-
-      it "shouldn't prepend package name in short form" do
-        subject.provides_names(:short => true).should == ["Test"]
-      end
-    end
-
-    describe "#dependencies_names" do
-      it "should prepend package names to inner dependencies by default and when explicitly asked for long form" do
-        subject.should have_exactly(2).dependencies_names
-        subject.dependencies_names.should include("Orwik/Class", "Mash/Mash")
-        subject.should have_exactly(2).dependencies_names(:short => false)
-        subject.dependencies_names(:short => false).should include("Orwik/Class", "Mash/Mash")
-      end
-
-      it "should not prepend package names to inner dependencies in short form" do
-        subject.should have_exactly(2).dependencies_names(:short => true)
-        subject.dependencies_names(:short => true).should include("Class", "Mash/Mash")
-      end
-    end
-
-    describe "#external_dependencies" do
-      it "should include external dependencies" do
-        subject.should have_exactly(1).external_dependencies
-        subject.external_dependencies.should include(Jsus::Tag["Mash/Mash"])
-      end
-
-      it "should not include internal dependencies" do
-        subject.external_dependencies.should_not include(Jsus::Tag["Orwik/Class"])
-      end
-    end
-
-    describe "#external_dependencies_names" do
-      it "should include names of external dependencies" do
-        subject.external_dependencies_names.should include("Mash/Mash")
-      end
-
-      it "should not include names of internal dependencies" do
-        subject.external_dependencies_names.should_not include("Orwik/Class")
-      end
-    end
-
-  end
-
-  context "when pool is not set, " do
-    subject { Jsus::SourceFile.from_file("spec/data/Extensions/app/javascripts/Core/Source/Class.js", :package => Package.new(:name => "Core")) }
-    describe "#pool" do
-      it "should return nil" do
-        subject.pool.should be_nil
-      end
-    end
-
-    describe "#include_extensions!" do
-      it "should do nothing" do
-        lambda {
-          subject.include_extensions!
-        }.should_not change(subject, :extensions)
-      end
-    end
-  end
-
-  context "when pool is set, " do
-    let(:pool) { Jsus::Pool.new("spec/data/Extensions/app/javascripts") }
-    subject { Jsus::SourceFile.from_file("spec/data/Extensions/app/javascripts/Core/Source/Class.js", :pool => pool, :package => Package.new(:name => "Core")) }
-    describe "#pool" do
-      it "should return the pool" do
-        subject.pool.should == pool
-      end
-    end
-
-    context "and there are extensions for subject in its pool, " do
-      describe "#include_extensions!" do
-        it "should add all extensions to @extensions" do
-          subject.extensions.should be_empty
-          subject.include_extensions!
-          subject.extensions.should have_exactly(1).item
-        end
-      end
-    end
-
-    context "and there are no extensions for subject in its pool, " do
-      let(:pool) { Jsus::Pool.new }
-      describe "#include_extensions!" do
-        it "should add all extensions to @extensions" do
-          lambda {
-            subject.include_extensions!
-          }.should_not change(subject, :extensions)
-        end
-      end
-    end
-  end
-
   context "when it is not an extension, " do
     subject { Jsus::SourceFile.from_file("spec/data/Extensions/app/javascripts/Core/Source/Class.js") }
 
@@ -241,51 +111,16 @@ describe Jsus::SourceFile do
     end
   end
 
-  context "when there are no extensions, " do
-    let(:input_dir) { "spec/data/Extensions/app/javascripts" }
-    subject { Jsus::SourceFile.from_file("#{input_dir}/Core/Source/Class.js")}
-
-    describe "#required_files" do
-      it "should have only the filename itself" do
-        subject.required_files.should == [subject.filename]
-      end
-    end
-  end
-
-  context "when there are extensions, " do
-    let(:input_dir) { "spec/data/Extensions/app/javascripts" }
-    let(:extension) { Jsus::SourceFile.from_file("#{input_dir}/Orwik/Extensions/Class.js") }
-    subject { Jsus::SourceFile.from_file("#{input_dir}/Core/Source/Class.js")}
-    let(:initial_content) { subject.content }
-    before(:each) { initial_content; subject.extensions << extension }
-
-    describe "#required_files" do
-      it "should include source_file filename itself" do
-        subject.required_files.should include(subject.filename)
-      end
-
-      it "should include extensions filenames" do
-        subject.required_files.should include(extension.filename)
-      end
-
-      it "should put the subject's filename first" do
-        subject.required_files[0].should == subject.filename
-      end
-    end
-
-    describe "#content" do
-      it "should have extensions applied to the initial file content" do
-        subject.content.should_not == initial_content
-        subject.content.index(initial_content).should_not be_nil
-        subject.content.index(extension.content).should_not be_nil
-        subject.content.index(initial_content).should < subject.content.index(extension.content)
-      end
+  describe "#required_files" do
+    it "should include original source" do
+      subject = described_class.from_file(filename)
+      subject.required_files.should == [File.expand_path(filename)]
     end
   end
 
   it "should allow quirky mooforge dependencies syntax" do
     subject = described_class.from_file("spec/data/mooforge_quirky_source.js")
-    subject.dependencies_names.should == ["MootoolsCore/Core"]
+    subject.dependencies.map {|d| d.to_s }.should == ["MootoolsCore/Core"]
   end
 
   describe "#==, eql, hash" do
@@ -301,4 +136,20 @@ describe Jsus::SourceFile do
       subject.hash.should_not == described_class.from_file("spec/data/Extensions/app/javascripts/Orwik/Extensions/Class.js").hash
     end
   end
+
+  describe "#to_hash" do
+    subject { described_class.from_file(filename, :namespace => "Core") }
+    it "should include shortened provides tags" do
+      subject.to_hash["provides"].should =~ ["Chain", "Events", "Options"]
+    end
+
+    it "should include shortened requirement tags for local dependencies" do
+      subject.to_hash["requires"].should == ["Class"]
+    end
+
+    it "should include full-form requirement tags for external dependencies" do
+      subject = described_class.from_file("spec/data/OutsideDependencies/app/javascripts/Orwik/Source/Widget/Widget.js", :namespace => "Orwik")
+      subject.to_hash["requires"].should == ["Core/Class"]
+    end
+  end
 end