cir 0.1

data/lib/cir/cli/register_command.rb

@@ -0,0 +1,35 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Cir
+  module Cli
+    ##
+    # Register command
+    class RegisterCommand < CommandWithRepository
+
+      def opts
+        Trollop::Parser.new do
+          banner "Start tracking new file(s)."
+          opt :message, "Optional commit message that should be used when updating the changes in tracking git repository.", type: :string
+        end
+      end
+
+      def process
+        Trollop::die "Missing file list" if self.files.empty?
+
+        self.repository.register(self.files, {message: self.args.message})
+      end
+
+    end
+  end
+end

data/lib/cir/cli/restore_command.rb

@@ -0,0 +1,34 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Cir
+  module Cli
+    ##
+    # Restore command
+    class RestoreCommand < CommandWithRepository
+
+      def opts
+        Trollop::Parser.new do
+          banner "Discard local changes and restore last known version of the file (~ git reset)"
+        end
+      end
+
+      def process
+        Trollop::die "Missing file list" if self.files.empty?
+
+        self.repository.restore(self.files)
+      end
+
+    end
+  end
+end

data/lib/cir/cli/status_command.rb

@@ -0,0 +1,43 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Cir
+  module Cli
+    ##
+    # Status command
+    class StatusCommand < CommandWithRepository
+
+      def opts
+        Trollop::Parser.new do
+          banner "Show status of registered files."
+          opt :show_diff, "Show diffs for changed files", :default => false
+          opt :all, "Display all files even those that haven't been changed", :default => false
+        end
+      end
+
+      def process
+        files = self.repository.status(self.files.empty? ? nil : self.files)
+
+        files.each do |file|
+          diff = file.diff
+          if diff.changed?
+            puts "File #{file.file_path} changed."
+            puts "#{diff.to_s}\n" if self.args[:show_diff]
+          elsif self.args[:all]
+            puts "File #{file.file_path} is the same."
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cir/cli/update_command.rb

@@ -0,0 +1,35 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+module Cir
+  module Cli
+    ##
+    # Update command
+    class UpdateCommand < CommandWithRepository
+
+      def opts
+        Trollop::Parser.new do
+          banner "Note new local changes to the tracked file(s) in the repository (~ git commit)"
+          opt :message, "Optional commit message that should be used when updating the changes in tracking git repository.", type: :string
+        end
+      end
+
+      def process
+        Trollop::die "Missing file list" if self.files.empty?
+
+        self.repository.update(self.files, {message: self.args.message})
+      end
+
+    end
+  end
+end

data/lib/cir/diff_manager.rb

@@ -0,0 +1,52 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'diffy'
+
+module Cir
+  ##
+  # Abstraction above chosen diff library so that we can switch it at runtime if/when needed
+  class DiffManager
+
+    def self.create(source, destination)
+      # Compare stored version in our internal repo and then the current version
+      diff = Diffy::Diff.new(source, destination, source: "files", diff: "-U 3")
+
+      # And finally return diff object with standardized interface
+      DiffManager.new(diff)
+    end
+
+    private
+
+    ##
+    # Persist generated diff inside the class
+    def initialize(diff)
+      @diff = diff
+    end
+
+    public
+
+    ##
+    # Return true if the files are different (e.g. diff is non-empty)
+    def changed?
+      return !@diff.to_s.empty?
+    end
+
+    ##
+    # Serialize the diff into string that can be printed to the console
+    def to_s
+      # We want nice colors by default
+      @diff.to_s(:color)
+    end
+
+  end # class DiffManager
+end # module Cir

data/lib/cir/exception/exceptions.rb

@@ -0,0 +1,28 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module Cir
+  module Exception
+    ##
+    # Thrown in case that we're initializing already existing repository
+    class AlreadyRegistered < RuntimeError; end
+
+    ##
+    # Thrown in case that we're trying to access non existing repository
+    class RepositoryExists < RuntimeError; end
+
+    ##
+    # Thrown if we're trying to work with file that haven't been registered
+    class NotRegistered < RuntimeError; end
+  end
+end
+

