meta_commit 0.1.0.alpha → 0.2.0.pre.alpha

data/lib/meta_commit/container.rb

@@ -0,0 +1,80 @@
+require 'dry/container'
+module MetaCommit
+  class Container
+    include Dry::Container::Mixin
+
+    def initialize
+      super
+      register :parser_classes, []
+      register :diff_classes, []
+    end
+
+    # @param [MetaCommit::ConfigStore] config_store
+    # @return [MetaCommit::Container]
+    def boot(config_store)
+      load_packages(config_store.get(:extensions))
+
+      register :diff_factory, MetaCommit::Factories::DiffFactory.new(self[:diff_classes])
+      register :parser_factory, MetaCommit::Factories::ParserFactory.new(self[:parser_classes])
+      register :parse_command, MetaCommit::Services::Parse.new(self[:parser_factory])
+      register :contextual_ast_node_factory, MetaCommit::Factories::ContextualAstNodeFactory.new
+
+      self
+    end
+
+    # @param [Array<String>] extensions_to_load
+    def load_packages(extensions_to_load)
+      # @TODO refactor so it search in GEM_HOME dir (?)
+      required_extensions(extensions_to_load).each do |gem|
+        gem.require_paths.each do |path|
+          gem_source_path = File.join(gem.full_gem_path, path)
+          $LOAD_PATH.unshift gem_source_path
+          require gem.name
+        end
+
+        extension = extension_class(camelize(without_extension_prefix(gem.name))).new
+
+        self[:parser_classes].concat(extension.parsers)
+        self[:diff_classes].concat(extension.diffs)
+      end
+    end
+
+    protected :load_packages
+
+    # @param [Array<String>] extensions_to_load
+    # @return [Array<String>]
+    def required_extensions(extensions_to_load)
+      extensions = Gem::Specification.find_all.select do |gem|
+        gem.name =~ /^meta_commit_/ && gem.name != 'meta_commit_contracts' && extensions_to_load.include?(without_extension_prefix gem.name)
+      end
+      extensions.uniq {|gem| gem.name}
+    end
+
+    protected :required_extensions
+
+    # @param [String] extension name
+    # @return [Class] extension class
+    def extension_class(extension)
+      "MetaCommit::Extension::#{extension}::Locator".split('::').inject(Object) {|o, c| o.const_get(c)}
+    end
+
+    protected :extension_class
+
+    # @param [String] extension_name
+    # @return [String]
+    def camelize(extension_name)
+      return extension_name.slice(0, 1).capitalize + extension_name.slice(1..-1) unless extension_name.include?('_') #  capitalize only first letter if name is not in snake case
+      extension_name.split('_').collect(&:capitalize).join
+    end
+
+    protected :camelize
+
+    # @param [String] extension_name
+    # @return [String]
+    def without_extension_prefix(extension_name)
+      extension_name.sub('meta_commit_', '')
+    end
+
+    protected :without_extension_prefix
+  end
+end

data/lib/meta_commit/errors.rb

@@ -0,0 +1,12 @@
+module MetaCommit::Errors
+  class MissingRepoError < StandardError
+    def initialize(msg='Passed directory is not a git repo')
+      super(msg)
+    end
+  end
+  class MissingConfigError < StandardError
+    def initialize(msg='Passed config file does not exist')
+      super(msg)
+    end
+  end
+end

data/lib/meta_commit/factories/contextual_ast_node_factory.rb

