reapack-index 1.0beta3 → 1.0beta4

data/lib/reapack/index/cdetector.rb

@@ -0,0 +1,120 @@
+class ReaPack::Index
+  class ConflictDetector
+    Entry = Struct.new :key, :platform, :file
+
+    class Selector
+      def initialize(bucket, key, cdetector)
+        @bucket, @key, @cdetector = bucket, key, cdetector
+        @entries = @cdetector.bucket bucket
+      end
+
+      def push(platform, file)
+        @entries << Entry.new(@key, platform, file).freeze
+      end
+
+      def clear
+        @entries.reject! {|e| e.key == @key }
+      end
+
+      def resolve
+        @cdetector.resolve @bucket, @key
+      end
+    end
+
+    def initialize
+      @buckets = {}
+    end
+
+    def initialize_clone(other)
+      super
+      other.instance_variable_set :@buckets,
+        Hash[@buckets.map {|k, v| [k, v.clone] }]
+    end
+
+    def [](bucket, key)
+      Selector.new bucket, key, self
+    end
+
+    def bucket(name)
+      @buckets[name] ||= []
+    end
+
+    def resolve(bucket, key = nil)
+      return unless bucket = @buckets[bucket]
+
+      dups = bucket.group_by {|e| e.file }.values.select {|a| a.size > 1 }
+
+      errors = dups.map {|a|
+        packages = a.map {|e| e.key }.uniq
+        next if key && !packages.include?(key)
+
+        if packages.size == 1 || !key
+          original = sort(a)[1]
+          msg = "duplicate file '#{original.file}'"
+        else
+          original = sort(a.select {|e| e.key != key }).first
+          msg = "'#{original.file}' conflicts with '#{original.key}'"
+        end
+
+        platforms = a.map {|e| e.platform }.uniq
+
+        if platforms.size > 1
+          # check platform inheritance
+          platforms.any? {|p|
+            loop do
+              p = Source::PLATFORMS[p] or break false
+              break true if platforms.include? p
+            end
+          } or next
+        end
+
+        platform = original.platform
+        platform == :all ? msg : "#{msg} on #{platform}"
+      }.compact
+
+      errors unless errors.empty?
+    end
+
+    def load_xml(node)
+      Category.find_all(node).each {|cat|
+        Package.find_all(cat.node).each {|pkg|
+          pkgroot = File.join(cat.name, pkg.name)
+
+          pkg.versions.last&.children(Source::TAG)&.each {|src|
+            entry = Entry.new pkgroot, src[:platform].to_sym
+
+            if src[:file]
+              entry.file = ReaPack::Index.expand(src[:file], cat.name)
+            else
+              entry.file = pkgroot
+            end
+
+            bucket(pkg.type) << entry
+          }
+        }
+      }
+    end
+
+  private
+    def sort(set)
+      sorted = set.sort_by {|e| levels[e.platform] }
+      sorted.sort_by! {|e| Source::PLATFORMS.keys.index e.platform }
+    end
+
+    def levels
+      @@levels ||= begin
+        Hash[Source::PLATFORMS.map {|name, parent|
+          levels = 0
+
+          loop do
+            break unless parent
+            levels += 1
+            parent = Source::PLATFORMS[parent]
+          end
+
+          [name, levels]
+        }]
+      end
+    end
+  end
+end

data/lib/reapack/index/cli.rb

@@ -1,17 +1,24 @@
 class ReaPack::Index::CLI
+  attr_reader :index
+
   def initialize(argv = [])
     @opts = parse_options(argv)
     path = argv.last || Dir.pwd
 
     return unless @exit.nil?
 
-    @git = Rugged::Repository.discover path
+    @git = ReaPack::Index::Git.new path
     @opts = parse_options(read_config).merge @opts unless @opts[:noconfig]
 
     @opts = DEFAULTS.merge @opts
+    return unless @exit.nil?
+
+    log Hash[@opts.sort].inspect
 