data/lib/cir/git_repository.rb

@@ -0,0 +1,96 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'rugged'
+
+module Cir
+  ##
+  # Class wrapping underlying Git library (rugged) and making simple certain operations
+  # that cir needs to do the most.
+  class GitRepository
+
+    ##
+    # Create new git repository
+    def self.create(rootPath)
+      raise Cir::Exception::RepositoryExists, "Path #{rootPath} already exists." if Dir.exists?(rootPath)
+
+      # Without remote we will create blank new repository
+      Rugged::Repository.init_at(rootPath)
+
+      # And return our own wrapper on top of the underlying Rugged object
+      Cir::GitRepository.new(rootPath)
+    end
+
+    ##
+    # Open given existing repository on disk. You might need to {#create} one if needed.
+    def initialize(rootPath)
+      @repo = Rugged::Repository.new(rootPath)
+    end
+
+    ##
+    # Adds given file to index, so that it's properly tracked for next commit. This file *must* contain
+    # local path relative to the root of working directory.
+    def add_file(file)
+      index = @repo.index
+      index.add path: file, oid: (Rugged::Blob.from_workdir @repo, file), mode: 0100644
+      index.write
+    end
+
+    ##
+    # Remove given file from the repository. The path must have the same characteristics as it have
+    # for #add_file method.
+    def remove_file(file)
+      index = @repo.index
+      index.remove file
+    end
+
+    ##
+    # Path to the root of the repository
+    def repository_root
+      File.expand_path(@repo.path + "/../")
+    end
+
+    ##
+    # Commit all staged changes to the git repository
+    def commit(message = nil)
+      # Write current index back to the repository
+      index = @repo.index
+      commit_tree = index.write_tree @repo
+
+      # Commit message
+      files = []
+      index.each {|i| files << File.basename(i[:path]) }
+      message = "Affected files: #{files.join(', ')}" if message.nil?
+
+      # User handling
+      user = ENV['USER']
+      user = "cir-out-commit" if user.nil?
+
+      # Commit author structure for git
+      commit_author = {
+        email: 'cir-auto-commit@nowhere.cz',
+        name: user,
+        time: Time.now
+      }
+
+      # And finally commit itself
+      Rugged::Commit.create @repo,
+        author: commit_author,
+        committer: commit_author,
+        message: message,
+        parents: @repo.empty? ? [] : [ @repo.head.target ].compact,
+        tree: commit_tree,
+        update_ref: 'HEAD'
+    end
+
+  end # class GitRepository
+end # module Cir

data/lib/cir/repository.rb