@@ -0,0 +1,61 @@
+module MetaCommit::Factories
+  # Factory that builds ContextualAstNode from ast nodes
+  class ContextualAstNodeFactory
+
+    # @param [MetaCommit::Contracts::Ast] source_ast
+    # @param [Integer] line_number
+    # @return [MetaCommit::Models::ContextualAstNode]
+    def create_ast_path(source_ast, line_number)
+      visited_nodes = []
+      ast_path = MetaCommit::Models::ContextualAstNode.new
+      ast_path.parser_class = source_ast.parser_class
+      ast_path.target_node = collect_path_to_ast_at_line(source_ast, line_number, visited_nodes)
+      ast_path.context_nodes = visited_nodes
+      ast_path
+    end
+
+    # @param [MetaCommit::Contracts::Ast] ast
+    # @param [Integer] lineno
+    # @param [Array<MetaCommit::Contracts::Ast>] accumulator
+    # @return [MetaCommit::Contracts::Ast]
+    def collect_path_to_ast_at_line(ast, lineno, accumulator)
+      return nil if ast.nil? or not covers_line(ast, lineno)
+      closest_ast = ast
+      accumulator.push(closest_ast)
+      ast.children.each do |child|
+        found_ast = collect_path_to_ast_at_line(child, lineno, accumulator)
+        closest_ast = found_ast unless found_ast.nil?
+      end
+      closest_ast
+    end
+
+    protected :collect_path_to_ast_at_line
+
+
+    # @param [MetaCommit::Contracts::Ast] ast
+    # @param [Integer] lineno
+    # @return [MetaCommit::Contracts::Ast]
+    def get_ast_at_line(ast, lineno)
+      return nil unless covers_line(ast, lineno)
+      closest_ast = ast
+      ast.children.each do |child|
+        found_ast = get_ast_at_line(child, lineno)
+        closest_ast = found_ast unless found_ast.nil?
+      end
+      closest_ast
+    end
+
+    protected :get_ast_at_line
+
+
+    # @param [MetaCommit::Contracts::Ast] ast
+    # @param [Integer] line
+    # @return [Boolean]
+    def covers_line(ast, line)
+      return false if ((ast.first_line.nil?) && (ast.last_line.nil?))
+      ((ast.first_line <= line) && (ast.last_line >= line))
+    end
+
+    protected :covers_line
+  end
+end

data/lib/meta_commit/factories/diff_factory.rb

@@ -0,0 +1,37 @@
+module MetaCommit::Factories
+  # Diff factory
+  # @attr [Array<Class>] available_diff_classes diff classes that factory can build
+  class DiffFactory
+    attr_accessor :available_diff_classes
+
+    def initialize(diff_classes)
+      @available_diff_classes = diff_classes
+    end
+
+    # Factory method
+    # @param [Symbol] type
+    # @param [Hash] options
+    # @return [Diff, nil] created diff or nil if matched diff not found
+    def create_diff_of_type(type, options)
+      @available_diff_classes.each do |diff_class|
+        diff = diff_class.new
+        if diff.supports_parser?(options[:old_ast_path].parser_class) &&
+            diff.supports_parser?(options[:new_ast_path].parser_class) &&
+            diff.supports_change(type, options[:old_file_path], options[:new_file_path], options[:old_ast_path], options[:new_ast_path])
+          line = options[:line]
+          diff.diff_type = line.line_origin
+          diff.commit_old = options[:commit_id_old]
+          diff.commit_new = options[:commit_id_new]
+          diff.old_file = options[:old_file_path]
+          diff.new_file = options[:new_file_path]
+          diff.old_lineno = line.old_lineno
+          diff.new_lineno = line.new_lineno
+          diff.old_ast_path = options[:old_ast_path]
+          diff.new_ast_path = options[:new_ast_path]
+          return diff
+        end
+      end
+      nil
+    end
+  end
+end

data/lib/meta_commit/factories/parser_factory.rb

@@ -0,0 +1,30 @@
+module MetaCommit::Factories
+  # Parser factory
+  # @attr [Array<Class>] available_parser_classes parser classes that factory can build
+  class ParserFactory
+    attr_accessor :available_parser_classes
+
+    # @param [Array<Class>] parser_classes
+    def initialize(parser_classes)
+      @available_parser_classes = parser_classes
+    end
+
+    # @param [String] filename
+    # @param [String] content
+    # @return [MetaCommit::Contracts::Parser, Nil]
+    def create_parser_for(filename, content)
+      @available_parser_classes.each do |parser|
+        return parser.new if parser_supports(parser, filename, content)
+      end
+      nil
+    end
+
+    # @param [Class] parser
+    # @param [String] filename
+    # @param [String] content
+    # @return [Boolean]
+    def parser_supports(parser, filename, content)
+      (parser.supported_file_extensions.any? {|ext| filename.end_with?(ext)}) && (parser.supports_syntax?(content))
+    end
+  end
+end

