tetra 0.40.0

data/lib/tetra/pom.rb

@@ -0,0 +1,55 @@
+# encoding: UTF-8
+
+module Tetra
+  # encapsulates a pom.xml file
+  class Pom
+    def initialize(filename)
+      @doc = Nokogiri::XML(open(filename).read)
+      @doc.remove_namespaces!
+    end
+
+    def group_id
+      @doc.xpath("project/groupId").text || ""
+    end
+
+    def artifact_id
+      @doc.xpath("project/artifactId").text || ""
+    end
+
+    def name
+      @doc.xpath("project/name").text || ""
+    end
+
+    def version
+      @doc.xpath("project/version").text || ""
+    end
+
+    def description
+      @doc.xpath("project/description").text || ""
+    end
+
+    def url
+      @doc.xpath("project/url").text || ""
+    end
+
+    def license_name
+      @doc.xpath("project/licenses/license/name").text || ""
+    end
+
+    def runtime_dependency_ids
+      @doc.xpath("project/dependencies/dependency[\
+        not(optional='true') and not(scope='provided') and not(scope='test') and not(scope='system')\
+      ]").map do |element|
+        [element.xpath("groupId").text, element.xpath("artifactId").text, element.xpath("version").text]
+      end
+    end
+
+    def scm_connection
+      @doc.xpath("project/scm/connection").text || ""
+    end
+
+    def scm_url
+      @doc.xpath("project/scm/url").text || ""
+    end
+  end
+end

data/lib/tetra/pom_getter.rb

@@ -0,0 +1,104 @@
+# encoding: UTF-8
+
+module Tetra
+  # attempts to get java projects' pom file
+  class PomGetter
+    include Logging
+
+    # saves a jar poms in <jar_filename>.pom
+    # returns filename and status if found, else nil
+    def get_pom(filename)
+      content, status = (get_pom_from_jar(filename) || get_pom_from_sha1(filename) || get_pom_from_heuristic(filename))
+      return unless content
+
+      pom_filename = filename.sub(/(\.jar)?$/, ".pom")
+      File.open(pom_filename, "w") { |io| io.write(content) }
+      [pom_filename, status]
+    end
+
+    # returns a pom embedded in a jar file
+    def get_pom_from_jar(file)
+      log.debug("Attempting unpack of #{file} to find a POM")
+      begin
+        Zip::File.foreach(file) do |entry|
+          if entry.name =~ /\/pom.xml$/
+            log.info("pom.xml found in #{file}##{entry.name}")
+            return entry.get_input_stream.read, :found_in_jar
+          end
+        end
+      rescue Zip::Error
+        log.warn("#{file} does not seem to be a valid jar archive, skipping")
+      rescue TypeError
+        log.warn("#{file} seems to be a valid jar archive but is corrupt, skipping")
+      end
+      nil
+    end
+
+    # returns a pom from search.maven.org with a jar sha1 search
+    def get_pom_from_sha1(file)
+      log.debug("Attempting SHA1 POM lookup for #{file}")
+      begin
+        if File.file?(file)
+          site = MavenWebsite.new
+          sha1 = Digest::SHA1.hexdigest File.read(file)
+          results = site.search_by_sha1(sha1).select { |result| result["ec"].include?(".pom") }
+          result = results.first
+          unless result.nil?
+            log.info("pom.xml for #{file} found on search.maven.org for sha1 #{sha1}\
+              (#{result["g"]}:#{result["a"]}:#{result["v"]})"
+            )
+            group_id, artifact_id, version = site.get_maven_id_from result
+            return site.download_pom(group_id, artifact_id, version), :found_via_sha1
+          end
+        end
+      rescue RestClient::ResourceNotFound
+        log.warn("Got a 404 error while looking for #{file}'s SHA1 in search.maven.org")
+      end
+      nil
+    end
+
+    # returns a pom from search.maven.org with a heuristic name search
+    def get_pom_from_heuristic(filename)
+      begin
+        log.debug("Attempting heuristic POM search for #{filename}")
+        site = MavenWebsite.new
+        filename = cleanup_name(filename)
+        version_matcher = VersionMatcher.new
+        my_artifact_id, my_version = version_matcher.split_version(filename)
+        log.debug("Guessed artifact id: #{my_artifact_id}, version: #{my_version}")
+
+        result = site.search_by_name(my_artifact_id).first
+        log.debug("Artifact id search result: #{result}")
+        unless result.nil?
+          group_id, artifact_id, _ = site.get_maven_id_from result
+          results = site.search_by_group_id_and_artifact_id(group_id, artifact_id)
+          log.debug("All versions: #{results}")
+          their_versions = results.map { |doc| doc["v"] }
+          best_matched_version = (
+            if !my_version.nil?
+              version_matcher.best_match(my_version, their_versions)
+            else
+              their_versions.max
+            end
+          )
+          best_matched_result = (results.select { |r| r["v"] == best_matched_version }).first
+
+          group_id, artifact_id, version = site.get_maven_id_from(best_matched_result)
+          log.warn("pom.xml for #{filename} found on search.maven.org with heuristic search\
+            (#{group_id}:#{artifact_id}:#{version})"
+          )
+
+          return site.download_pom(group_id, artifact_id, version), :found_via_heuristic
+        end
+      rescue RestClient::ResourceNotFound
+        log.warn("Got a 404 error while looking for #{filename} heuristically in search.maven.org")
+      end
+      nil
+    end
+
+    # get a heuristic name from a path
+    def cleanup_name(path)
+      Pathname.new(path).basename.to_s.sub(/.jar$/, "")
+    end
+  end
+end