@@ -0,0 +1,209 @@
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+require 'yaml/store'
+
+module Cir
+  ##
+  # Main database with tracked files and such.
+  class Repository
+    ##
+    # Outside of the git repository we also have separate database of all files that we're tracking with
+    # additional metadata stored in this yaml file.
+    FILE_LIST = 'cir.file_list.yml'
+
+    ##
+    # Create new repository backend (initialize git repo and the metadata database)
+    def self.create(rootPath)
+      git = Cir::GitRepository.create(rootPath)
+
+      # Create database
+      database = YAML::Store.new(rootPath + '/' + FILE_LIST)
+      database.transaction do
+        database[:version] = 1
+        database[:files] = {} 
+      end
+
+      # Add it to git and finish
+      git.add_file FILE_LIST
+      git.commit
+    end
+
+    ##
+    # Load repository (must exists) from given path.
+    def initialize(rootPath)
+      # Database with files and their characteristics
+      @git = Cir::GitRepository.new(rootPath)
+      @database = YAML::Store.new(rootPath + '/' + FILE_LIST)
+    end
+
+    ##
+    # Register new file. Given path must be absolute.
+    #
+    # Options
+    #   :message -> optional git message that should be used
+    def register(files, options = {})
+      expand(files) do |file|
+        # Register is one time operation, one can't re-register existing file
+        raise Cir::Exception::AlreadyRegistered, file if registered?(file)
+
+        # Import file to repository
+        import_file file
+
+        # Create new metadata for the tracked file
+        @database.transaction { @database[:files][file] = {} }
+
+        puts "Registering file: #{file}"
+      end
+
+      # And finally commit the transaction
+      @git.commit(options[:message])
+    end
+
+    ##
+    # Deregister file
+    #
+    # Options
+    #   :message -> optional git message that should be used
+    def deregister(files, options = {})
+      @database.transaction do
+        expand(files) do |file|
+          stored = stored_file(file)
+
+          # Remove the file from git, our database and finally from git working directory
+          FileUtils.rm(stored.repository_location)
+          @git.remove_file(file[1..-1]) # Removing leading "/" to make the absolute path relative to the repository's root
+          @database[:files].delete(file)
+
+          puts "Deregistering file: #{file}"
+        end
+      end
+
+      # And finally commit the transaction
+      @git.commit(options[:message])
+    end
+
+
+    ##
+    # Returns true if given file is registered, otherwise false.
+    def registered?(file)
+      @database.transaction { return @database[:files][file] != nil }
+    end
+
+    ##
+    # Return status for all registered files
+    def status(requested_files = nil)
+      generate_file_list(requested_files)
+    end
+
+
+    ##
+    # Will update stored variant of existing files with their newer copy
+    #
+    # Options
+    #   :message -> optional git message that should be used
+    def update(requested_files = nil, options = {})
+      generate_file_list(requested_files).each do |file|
+        if file.diff.changed?
+          import_file(file.file_path)
+          puts "Updating #{file.file_path}"
+        end
+      end
+
+      # Finally commit the transaction
+      @git.commit(options[:message])
+    end
+
+    ##
+    # Restore persistent variant of the files
+    def restore(requested_files = nil, force = false)
+      generate_file_list(requested_files).each do |file|
+        # If the destination file doesn't exist, we will simply copy it over
+        if not File.exists?(file.file_path)
+          FileUtils.cp(file.repository_location, file.file_path)
+          puts "Restoring #{file.file_path}"
+          next
+        end
+
+        # Skipping files that did not changed
+        next unless file.diff.changed?
+
+        # If we're run with force or in case of specific files, remove existing file and replace it
+        if force or not requested_files.nil?
+          FileUtils.remove_entry(file.file_path)
+          FileUtils.cp(file.repository_location, file.file_path)
+          puts "Restoring #{file.file_path}"
+        else
+          puts "Skipped mass change to #{key}."
+        end
+      end
+    end
+
+    private
+
+    ##
+    # Prepare file list for commands that accepts multiple files or none at all
+    def generate_file_list(requested_files)
+      files = []
+
+      @database.transaction do
+        if requested_files.nil?
+          # No file list, go over all files and detect if they changed
+          @database[:files].each { |file, value| files << stored_file(file) }
+        else
+          # User supplied set of files
+          expand(requested_files) { |file| files << stored_file(file) }
+        end
+      end
+
+      files
+    end
+
+    # Create stored file entity for given file (full path)
+    def stored_file(file)
+      raise Cir::Exception::NotRegistered, file unless @database[:files].include? file
+
+      return Cir::StoredFile.new(
+        file_path: file,
+        repository_location: File.expand_path(@git.repository_root + "/" + file)
+      )
+    end
+
+    ##
+    # Import given file to git repository and add it to index
+    def import_file(file)
+      target_file = File.expand_path(@git.repository_root + "/" + file)
+      target_dir = File.dirname(target_file)
+
+      if File.exists?(target_file)
+        FileUtils.rm_rf(target_file, secure: true)
+      else
+        FileUtils.mkdir_p(target_dir)
+      end
+
+      # And finally copy the file to repository
+      FileUtils.cp(file, target_file)
+
+      # And register it inside git and our metadata database
+      @git.add_file(file[1..-1]) # Removing leading "/" to make the absolute path relative to the repository's root
+    end
+
+    ##
+    # Loop over user specified file paths that will always expand the specified path
+    def expand(files)
+      files.each do |file|
+        expanded = File.expand_path(file)
+        yield expanded
+      end
+    end
+  end # end class Repository
+end # end module Cir