data/lib/meta_commit/git/repo.rb

@@ -1,13 +1,26 @@
 require 'rugged'
 
 module MetaCommit::Git
+  # Rugged::Repository wrapper
+  # @attr [Rugged::Repository] repo
   class Repo
+    DIFF_OPTIONS = {:context_lines => 0, :ignore_whitespace => true}
+    FILE_NOT_EXISTS_OID = '0000000000000000000000000000000000000000'
+
     attr_accessor :repo
 
+    # @param [String] repo_path
     def initialize(repo_path)
-      @repo = Rugged::Repository.new(repo_path)
+      begin
+        @repo = Rugged::Repository.new(repo_path)
+      rescue Rugged::OSError
+        raise MetaCommit::Errors::MissingRepoError
+      rescue Rugged::RepositoryError
+        raise MetaCommit::Errors::MissingRepoError
+      end
     end
 
+    # @return [Rugged::Walker] commit iterator
     def walker
       walker = Rugged::Walker.new(@repo)
       walker.sorting(Rugged::SORT_REVERSE)
@@ -15,6 +28,8 @@ module MetaCommit::Git
       walker
     end
 
+    # Starts commit walker and yields following commits for easier iteration
+    # @yield [previous_commit, current_commit]
     def walk_by_commits
       walker = Rugged::Walker.new(@repo)
       walker.sorting(Rugged::SORT_REVERSE)
@@ -29,22 +44,64 @@ module MetaCommit::Git
       end
     end
 
+    # Proxy to Rugged::Repository#diff
+    # @param [Object] left
+    # @param [Object] right
+    # @param [Hash] options
+    # @return [Rugged::Diff::Delta]
     def diff(left, right, options)
       @repo.diff(left, right, options)
     end
 
+    # Iterates over optimized lines in diff
+    # @param [Object] left
+    # @param [Object] right
+    # @yield [old_file_path, new_file_path, patch, line]
+    # @return [Object]
+    def diff_with_optimized_lines(left, right)
+      diff = @repo.diff(left, right, DIFF_OPTIONS)
+      diff.deltas.zip(diff.patches).each do |delta, patch|
+        lines = organize_lines(delta, patch)
+        lines.each do |line|
+          yield(delta.old_file[:path], delta.new_file[:path], patch, line)
+        end
+      end
+    end
+
+    # Iterates over optimized lines in index diff
+    # @yield [old_file_path, new_file_path, patch, line]
+    # @return [Object]
+    def index_diff_with_optimized_lines
+      diff = index_diff(DIFF_OPTIONS)
+      diff.deltas.zip(diff.patches).each do |delta, patch|
+        lines = organize_lines(delta, patch)
+        lines.each do |line|
+          yield(delta.old_file[:path], delta.new_file[:path], patch, line)
+        end
+      end
+    end
+
+    # Proxy to Rugged::Index#diff
+    # @param [Hash] options
+    # @return [Rugged::Diff::Delta]
     def index_diff(options)
       @repo.index.diff(@repo.head.target.tree, options)
     end
 
+    # @param [String] revision commit hash
+    # @param [String] path
+    # @param [String] default value to be returned if error appears
     def get_blob_at(revision, path, default = nil)
       blob = @repo.blob_at(revision, path)
       return blob.content unless blob.nil?
       default
     end
 
+    # @param [String] rel_repo_file_path file path relative to repository root
+    # @param [String] default value to be returned if error appears
+    # @return [String] file content or default value
     def get_content_of(rel_repo_file_path, default = nil)
