inqlude 0.7.0 → 0.7.1

data/spec/{kde_frameworks_creator_spec.rb → unit/kde_frameworks_creator_spec.rb}

@@ -7,7 +7,7 @@ describe KdeFrameworksCreator do
   describe "#framework" do
     it "raises error on invalid name" do
       c = KdeFrameworksCreator.new
-      expect{c.framework("invalid-name")}.to raise_error
+      expect{c.framework("invalid-name")}.to raise_error(InqludeError)
     end
   end
   
@@ -24,9 +24,9 @@ describe KdeFrameworksCreator do
       }
       k.fill_in_data framework, manifest
       
-      expect( manifest["display_name"] ).to eq "KArchive"
-      expect( manifest["description"] ).to eq "The intro"
-      expect( manifest["urls"]["vcs"] ).to eq "http://git.kde.org/karchive"
+      expect( manifest.display_name ).to eq "KArchive"
+      expect( manifest.description ).to eq "The intro"
+      expect( manifest.urls.vcs ).to eq "http://git.kde.org/karchive"
     end
   end
 
@@ -144,7 +144,7 @@ describe KdeFrameworksCreator do
       
       f = c.framework("ki18n")
       
-      expect( c.errors.count ).to eq 4
+      expect( c.errors.count ).to eq 3
       
       error_hash = {}
       c.errors.each do |error|
@@ -154,7 +154,6 @@ describe KdeFrameworksCreator do
       expect( error_hash.has_key? "missing_title" ).to be true
       expect( error_hash.has_key? "missing_summary" ).to be true
       expect( error_hash.has_key? "missing_introduction" ).to be true
-      expect( error_hash.has_key? "missing_link_home_page" ).to be true
     end
     
     it "generates error for missing summary" do
@@ -173,7 +172,7 @@ describe KdeFrameworksCreator do
       expect( f["title"] ).to eq "KService"
       expect( f["summary"] ).to be nil
       
-      expect( c.errors.count ).to eq 3
+      expect( c.errors.count ).to eq 2
     end
       
     it "optionally doesn't generate error for missing summary" do
@@ -232,13 +231,13 @@ describe KdeFrameworksCreator do
         manifest = Manifest.parse_file File.join(output_dir,"karchive",
           "karchive.manifest")
         
-        expect( manifest["name"] ).to eq "karchive"
-        expect( manifest["display_name"] ).to eq "KArchive"
-        expect( manifest["urls"]["vcs"] ).to eq "https://projects.kde.org/projects/frameworks/karchive/repository"
-        expect( manifest["urls"]["homepage"] ).to eq "https://projects.kde.org/projects/frameworks/karchive"
-        expect( manifest["description"] ).to eq "KArchive provides classes for easy reading, creation and manipulation of\n\"archive\" formats like ZIP and TAR.\n\nIf also provides transparent compression and decompression of data, like the\nGZip format, via a subclass of QIODevice."
-        expect( manifest["urls"]["mailing_list"] ).to eq "https://mail.kde.org/mailman/listinfo/kde-frameworks-devel"
-        expect( manifest["summary"] ).to eq "Reading, creation, and manipulation of file archives"
+        expect( manifest.name ).to eq "karchive"
+        expect( manifest.display_name ).to eq "KArchive"
+        expect( manifest.urls.vcs ).to eq "https://projects.kde.org/projects/frameworks/karchive/repository"
+        expect( manifest.urls.homepage ).to eq "https://projects.kde.org/projects/frameworks/karchive"
+        expect( manifest.description ).to eq "KArchive provides classes for easy reading, creation and manipulation of\n\"archive\" formats like ZIP and TAR.\n\nIf also provides transparent compression and decompression of data, like the\nGZip format, via a subclass of QIODevice."
+        expect( manifest.urls.mailing_list ).to eq "https://mail.kde.org/mailman/listinfo/kde-frameworks-devel"
+        expect( manifest.summary ).to eq "Reading, creation, and manipulation of file archives"
       end
       
       it "overwrites existing manifests" do

