vcs_toolkit 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2f7c92235e805cd0715922732c68622c509ea05e
+  data.tar.gz: f72a425fcf33a19ff060fb20a16e4818730c82e1
+SHA512:
+  metadata.gz: 2b8c306c6e8ce861ae375f2090abbc7f45cbcba7c3b09d4663a86e03a185a34a8a9c7ae2ebc5bd775719cd515b6005b070e01aa4b0cac51fc595116f9bfdfdc9
+  data.tar.gz: 7cee17342b67f593b5abedbdc4ccd20684745a5f224c4269f2169a9c025bfbb935f850416d7478508e28d4de0ec206fb375716d549107916413e6bda28b8c266

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Georgy Angelov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,8 @@
+VCSToolkit
+==========
+
+This gem implements the most basic tasks and objects needed
+to build a fully working Version Control System.
+
+The sample VCS that is being implemented using the VCSToolkit
+is [SCV](https://github.com/stormbreakerbg/scv).

data/lib/vcs_toolkit.rb

@@ -0,0 +1,16 @@
+require 'vcs_toolkit/version'
+require 'vcs_toolkit/exceptions'
+
+require 'vcs_toolkit/diff'
+require 'vcs_toolkit/conflict'
+require 'vcs_toolkit/merge'
+require 'vcs_toolkit/objects'
+
+require 'vcs_toolkit/object_store'
+require 'vcs_toolkit/file_store'
+
+require 'vcs_toolkit/repository'
+
+require 'vcs_toolkit/utils/memory_file_store'
+require 'vcs_toolkit/utils/status'
+require 'vcs_toolkit/utils/sync'

data/lib/vcs_toolkit/conflict.rb

@@ -0,0 +1,55 @@
+require 'diff-lcs'
+require 'vcs_toolkit/diff'
+
+# I know monkey patching is evil but
+# this is used only for consistency in arrays
+# that contain both Diff::LCS::Change and Conflict.
+# So we can do this: `changes.any? { |change| change.conflict? }`
+# instead of `changes.any? { |change| change.is_a? VCSToolkit::Conflict }`
+class Diff::LCS::Change
+  def conflict?
+    false
+  end
+end
+
+module VCSToolkit
+  class Conflict
+    attr_reader :diff_one, :diff_two
+
+    def initialize(diff_one, diff_two)
+      @diff_one = diff_one
+      @diff_two = diff_two
+    end
+
+    def conflict?
+      true
+    end
+
+    # These methods are used for compatibility with ::Diff::LCS::Change
+    # so we can do this: `changes.any? { |change| change.adding? }`
+    # instead of `changes.any? { |change| (not change.is_a? VCSToolkit::Conflict) and change.adding? }`
+    def adding?
+      false
+    end
+
+    def deleting?
+      false
+    end
+
+    def unchanged?
+      false
+    end
+
+    def changed?
+      false
+    end
+
+    def finished_a?
+      false
+    end
+
+    def finished_b?
+      false
+    end
+  end
+end

data/lib/vcs_toolkit/diff.rb

@@ -0,0 +1,61 @@
+require 'diff-lcs'
+
+module VCSToolkit
+  class Diff
+    include Enumerable
+
+    def initialize(changes)
+      @changes = changes
+    end
+
+    def has_changes?
+      not @changes.all?(&:unchanged?)
+    end
+
+    def has_conflicts?
+      @changes.any?(&:conflict?)
+    end
+
+    def each(&block)
+      @changes.each &block
+    end
+
+    def to_s
+      flat_map do |change|
+        if change.unchanged?
+          [change.new_element]
+        elsif change.deleting?
+          ["-#{change.old_element}"]
+        elsif change.adding?
+          ["+#{change.new_element}"]
+        elsif change.changed?
+          ["-#{change.old_element}", "+#{change.new_element}"]
+        else
+          raise "Unknown change in the diff #{change.action}"
+        end
+      end.join ''
+    end
+
+    ##
+    # Reconstruct the new sequence from the diff
+    #
+    def new_content(conflict_start='<<<', conflict_switch='>>>', conflict_end='===')
+      flat_map do |change|
+        if change.conflict?
+          version_one = change.diff_one.new_content(conflict_start, conflict_switch, conflict_end)
+          version_two = change.diff_two.new_content(conflict_start, conflict_switch, conflict_end)
+
+          [conflict_start] + version_one + [conflict_switch] + version_two + [conflict_end]
+        elsif change.deleting?
+          []
+        else
+          [change.new_element]
+        end
+      end
+    end
+
+    def self.from_sequences(sequence_one, sequence_two)
+      new ::Diff::LCS.sdiff(sequence_one, sequence_two)
+    end
+  end
+end

data/lib/vcs_toolkit/exceptions.rb

@@ -0,0 +1,10 @@
+module VCSToolkit
+  class VCSToolkitError < StandardError
+  end
+
+  class InvalidObjectError < VCSToolkitError
+  end
+
+  class UnknownLabelError < VCSToolkitError
+  end
+end

data/lib/vcs_toolkit/file_store.rb

@@ -0,0 +1,139 @@
+require 'vcs_toolkit/exceptions'
+
+module VCSToolkit
+  ##
+  # This class is used to implement a custom storage provider for
+  # files.
+  #
+  class FileStore
+    ##
+    # Implement this to store a specific file in persistent storage.
+    #
+    def store(path, blob)
+      raise NotImplementedError, 'You must implement FileStore#store'
+    end
+
+    ##
+    # Implement this to retrieve a file with the specified name.
+    #
+    def fetch(path)
+      raise NotImplementedError, 'You must implement FileStore#fetch'
+    end
+
+    ##
+    # Implement this to delete the specified file
+    #
+    def delete_file(path)
+      raise NotImplementedError, 'You must implement FileStore#delete_file'
+    end
+
+    ##
+    # Implement this to delete the specified directory.
+    # This method will be called only on empty directories.
+    # Use #delete if you want to recursively delete a directory.
+    #
+    def delete_dir(path)
+      raise NotImplementedError, 'You must implement FileStore#delete_dir'
+    end
+
+    ##
+    # Implement this to detect wether a file with that name exists.
+    #
+    def file?(path)
+      raise NotImplementedError, 'You must implement FileStore#file?'
+    end
+
+    ##
+    # Implement this to detect wether a directory with that name exists.
+    #
+    def directory?(path)
+      raise NotImplementedError, 'You must implement FileStore#directory?'
+    end
+
+    ##
+    # Implement this to compare a file and a blob object.
+    # It should return boolean value to indicate wether the file is different.
+    #
+    # The hash algorithm should be the same one used in `Objects::*`.
+    #
+    def changed?(path, blob)
+      raise NotImplementedError, 'You must implement FileStore#changed?'
+    end
+
+    ##
+    # Implement this to enumerate over all files in the given directory.
+    #
+    # The order of enumeration doesn't matter.
+    #
+    def each_file(path='')
+      raise NotImplementedError, 'You must implement FileStore#each_file'
+    end
+
+    ##
+    # Implement this to enumerate over all files.
+    #
+    # The order of enumeration doesn't matter.
+    #
+    def each_directory(path='')
+      raise NotImplementedError, 'You must implement FileStore#each_directory'
+    end
+
+    def exist?(path)
+      file?(path) or directory?(path)
+    end
+
+    def files(path='', ignore: [])
+      enum_for(:each_file, path).reject { |file| ignored? file, ignore }
+    end
+
+    def directories(path='', ignore: [])
+      enum_for(:each_directory, path).reject { |file| ignored? file, ignore }
+    end
+
+    def all_files(path='', ignore: [])
+      enum_for :yield_all_files, path, ignore: ignore
+    end
+
+    def delete(path)
+      if directory? path
+        files(path).each do |file|
+          delete_file File.join(path, file)
+        end
+
+        directories(path).each do |directory|
+          delete File.join(path, directory)
+        end
+
+        delete_dir path
+      else
+        delete_file path
+      end
+    end
+
+    private
+
+    def yield_all_files(path='', ignore: [], &block)
+      files(path).reject { |path| ignored? path, ignore }.each &block
+
+      directories(path).each do |dir_name|
+        dir_path = File.join(path, dir_name).sub(/^\/+/, '')
+
+        all_files(dir_path).each do |file|
+          file_path = File.join(dir_name, file)
+
+          yield file_path unless ignored?(file_path, ignore) or ignored?(file.split('/').last, ignore)
+        end
+      end
+    end
+
+    def ignored?(path, ignores)
+      ignores.any? do |ignore|
+        if ignore.is_a? Regexp
+          ignore =~ path
+        else
+          ignore == path
+        end
+      end
+    end
+  end
+end

data/lib/vcs_toolkit/merge.rb

@@ -0,0 +1,96 @@
+require 'vcs_toolkit/diff'
+require 'vcs_toolkit/conflict'
+
+module VCSToolkit
+  module Merge
+    extend self
+
+    def three_way(sequence_one, sequence_two, sequence_three)
+      diff_one = Diff.from_sequences(sequence_one, sequence_two)
+      diff_two = Diff.from_sequences(sequence_one, sequence_three)
+
+      combined_changes = combine_diffs diff_one, diff_two
+      merge_changes = combined_changes.flat_map do |line_number, (changeset_one, changeset_two)|
+        if changeset_one.all?(&:unchanged?)
+          changeset_two
+        elsif changeset_two.all?(&:unchanged?)
+          changeset_one
+        elsif same_changes(changeset_one, changeset_two)
+          # TODO: Check if they can be the same but one is split in two parts
+          changeset_one
+        else
+          extract_conflict(changeset_one, changeset_two)
+        end
+      end
+
+      Diff.new merge_changes
+    end
+
+    private
+
+    ##
+    # Return common prefix and suffix of the two changesets
+    # in the following format:
+    #
+    #  [<common_prefix_list>, Conflict(Diff, Diff), <common_suffix_list>]
+    #
+    def extract_conflict(changeset_one, changeset_two)
+      common_start = changeset_one.zip(changeset_two).take_while do |change_one, change_two|
+        same_change(change_one, change_two)
+      end
+
+      common_end = changeset_one.reverse.zip(changeset_two.reverse).take_while do |change_one, change_two|
+        same_change(change_one, change_two)
+      end
+
+      common_size = common_end.size + common_start.size
+
+      diff_one = Diff.new changeset_one.slice(common_start.size, changeset_one.size - common_size)
+      diff_two = Diff.new changeset_two.slice(common_start.size, changeset_two.size - common_size)
+
+      common_start.map(&:first) + [Conflict.new(diff_one, diff_two)] + common_end.map(&:first)
+    end
+
+    def same_changes(changeset_one, changeset_two)
+      changeset_one.size == changeset_two.size and
+      changeset_one.zip(changeset_two).all? do |change_one, change_two|
+        same_change(change_one, change_two)
+      end
+    end
+
+    def same_change(change_one, change_two)
+      # new_position is not compared deliberately
+      # because any additions on a file will increase new_position
+      # and because of that it will cause conflicts even
+      # if the changes are the same
+      change_one.action       == change_two.action       and
+      change_one.old_position == change_two.old_position and
+      change_one.old_element  == change_two.old_element  and
+      change_one.new_element  == change_two.new_element
+    end
+
+    ##
+    # Group changes by their old index.
+    #
+    # The structure is as follows:
+    #
+    #   {
+    #     <line_number_on_ancestor> => [
+    #       [ <change>, ... ], # The changes in the first file
+    #       [ <change>, ... ]  # The changes in the second file
+    #     ]
+    #   }
+    def combine_diffs(diff_one, diff_two)
+      Hash.new { |hash, key| hash[key] = [[], []] }.tap do |combined_diff|
+        diff_one.each do |change|
+          combined_diff[change.old_position].first << change
+        end
+
+        diff_two.each do |change|
+          combined_diff[change.old_position].last << change
+        end
+      end
+    end
+
+  end
+end

data/lib/vcs_toolkit/object_store.rb

@@ -0,0 +1,51 @@
+require 'vcs_toolkit/exceptions'
+
+module VCSToolkit
+  ##
+  # This class is used to implement a custom storage provider for
+  # objects.
+  #
+  # The methods are compatible with the interface of Hash so that
+  # a simple Hash can be used instead of a full-featured object manager.
+  #
+  class ObjectStore
+    include Enumerable
+
+    ##
+    # Implement this to store a specific object in persistent storage.
+    #
+    # object_id is here for compatibility with Hash
+    #
+    def store(object_id, object)
+      raise NotImplementedError, 'You must implement ObjectStore#store'
+    end
+
+    ##
+    # Implement this to retrieve an object with the specified object_id.
+    # It should detect the object type and instantiate the specific
+    # object class (or a subclass of it).
+    #
+    def fetch(object_id)
+      raise NotImplementedError, 'You must implement ObjectStore#fetch'
+    end
+
+    ##
+    # Implement this to detect wether a object with that object_id exists.
+    #
+    def key?(object_id)
+      raise NotImplementedError, 'You must implement ObjectStore#key?'
+    end
+
+    ##
+    # Implement this to enumerate over all objects that
+    # have Object#named? set to true.
+    # Even enumeration of all objects is possible, but is not
+    # neccessary.
+    #
+    # The order of enumeration doesn't matter.
+    #
+    def each
+      raise NotImplementedError, 'You must implement ObjectStore#each'
+    end
+  end
+end