data/lib/tetra/project.rb

@@ -0,0 +1,245 @@
+# encoding: UTF-8
+
+module Tetra
+  # encapsulates a Tetra project directory
+  class Project
+    include Logging
+
+    attr_accessor :full_path
+    attr_accessor :git
+
+    def initialize(path)
+      @full_path = Tetra::Project.find_project_dir(File.expand_path(path))
+      @git = Tetra::Git.new(@full_path)
+    end
+
+    def name
+      File.basename(@full_path)
+    end
+
+    def version
+      latest_tag_count(:dry_run_finished)
+    end
+
+    # finds the project directory up in the tree, like git does
+    def self.find_project_dir(starting_dir)
+      result = starting_dir
+      while project?(result) == false && result != "/"
+        result = File.expand_path("..", result)
+      end
+
+      fail NoProjectDirectoryError, starting_dir if result == "/"
+
+      result
+    end
+
+    # returns true if the specified directory is a valid tetra project
+    def self.project?(dir)
+      File.directory?(File.join(dir, "src")) &&
+      File.directory?(File.join(dir, "kit")) &&
+      File.directory?(File.join(dir, ".git"))
+    end
+
+    # returns the package name corresponding to the specified dir, if any
+    # raises NoPackageDirectoryError if dir is not a (sub)directory of a package
+    def get_package_name(dir)
+      dir_path = Pathname.new(File.expand_path(dir)).relative_path_from(Pathname.new(@full_path))
+      components = dir_path.to_s.split(File::SEPARATOR)
+      if components.count >= 2 &&
+        components.first == "src" &&
+        Dir.exist?(File.join(@full_path, components[0], components[1]))
+        components[1]
+      else
+        fail NoPackageDirectoryError
+      end
+    rescue ArgumentError, NoProjectDirectoryError
+      raise NoPackageDirectoryError, dir
+    end
+
+    # inits a new project directory structure
+    def self.init(dir)
+      Dir.chdir(dir) do
+        Tetra::Git.new(".").init
+
+        FileUtils.mkdir_p "src"
+        FileUtils.mkdir_p "kit"
+
+        # populate the project with templates and take a snapshot
+        project = Project.new(".")
+
+        template_manager = Tetra::TemplateManager.new
+        template_manager.copy "output", "."
+        template_manager.copy "kit", "."
+        template_manager.copy "src", "."
+        template_manager.copy "gitignore", ".gitignore"
+
+        project.take_snapshot "Template files added", :init
+      end
+    end
+
+    # starts a dry running phase: files added to kit/ will be added
+    # to the kit package, src/ will be reset at the current state
+    # when finished
+    def dry_run
+      return false if dry_running?
+
+      current_directory = Pathname.new(Dir.pwd).relative_path_from Pathname.new(@full_path)
+
+      take_snapshot("Dry-run started", :dry_run_started, current_directory)
+      true
+    end
+
+    # returns true iff we are currently dry-running
+    def dry_running?
+      latest_tag_count(:dry_run_started) > latest_tag_count(:dry_run_finished)
+    end
+
+    # ends a dry-run.
+    # if abort is true, reverts the whole directory
+    # if abort is false, reverts sources and updates output file lists
+    def finish(abort)
+      if dry_running?
+        if abort
+          @git.revert_whole_directory(".", latest_tag(:dry_run_started))
+          @git.delete_tag(latest_tag(:dry_run_started))
+        else
+          take_snapshot "Changes during dry-run", :dry_run_changed
+
+          @git.revert_whole_directory("src", latest_tag(:dry_run_started))
+
+          take_snapshot "Dry run finished", :dry_run_finished
+        end
+        return true
+      end
+      false
+    end
+
+    # takes a revertable snapshot of this project
+    def take_snapshot(message, tag_prefix = nil, tag_message = nil)
+      tag = (
+        if tag_prefix
+          "#{tag_prefix}_#{latest_tag_count(tag_prefix) + 1}"
+        else
+          nil
+        end
+      )
+
+      @git.commit_whole_directory(message, tag, tag_message)
+    end
+
+    # replaces content in path with new_content, takes a snapshot using
+    # snapshot_message and tag_prefix and 3-way merges new and old content
+    # with a previous snapshotted file same path tag_prefix, if it exists.
+    # returns the number of conflicts
+    def merge_new_content(new_content, path, snapshot_message, tag_prefix)
+      from_directory do
+        log.debug "merging new content to #{path} with prefix #{tag_prefix}"
+        already_existing = File.exist? path
+        previous_tag = latest_tag(tag_prefix)
+
+        if already_existing
+          log.debug "moving #{path} to #{path}.tetra_user_edited"
+          File.rename path, "#{path}.tetra_user_edited"
+        end
+
+        File.open(path, "w") { |io| io.write(new_content) }
+        log.debug "taking snapshot with new content: #{snapshot_message}"
+        take_snapshot(snapshot_message, tag_prefix)
+
+        if already_existing
+          if previous_tag == ""
+            previous_tag = latest_tag(tag_prefix)
+            log.debug "there was no tag with prefix #{tag_prefix} before snapshot"
+            log.debug "defaulting to #{previous_tag} after snapshot"
+          end
+
+          # 3-way merge
+          conflict_count = @git.merge_with_tag("#{path}", "#{path}.tetra_user_edited", previous_tag)
+          File.delete "#{path}.tetra_user_edited"
+          return conflict_count
+        end
+        return 0
+      end
+    end
+
+    # returns the tag with maximum count for a given tag prefix
+    def latest_tag(prefix)
+      "#{prefix}_#{latest_tag_count(prefix)}"
+    end
+
+    # returns the maximum tag count for a given tag prefix
+    def latest_tag_count(prefix)
+      @git.get_tag_maximum_suffix(prefix)
+    end
+
+    # runs a block from the project directory or a subdirectory
+    def from_directory(subdirectory = "")
+      Dir.chdir(File.join(@full_path, subdirectory)) do
+        yield
+      end
+    end
+
+    # returns the latest dry run start directory
+    def latest_dry_run_directory
+      @git.get_message(latest_tag(:dry_run_started))
+    end
+
+    # returns a list of files produced during dry-runs in a certain package
+    def get_produced_files(package)
+      dry_run_count = latest_tag_count(:dry_run_changed)
+      log.debug "Getting produced files from #{dry_run_count} dry runs"
+      if dry_run_count >= 1
+        package_dir = File.join("src", package)
+        (1..dry_run_count).map do |i|
+          @git.changed_files_between("dry_run_started_#{i}", "dry_run_changed_#{i}", package_dir)
+        end
+          .flatten
+          .uniq
+          .sort
+          .map { |file| Pathname.new(file).relative_path_from(Pathname.new(package_dir)).to_s }
+      else
+        []
+      end
+    end
+
+    # moves any .jar from src/ to kit/ and links it back
+    def purge_jars
+      from_directory do
+        result = []
+        Find.find("src") do |file|
+          next unless file =~ /.jar$/ && !File.symlink?(file)
+
+          new_location = File.join("kit", "jars", Pathname.new(file).split[1])
+          FileUtils.mv(file, new_location)
+
+          link_target = Pathname.new(new_location)
+            .relative_path_from(Pathname.new(file).split.first)
+            .to_s
+
+          File.symlink(link_target, file)
+          result << [file, new_location]
+        end
+
+        result
+      end
+    end
+  end
+
+  # current directory is not a tetra project
+  class NoProjectDirectoryError < StandardError
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = directory
+    end
+  end
+
+  # current directory is not a tetra package directory
+  class NoPackageDirectoryError < StandardError
+    attr_reader :directory
+
+    def initialize(directory)
+      @directory = directory
+    end
+  end
+end