data/spec/{kde_frameworks_release_spec.rb → unit/kde_frameworks_release_spec.rb}

@@ -31,8 +31,8 @@ describe KdeFrameworksRelease do
       k.read_generic_manifests
       
       expect( k.generic_manifests.count ).to eq 2
-      expect( k.generic_manifests[0]["name"] ).to eq "karchive"
-      expect( k.generic_manifests[1]["name"] ).to eq "kservice"
+      expect( k.generic_manifests[0].name ).to eq "karchive"
+      expect( k.generic_manifests[1].name ).to eq "kservice"
     end
     
     it "writes release manifests" do
@@ -50,23 +50,27 @@ describe KdeFrameworksRelease do
       expect( File.exists? manifest_path ).to be true
       
       manifest = Manifest.parse_file( manifest_path )
-      expect( manifest["name"] ).to eq "kservice"
-      expect( manifest["version"] ).to eq "4.9.90"
-      expect( manifest["release_date"] ).to eq "2014-02-01"
-      expect( manifest["schema_type"] ).to eq "release"
+      expect(manifest.class).to be ManifestRelease
+      expect( manifest.name ).to eq "kservice"
+      expect( manifest.version ).to eq "4.9.90"
+      expect( manifest.release_date ).to eq "2014-02-01"
     end
   end
 
   it "creates release manifest from generic manifest" do
     generic_manifest = Manifest.parse_file(
       given_file("karchive-generic.manifest") )
-    date = "2014-07-07"
-    version = "5.0.0"
+    date = "2014-11-06"
+    version = "5.4.0"
     release_manifest = KdeFrameworksRelease.create_release_manifest(
       generic_manifest, date, version)
-    expected_json = File.read( given_file("karchive-release.manifest") )
+    expected_json = File.read( given_file("karchive-release-5.4.manifest") )
     expected_json.chomp! # Remove newline added by File.read
-    expect( Manifest.to_json(release_manifest) ).to eq expected_json
+    expect( release_manifest.to_json ).to eq expected_json
+  end
+
+  it "strips patch release" do
+    expect(KdeFrameworksRelease.strip_patch_release("5.4.0")).to eq "5.4"
   end
   
 end

data/spec/{library_spec.rb → unit/library_spec.rb}

@@ -25,8 +25,8 @@ describe Library do
     library = Library.new
     library.manifests = manifests
     
-    expect( library.generic_manifest["name"] ).to eq "mylib"
-    expect( library.generic_manifest["schema_type"] ).to eq "generic"
+    expect( library.generic_manifest.name ).to eq "mylib"
+    expect( library.generic_manifest.class ).to be ManifestGeneric
   end
   
   it "returns relase manifests" do
@@ -40,7 +40,7 @@ describe Library do
     
     expect( library.release_manifests.count ).to eq 2
     library.release_manifests.each do |release_manifest|
-      expect( release_manifest["schema_type"] ).to eq "release"
+      expect( release_manifest.class ).to be ManifestRelease
     end
   end
   
@@ -53,8 +53,8 @@ describe Library do
     library = Library.new
     library.manifests = manifests
     
-    expect( library.latest_manifest["schema_type"] ).to eq "release"
-    expect( library.latest_manifest["version"] ).to eq "1.1"
+    expect( library.latest_manifest.class ).to be ManifestRelease
+    expect( library.latest_manifest.version ).to eq "1.1"
   end
 
   it "returns latest manifest from generic manifest" do
@@ -64,8 +64,8 @@ describe Library do
     library = Library.new
     library.manifests = manifests
     
-    expect( library.latest_manifest["schema_type"] ).to eq "generic"
-    expect( library.latest_manifest["version"] ).to be nil
+    expect( library.latest_manifest.class ).to be ManifestGeneric
+    expect( library.latest_manifest.version ).to be nil
   end
 
 end

data/spec/{manifest_handler_spec.rb → unit/manifest_handler_spec.rb}

@@ -26,14 +26,14 @@ describe ManifestHandler do
   end
 
   it "provides access to manifests" do
