gjp 0.9.0 → 0.10.0

data/README.md

@@ -19,6 +19,7 @@ Currently available tools:
 * `gjp get-parent-pom POM` will attempt to download a pom's parent from search.maven.org, where `POM` is a filename or URI;
 * `gjp get-source-address POM` will attempt to find the SCM Internet address of a pom.xml from the file itself or through api.github.com. `POM` can either be a filename or a URI;
 * `gjp get-source POM ADDRESS` downloads the source of a pom.xml's project from its SCM at ADDRESS;
+* `gjp scaffold-jar-table DIRECTORY` looks for jars in the project's DIRECTORY and classifies them as build-time dependencies (b), run-time dependencies (r) or products (p);
 
 ## Source
 

data/lib/gjp/cli.rb

@@ -77,9 +77,10 @@ module Gjp
 
     subcommand "scaffold-jar-table", "Creates a heuristic version of a project's jar table" do
       parameter "[DIRECTORY]", "project directory", :default => "."
+      option ["--include-all"], :flag, "include tests and samples in produced jars", :default => false
 
       def execute
-        puts Gjp::JarTable.new(directory).to_s
+        puts Gjp::JarTable.new(directory, include_all?).to_s
       end    
     end
   end

data/lib/gjp/jar_table.rb

@@ -7,19 +7,26 @@ module Gjp
   # assumes the project is in a directory with jar files
   # in its (possibly nested) subdirectories
   class JarTable
-    def self.log
+    def log
       Gjp.logger
     end
 
-    attr_reader :dir, :rows
+    attr_reader :rows, :runtime_required_packages, :source_defined_packages
 
     # builds a JarTable from a directory (paths relative to the current directory)
-    def initialize(dir)
-      @dir = dir
+    def initialize(dir, include_all)
+      jars = get_jars(dir)
+      sources = get_sources(dir)
+      statements = get_statements(sources)
+      @runtime_required_packages = get_runtime_required_packages(statements)
+      @source_defined_packages = get_source_defined_packages(statements)
+
+      log.debug "Runtime required packages are:\n#{@runtime_required_packages.join("\n")}"
+      log.debug "Source defined packages are:\n#{@source_defined_packages.join("\n")}"
 
       @rows = Hash[
         jars.map do |jar|
-          [jar, get_type(jar)]
+          [jar, get_type(jar, include_all)]
         end
       ]
     end
@@ -29,66 +36,24 @@ module Gjp
       "#b - jar is required for building the project"
       "#r - jar is required runtime by the project"
       "#p - jar is produced by the project"
+      "#i - jar is ignored"
       @rows.map do |key, value|
         "#{value.to_s[0]} #{key}"
       end.sort
     end
 
     # jar files in the project's directory
-    def jars
-      Dir["#{@dir}/**/*.jar"]
-    end
-
-    # returns packages defined in a jar file
-    def jar_defined_packages(jar)
-      result = []
-      begin
-        Zip::ZipFile.foreach(jar) do |entry|
-          if entry.name =~ /^(.+)\/.+?\.class$/
-            result << $1.gsub("/", ".")
-          end
-        end
-      rescue Zip::ZipError
-        log.info "#{file} does not seem to be a valid jar archive, skipping"
-      rescue TypeError
-        log.info "#{file} seems to be a valid jar archive but is corrupt, skipping"
-      end
-
-      return result.sort.uniq
-    end
-
-    # returns :produced if the jar was produced from the project's sources, and
-    # :required or :build_required if it is needed at runtime or build time
-    # (heuristically)
-    def get_type(jar)
-      if source_defined?(jar)
-        :produced
-      elsif runtime_required?(jar)
-        :required
-      else
-        :build_required        
-      end
-    end
-
-    # returns true if a jar is produced from source code in the project's directory
-    def source_defined?(jar)
-      jar_defined_packages(jar).all? { |package| source_defined_packages.include?(package)  }
-    end
-
-    # returns true if a jar is required runtime, false if it is only needed
-    # at compile time. Current implementation is heuristic (looks for "import" statements
-    # in java code)
-    def runtime_required?(jar)
-      jar_defined_packages(jar).any? { |package| source_required_packages.include?(package)  }
+    def get_jars(dir)
+      Dir["#{dir}/**/*.jar"]
     end
 
     # java source files in the project's directory
-    def sources
-      Dir["#{@dir}/**/*.java"]
+    def get_sources(dir)
+      Dir["#{dir}/**/*.java"]
     end
 
     # java statements in java source files
-    def statements
+    def get_statements(sources)
       sources.map do |source|
         File.readlines(source)
           .map { |line| line.split(";")  }
@@ -98,22 +63,86 @@ module Gjp
     end
 
     # heuristically determined package names that the sources require
-    def source_required_packages
-      statement_fragments_from(/^import[ \t]+(?:static[ \t]+)?(.+)\..+?$/)
+    def get_runtime_required_packages(statements)
+      get_statement_fragments_from(statements, /^import[ \t]+(?:static[ \t]+)?(.+)\..+?$/)
     end
 
     # heuristically determined package names that the sources define