-      absolute_file_path = @repo.path.reverse.sub('/.git'.reverse, '').reverse + rel_repo_file_path
+      absolute_file_path = dir + rel_repo_file_path
       begin
         content = open(absolute_file_path).read
       rescue Errno::ENOENT
@@ -53,8 +110,73 @@ module MetaCommit::Git
       content
     end
 
+    # @return [String] path to .git folder of repository
     def path
       @repo.path
     end
+
+    # @return [String] directory of repository
+    def dir
+      @repo.path.reverse.sub('/.git'.reverse, '').reverse
+    end
+
+    # @param [String] search_tag
+    # @return [Rugged::Commit, nil]
+    def commit_of_tag(search_tag)
+      @repo.tags.each do |tag|
+        return tag.target if tag.name == search_tag
+      end
+    end
+
+    # @return [String] last commit oid
+    def last_commit_oid
+      @repo.last_commit.oid
+    end
+
+    # @param [Object] delta
+    # @param [Object] patch
+    # @return [Array<MetaCommit::Models::Line>]
+    def organize_lines(delta, patch)
+      lines_to_walk = []
+      # if whole file was changed examine one time only
+      whole_file_changed = (delta.old_file[:oid] == FILE_NOT_EXISTS_OID) || (delta.new_file[:oid] == FILE_NOT_EXISTS_OID)
+      skip_walking = false
+      skip_next_line = false
+      patch.hunks.each_with_index do |hunk|
+        break if skip_walking
+        hunk.lines.each_with_index do |line, line_index|
+          break if skip_walking
+
+          if skip_next_line
+            skip_next_line = false
+            next
+          end
+
+          next_line = hunk.lines[line_index + 1]
+          is_replace_change = (line.deletion?) && (!next_line.nil? && next_line.addition?) && (line.old_lineno && next_line.new_lineno)
+
+          line_to_walk = MetaCommit::Models::Line.new
+          if is_replace_change
+            line_to_walk.line_origin=:replace
+            line_to_walk.old_lineno=line.old_lineno
+            line_to_walk.new_lineno=next_line.new_lineno
+          else
+            line_to_walk.line_origin=line.line_origin
+            line_to_walk.old_lineno=line.old_lineno
+            line_to_walk.new_lineno=line.new_lineno
+          end
+          if is_replace_change
+            skip_next_line = true
+          end
+          lines_to_walk.push(line_to_walk)
+
+          skip_walking = true if whole_file_changed
+        end
+      end
+      lines_to_walk
+    end
+
+    private :organize_lines
+
   end
 end

data/lib/meta_commit/index/adapters/git_notes.rb

@@ -0,0 +1,34 @@
+module MetaCommit::Index
+  module Adapters
+    # Adapter class to write repository changes to git notes
+    # @attr [String] git_folder_path
+    class GitNotes
+      attr_accessor :git_folder_path
+
+      # @param [String] git_folder_path
+      def initialize(git_folder_path)
+        @git_folder_path = git_folder_path
+      end
+
+      # @param [MetaCommit::Git::Repo] repo
+      # @param [MetaCommit::Models::Changes::Repository] repository_changes
+      def write_repository_change_chunk(repo, repository_changes)
+        repository_changes.each do |commit_changes|
+          diffs=[]
+          commit_changes.file_changes.uniq.each do |change|
+            diffs.push(" - #{change.string_representation}")
+          end
+          write_to_notes(commit_changes.new_commit_id, diffs.join("\n"))
+        end
+      end
+
+      # @param [String] commit_id
+      # @param [String] message
+      def write_to_notes(commit_id, message)
+        system("git --git-dir '#{@git_folder_path}' notes add -f -m '#{message}' #{commit_id}")
+      end
+
+      protected :write_to_notes
+    end
+  end
+end

data/lib/meta_commit/index/commands/diff_examiner.rb

