esr-rim 1.1.5

data/lib/rim/manifest/helper.rb

@@ -0,0 +1,82 @@
+require 'monitor'
+require 'pathname'
+
+module RIM
+module Manifest
+
+class RimError < StandardError
+  def self.status_code(code)
+    define_method(:status_code) { code }
+  end
+end
+
+class ManifestFileNotFound       < RimError; status_code(10) ; end
+
+module Helpers
+  CHDIR_MONITOR = Monitor.new
+  CONFIG_FILE_NAME = "manifest.rim"
+
+  def default_manifest
+    manifest = find_manifest
+    raise ManifestFileNotFound, "Could not locate #{CONFIG_FILE_NAME}" unless manifest
+    Pathname.new(manifest)
+  end
+
+  def default_lockfile
+    manifest = default_manifest
+    Pathname.new(manifest.sub(/.rim$/, '.locked'))
+  end
+
+  def in_rim_project?
+    find_manifest
+  end
+
+  def chdir_monitor
+    CHDIR_MONITOR
+  end
+
+  def chdir(dir, &blk)
+    chdir_monitor.synchronize do
+      Dir.chdir dir, &blk
+    end
+  end
+
+private
+
+  def find_manifest
+    given = ENV['RIM_MANIFEST']
+    return given if given && !given.empty?
+
+    find_file(CONFIG_FILE_NAME)
+  end
+
+  def find_file(*names)
+    search_up(*names) {|filename|
+      return filename if File.file?(filename)
+    }
+  end
+
+  def find_directory(*names)
+    search_up(*names) do |dirname|
+      return dirname if File.directory?(dirname)
+    end
+  end
+
+  def search_up(*names)
+    previous = nil
+    current  = File.expand_path(Dir.pwd)
+
+    until !File.directory?(current) || current == previous
+      names.each do |name|
+        filename = File.join(current, name)
+        yield filename
+      end
+      current, previous = File.expand_path("..", current), current
+    end
+  end
+  extend self
+end
+
+end # Manifest
+end # RIM
+

data/lib/rim/manifest/json_reader.rb

@@ -0,0 +1,40 @@
+require 'json'
+require 'csv'
+require 'rim/manifest/model'
+
+class RimError < StandardError
+  def self.status_code(code)
+    define_method(:status_code) { code }
+  end
+end
+
+class ManifestFileNotFound       < RimError; status_code(10) ; end
+
+module RIM
+module Manifest
+
+  def read_manifest(f)
+    raise "no manifest found" unless f
+    parse_manifest(File.read(f))
+  end
+    
+  def parse_manifest(json)
+    data_hash = JSON.parse(json)
+    modules = []
+    if data_hash.has_key?("modules")
+      data_hash["modules"].each do |mod|
+        modules.push(
+          Module.new(
+            :remote_path => mod["remote_path"],
+            :local_path => mod["local_path"],
+            :target_revision => mod["target_revision"],
+            :ignores => mod["ignores"]
+          ))
+      end
+    end
+    Manifest.new(data_hash["remote_url"], modules)
+  end
+
+end
+
+end

data/lib/rim/manifest/manifest.json

@@ -0,0 +1,7 @@
+{
+    "remote_url" : "ssh://gerrit",
+    "modules" : [
+        {"local_path": "./bsw/nvStorage", "remote_path": "bsw/modules/nvStorage", "target_revision": "1.1"},
+        {"local_path": "./bsw/eepromManager", "remote_path":"bsw/modules/eepromManager", "target_revision": "1.0"}
+    ]
+}

data/lib/rim/manifest/model.rb

@@ -0,0 +1,33 @@
+module RIM
+module Manifest
+
+class Manifest
+
+  attr_reader :remote_url
+  attr_reader :modules
+  
+  def initialize(remote_url, modules)
+    @remote_url = remote_url
+    @modules = modules
+  end
+
+end
+
+class Module
+  attr_reader :remote_path
+  attr_reader :local_path
+  attr_reader :target_revision
+  attr_reader :ignores
+
+  def initialize(args = {})
+    @remote_path = args[:remote_path]
+    @local_path = args[:local_path]
+    @target_revision = args[:target_revision]
+    @ignores = args[:ignores]
+  end
+end
+
+end
+
+end
+

data/lib/rim/manifest/repo_reader.rb