-    def source_defined_packages
-      statement_fragments_from(/^package[ \t]+(.+)$/)
+    def get_source_defined_packages(statements)
+      get_statement_fragments_from(statements, /^package[ \t]+(.+)$/)
     end
 
     # matches a regex against all source statements
-    def statement_fragments_from(regex)
+    def get_statement_fragments_from(statements, regex)
       statements.map do |statement|
         if statement =~ regex
           $1
         end
       end.select {|package| package != nil}.flatten.sort.uniq
     end
+
+
+    # returns :produced if the jar was produced from the project's sources, and
+    # :required or :build_required if it is needed at runtime or build time
+    # (heuristically)
+    def get_type(jar, include_all)
+      if not include_all and (jar =~ /(test)|(sample)/)
+        :ignored
+      else
+        jar_defined_packages = get_jar_defined_packages(jar)
+
+        if source_defined?(jar, jar_defined_packages)
+          :produced
+        elsif runtime_required?(jar, jar_defined_packages)
+          :required
+        else
+          :build_required
+        end
+      end
+    end
+
+    # returns true if a jar is produced from source code in the project's directory
+    def source_defined?(jar, jar_defined_packages)
+      log.debug "Determining if #{jar} is defined in the sources"
+      log.debug "#{jar} contains:\n#{jar_defined_packages.join("\n")}"
+
+      result = jar_defined_packages.all? { |package| @source_defined_packages.include?(package)  }
+
+      log.debug "result is:#{result}"
+
+      return result
+    end
+
+    # returns true if a jar is required runtime, false if it is only needed
+    # at compile time. Current implementation is heuristic (looks for "import" statements
+    # in java code)
+    def runtime_required?(jar, jar_defined_packages)
+      log.debug "Determining if #{jar} is required at runtime"
+      log.debug "#{jar} contains:\n#{jar_defined_packages.join("\n")}"
+
+      result = jar_defined_packages.any? { |package| @runtime_required_packages.include?(package)  }
+
+      log.debug "result is:#{result}"
+
+      return result
+    end
+
+    # returns packages defined in a jar file
+    def get_jar_defined_packages(jar)
+      result = []
+      begin
+        Zip::ZipFile.foreach(jar) do |entry|
+          if entry.name =~ /^(.+)\/.+?\.class$/
+            result << $1.gsub("/", ".")
+          end
+        end
+      rescue Zip::ZipError
+        log.info "#{jar} does not seem to be a valid jar archive, skipping"
+      rescue TypeError
+        log.info "#{jar} seems to be a valid jar archive but is corrupt, skipping"
+      end
+
+      return result.sort.uniq
+    end
   end
 end

data/lib/gjp/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Gjp
-  VERSION = "0.9.0"
+  VERSION = "0.10.0"
 end

data/spec/lib/jar_table_spec.rb

@@ -4,11 +4,11 @@ require 'spec_helper'
 
 describe Gjp::JarTable do
   let(:dir) { File.join("spec", "data", "ant-super-simple-code") }
-  let(:jar_table) { Gjp::JarTable.new(dir) }
+  let(:jar_table) { Gjp::JarTable.new(dir, true) }
 
-  describe "#jars" do
+  describe "#get_jars" do
     it "finds jar paths in a directory" do 
-      jar_table.jars.should include(
+      jar_table.get_jars(dir).should include(
         File.join(dir, "dist", "antsimple-20130618.jar"),
         File.join(dir, "lib", "junit-4.11.jar"),
         File.join(dir, "lib", "log4j-1.2.13.jar")
@@ -16,9 +16,9 @@ describe Gjp::JarTable do
     end
   end
 
-  describe "#jar_defined_packages" do
+  describe "#get_jar_defined_packages" do
     it "finds the package names part of a jar file" do 
-      jar_table.jar_defined_packages(File.join(dir, "lib", "junit-4.11.jar")).should include(
+      jar_table.get_jar_defined_packages(File.join(dir, "lib", "junit-4.11.jar")).should include(
         "junit.framework",
         "junit.extensions",
         "org.junit.runner",
@@ -27,16 +27,9 @@ describe Gjp::JarTable do
     end
   end
 
-  describe "#runtime_required?" do
-    it "heuristically determines if a jar file is needed runtime" do 
-      jar_table.runtime_required?(File.join(dir, "lib", "junit-4.11.jar")).should be_false
-      jar_table.runtime_required?(File.join(dir, "lib", "log4j-1.2.13.jar")).should be_true
-    end
-  end
-
   describe "#sources" do
     it "finds source paths in a directory" do 
-      jar_table.sources.should include(
+      jar_table.get_sources(dir).should include(
         File.join(dir, "src", "mypackage", "HW.java")
       )
     end
@@ -48,9 +41,9 @@ describe Gjp::JarTable do
     end
   end
 
-  describe "#source_required_packages" do
+  describe "#runtime_required_packages" do
     it "finds the package names required by this project's sources" do 
-      jar_table.source_required_packages.should include("org.apache.log4j")
+      jar_table.runtime_required_packages.should include("org.apache.log4j")
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gjp
 version: !ruby/object:Gem::Version
-  version: 0.9.0
+  version: 0.10.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-18 00:00:00.000000000 Z
+date: 2013-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake