inqlude 0.7.0 → 0.7.1

data/lib/json_object.rb

@@ -0,0 +1,104 @@
+class JsonObject
+
+  def self.attribute(name, &block)
+    define_method("#{name}=") do |value|
+      @values[name] = value
+      @valid[name] = true
+    end
+
+    @keys ||= Hash.new
+
+    if block_given?
+      define_method("#{name}") do
+        return @values[name]
+      end
+
+      nested_class = self.const_set(name.to_s.capitalize, Class.new(JsonObject))
+      nested_class.class_exec(&block)
+      type = nested_class
+    else
+      define_method("#{name}") do
+        if @valid[name]
+          return @values[name]
+        else
+          return nil
+        end
+      end
+
+      type = nil
+    end
+    @keys[name] = type
+  end
+
+  def self.keys
+    @keys
+  end
+
+  def self.all_keys
+    keys = Hash.new
+    klass = self
+    while(klass != JsonObject) do
+      if klass.keys
+        keys.merge!(klass.keys)
+      end
+      klass = klass.superclass
+    end
+    keys
+  end
+
+  attr_accessor :schema_id
+
+  def initialize
+    @values = Hash.new
+    self.class.all_keys.each do |key,value|
+      if value
+        @values[key] = value.new
+      end
+    end
+    @valid = Hash.new
+  end
+
+  def valid?
+    !@valid.empty?
+  end
+
+  def from_hash(hash)
+    hash.each do |key, value|
+      next if key == "$schema"
+      type = self.class.all_keys[key.to_sym]
+      value = hash[key]
+      if type
+        nested_object = send("#{key}")
+        nested_object.from_hash(value)
+      else
+        send("#{key}=", value)
+      end
+    end
+    self
+  end
+
+  def from_json(json_string)
+    from_hash(JSON(json_string))
+  end
+
+  def to_hash
+    hash = Hash.new
+    if schema_id
+      hash["$schema"] = schema_id
+    end
+    self.class.all_keys.each do |attribute,type|
+      value = @values[attribute]
+      if type && value.valid?
+        hash[attribute] = value.to_hash
+      elsif @valid[attribute]
+        hash[attribute] = value
+      end
+    end
+    hash
+  end
+
+  def to_json
+    JSON.pretty_generate(to_hash)
+  end
+
+end

data/lib/kde_frameworks_creator.rb

@@ -42,7 +42,7 @@ class KdeFrameworksCreator
   
   def framework name
     f = @frameworks[name]
-    raise "Unable to read '#{name}'" if !f
+    raise InqludeError.new("Unable to read '#{name}'") if !f
     f
   end
   
@@ -52,6 +52,10 @@ class KdeFrameworksCreator
     name = extract_name( path )
     framework = @frameworks[name] || {}
 
+    framework["link_home_page"] = "https://projects.kde.org/projects/frameworks/#{name}"
+    framework["link_mailing_list"] = "https://mail.kde.org/mailman/listinfo/kde-frameworks-devel"
+    framework["link_git_repository"] = "https://projects.kde.org/projects/frameworks/#{name}/repository"
+
     state = nil
     File.open(File.join(path,"README.md")).each_line do |line|
       if line =~ /^# (.*)/
@@ -160,14 +164,14 @@ class KdeFrameworksCreator
   end
   
   def fill_in_data framework, manifest
-    manifest["display_name"] = framework["title"]
-    manifest["summary"] = framework["summary"]
-    manifest["description"] = framework["introduction"]
-    manifest["urls"]["vcs"] = framework["link_git_repository"]
-    manifest["urls"]["homepage"] = framework["link_home_page"]
-    manifest["urls"]["mailing_list"] = framework["link_mailing_list"]
-    manifest["licenses"] = [ "LGPLv2.1+" ]
-    manifest["authors"] = [ "The KDE Community" ]
-    manifest["group"] = "kde-frameworks"
+    manifest.display_name = framework["title"]
+    manifest.summary = framework["summary"]
+    manifest.description = framework["introduction"]
+    manifest.urls.vcs = framework["link_git_repository"]
+    manifest.urls.homepage = framework["link_home_page"]
+    manifest.urls.mailing_list = framework["link_mailing_list"]
+    manifest.licenses = [ "LGPLv2.1+" ]
+    manifest.authors = [ "The KDE Community" ]
+    manifest.group = "kde-frameworks"
   end
 end

data/lib/kde_frameworks_release.rb

@@ -22,19 +22,20 @@ class KdeFrameworksRelease
     @handler = handler
   end
   
+  def self.strip_patch_release(version)
+    version =~ /^(\d+\.\d+)\./
+    $1
+  end
+
   def self.create_release_manifest generic_manifest, release_date, version