@@ -0,0 +1,58 @@
+module MetaCommit::Index
+  module Commands
+    class DiffExaminer
+      # @param [MetaCommit::Services::Parse] parse_command
+      # @param [MetaCommit::Factories::ContextualAstNodeFactory] ast_path_factory
+      # @param [MetaCommit::Factories::DiffFactory] diff_factory
+      def initialize(parse_command, ast_path_factory, diff_factory)
+        @parse_command = parse_command
+        @ast_path_factory = ast_path_factory
+        @diff_factory = diff_factory
+      end
+
+      # Creates diff objects with meta information of changes in repository commits
+      # @param [MetaCommit::Git::Repo] repo
+      def meta(repo)
+        repo_changes = MetaCommit::Models::Changes::Repository.new(repo.path)
+        repo.walk_by_commits do |left_commit, right_commit|
+          commit_changes = MetaCommit::Models::Changes::Commit.new(left_commit.oid, right_commit.oid)
+          diffs = examine_diff(repo, left_commit, right_commit)
+          commit_changes.push_changes(diffs)
+          repo_changes.push(commit_changes)
+        end
+        repo_changes
+      end
+
+      # @return [Array<MetaCommit::Models::Diffs::Diff>]
+      def examine_diff(repo, left_commit, right_commit)
+        diffs = []
+        repo.diff_with_optimized_lines(left_commit, right_commit) do |old_file_path, new_file_path, patch, line|
+          old_file_content = repo.get_blob_at(left_commit.oid, old_file_path, '')
+          new_file_content = repo.get_blob_at(right_commit.oid, new_file_path, '')
+
+          old_file_ast = @parse_command.execute(old_file_path, old_file_content)
+          next if old_file_ast.nil?
+          new_file_ast = @parse_command.execute(new_file_path, new_file_content)
+          next if new_file_ast.nil?
+
+          old_ast_path = @ast_path_factory.create_ast_path(old_file_ast, line.old_lineno)
+          new_ast_path = @ast_path_factory.create_ast_path(new_file_ast, line.new_lineno)
+
+          created_diff = @diff_factory.create_diff_of_type(line.line_origin, {
+              :line => line,
+              :commit_id_old => left_commit.oid,
+              :commit_id_new => right_commit.oid,
+              :old_ast_path => old_ast_path,
+              :new_ast_path => new_ast_path,
+              :old_file_path => old_file_path,
+              :new_file_path => new_file_path,
+          })
+          diffs.push(created_diff) unless created_diff.nil?
+        end
+        diffs
+      end
+
+      private :examine_diff
+    end
+  end
+end

data/lib/meta_commit/message/commands/diff_index_examiner.rb

@@ -0,0 +1,48 @@
+module MetaCommit::Message
+  module Commands
+    class DiffIndexExaminer
+      # @param [MetaCommit::Services::Parse] parse_command
+      # @param [MetaCommit::Factories::ContextualAstNodeFactory] ast_path_factory
+      # @param [MetaCommit::Factories::DiffFactory] diff_factory
+      def initialize(parse_command, ast_path_factory, diff_factory)
+        @parse_command = parse_command
+        @ast_path_factory = ast_path_factory
+        @diff_factory = diff_factory
+      end
+
+      # Creates diff objects with meta information of changes in index staged files
+      # @param [MetaCommit::Git::Repo] repo
+      # @return [Array<MetaCommit::Models::Diffs::Diff>]
+      def index_meta(repo)
+        diffs = MetaCommit::Models::Changes::Commit.new(repo.last_commit_oid, 'staged')
+        repo.index_diff_with_optimized_lines do |old_file_path, new_file_path, patch, line|
+          commit_id_old = repo.last_commit_oid
+          commit_id_new = 'staged'
+
+          old_file_content = repo.get_blob_at(commit_id_old, old_file_path, '')
+          new_file_content = repo.get_content_of(new_file_path, '')
+
+          old_file_ast = @parse_command.execute(old_file_path, old_file_content)
+          next if old_file_ast.nil?
+          new_file_ast = @parse_command.execute(new_file_path, new_file_content)
+          next if new_file_ast.nil?
+
+          old_ast_path = @ast_path_factory.create_ast_path(old_file_ast, line.old_lineno)
+          new_ast_path = @ast_path_factory.create_ast_path(new_file_ast, line.new_lineno)
+
+          created_diff = @diff_factory.create_diff_of_type(line.line_origin, {
+              :line => line,
+              :commit_id_old => commit_id_old,
+              :commit_id_new => commit_id_new,
+              :old_ast_path => old_ast_path,
+              :new_ast_path => new_ast_path,
+              :old_file_path => old_file_path,
+              :new_file_path => new_file_path,
+          })
+          diffs.push(created_diff) unless created_diff.nil?
+        end
+        diffs
+      end
+    end
+  end
+end