@@ -0,0 +1,61 @@
+require 'nokogiri'
+require 'rim/manifest/model'
+
+module RIM
+module Manifest
+
+# Reader for the original Google Repo manifest
+class RepoReader
+
+def read(file)
+  manifest = Manifest.new
+  File.open(file) do |f|
+    doc = Nokogiri::XML::Document.parse(f)
+    remote_by_name = {}
+    defaults = nil
+    doc.xpath("/manifest/default").each do |d|
+      raise "duplicate default setting" if defaults
+      defaults = {
+        :revision => d.attr("revision"),
+        :remote => d.attr("remote")
+      }
+    end
+    doc.xpath("/manifest/remote").each do |r|
+      name = r.attr("name")
+      raise "remote without a name" unless name
+      rem = Remote.new(
+        :fetch_url => r.attr("fetch"),
+        :review_url => r.attr("review")
+        )
+      raise "conflicting remote name #{name}" if remote_by_name[name]
+      remote_by_name[name] = rem
+    end
+    doc.xpath("/manifest/project").each do |p|
+      remote = p.attr("remote")
+      remote ||= defaults[:remote]
+      if remote
+        raise "remote #{remote} not found" unless remote_by_name[remote]
+      else
+        raise "no remote specified and no default remote either"
+      end
+      revision = p.attr("revision")
+      revision ||= defaults[:revision]
+      if !revision
+        raise "no revision specified and no default revision either"
+      end
+      mod = Module.new(
+        :remote_path => p.attr("name"),
+        :local_path => p.attr("path"),
+        :revision => revision,
+        :remote => remote_by_name[remote]
+        )
+      manifest.add_module(mod)
+    end
+  end
+  manifest
+end
+
+end
+
+end
+end

data/lib/rim/module_helper.rb

@@ -0,0 +1,52 @@
+require 'rim/processor'
+require 'rim/rim_exception'
+require 'rim/rim_info'
+require 'rim/file_helper'
+require 'rim/dirty_check'
+
+module RIM
+
+class ModuleHelper < Processor
+
+  def initialize(workspace_root, module_info, logger)
+    super(workspace_root, logger)
+    @module_info = module_info
+    @remote_url = get_absolute_remote_url(@module_info.remote_url)
+    @remote_path = remote_path(@module_info.remote_url)
+    @logger = logger
+  end
+  
+protected
+  
+  # fetch module +mod+ into the .rim folder
+  # works both for initial fetch and updates
+  def fetch_module
+    git_path = module_git_path(@remote_path)
+    FileUtils.mkdir_p git_path
+    RIM::git_session(git_path) do |s|
+      if !File.exist?(git_path + "/config")
+        s.execute("git clone --mirror #{@remote_url} #{git_path}") do |out, e|
+          raise RimException.new("Remote repository '#{@remote_url}' of module '#{@module_info.local_path}' not found.") if e
+        end
+      else
+        s.execute("git remote update")
+      end
+    end
+    git_path
+  end
+
+  # prepare empty folder: remove all files not on the ignore list and empty folders
+  def prepare_empty_folder(local_path, ignores)
+    ignores = FileHelper.find_matching_files(local_path, true, ignores)
+    FileHelper.find_matching_files(local_path, true, "/**/*", File::FNM_DOTMATCH).each do |f|
+      if File.file?(f) && !ignores.include?(f)
+        FileUtils.rm(f)
+      end
+    end
+    FileHelper.remove_empty_dirs(local_path)
+    FileUtils.mkdir_p(local_path)
+  end
+
+end
+
+end

data/lib/rim/module_info.rb

@@ -0,0 +1,30 @@
+module RIM
+
+class ModuleInfo
+  # remote url (unique identifier of module)
+  attr_reader :remote_url
+  # remote branch format
+  attr_reader :remote_branch_format
+  # locale module path
+  attr_reader :local_path
+  # target revision
+  attr_reader :target_revision
+  # ignores
+  attr_reader :ignores
+  
+  def initialize(remote_url, local_path, target_revision, ignores = nil, remote_branch_format = nil)
+    @remote_url = remote_url
+    @remote_branch_format = remote_branch_format
+    @local_path = local_path
+    @target_revision = target_revision
+    if ignores.is_a?(String)
+      @ignores = ignores.split(",").each do |s| 
+        s.strip! 
+      end 
+    else
+      @ignores = ignores || []
+    end
+  end
+end
+
+end

data/lib/rim/processor.rb