-    expect(mh.manifest("awesomelib").class).to be Hash
-    expect { mh.manifest("nonexisting") }.to raise_error
+    expect(mh.manifest("awesomelib")).to be_a Manifest
+    expect { mh.manifest("nonexisting") }.to raise_error(InqludeError)
   end
 
   it "reads schema type" do
-    expect(mh.manifest("awesomelib")["schema_type"]).to eq "release"
-    expect(mh.manifest("newlib")["schema_type"]).to eq "generic"
-    expect(mh.manifest("proprietarylib")["schema_type"]).to eq "proprietary-release"
+    expect(mh.manifest("awesomelib").class).to be ManifestRelease
+    expect(mh.manifest("newlib").class).to be ManifestGeneric
+    expect(mh.manifest("proprietarylib").class).to be ManifestProprietaryRelease
   end
 
   context "default manifest path" do
@@ -63,28 +63,28 @@ describe ManifestHandler do
     it "returns stable libraries" do
       libraries = mh.libraries :stable
       expect( libraries.count ).to eq 2
-      expect( libraries.first.manifests.last["name"] ).to eq "awesomelib"
-      expect( libraries.first.manifests.last["version"] ).to eq "0.2.0"
+      expect( libraries.first.manifests.last.name ).to eq "awesomelib"
+      expect( libraries.first.manifests.last.version ).to eq "0.2.0"
     end
     
     it "returns development versions" do
       libraries = mh.libraries :edge
       expect( libraries.count ).to eq 1
-      expect( libraries.first.manifests.last["name"] ).to eq "bleedingedge"
-      expect( libraries.first.manifests.last["version"] ).to eq "edge"
+      expect( libraries.first.manifests.last.name ).to eq "bleedingedge"
+      expect( libraries.first.manifests.last.version ).to eq "edge"
     end
     
     it "returns unreleased libraries" do
       libraries = mh.unreleased_libraries
       expect( libraries.count ).to eq 1
-      expect( libraries.first.manifests.last["name"] ).to eq "newlib"
+      expect( libraries.first.manifests.last.name ).to eq "newlib"
     end
     
     it "returns commercial libraries" do
       libraries = mh.commercial_libraries
       expect( libraries.count ).to eq 3
-      expect( libraries.first.manifests.last["name"] ).to eq "awesomelib"
-      expect( libraries[1].manifests.last["name"] ).to eq "commercial"
+      expect( libraries.first.manifests.last.name ).to eq "awesomelib"
+      expect( libraries[1].manifests.last.name ).to eq "commercial"
     end
 
   end
@@ -93,7 +93,7 @@ describe ManifestHandler do
     it "returns all libraries of a group" do
       libraries = mh.group("kde-frameworks")
       expect( libraries.count ).to eq 2
-      expect( libraries.first.manifests.last["name"] ).to eq "awesomelib"
+      expect( libraries.first.manifests.last.name ).to eq "awesomelib"
     end
   end
   
@@ -127,15 +127,15 @@ describe ManifestHandler do
     it "reads generic manifest" do
       expect( @manifest_handler.library("karchive").manifests.count ).to eq 2
       generic_manifest = @manifest_handler.library("karchive").generic_manifest
-      expect( generic_manifest["name"] ).to eq "karchive"
-      expect( generic_manifest["schema_type"] ).to eq "generic"
+      expect( generic_manifest.name ).to eq "karchive"
+      expect( generic_manifest.class ).to be ManifestGeneric
     end
     
     it "lists development versions" do
       libraries = @manifest_handler.libraries :beta
       expect( libraries.count ).to eq 1
-      expect( libraries.first.latest_manifest["name"] ).to eq "karchive"
-      expect( libraries.first.latest_manifest["version"] ).to eq "4.9.90"
+      expect( libraries.first.latest_manifest.name ).to eq "karchive"
+      expect( libraries.first.latest_manifest.version ).to eq "4.9.90"
     end
     
     it "lists unreleased libraries" do