data/lib/meta_commit/message/formatters/commit_message_builder.rb

@@ -0,0 +1,16 @@
+module MetaCommit::Message
+  module Formatters
+    # Class builds message to commit changes
+    class CommitMessageBuilder
+      # @param [Array<MetaCommit::Models::Diffs::Diff>] diffs
+      # @return [String]
+      def build(diffs)
+        result = ''
+        diffs.each do |diff|
+          result << "- #{diff.string_representation} \n"
+        end
+        result
+      end
+    end
+  end
+end

data/lib/meta_commit/models/changes/commit.rb

@@ -1,17 +1,30 @@
 module MetaCommit::Models::Changes
+  # Collection of file changes
+  # @attr [Symbol] old_commit_id
+  # @attr [Symbol] new_commit_id
+  # @attr [Array<MetaCommit::Contracts::Diff>] file_changes
   class Commit
     attr_accessor :old_commit_id, :new_commit_id, :file_changes
 
+    # @param [Symbol] old_commit_id
+    # @param [Symbol] new_commit_id
     def initialize(old_commit_id, new_commit_id)
       @old_commit_id = old_commit_id
       @new_commit_id = new_commit_id
       @file_changes = []
     end
 
+    # @param [MetaCommit::Contracts::Diff] file_change
     def push(file_change)
       @file_changes.push(file_change)
     end
 
+    # @param [Array<MetaCommit::Contracts::Diff>] file_changes
+    def push_changes(file_changes)
+      @file_changes+=file_changes
+    end
+
+    # @return [String]
     def commit_id
       if @old_commit_id == @new_commit_id
         @new_commit_id
@@ -20,8 +33,19 @@ module MetaCommit::Models::Changes
       end
     end
 
+    # @yield file changes
     def each(&block)
       @file_changes.each(&block)
     end
+
+    # @return [Boolean]
+    def empty?
+      @file_changes.empty?
+    end
+
+    # @return [Boolean]
+    def include?(change)
+      @file_changes.include?(change)
+    end
   end
 end

data/lib/meta_commit/models/changes/repository.rb

@@ -1,18 +1,30 @@
 module MetaCommit::Models::Changes
+  # Collection of commit changes
+  # @attr [String] repo_id
+  # @attr [Array<MetaCommit::Models::Commit>] commit_changes
   class Repository
     attr_accessor :repo_id, :commit_changes
 
+    # @param [String] repo_id
     def initialize(repo_id)
       @repo_id = repo_id
       @commit_changes = []
     end
 
+
+    # @param [MetaCommit::Models::Commit] commit_change
     def push(commit_change)
       @commit_changes.push(commit_change)
     end
 
+    # @yield commit changes
     def each(&block)
       @commit_changes.each(&block)
     end
+
+    # @return [Boolean]
+    def empty?
+      @commit_changes.empty?
+    end
   end
 end

data/lib/meta_commit/models/contextual_ast_node.rb

@@ -0,0 +1,9 @@
+module MetaCommit::Models
+  # Stores specific node from ast and all nodes bypassed on the way to target node
+  # @attr [MetaCommit::Contracts::Ast] target_node Target node from AST
+  # @attr [Array<MetaCommit::Contracts::Ast>] context_nodes Nodes bypassed on the way to target node
+  # @attr [Class] parser_class
+  class ContextualAstNode
+    attr_accessor :target_node, :context_nodes, :parser_class
+  end
+end