data/lib/tetra/script_generator.rb

@@ -0,0 +1,57 @@
+# encoding: UTF-8
+
+module Tetra
+  # generates build scripts from bash_history
+  class ScriptGenerator
+    include Logging
+
+    def initialize(project, history_path)
+      @project = project
+      @ant_runner = Tetra::AntRunner.new(project)
+      @maven_runner = Tetra::MavenRunner.new(project)
+      @history_path = history_path
+    end
+
+    def generate_build_script(name)
+      @project.from_directory do
+        history_lines = File.readlines(@history_path).map { |e| e.strip }
+        relevant_lines =
+          history_lines
+            .reverse
+            .take_while { |e| e.match(/tetra +dry-run/).nil? }
+            .reverse
+            .take_while { |e| e.match(/tetra +finish/).nil? }
+            .select { |e| e.match(/^#/).nil? }
+
+        script_lines = [
+          "#!/bin/bash",
+          "PROJECT_PREFIX=`readlink -e .`",
+          "cd #{@project.latest_dry_run_directory}"
+        ] +
+        relevant_lines.map do |line|
+          if line =~ /tetra +mvn/
+            line.gsub(/tetra +mvn/, "#{@maven_runner.get_maven_commandline("$PROJECT_PREFIX", ["-o"])}")
+          elsif line =~ /tetra +ant/
+            line.gsub(/tetra +ant/, "#{@ant_runner.get_ant_commandline("$PROJECT_PREFIX")}")
+          else
+            line
+          end
+        end
+
+        new_content = script_lines.join("\n") + "\n"
+
+        script_name = "build.sh"
+        result_path = File.join("src", name, script_name)
+        conflict_count = @project.merge_new_content(new_content, result_path, "Build script generated",
+                                                    "generate_#{name}_build_script")
+
+        destination_dir = File.join("output", name)
+        FileUtils.mkdir_p(destination_dir)
+        destination_script_path =  File.join(destination_dir, script_name)
+        FileUtils.symlink(File.expand_path(result_path), destination_script_path, force: true)
+
+        [result_path, conflict_count]
+      end
+    end
+  end
+end