-    log Hash[@opts.sort].inspect if @exit.nil?
-  rescue Rugged::OSError, Rugged::RepositoryError => e
+    @index = ReaPack::Index.new expand_path(@opts[:output])
+    @index.amend = @opts[:amend]
+    set_url_template
+  rescue Rugged::OSError, Rugged::RepositoryError, ReaPack::Index::Error => e
     $stderr.puts e.message
     @exit = false
   end
@@ -19,11 +26,8 @@ class ReaPack::Index::CLI
   def run
     return @exit unless @exit.nil?
 
-    @db = ReaPack::Index.new expand_path(@opts[:output])
-    @db.amend = @opts[:amend]
-
     if @opts[:check]
-      return check
+      return do_check
     end
 
     if @opts[:lslinks]
@@ -32,135 +36,101 @@ class ReaPack::Index::CLI
     end
 
     if @opts[:dump_about]
-      print @db.description
+      print @index.description
       return true
     end
 
-    begin
-      tpl = @opts[:url_template]
-      is_custom = tpl != DEFAULTS[:url_template]
+    do_name; do_about; eval_links; do_scan
 
-      @db.url_template = is_custom ? tpl : auto_url_tpl
-    rescue ReaPack::Index::Error => e
-      warn '--url-template: ' + e.message if is_custom
-    end
-
-    do_name; do_about; eval_links; scan_commits
-
-    unless @db.modified?
+    unless @index.modified?
       $stderr.puts 'Nothing to do!' unless @opts[:quiet]
-      return true
+      return success_code
     end
 
     # changelog will be cleared by Index#write!
-    changelog = @db.changelog
+    changelog = @index.changelog
     puts changelog unless @opts[:quiet]
 
-    @db.write!
+    @index.write!
     commit changelog
 
-    true
+    success_code
   end
 
 private
-  def scan_commits
+  def success_code
+    @exit.nil? ? true : @exit
+  end
+
+  def set_url_template
+    tpl = @opts[:url_template]
+    is_custom = tpl != DEFAULTS[:url_template]
+
+    @index.url_template = is_custom ? tpl : @git.guess_url_template
+  rescue ReaPack::Index::Error => e
+    warn '--url-template: ' + e.message if is_custom
+  end
+
+  def do_scan
     if @git.empty?
       warn 'The current branch does not contains any commit.'
       return
     end
 
-    walker = Rugged::Walker.new @git
-    walker.sorting Rugged::SORT_TOPO | Rugged::SORT_REVERSE
-    walker.push @git.head.target_id
-
-    last_commit = @db.commit.to_s
-    if Rugged.valid_full_oid?(last_commit) && last_commit.size <= 40
-      walker.hide last_commit if @git.include? last_commit
+    if @opts[:scan].empty?
+      commits = @git.commits_since @index.commit.to_s
+    else
+      commits = @opts[:scan].map {|hash|
+        @git.get_commit hash or begin
+          $stderr.puts '--scan: bad revision: %s' % @opts[:scan]
+          @exit = false
+          nil
+        end
+      }.compact
     end
 
-    commits = walker.each.to_a
-
-    @done, @total = 0, commits.size
-
     unless commits.empty?
-      print_progress
-      commits.each {|commit| process commit }
-      $stderr.print "\n" if @add_nl
+      progress_wrapper commits.size do
+        commits.each {|commit| process_commit commit }
+      end
     end
   end
 
-  def process(commit)
+  def process_commit(commit)
     if @opts[:verbose]
-      sha = commit.oid[0..6]
-      message = commit.message.lines.first.chomp
-      log "processing %s: %s" % [sha, message]
+      log 'processing %s: %s' % [commit.short_id, commit.summary]
     end
 
-    @db.commit = commit.oid
-    @db.time = commit.time
-    @db.files = lsfiles commit.tree
+    @index.commit = commit.id
+    @index.time = commit.time
+    @index.files = commit.filelist
 
-    parent = commit.parents.first
-
-    if parent
-      diff = parent.diff commit.oid
-    else
-      diff = commit.diff
-    end
-
-    diff.each_delta {|delta| index delta, parent.nil? }
+    commit.each_diff {|diff| process_diff diff }
   ensure
-    @done += 1
-    print_progress
+    bump_progress
   end
 