@@ -144,4 +144,8 @@ describe ManifestHandler do
     end
   end
   
+  it "generates inqlude-all.json" do
+    expected_json = File.read(test_data_path("inqlude-all.json"))
+    expect(mh.generate_inqlude_all).to eq expected_json
+  end
 end

data/spec/unit/manifest_spec.rb

@@ -0,0 +1,301 @@
+require File.expand_path('../spec_helper', __FILE__)
+
+describe Manifest do
+
+  include_context "manifest_files"
+  
+  it "provides schema identifier" do
+    expect(ManifestRelease.schema_id).to include("inqlude.org")
+    expect(ManifestRelease.schema_id).to include("release")
+
+    expect(ManifestGeneric.schema_id).to include("inqlude.org")
+    expect(ManifestGeneric.schema_id).to include("generic")
+
+    expect(ManifestProprietaryRelease.schema_id).to include("inqlude.org")
+    expect(ManifestProprietaryRelease.schema_id).to include("proprietary")
+  end
+
+  it "returns schema id" do
+    expect(ManifestGeneric.schema_id).to eq(
+      "http://inqlude.org/schema/generic-manifest-v1#")
+    expect(ManifestRelease.schema_id).to eq(
+      "http://inqlude.org/schema/release-manifest-v1#")
+    expect(ManifestProprietaryRelease.schema_id).to eq(
+      "http://inqlude.org/schema/proprietary-release-manifest-v1#")
+  end
+  
+  it "parses schema version" do
+    expect{Manifest.parse_schema_version("xxx")}.to raise_error(InqludeError)
+
+    version = Manifest.parse_schema_version(
+      "http://inqlude.org/schema/release-manifest-v1#" )
+    expect(version).to eq 1
+
+    version = Manifest.parse_schema_version(
+      "http://inqlude.org/schema/release-manifest-v2#" )
+    expect(version).to eq 2
+
+    version = Manifest.parse_schema_version(
+      "http://inqlude.org/schema/generic-manifest-v1#" )
+    expect(version).to eq 1
+  end
+  
+  it "parses release manifest" do
+    filename = File.join settings.manifest_path, awesomelib_manifest_file
+    manifest = Manifest.parse_file filename
+    expect(manifest.class).to be ManifestRelease
+    expect(manifest.name).to eq "awesomelib"
+    expect(manifest.version).to eq "0.2.0"
+
+    expect(manifest.filename).to eq "awesomelib.2013-09-08.manifest"
+    expect(manifest.libraryname).to eq "awesomelib"
+
+    expect(manifest.schema_version).to eq 1
+  end
+
+  it "parses generic manifest" do
+    filename = File.join settings.manifest_path, newlib_manifest_file
+    manifest = Manifest.parse_file filename
+    expect(manifest.class).to be ManifestGeneric
+    expect(manifest.name).to eq "newlib"
+    expect(manifest.version).to eq nil
+
+    expect(manifest.filename).to eq "newlib.manifest"
+
+    expect(manifest.schema_version).to eq 1
+  end
+
+  it "writes JSON for release manifest" do
+    filename = File.join settings.manifest_path, awesomelib_manifest_file
+    manifest = Manifest.parse_file filename
+    expect( manifest.to_json ).to eq File.read( filename )
+  end
+
+  it "writes JSON for generic manifest" do
+    filename = File.join settings.manifest_path, newlib_manifest_file
+    manifest = Manifest.parse_file filename
+    expect( manifest.to_json ).to eq File.read( filename )
+  end
+
+  it "has accessors for all attributes" do
+    m = ManifestRelease.new
+
+    m.name = "Name"
+    expect(m.name).to eq "Name"
+
+    m.release_date = Date.parse("2014-08-11")
+    expect(m.release_date).to eq Date.parse("2014-08-11")
+    expect(m.release_date.to_s).to eq "2014-08-11"
+
+    m.version = "0.7.0"
+    expect(m.version).to eq "0.7.0"
+
+    m.summary = "One-line summary"
+    expect(m.summary).to eq "One-line summary"
+
+    m.urls.homepage = "http://example.com"
+    expect(m.urls.homepage).to eq "http://example.com"
+    m.urls.api_docs = "http://example.com/api"
+    expect(m.urls.api_docs).to eq "http://example.com/api"
+    m.urls.download = "http://example.com/download"
+    expect(m.urls.download).to eq "http://example.com/download"
+    m.urls.vcs = "https://example.com/git"
+    expect(m.urls.vcs).to eq "https://example.com/git"
+    m.urls.tutorial = "http://tutorial.example.com"
+    expect(m.urls.tutorial).to eq "http://tutorial.example.com"
+    m.urls.description_source = "http://wikipedia.de/juhu"
+    expect(m.urls.description_source).to eq "http://wikipedia.de/juhu"
+    m.urls.announcement = "http://cnn.com/headline"
+    expect(m.urls.announcement).to eq "http://cnn.com/headline"
+    m.urls.mailing_list = "mailto:list@example.com"
+    expect(m.urls.mailing_list).to eq "mailto:list@example.com"
+    m.urls.contact = "contact@example.com"
+    expect(m.urls.contact).to eq "contact@example.com"
+
+    m.urls.custom = { "special" => "pointer" }
+    expect(m.urls.custom["special"]).to eq "pointer"
+
+    m.licenses = ["GPLv2", "LGPLv2"]
+    expect(m.licenses).to eq ["GPLv2", "LGPLv2"]
+
+    m.description = "Multi-line description\nwith info."
+    expect(m.description).to eq "Multi-line description\nwith info."
+
+    m.authors = ["Clark Kent <ck@example.com>"]
+    expect(m.authors).to be_a Array
+    expect(m.authors).to eq ["Clark Kent <ck@example.com>"]
+
+    m.maturity = "stable"
+    expect(m.maturity).to eq "stable"
+
+    m.platforms = ["Linux", "Windows"]
+    expect(m.platforms).to eq ["Linux", "Windows"]
+
+    m.packages.source = "http://download.example.com/file"
+    expect(m.packages.source).to eq "http://download.example.com/file"
+
+    m.packages.openSUSE = { "something" => "here" }
+    expect(m.packages.openSUSE).to eq( { "something" => "here" } )
+
+    m.group = "kde-frameworks"
+    expect(m.group).to eq "kde-frameworks"
+  end
+
+  it "constructs object from schema id" do
+    m = Manifest.new(ManifestRelease.schema_id)
+    expect(m.schema_version).to eq 1
+  end
+
+  it "returns descendants" do
+    expect(Manifest.descendants).to be_a(Array)
+    expect(Manifest.descendants.count).to be >= 3
+    expect(Manifest.descendants).to include ManifestGeneric
+    expect(Manifest.descendants).to include ManifestRelease
+  end
+
+  it "contructs generic manifest from schema id" do
+    expect(Manifest.for_schema_id(ManifestGeneric.schema_id)).to(
+      be_a ManifestGeneric)
+  end
+
+  it "contructs release manifest from schema id" do
+    expect(Manifest.for_schema_id(ManifestRelease.schema_id)).to(
+      be_a ManifestRelease)
+  end
+
+  it "contructs proprietary release manifest from schema id" do
+    expect(Manifest.for_schema_id(ManifestProprietaryRelease.schema_id)).to(
+      be_a ManifestProprietaryRelease)
+  end
+
+  describe ".is_released?" do
+    it "returns release state for generic manifest without commercial license" do
+      expect(ManifestGeneric.new.is_released?).to be false
+    end
+
+    it "returns release state for generic manifest with only commercial license" do
+      manifest = ManifestGeneric.new
+      manifest.licenses = ["Commercial"]
+      expect(manifest.is_released?).to be true
+    end
+
+    it "returns release state for generic manifest with additional commercial license" do
+      manifest = ManifestGeneric.new
+      manifest.licenses = ["Commercial", "GPLv2"]
+      expect(manifest.is_released?).to be false
+    end
+
+    it "returns release state for release manifest" do
+      expect(ManifestRelease.new.is_released?).to be true
+    end
+
+    it "returns release state for proprietary release manifest" do
+      expect(ManifestProprietaryRelease.new.is_released?).to be true
+    end
+  end
+
+  describe ".path" do
+    it "returns generic manifest path" do
+      manifest = create_generic_manifest( "mylib" )
+      expect( manifest.path ).to eq( "mylib/mylib.manifest" )
+    end
+
+    it "returns release manifest path" do
+      manifest = create_manifest( "mylib", "2014-02-01", "1.0" )
+      expect( manifest.path ).to eq( "mylib/mylib.2014-02-01.manifest" )
+    end
+  end
+
+  describe ".expected_filename" do
+    it "returns expected filename for generic manifest" do
+      m = ManifestGeneric.new
+      m.name = "xyz"
+
+      expect(m.expected_filename).to eq "xyz.manifest"
+    end
+
+    it "returns expected filename for release manifest" do
+      m = ManifestRelease.new
+      m.name = "xyz"
+      m.release_date = "2014-08-14"
+
+      expect(m.expected_filename).to eq "xyz.2014-08-14.manifest"
+    end
+
+    it "returns expected filename for proprietary release manifest" do
+      m = ManifestProprietaryRelease.new
+      m.name = "xyz"
+      m.release_date = "2014-08-14"
+
+      expect(m.expected_filename).to eq "xyz.2014-08-14.manifest"
+    end
+  end
+
+  describe ".schema_name" do
+    it "returns expected schema name for generic manifest" do
+      m = ManifestGeneric.new
+      expect(m.schema_name).to eq "generic-manifest-v1"
+    end
+
+    it "returns expected schema name for release manifest" do
+      m = ManifestRelease.new
+      expect(m.schema_name).to eq "release-manifest-v1"
+    end
+
+    it "returns expected schema name for proprietary release manifest" do
+      m = ManifestProprietaryRelease.new
+      expect(m.schema_name).to eq "proprietary-release-manifest-v1"
+    end
+  end
+
+  describe ".has_version?" do
+    it "returns if generic manifest has version" do
+      expect(ManifestGeneric.new.has_version?).to be false
+    end
+
+    it "returns if release manifest has version" do
+      expect(ManifestGeneric.new.has_version?).to be false
+    end
+
+    it "returns if proprietary release manifest has version" do
+      expect(ManifestGeneric.new.has_version?).to be false
+    end
+  end
+
+  describe ".create_release_manifest" do
+    it "copies all data" do
+      generic = ManifestGeneric.new
+      generic.name = "MyLib"
+      generic.summary = "My Lib"
+      generic.urls.homepage = "http://example.com"
+      generic.urls.download = "http://example.com/download"
+      generic.licenses = ["LGPLv2.1+", "Commercial"]
+      generic.description = "My Library"
+      generic.authors = "Cornelius Schumacher <schumacher@kde.org>"
+      generic.maturity = "stable"
+      generic.platforms = ["Linux"]
+      generic.packages.source = "ftp://example.com"
+      generic.group = "magic"
+
+      release = generic.create_release_manifest("2014-08-17", "1.0")
+
+      expect(release.name).to eq "MyLib"
+      expect(release.summary).to eq "My Lib"
+      expect(release.urls.homepage).to eq "http://example.com"
+      expect(release.urls.download).to eq "http://example.com/download"
+      expect(release.licenses).to eq ["LGPLv2.1+", "Commercial"]
+      expect(release.description).to eq "My Library"
+      expect(release.authors).to eq "Cornelius Schumacher <schumacher@kde.org>"
+      expect(release.maturity).to eq "stable"
+      expect(release.platforms).to eq ["Linux"]
+      expect(release.packages.source).to eq "ftp://example.com"
+      expect(release.group).to eq "magic"
+
+      expect(release.release_date).to eq "2014-08-17"
+      expect(release.version).to eq "1.0"
+    end
+
+    it "sets release_date and version" do
+    end
+  end
+end