tetra 0.40.0

data/lib/tetra/kit_checker.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+
+module Tetra
+  # checks kits for errors
+  class KitChecker
+    include Logging
+
+    def initialize(project)
+      @project = project
+    end
+
+    # returns an array of [path, archive] couples found in kit/
+    # archive is not nil if path is inside a zip file
+    def kit_file_paths
+      @project.from_directory("kit") do
+        plain_file_paths = Dir[File.join("**", "*")].select do |path|
+          File.file?(path)
+        end.map do |path|
+          [path, nil]
+        end
+
+        archived_file_paths = plain_file_paths.select do |path, _archive|
+          path. =~ (/\.(zip)|([jwe]ar)$/)
+        end.map do |path, _archive|
+          result = []
+          Zip::File.foreach(path) do |entry|
+            result << [entry.to_s, path] if entry.file?
+          end
+          result
+        end.flatten(1)
+
+        plain_file_paths + archived_file_paths
+      end
+    end
+
+    # returns a list of class names for which
+    # we have source files in kit/
+    def source_class_names(paths)
+      source_paths = paths.select do |path, _archive|
+        path =~ /\.java$/
+      end
+
+      # heuristically add all possible package names, walking
+      # back the directory tree all the way back to root.
+      # This could add non-existent names, but allows not looking
+      # in the file at all
+      class_names = source_paths.map do |path, _archive|
+        class_name = path_to_class(path)
+        parts = class_name.split(".")
+        last_index = parts.length - 1
+        (0..last_index).map do |i|
+          parts[i..last_index].join(".")
+        end
+      end.flatten
+
+      Set.new(class_names)
+    end
+
+    # returns a list of class names for which
+    # we have binary files in kit/
+    def compiled_classes(paths)
+      result = {}
+      paths.select do |path, _archive|
+        path =~ /\.class$/
+      end.each do |path, archive|
+        class_name = path_to_class(path)
+        if result[archive].nil?
+          result[archive] = [class_name]
+        else
+          result[archive] << class_name
+        end
+      end
+
+      result
+    end
+
+    # returns a hash that associates archive names and
+    # the unsourced classes within them
+    def unsourced_archives
+      paths = kit_file_paths
+      source_class_names = source_class_names(paths)
+      archive_paths_to_class_names = compiled_classes(paths)
+
+      archive_paths_to_class_names.map do |archive, class_names|
+        unsourced_class_names = class_names.select do |class_name|
+          source_class_names.include?(class_name) == false
+        end
+        { archive: archive, class_names: class_names, unsourced_class_names: unsourced_class_names }
+      end.select do |archive|
+        archive[:unsourced_class_names].any?
+      end
+    end
+
+    private
+
+    # attempts to turn a .java/.class file name into a class name
+    def path_to_class(path)
+      path
+        .gsub(/\$.+?\./, ".") # remove $InnerClasses
+        .gsub(/\..+?$/, "") # remove .extension
+        .gsub("/", ".") # convert paths in package names
+    end
+  end
+end

data/lib/tetra/kit_runner.rb

@@ -0,0 +1,43 @@
+# encoding: UTF-8
+
+module Tetra
+  # runs programs from a tetra kit with tetra-specific options
+  class KitRunner
+    include Logging
+
+    def initialize(project)
+      @project = project
+    end
+
+    # finds an executable in a bin/ subdirectory of kit
+    def find_executable(name)
+      @project.from_directory do
+        Find.find("kit") do |path|
+          next unless path =~ /bin\/#{name}$/
+
+          log.debug("found #{name} executable: #{path}")
+          return path
+        end
+      end
+
+      log.debug("#{name} executable not found")
+      nil
+    end
+
+    # runs an external executable, returns true on success
+    def run_executable(full_commandline)
+      log.debug "running #{full_commandline}"
+      Process.wait(Process.spawn(full_commandline))
+      $CHILD_STATUS.exitstatus == 0
+    end
+  end
+
+  # an executable from the kit was not found
+  class ExecutableNotFoundError < Exception
+    attr_reader :executable
+
+    def initialize(executable)
+      @executable = executable
+    end
+  end
+end

data/lib/tetra/kit_spec_adapter.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Tetra
+  # encapsulates details of a kit needed by the spec file
+  # retrieving them from other objects
+  class KitSpecAdapter
+    attr_reader :name
+    attr_reader :version
+    attr_reader :archives
+
+    def initialize(project)
+      @name = project.name
+      @version = project.version
+
+      @archives =
+        project.from_directory do
+          ["#{name}-kit.tar.xz"] +
+          Dir.entries("output/#{name}-kit")
+            .select { |f| f =~ /_[0-9]+.tar.xz$/ }
+            .sort
+        end
+    end
+
+    def public_binding
+      binding
+    end
+  end
+end