-  def index(delta, is_initial)
-    if is_initial
-      status = 'new'
-      file = delta.old_file
-    else
-      status = delta.status
-      file = delta.new_file
-    end
+  def process_diff(diff)
+    return if ignored? expand_path(diff.file)
+    return unless ReaPack::Index.type_of diff.file
 
-    return if ignored? expand_path(file[:path])
-    return unless ReaPack::Index.type_of file[:path]
+    log "-> indexing #{diff.status} file #{diff.file}"
 
-    log "-> indexing #{status} file #{file[:path]}"
-
-    if status == :deleted
-      @db.remove file[:path]
+    if diff.status == :deleted
+      @index.remove diff.file
     else
-      blob = @git.lookup file[:oid]
-
       begin
-        @db.scan file[:path], blob.content.force_encoding("UTF-8")
+        @index.scan diff.file, diff.new_content
       rescue ReaPack::Index::Error => e
-        warn "#{file[:path]}: #{e.message}"
+        warn "#{diff.file}:\n#{indent e.message}"
       end
     end
   end
 
-  def lsfiles(tree, base = String.new)
-    files = []
-
-    tree.each {|obj|
-      fullname = base.empty? ? obj[:name] : File.join(base, obj[:name])
-      case obj[:type]
-      when :blob
-        files << fullname
-      when :tree
-        files.concat lsfiles(@git.lookup(obj[:oid]), fullname)
-      end
-    }
-
-    files
-  end
-
   def eval_links
     Array(@opts[:links]).each {|link|
       begin
-        @db.eval_link *link
+        @index.eval_link *link
       rescue ReaPack::Index::Error => e
         opt = case link.first
         when :website
@@ -177,7 +147,7 @@ private
   def print_links
     ReaPack::Index::Link::VALID_TYPES.each {|type|
       prefix = "[#{type}]".bold.light_black
-      @db.links(type).each {|link|
+      @index.links(type).each {|link|
         display = link.name == link.url ? link.url : '%s (%s)' % [link.name, link.url]
         puts '%s %s' % [prefix, display]
       }
@@ -185,74 +155,85 @@ private
   end
 
   def do_name
-    @db.name = @opts[:name] if @opts[:name]
-
-    if @db.name.empty?
-      warn "The name of this index is unset. " \
-        "Run the following command with a name of your choice:" \
-        "\n  #{$0} --name 'FooBar Scripts'"
-    end
+    @index.name = @opts[:name] if @opts[:name]
+    check_name
   rescue ReaPack::Index::Error => e
     warn '--name: ' + e.message
   end
 
+  def check_name
+    if @index.name.empty?
+      warn 'This index is unnamed. ' \
+        'Run the following command to set a name of your choice:' \
+        "\n  #{File.basename $0} --name 'FooBar Scripts'"
+    end
+  end
+
   def do_about
     path = @opts[:about]
 
     unless path
-      @db.description = String.new if @opts[:rmabout]
+      @index.description = String.new if @opts[:rmabout]
       return
     end
 
     log "converting #{path} into RTF..."
 
     # look for the file in the working directory, not on the repository root
-    @db.description = File.read(path)
+    @index.description = File.read(path)
   rescue Errno::ENOENT => e
     warn '--about: ' + e.message.sub(' @ rb_sysopen', '')
   rescue ReaPack::Index::Error => e
     warn e.message
   end
 
-  def check
+  def do_check
+    check_name
+
+    @index.amend = true # enable checks for released versions as well
     failures = []
-    root = @git.workdir
 
-    types = ReaPack::Index::FILE_TYPES.keys
-    files = Dir.glob "#{Regexp.quote(root)}**/*.{#{types.join ','}}"
-    count = 0
+    pkgs = Hash[Dir.glob("#{Regexp.quote(@git.path)}/**/*").sort.map {|abs|
+      rel = @git.relative_path abs
+      @index.files << rel
 
-    files.sort.each {|file|
-      next if ignored? file
+      next if !File.file?(abs) || ignored?(abs) || !ReaPack::Index.is_package?(abs)
 
-      errors = ReaPack::Index.validate_file file
-      count += 1
+      [abs, rel]
+    }.compact]
 
-      if errors
-        $stderr.print 'F' unless @opts[:quiet]
-        prefix = "\n  - "
-        file[0..root.size-1] = ''
+    pkgs.each_pair {|abs, rel|
+      begin
+        @index.scan rel, File.read(abs)
 
-        failures << "%s contains invalid metadata:#{prefix}%s" %
-          [file, errors.join(prefix)]
-      else
-        $stderr.print '.' unless @opts[:quiet]
+        if @opts[:verbose]
+          $stderr.puts '%s: passed' % rel
+        elsif !@opts[:quiet]
+          $stderr.print '.'
+        end
+      rescue ReaPack::Index::Error => e
+        if @opts[:verbose]
+          $stderr.puts '%s: failed' % rel
+        elsif !@opts[:quiet]
+          $stderr.print 'F'
+        end
+
+        failures << "%s failed:\n%s" % [rel, indent(e.message).yellow]
       end
     }
 
-    $stderr.puts "\n" unless @opts[:quiet]
+    $stderr.puts "\n" unless @opts[:quiet] || @opts[:verbose]
 
     failures.each_with_index {|msg, index|
       $stderr.puts unless @opts[:quiet] && index == 0
-      $stderr.puts msg.yellow
+      $stderr.puts '%d) %s' % [index + 1, msg]
     }
 
     unless @opts[:quiet]
       $stderr.puts "\n"
-
-      $stderr.puts "Finished checks for %d package%s with %d failure%s" % [
-        count, count == 1 ? '' : 's',
-        failures.size, failures.size == 1 ? '' : 's'
+      $stderr.puts 'Finished checks for %d package%s with %d failure%s' % [
+        pkgs.size, pkgs.size == 1 ? '' : 's',
+        failures.size, failures.size == 1 ? '' : 's',
       ]
     end
 
@@ -267,29 +248,7 @@ private
       prompt 'Commit the new index?'
     end
 
-    old_index = @git.index
-    target = @git.empty? ? nil : @git.head.target
-
-    if target
-      old_index.read_tree target.tree
-    else
-      old_index.clear
-    end
-
-    root = Pathname.new @git.workdir
-    file = Pathname.new @db.path
-
-    index = @git.index
-    index.add file.relative_path_from(root).to_s
-
-    Rugged::Commit.create @git, \
-      tree: index.write_tree(@git),
-      message: "index: #{changelog}",
-      parents: [target].compact,
-      update_ref: 'HEAD'
-
-    old_index.write
-
+    @git.create_commit "index: #{changelog}", [@index.path]
     $stderr.puts 'commit created'
   end
 
@@ -316,7 +275,19 @@ private
       @add_nl = false
     end
 
-    $stderr.puts "Warning: #{line}".yellow
+    $stderr.puts "warning: #{line}".yellow
+  end
+
+  def progress_wrapper(total, &block)
+    @done, @total = 0, total
+    print_progress
+    block[]
+    $stderr.print "\n" if @add_nl
+  end
+
+  def bump_progress
+    @done += 1
+    print_progress
   end
 
   def print_progress
@@ -330,8 +301,10 @@ private
   end
 
   def ignored?(path)
+    path = path + '/'
+
     @opts[:ignore].each {|pattern|
-      return true if path.start_with? pattern
+      return true if path.start_with? pattern + '/'
     }
 
     false
@@ -340,19 +313,12 @@ private
   def expand_path(path)
     # expand from the repository root or from the current directory if
     # the repository is not yet initialized
-    File.expand_path path, @git ? @git.workdir : Dir.pwd
+    File.expand_path path, @git ? @git.path : Dir.pwd
   end
 
-  def auto_url_tpl
-    remote = @git.remotes['origin']
-    return unless remote
-
-    uri = Gitable::URI.parse remote.url
-    return unless uri.path =~ /\A\/?(?<user>[^\/]+)\/(?<repo>[^\/]+)\.git\Z/
-
-    tpl = uri.to_web_uri
-    tpl.path += '/raw/$commit/$path'
-
-    tpl.to_s
+  def indent(input)
+    output = String.new
+    input.lines {|l| output += "\x20\x20#{l}" }
+    output
   end
 end