-    m = generic_manifest
-    name = m["name"]
-    download_url = "http://download.kde.org/stable/frameworks/#{version}/"
-    m["$schema"] = Manifest.release_schema_id
-    m["schema_type"] = "release"
-    m["urls"]["download"] = download_url
-    m["maturity"] = "stable"
-    m["release_date"] = release_date
-    m["version"] = version
-    m["packages"] = {
-      "source" => "#{download_url}#{name}-#{version}.tar.xz"
-    }
+    m = generic_manifest.create_release_manifest(release_date, version)
+
+    version_dir = strip_patch_release(version)
+
+    download_url = "http://download.kde.org/stable/frameworks/#{version_dir}/"
+    m.urls.download = download_url
+    m.maturity = "stable"
+    m.packages.source = "#{download_url}#{m.name}-#{version}.tar.xz"
     m
   end
 
@@ -53,7 +54,7 @@ class KdeFrameworksRelease
         generic_manifest, release_date, version )
       path = @handler.manifest_path( release_manifest )
       File.open( path, "w" ) do |file|
-        file.write Manifest.to_json( release_manifest )
+        file.write release_manifest.to_json
       end
     end    
   end

data/lib/library.rb

@@ -4,12 +4,12 @@ class Library
   attr_accessor :manifests
 
   def versions
-    versions = release_manifests.map { |m| m["version"] }
+    versions = release_manifests.map { |m| m.version }
   end
   
   def generic_manifest
     @manifests.each do |m|
-      if m["schema_type"] == "generic"
+      if m.is_a?(ManifestGeneric)
         return m
       end
     end
@@ -17,9 +17,9 @@ class Library
   end
 
   def release_manifests
-    result = @manifests.reject { |m| m["schema_type"] == "generic" }
+    result = @manifests.reject { |m| m.is_a?(ManifestGeneric) }
     result.sort! do |m1,m2|
-      m1["release_date"] <=> m2["release_date"]
+      m1.release_date <=> m2.release_date
     end
     result
   end

data/lib/manifest.rb

@@ -1,43 +1,180 @@
-class Manifest
+class Manifest < JsonObject
 
-  def self.generic_schema_id
+  def self.descendants
+    ObjectSpace.each_object(::Class).select { |klass| klass < self }
+  end
+
+  def self.for_schema_id schema_id
+    descendants.each do |manifest_class|
+      if schema_id == manifest_class.schema_id
+        return manifest_class.new
+      end
+    end
+    raise VerificationError.new("Unknown schema id '#{schema_id}'")
+  end
+
+  def self.parse_file path
+    json = JSON File.read path
+    manifest = Manifest.for_schema_id(json["$schema"])
+    manifest.filename = File.basename path
+    manifest.filename =~ /^(.*?)\./
+    manifest.libraryname = $1
+
+    manifest.from_hash(json)
+  end
+  
+  def self.parse_schema_version schema_id
+    schema_id =~ /^http:\/\/inqlude\.org\/schema\/(.*)-manifest-v(.*)\#$/
+    type = $1
+    version = $2.to_i
+    if !type || !version
+      raise InqludeError.new("Unable to parse schema id '{schema_id}'")
+    end
+    version
+  end
+
+  attribute :name
+  attribute :display_name
+  attribute :release_date
+  attribute :version
+  attribute :summary
+  attribute :urls do
+    attribute :homepage
+    attribute :api_docs
+    attribute :download
+    attribute :tutorial
+    attribute :vcs
+    attribute :description_source
+    attribute :announcement
+    attribute :mailing_list
+    attribute :contact
+    attribute :custom
+  end
+  attribute :licenses
+  attribute :description
+  attribute :authors
+  attribute :maturity
+  attribute :platforms
+  attribute :packages do
+    attribute :source
+    attribute :openSUSE
+    attribute :windows
+    attribute :ubuntu
+  end
+  attribute :group
+
+  attr_reader :schema_version
+
+  attr_accessor :filename, :libraryname
+
+  def initialize(schema_id)
+    @schema_id = schema_id
+    @schema_version = Manifest.parse_schema_version(schema_id)
+    super()
+  end
+
+  def schema_name
+    regexp = /Manifest([A-Z][a-z]*)([A-Z][a-z]*)?/
+    match = regexp.match(self.class.to_s)
+    if !match
+      raise "Class '#{self.class} is not a Manifest sub class"
+    end
+    schema_type = match[1].downcase
+    if match[2]
+      schema_type += "-" + match[2].downcase
+    end
+    "#{schema_type}-manifest-v#{schema_version}"
+  end
+
+  def path
+    File.join( name, expected_filename )
+  end
+end
+
+class ManifestGeneric < Manifest
+  def self.schema_id
     "http://inqlude.org/schema/generic-manifest-v1#"
   end
 