data/lib/tetra/logger.rb

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+
+module Tetra
+  # configures logging for this application
+  class Logger
+    include Singleton
+    extend Forwardable
+
+    def_delegators :@logger, :debug, :info, :warn, :error, :fatal, :level=
+
+    def initialize
+      @logger = ::Logger.new(STDERR)
+      @logger.datetime_format = "%Y-%m-%d %H:%M "
+      @logger.level = ::Logger::ERROR
+      @logger.formatter = proc do |severity, _datetime, _progname, msg|
+        "#{severity.chars.first}: #{msg}\n"
+      end
+    end
+  end
+
+  # convenience methods
+  module Logging
+    # convenience instance method
+    def log
+      Tetra::Logger.instance
+    end
+  end
+end

data/lib/tetra/main.rb

@@ -0,0 +1,102 @@
+# encoding: UTF-8
+
+module Tetra
+  # program entry point
+  class MainCommand < Clamp::Command
+    subcommand(
+      "init",
+      "Inits a tetra project in the current directory",
+      Tetra::InitCommand
+    )
+
+    subcommand(
+      "dry-run",
+      "Starts a dry-run build",
+      Tetra::DryRunCommand
+    )
+
+    subcommand(
+      "mvn",
+      "Locates and runs Maven from any directory in kit/",
+      Tetra::MavenCommand
+    )
+
+    subcommand(
+      "ant",
+      "Locates and runs Ant from any directory in kit/",
+      Tetra::AntCommand
+    )
+
+    subcommand(
+      "finish",
+      "Ends the current dry-run",
+      Tetra::FinishCommand
+    )
+
+    subcommand(
+      "generate-kit-archive",
+      "Create or refresh the kit tarball",
+      Tetra::GenerateKitArchiveCommand
+    )
+
+    subcommand(
+      "generate-kit-spec",
+      "Create or refresh a spec file for the kit",
+      Tetra::GenerateKitSpecCommand
+    )
+
+    subcommand(
+      "generate-package-script",
+      "Create or refresh a build.sh file for a package",
+      Tetra::GeneratePackageScriptCommand
+    )
+
+    subcommand(
+      "generate-package-archive",
+      "Create or refresh a package tarball",
+      Tetra::GeneratePackageArchiveCommand
+    )
+
+    subcommand(
+      "generate-package-spec",
+      "Create or refresh a spec file for a package",
+      Tetra::GeneratePackageSpecCommand
+    )
+
+    subcommand(
+      "generate-all",
+      "Create or refresh specs, archives, scripts for a package and the kit",
+      Tetra::GenerateAllCommand
+    )
+
+    subcommand(
+      "move-jars-to-kit",
+      "Locates jars in src/ and moves them to kit/",
+      Tetra::MoveJarsToKitCommand
+    )
+
+    subcommand(
+      "download-maven-source-jars",
+      "Attempts to download Maven kit/ sources",
+      Tetra::DownloadMavenSourceJarsCommand
+    )
+
+    subcommand(
+      "get-pom",
+      "Retrieves a pom file",
+      Tetra::GetPomCommand
+    )
+
+    subcommand(
+      "get-source",
+      "Attempts to retrieve a project's sources",
+      Tetra::GetSourceCommand
+    )
+
+    subcommand(
+      "list-kit-missing-sources",
+      "Locates jars in kit/ that have no source files",
+      Tetra::ListKitMissingSourcesCommand
+    )
+  end
+end

data/lib/tetra/maven_runner.rb

@@ -0,0 +1,47 @@
+# encoding: UTF-8
+
+module Tetra
+  # runs Maven with tetra-specific options
+  class MavenRunner < KitRunner
+    include Logging
+
+    # runs Maven in a subprocess
+    def mvn(options)
+      run_executable(get_maven_commandline(@project.full_path, options))
+    end
+
+    # runs Maven to attempt getting a source jar
+    # returns true if successful
+    def get_source_jar(group_id, artifact_id, version)
+      mvn(["dependency:get", "-Dartifact=#{group_id}:#{artifact_id}:#{version}:jar:sources", "-Dtransitive=false"])
+    end
+
+    # runs Maven to get the effective POM from an existing POM
+    # returns effective pom path or nil if not found
+    def get_effective_pom(pom_path)
+      effective_pom_path = "#{pom_path}.effective"
+      success = mvn(["help:effective-pom", "-f#{pom_path}", "-Doutput=#{File.split(effective_pom_path)[1]}"])
+      if success
+        effective_pom_path
+      else
+        nil
+      end
+    end
+
+    # returns a command line for running Maven from the specified
+    # prefix
+    def get_maven_commandline(prefix, options)
+      executable = find_executable("mvn")
+
+      if !executable.nil?
+        mvn_path = File.join(prefix, executable)
+        repo_path = File.join(prefix, "kit", "m2")
+        config_path = File.join(prefix, "kit", "m2", "settings.xml")
+
+        "#{mvn_path} -Dmaven.repo.local=#{repo_path} -s#{config_path} #{options.join(" ")}"
+      else
+        fail ExecutableNotFoundError, "mvn"
+      end
+    end
+  end
+end

