gjp 0.5.0

data/.gitignore

@@ -0,0 +1,21 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# SPEC generated files
+spec/data/tomcat/org.apache.tomcat\:tomcat\:7.0.40
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# See gjp.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,40 @@
+PATH
+  remote: .
+  specs:
+    gjp (0.5.0)
+      clamp
+      json
+      nokogiri
+      rest-client
+      rubyzip
+      text
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    clamp (0.6.1)
+    diff-lcs (1.2.4)
+    json (1.8.0)
+    mime-types (1.23)
+    nokogiri (1.5.9)
+    rake (10.0.4)
+    rest-client (1.6.7)
+      mime-types (>= 1.16)
+    rspec (2.13.0)
+      rspec-core (~> 2.13.0)
+      rspec-expectations (~> 2.13.0)
+      rspec-mocks (~> 2.13.0)
+    rspec-core (2.13.1)
+    rspec-expectations (2.13.0)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.13.1)
+    rubyzip (0.9.9)
+    text (1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  gjp!
+  rake
+  rspec

data/README.md

@@ -0,0 +1,30 @@
+gjp – Green Java Packager's tools
+===
+
+`gjp` (pronounced _/ˈdʒiː ˈaɪ ˈd͡ʒəʊ/_) is a set of tools to ease and partially automate Linux packaging of Java projects.
+
+The project focus is on producing rpm packages for SUSE distributions, but it is general enough to be useful even for other distributions.
+
+
+## Install
+
+Easiest install is via RubyGems:
+
+    $ gem install gjp
+
+## Usage
+
+Currently available tools:
+* `gjp get-pom PATH` will attempt to find an artifact's pom.xml, if it exists (from the package itself or through search.maven.org)
+* `gjp get-source-address PATH` will attempt to find the SCM address of an artifact from its pom.xml (from the pom.xml itself or through api.github.com)
+* `gjp get-source PATH ADDRESS` downloads the source of a pom.xml's project from its SCM at ADDRESS
+
+## Source
+
+`gjp`'s Git repo is available on GitHub, which can be browsed at:
+
+    https://github.com/SilvioMoioli/gjp
+
+and cloned with:
+
+    git clone git@github.com:SilvioMoioli/gjp.git

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new
+
+task :default => :test
+task :test => :spec

data/bin/gjp

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+#
+# The (open)?SUSE ((Linux Enterprise) (Server|Desktop))?'s
+# packager Swiss Army Knife.
+#
+# Copyright 2013 Silvio Moioli <smoioli@suse.de>
+#
+# Inspired mainly by pom2spec by:
+#  Pascal Bleser <pascal.bleser@opensuse.org>
+#  Duncan Mac-Vicar Prett <dmacvicar@suse.de>
+#
+# This file is licensed under the
+# GNU Lesser General Public License version 2.1 or later:
+# http://www.gnu.org/licenses/lgpl-2.1.html
+#
+
+begin
+  require 'gjp'
+rescue LoadError
+  require 'rubygems'
+  require 'gjp'
+end
+
+MainCommand.run

data/gjp.gemspec

@@ -0,0 +1,30 @@
+# encoding: UTF-8
+$:.push File.expand_path("../lib", __FILE__)
+require "gjp/version"
+
+Gem::Specification.new do |s|
+  s.name = "gjp"
+  s.version = Gjp::VERSION
+  s.authors = ["Silvio Moioli"]
+  s.email = ["smoioli@suse.de"]
+  s.homepage = "https://github.com/SilvioMoioli/gjp"
+  s.summary = "Green Java Packager's Tools"
+  s.description = "A suite of tools to ease Java packaging in SUSE systems"
+
+  s.rubyforge_project = "gjp"
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  
+  s.add_runtime_dependency "clamp"
+  s.add_runtime_dependency "rubyzip"
+  s.add_runtime_dependency "rest-client"
+  s.add_runtime_dependency "json"
+  s.add_runtime_dependency "text"
+  s.add_runtime_dependency "nokogiri"
+end

data/lib/gjp.rb

@@ -0,0 +1,7 @@
+require "gjp/version"
+require "gjp/logger"
+require "gjp/cli"
+require "gjp/pom"
+require "gjp/get_pom"
+require "gjp/get_source_address"
+require "gjp/get_source"

data/lib/gjp/cli.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+require "clamp"
+
+class MainCommand < Clamp::Command
+  subcommand "get-pom", "Retrieves a pom corresponding to a jar" do
+    parameter "JAR", "jar file path"
+    option ["-v", "--verbose"], :flag, "verbose output"
+    option ["--very-verbose"], :flag, "very verbose output"
+    option ["--very-very-verbose"], :flag, "very very verbose output"
+
+    def execute
+      begin
+        init_logger    
+        puts PomGetter.get_pom(jar)
+      rescue Zip::ZipError
+        $stderr.puts "#{jar} does not seem to be a valid jar archive, skipping"
+      rescue TypeError
+        $stderr.puts "#{jar} seems to be a valid jar archive but is corrupt, skipping"
+      rescue RestClient::ResourceNotFound
+        $stderr.puts "Got an error while looking for #{jar} in search.maven.org" 
+      end
+    end
+  end
+    
+  subcommand "get-source-address", "Retrieves a project's SCM Internet address" do
+    parameter "POM", "project's pom file path"
+    option ["-v", "--verbose"], :flag, "verbose output"
+    option ["--very-verbose"], :flag, "very verbose output"
+    option ["--very-very-verbose"], :flag, "very very verbose output"
+
+    def execute
+      init_logger
+      puts SourceAddressGetter.get_source_address(pom)
+    end    
+  end
+  
+  subcommand "get-source", "Retrieves a project's source code directory" do
+    parameter "ADDRESS", "project's SCM Internet address"
+    parameter "POM", "project's pom file path"
+    parameter "[DIRECTORY]", "directory in which to save the source code", :default => "."
+    option ["-v", "--verbose"], :flag, "verbose output"
+    option ["--very-verbose"], :flag, "very verbose output"
+    option ["--very-very-verbose"], :flag, "very very verbose output"
+
+    def execute
+      init_logger
+      puts SourceGetter.get_source(address, pom, directory)
+    end    
+  end
+end

data/lib/gjp/get_pom.rb

@@ -0,0 +1,158 @@
+# encoding: UTF-8
+
+require "digest/sha1"
+require "zip/zip"
+require "rest_client"
+require "json"
+require "text"
+require "pathname"
+
+# implements the get-pom subcommand
+class PomGetter
+
+  # returns the pom corresponding to a file or directory, if it can be found
+  def self.get_pom(file)
+    (get_pom_from_dir(file) or get_pom_from_jar(file) or get_pom_from_sha1(file) or get_pom_from_heuristic(file))
+  end
+
+  # returns the pom in a project directory
+  def self.get_pom_from_dir(dir)
+    if File.directory?(dir)
+      pom_path = File.join(dir, "pom.xml")
+      if File.file?(pom_path)
+          $log.info("pom.xml found in #{dir}/pom.xml")
+          return File.read(pom_path)
+      end
+    end
+  end
+  
+  # returns a pom embedded in a jar file
+  def self.get_pom_from_jar(file)
+    Zip::ZipFile.foreach(file) do |entry|
+      if entry.name =~ /\/pom.xml$/
+        $log.info("pom.xml found in #{file}##{entry.name}")
+        return entry.get_input_stream.read
+      end
+    end
+    return nil
+  end
+  
+  # returns a pom from search.maven.org with a jar sha1 search
+  def self.get_pom_from_sha1(file)
+    sha1 = Digest::SHA1.hexdigest File.read(file)
+    results = repository_search({:q => "1:\"#{sha1}\""}).select {|result| result["ec"].include?(".pom")}
+    result = results.first    
+    if result != nil
+      $log.info("pom.xml for #{file} found on search.maven.org for sha1 #{sha1} (#{result["g"]}:#{result["a"]}:#{result["v"]})")
+      return repository_download(result)
+    end
+  end
+
+  # returns a pom from search.maven.org with a heuristic name search
+  def self.get_pom_from_heuristic(file)
+    filename = Pathname.new(file).basename.to_s
+    matches = filename.match(/([^\/]*?)(?:[\.\-\_ ~,]([0-9].*))?\.jar$/)
+    if matches != nil and matches.length > 1
+      my_artifact_id = matches[1]
+      my_version = matches[2]
+      result = repository_search({:q => my_artifact_id}).first
+      if result != nil
+          results = repository_search({:q => "g:\"#{result["g"]}\" AND a:\"#{result["a"]}\"", :core => "gav"})
+          their_versions = results.map {|doc| doc["v"]}
+          best_matched_version = if my_version != nil then best_match(my_version, their_versions) else their_versions.max end
+          best_matched_result = (results.select{|result| result["v"] == best_matched_version}).first
+          
+          $log.warn("pom.xml for #{file} found on search.maven.org with heuristic search (#{best_matched_result["g"]}:#{best_matched_result["a"]}:#{best_matched_result["v"]})")
+          
+          return repository_download(best_matched_result)
+      end
+   end
+  end
+  
+  # returns a JSON result from search.maven.com
+  def self.repository_search(params)
+    response = RestClient.get "http://search.maven.org/solrsearch/select", {:params => params.merge({"rows" => "100", "wt" => "json"})}
+    json = JSON.parse(response.to_s)
+    return json["response"]["docs"]
+  end
+  
+  # downloads a POM from a search.maven.com search result
+  def self.repository_download(result)
+    if result != nil
+      path = "#{result["g"].gsub(".", "/")}/#{result["a"]}/#{result["v"]}/#{result["a"]}-#{result["v"]}.pom"
+      return (RestClient.get "http://search.maven.org/remotecontent", {:params => {:filepath => path}}).to_s
+    end
+  end
+  
+  # returns the "best match" between a version number and a set of available version numbers
+  # using a heuristic criterion. Idea:
+  #  - split the version number in chunks divided by ., - etc.
+  #  - every chunk with same index is "compared", differences make up a score
+  #  - "comparison" is a subtraction if the chunk is an integer, a string distance measure otherwise
+  #  - score weighs differently on chunk index (first chunks are most important)
+  #  - lowest score wins
+  def self.best_match(my_version, their_versions)
+    $log.debug("version comparison: #{my_version} vs #{their_versions.join(', ')}")
+  
+    my_chunks = my_version.split /[\.\-\_ ~,]/
+    their_chunks_hash = Hash[
+      their_versions.map do |their_version|
+        their_chunks_for_version = their_version.split /[\.\-\_ ~,]/
+        their_chunks_for_version += [nil]*[my_chunks.length - their_chunks_for_version.length, 0].max
+        [their_version, their_chunks_for_version]
+      end
+    ]
+    
+    max_chunks_length = ([my_chunks.length] + their_chunks_hash.values.map {|chunk| chunk.length}).max
+    
+    scoreboard = []
+    their_versions.each do |their_version|
+      their_chunks = their_chunks_hash[their_version]
+      score = 0
+      their_chunks.each_with_index do |their_chunk, i|
+        score_multiplier = 100**(max_chunks_length -i -1)
+        my_chunk = my_chunks[i]
+        score += chunk_distance(my_chunk, their_chunk) * score_multiplier
+      end
+      scoreboard << {:version => their_version, :score => score}
+    end
+    
+    scoreboard = scoreboard.sort_by {|element| element[:score]}
+
+    $log.debug("scoreboard: ")
+    scoreboard.each_with_index do |element, i|
+      $log.debug("  #{i+1}. #{element[:version]} (score: #{element[:score]})")
+    end
+    
+    winner = scoreboard.first
+    
+    if winner != nil
+      return winner[:version]
+    end
+  end
+  
+  # returns a score representing the distance between two version chunks
+  # for integers, the score is the difference between their values
+  # for strings, the score is the Levenshtein distance
+  # in any case score is normalized between 0 (identical) and 99 (very different/uncomparable)
+  def self.chunk_distance(my_chunk, their_chunk)
+    if my_chunk == nil
+      my_chunk = "0"
+    end
+    if their_chunk == nil
+      their_chunk = "0"
+    end
+    if my_chunk.is_i? and their_chunk.is_i?
+      return [(my_chunk.to_i - their_chunk.to_i).abs, 99].min
+    else
+      return [Text::Levenshtein.distance(my_chunk.upcase, their_chunk.upcase), 99].min
+    end
+  end
+end
+
+class String
+  def is_i?
+    !!(self =~ /^[0-9]+$/)
+  end
+end
+

data/lib/gjp/get_source.rb

@@ -0,0 +1,29 @@
+# encoding: UTF-8
+
+require "rest_client"
+
+# implements the get-source subcommand
+class SourceGetter
+
+  # downloads a project's source into a specified directory
+  def self.get_source(address, pomfile, directory)
+    $log.info("downloading: #{address} in #{directory}, pomfile: #{pomfile}")
+    
+    dummy, prefix, scm_address = address.split(/^([^:]+):(.*)$/)
+    
+    $log.info("prefix: #{prefix}, scm_address: #{scm_address}")
+        
+    if prefix == "git"
+      get_source_from_git(scm_address, pomfile, directory)
+    end
+  end
+
+  # checks out from git
+  def self.get_source_from_git(scm_address, pomfile, directory)
+    pom = Pom.new(pomfile)
+    dir = File.join(directory, "#{pom.group_id}:#{pom.artifact_id}:#{pom.version}")
+    
+    Dir::mkdir(dir)
+    `git clone #{scm_address} #{dir}`
+  end
+end

data/lib/gjp/get_source_address.rb

@@ -0,0 +1,48 @@
+# encoding: UTF-8
+
+require "rest_client"
+require "json"
+require "open-uri"
+
+# implements the get-source-address subcommand
+class SourceAddressGetter
+
+  # returns the pom corresponding to a file or directory, if it can be found
+  def self.get_source_address(file)
+    $log.info("looking for source address for: #{file}")
+    (get_source_address_from_pom(file) or get_source_address_from_github(file))
+  end
+
+  # returns an scm address in a pom file
+  def self.get_source_address_from_pom(file)
+    pom = Pom.new(file)
+    result = pom.connection_address
+
+    if result != nil
+      $log.info("address found in pom")
+      result
+    end
+  end
+  
+  # returns an scm address looking for it on github
+  def self.get_source_address_from_github(file)
+    pom = Pom.new(file)
+
+    result = (github_search(pom.artifact_id) or github_search(pom.artifact_id.split("-").first) or github_search(pom.group_id))
+    
+    if result != nil
+      $log.info("address found on Github: #{result}")
+      result
+    end
+  end
+  
+  # returns a Giuthub repo address based on the keyword
+  def self.github_search(keyword)
+    if keyword != "" and keyword != nil
+      response = RestClient.get "https://api.github.com/legacy/repos/search/" + CGI::escape(keyword), :user_agent => "gjp/" + Gjp::VERSION, :language => "java", :sort => "forks"
+      json = JSON.parse(response.to_s)
+    
+      (json["repositories"].map {|repository| "git:" + repository["url"]}).first
+    end
+  end
+end