-  def self.release_schema_id
+  def initialize
+    super(ManifestGeneric.schema_id)
+  end
+
+  def expected_filename
+    "#{name}.manifest"
+  end
+
+  def is_released?
+    # Purely commercial libraries often don't have release information publicly
+    # available, so we treat them as released, even, if the manifest only has
+    # generic data.
+    if licenses == ["Commercial"]
+      return true
+    else
+      return false
+    end
+  end
+
+  def has_version?
+    false
+  end
+
+  def create_release_manifest(release_date, version)
+    m = ManifestRelease.new
+    ManifestGeneric.all_keys.each do |key, type|
+      value = send("#{key}")
+      if value
+        m.send("#{key}=", value)
+      end
+    end
+
+    m.release_date = release_date
+    m.version = version
+    m
+  end
+end
+
+class ManifestRelease < Manifest
+  def self.schema_id
     "http://inqlude.org/schema/release-manifest-v1#"
   end
 
-  def self.proprietary_release_schema_id
+  def initialize
+    super(ManifestRelease.schema_id)
+  end
+
+  def expected_filename
+    "#{name}.#{release_date}.manifest"
+  end
+
+  def is_released?
+    return true
+  end
+
+  def has_version?
+    true
+  end
+end
+
+class ManifestProprietaryRelease < Manifest
+  def self.schema_id
     "http://inqlude.org/schema/proprietary-release-manifest-v1#"
   end
 
-  def self.parse_file path
-    manifest = JSON File.read path
-    filename = File.basename path
-    manifest["filename"] = filename
-    filename =~ /^(.*?)\./
-    manifest["libraryname"] = $1
-    manifest["schema_type"],manifest["schema_version"] =
-      Manifest.parse_schema_id manifest["$schema"]
-    manifest
+  def initialize
+    super(ManifestProprietaryRelease.schema_id)
   end
-  
-  def self.to_json manifest
-    m = manifest.clone
-    m.delete "filename"
-    m.delete "libraryname"
-    m.delete "schema_type"
-    m.delete "schema_version"
-    JSON.pretty_generate m
+
+  def expected_filename
+    "#{name}.#{release_date}.manifest"
   end
-  
-  def self.parse_schema_id schema_id
-    schema_id =~ /^http:\/\/inqlude\.org\/schema\/(.*)-manifest-v(.*)\#$/
-    type = $1
-    version = $2.to_i
-    raise "Unable to parse schema id '{schema_id}'" if !type || !version
-    return type, version
+
+  def is_released?
+    return true
   end
 
+  def has_version?
+    true
+  end
 end
+

data/lib/manifest_handler.rb

@@ -26,13 +26,7 @@ class ManifestHandler
   end
 
   def manifest_path manifest
-    if manifest["schema_type"] == "release"
-      return File.join( @settings.manifest_path, manifest["name"],
-        "#{manifest["name"]}.#{manifest["release_date"]}.manifest" )
-    else
-      return File.join( @settings.manifest_path, manifest["name"],
-        "#{manifest["name"]}.manifest" )
-    end
+    File.join(@settings.manifest_path, manifest.path)
   end
 
   def libraries maturity = nil
@@ -41,31 +35,29 @@ class ManifestHandler
     else
       return @libraries.select do |l|
         manifest = l.latest_manifest
-        manifest["maturity"] == maturity.to_s &&
-            manifest["licenses"] != [ "Commercial" ]
+        manifest.maturity == maturity.to_s &&
+          manifest.licenses != [ "Commercial" ]
       end
     end
   end
 
   def unreleased_libraries
     return @libraries.select do |l|
-      manifest = l.latest_manifest
-      manifest["schema_type"] == "generic" &&
-          manifest["licenses"] != [ "Commercial" ]
+      !l.latest_manifest.is_released?
     end
   end
   
   def commercial_libraries
     return @libraries.select do |l|
       manifest = l.latest_manifest
-      manifest["licenses"].include? "Commercial"
+      manifest.licenses.include? "Commercial"
     end
   end
   
   def group name
     return @libraries.select do |l|
       manifest = l.latest_manifest
-      manifest["group"] == name
+      manifest.group == name
     end
   end
   
@@ -79,13 +71,12 @@ class ManifestHandler
   end
   
   def manifest name
-    read_remote
     @libraries.each do |library|
       if library.name == name
         return library.latest_manifest
       end
     end
-    raise "Unable to find manifest '#{name}'"
+    raise InqludeError.new("Unable to find manifest '#{name}'")
   end
 
   def read_remote
@@ -125,4 +116,11 @@ class ManifestHandler
     end
   end
 
+  def generate_inqlude_all
+    all = []
+    libraries.each do |l|
+      all.push(l.latest_manifest.to_hash)
+    end
+    JSON.pretty_generate(all)
+  end
 end