data/lib/tetra/maven_website.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+module Tetra
+  # Facade to search.maven.org
+  class MavenWebsite
+    include Logging
+
+    # returns a search result object from search.maven.com
+    # searching by a jar sha1 hash
+    # see output format at http://search.maven.org/#api
+    def search_by_sha1(sha1)
+      search(q: "1:\"#{sha1}\"")
+    end
+
+    # returns a search result object from search.maven.com
+    # searching by keyword (name)
+    # see output format at http://search.maven.org/#api
+    def search_by_name(name)
+      search(q: name)
+    end
+
+    # returns a search result object from search.maven.com
+    # searching by Maven's group id and artifact id
+    # see output format at http://search.maven.org/#api
+    def search_by_group_id_and_artifact_id(group_id, artifact_id)
+      search(q: "g:\"#{group_id}\" AND a:\"#{artifact_id}\"", core: "gav")
+    end
+
+    # returns a search result object from search.maven.com
+    # searching by Maven's id (group id, artifact id and version)
+    # see output format at http://search.maven.org/#api
+    def search_by_maven_id(group_id, artifact_id, version)
+      search(q: "g:\"#{group_id}\" AND a:\"#{artifact_id}\" AND v:\"#{version}\"")
+    end
+
+    # returns a search result object from search.maven.com
+    # see input and output format at http://search.maven.org/#api
+    def search(params)
+      response = RestClient.get("http://search.maven.org/solrsearch/select",
+                                params: params.merge("rows" => "100", "wt" => "json")
+      )
+      json = JSON.parse(response.to_s)
+      json["response"]["docs"]
+    end
+
+    # returns a Maven's triple (artifactId, groupId, version)
+    # from a result object
+    def get_maven_id_from(result)
+      [result["g"], result["a"], result["v"]]
+    end
+
+    # downloads a POM from a search.maven.com search result
+    def download_pom(group_id, artifact_id, version)
+      path = "#{group_id.gsub(".", "/")}/#{artifact_id}/#{version}/#{artifact_id}-#{version}.pom"
+      log.debug("downloading #{path}...")
+      (RestClient.get "http://search.maven.org/remotecontent", params: { filepath: path }).to_s
+    end
+  end
+end

data/lib/tetra/package_spec_adapter.rb

@@ -0,0 +1,59 @@
+# encoding: UTF-8
+
+module Tetra
+  # encapsulates details of a package needed by the spec file
+  # retrieving them from other objects
+  class PackageSpecAdapter
+    attr_reader :name
+    attr_reader :version
+    attr_reader :license
+    attr_reader :summary
+    attr_reader :url
+    attr_reader :project_name
+    attr_reader :project_version
+    attr_reader :group_id
+    attr_reader :artifact_id
+    attr_reader :version
+    attr_reader :runtime_dependency_ids
+    attr_reader :description
+    attr_reader :outputs
+
+    def initialize(project, package_name, pom, filter)
+      @name = package_name
+      @version = pom.version
+      @license = (
+        if pom.license_name != ""
+          pom.license_name
+        else
+          "Apache-2.0"
+        end
+      )
+      @summary = cleanup_description(pom.description, 60)
+      @url = pom.url
+      @project_name = project.name
+      @project_version = project.version
+      @group_id = pom.group_id
+      @artifact_id = pom.artifact_id
+      @version = pom.version
+      @runtime_dependency_ids = pom.runtime_dependency_ids
+      @description = cleanup_description(pom.description, 1500)
+
+      @outputs = project.get_produced_files(package_name).select do |file|
+        File.fnmatch? filter, File.basename(file)
+      end
+    end
+
+    def public_binding
+      binding
+    end
+
+    def cleanup_description(raw, max_length)
+      raw
+        .gsub(/[\s]+/, " ")
+        .strip
+        .slice(0..max_length - 1)
+        .sub(/\s\w+$/, "")
+        .sub(/\.+$/, "")
+    end
+  end
+end