@@ -0,0 +1,126 @@
+require 'fileutils'
+require 'pathname'
+require 'rim/file_helper'
+require 'rim/git'
+require 'rim/rim_exception'
+require 'rake'
+require 'pathname'
+require 'uri'
+
+module RIM
+
+class Processor
+
+MaxThreads = 10
+GerritServer = "ssh://gerrit/"
+
+def initialize(workspace_root, logger)
+  @ws_root = workspace_root
+  @logger = logger
+end
+
+def module_git_path(remote_path)
+  # remote url without protocol specifier
+  # this way the local path should be unique
+  File.join(@ws_root, ".rim", remote_path)
+end
+
+def module_tmp_git_path(remote_path)
+  # remote url without protocol specifier
+  # this way the local path should be unique
+  File.join(@ws_root, ".rim", ".tmp", remote_path)
+end
+
+def remote_path(remote_url)
+  remote_url.
+    # protocol specifier, e.g. ssh://
+    sub(/^\w+:\/\//,'').
+    # windows drive letter 
+    sub(/^\w+:/,'\1').
+    # make sure we don't .. up in a filesystem
+    gsub(/\.\.[\\\/]/,'')
+end
+
+def get_relative_path(path)
+  FileHelper.get_relative_path(path, @ws_root)
+end
+
+def get_absolute_remote_url(remote_url)
+  if remote_url.start_with?("file:")
+    remote_url = remote_url.gsub(/^file:(\/\/)?/, "")
+    match = remote_url.match(/^\/(\w)\|/)
+    if match
+      remote_url = "#{match[1]}:#{remote_url[match[0].size..-1]}"
+    elsif !remote_url.start_with?(File::SEPARATOR)
+      File.expand_path(remote_url, @ws_root)
+    else
+      remote_url
+    end
+  else
+    URI.parse(GerritServer).merge(URI.parse(remote_url)).to_s
+  end
+end
+
+def local_changes?(ws_dir, dir=ws_dir)
+  stat = nil
+  RIM::git_session(ws_dir) do |s|
+    stat = s.status(dir)
+  end
+  stat.lines.all?{|l| l.ignored?}
+end
+
+def clone_or_fetch_repository(remote_url, local_path, clone_log = nil)
+  FileUtils.mkdir_p local_path
+  RIM::git_session(local_path) do |s|
+    if !File.exist?(File.join(local_path, ".git"))
+      @logger.info(clone_log) if clone_log
+      FileHelper.make_empty_dir(local_path)
+      s.execute("git clone #{remote_url} .")
+      s.execute("git config core.ignorecase false")
+    else
+      s.execute("git remote set-url origin #{remote_url}") if !s.has_valid_remote_repository?()
+      s.execute("git fetch")
+    end
+  end
+  local_path
+end
+
+def each_module_parallel(task_desc, modules)
+  if !modules.empty?
+    @logger.debug "starting \"#{task_desc}\" for #{modules.size} modules\r"
+    threads = []
+    messages = []
+    i = 0
+    done = 0
+    while i == 0 || !threads.empty?
+      while threads.size < MaxThreads && i < modules.size
+        threads << Thread.new(i) do |i|
+          begin
+            yield(modules[i], i)
+          rescue RimException => e
+            messages += e.messages
+          end
+        end
+        i += 1
+      end
+      sleep(0.1)
+      threads = threads.select{|t|
+        if t.alive?
+          true
+        else
+          t.join
+          done += 1
+          @logger.debug "#{task_desc} #{done}/#{modules.size}\r"
+          false
+        end
+      }
+    end
+    if !messages.empty?
+      raise RimException.new(messages)
+    end
+  end
+end
+
+end
+
+end

data/lib/rim/rev_status.rb

@@ -0,0 +1,61 @@
+module RIM
+
+# RIM revision status object.
+#
+# Revision status objects hold the RIM status of a specific project git revision.
+# As a special case, this could also be the status of the current working copy.
+#
+# The revision status consists of a set of module status objects,
+# one for each module known to RIM in that revision. 
+# The module status points to a RimInfo object holding attribute values 
+# valid for that specific revision as well as the current dirty state as
+# calculated by DirtyCheck and the module directory.
+#
+# Revsion status objects can have parent status objects. This way,
+# chains and even trees of status objects can be built. For example in
+# case of a merge commit, the corresponding status object would have
+# two parent status objects, one for each parent git commit.
+#
+class RevStatus
+  # git revision (sha1) for which this status was created
+  # or nil if the status wasn't created for a git revision
+  attr_reader :git_rev
+  # module status objects
+  attr_reader :modules
+  # references to RevStatus objects of parent commits
+  attr_reader :parents
+  
+  class ModuleStatus
+    # module directory, relative to project dir root
+    attr_reader :dir
+    # reference to a RimInfo object
+    attr_reader :rim_info
+
+    # dirty state [true, false]
+    def dirty?
+      @dirty
+    end
+
+    def initialize(dir, rim_info, dirty)
+      @dir = dir
+      @rim_info = rim_info
+      @dirty = dirty
+    end
+  end
+
+  def initialize(modules)
+    @modules = modules
+    @parents = []
+  end
+
+  def dirty?
+    modules.any?{|m| m.dirty?}
+  end
+
+  def git_rev=(rev)
+    @git_rev = rev
+  end
+
+end
+
+end