delta_test 0.1.0

data/lib/delta_test/configuration.rb

@@ -0,0 +1,173 @@
+require 'set'
+require 'pathname'
+require 'yaml'
+
+require_relative 'git'
+require_relative 'utils'
+
+module DeltaTest
+  class Configuration
+
+    CONFIG_FILES = [
+      'delta_test.yml',
+      'delta_test.yaml',
+    ].freeze
+
+    attr_accessor *%i[
+      base_path
+      files
+
+      table_file
+      patterns
+      exclude_patterns
+      custom_mappings
+    ]
+
+    # for precalculated values
+    attr_reader *%i[
+      filtered_files
+      table_file_path
+    ]
+
+    def initialize
+      update do |c|
+        c.base_path        = File.expand_path('.')
+        c.table_file       = 'tmp/.delta_test_dt'
+        c.files            = []
+        c.patterns         = []
+        c.exclude_patterns = []
+        c.custom_mappings  = {}
+      end
+    end
+
+
+    #  Override setters
+    #-----------------------------------------------
+    ###
+    # Store base_path as Pathname
+    #
+    # @params {String|Pathname} path
+    # @return {Pathname}
+    ###
+    def base_path=(path)
+      @base_path = Pathname.new(path)
+    end
+
+    ###
+    # Store table_file as Pathname
+    #
+    # @params {String|Pathname} path
+    # @return {Pathname}
+    ###
+    def table_file=(path)
+      @table_file = Pathname.new(path)
+    end
+
+
+    #  Update
+    #-----------------------------------------------
+    ###
+    # Update, verify and precalculate
+    #
+    # @block
+    ###
+    def update
+      yield self if block_given?
+      validate!
+      precalculate!
+    end
+
+    ###
+    # Validate option values
+    ###
+    def validate!
+      if self.base_path.relative?
+        raise ValidationError.new(:base_path, 'need to be an absolute path')
+      end
+
+      unless self.files.is_a?(Array)
+        raise ValidationError.new(:files, 'need to be an array')
+      end
+
+      unless self.patterns.is_a?(Array)
+        raise ValidationError.new(:patterns, 'need to be an array')
+      end
+
+      unless self.exclude_patterns.is_a?(Array)
+        raise ValidationError.new(:exclude_patterns, 'need to be an array')
+      end
+
+      unless self.custom_mappings.is_a?(Hash)
+        raise ValidationError.new(:custom_mappings, 'need to be a hash')
+
+        unless self.custom_mappings.values.all? { |v| v.is_a?(Array) }
+          raise ValidationError.new(:custom_mappings, 'need to have an array in the contents')
+        end
+      end
+    end
+
+    ###
+    # Precalculate some values
+    ###
+    def precalculate!
+      filtered_files = self.files
+        .map { |f| Utils.regulate_filepath(f, self.base_path) }
+        .uniq
+
+      filtered_files = Utils.files_grep(filtered_files, self.patterns, self.exclude_patterns)
+
+      @filtered_files = Set.new(filtered_files)
+
+      @table_file_path = Pathname.new(File.absolute_path(self.table_file, self.base_path))
+    end
+
+
+    #  Auto configuration
+    #-----------------------------------------------
+    ###
+    # Use configuration file and git
+    ###
+    def auto_configure!
+      load_from_file!
+      retrive_files_from_git_index!
+      update
+    end
+
+    ###
+    # Load configuration file
+    # And update `base_path` to the directory
+    ###
+    def load_from_file!
+      config_file = Utils.find_file_upward(*CONFIG_FILES)
+
+      unless config_file
+        raise NoConfigurationFileFoundError
+      end
+
+      yaml = YAML.load_file(config_file)
+
+      self.base_path = File.dirname(config_file)
+
+      yaml.each do |k, v|
+        if self.respond_to?("#{k}=")
+          self.send("#{k}=", v)
+        else
+          raise InvalidOptionError.new(k)
+        end
+      end
+    end
+
+    ###
+    # Retrive files from git index
+    # And update `files`
+    ###
+    def retrive_files_from_git_index!
+      unless Git.git_repo?
+        raise NotInGitRepositoryError
+      end
+
+      self.files = Git.ls_files
+    end
+
+  end
+end

data/lib/delta_test/dependencies_table.rb

@@ -0,0 +1,83 @@
+require 'fileutils'
+require 'set'
+
+require_relative 'utils'
+
+module DeltaTest
+  class DependenciesTable < ::Hash
+
+    DEFAULT_PROC = -> (h, k) { h[k] = ::Set.new }
+
+    def initialize
+      super
+
+      self.default_proc = DEFAULT_PROC
+    end
+
+    ###
+    # Restore a table object from a file
+    #
+    # @params {String|Pathname} file
+    ###
+    def self.load(file)
+      begin
+        data = File.binread(file)
+        dt = Marshal.load(data)
+        dt.default_proc = DEFAULT_PROC
+        dt
+      rescue
+        self.new
+      end
+    end
+
+    ###
+    # Add a dependency for a spec file
+    #
+    # @params {String} spec_file
+    # @params {String} source_file
+    ###
+    def add(spec_file, source_file)
+      source_file = Utils.regulate_filepath(source_file, DeltaTest.config.base_path)
+      self[spec_file] << source_file if DeltaTest.config.filtered_files.include?(source_file)
+    end
+
+    ###
+    # Temporary disable default_proc
+    # Because Marshal can't dump Hash with default_proc
+    #
+    # @block
+    ###
+    def without_default_proc
+      self.default_proc = nil
+
+      begin
+        yield
+      ensure
+        self.default_proc = DEFAULT_PROC
+      end
+    end
+
+    ###
+    # Cleanup empty sets from the table
+    ###
+    def cleanup!
+      self.reject! { |k, v| v.empty? }
+    end
+
+    ###
+    # Dump the table object to a file
+    #
+    # @params {String|Pathname} file
+    ###
+    def dump(file)
+      # Marshal can't dump hash with default proc
+      without_default_proc do
+        cleanup!
+        data = Marshal.dump(self)
+        FileUtils.mkdir_p(File.dirname(file))
+        File.open(file, 'wb') { |f| f.write data }
+      end
+    end
+
+  end
+end

data/lib/delta_test/errors.rb

@@ -0,0 +1,55 @@
+module DeltaTest
+
+  class TableNotFoundError < IOError
+
+    def initialize(table_file_path)
+      @table_file_path = table_file_path
+    end
+
+    def message
+      'table file not found at: `%s`' % @table_file_path
+    end
+
+  end
+
+  class NotInGitRepositoryError < StandardError
+
+    def message
+      'the directory is not managed by git'
+    end
+
+  end
+
+  class NoConfigurationFileFoundError < IOError
+
+    def message
+      'no configuration file found'
+    end
+
+  end
+
+  class InvalidOptionError < StandardError
+
+    def initialize(option)
+      @option = option
+    end
+
+    def message
+      'invalid option: %s' % @option
+    end
+
+  end
+
+  class ValidationError < StandardError
+
+    def initialize(name, message)
+      @name, @_message = name, message
+    end
+
+    def message
+      '`%s` %s' % [@name, @_message]
+    end
+
+  end
+
+end

data/lib/delta_test/generator.rb

@@ -0,0 +1,101 @@
+require_relative 'analyzer'
+require_relative 'dependencies_table'
+
+require_relative 'utils'
+
+module DeltaTest
+  class Generator
+
+    attr_reader *%i[
+      current_spec_file
+      table
+    ]
+
+    ###
+    # Setup analyzer and table
+    #
+    # @params {Boolean} _auto_teardown
+    ###
+    def setup!(_auto_teardown = true)
+      return unless DeltaTest.active?
+
+      return if @_setup
+      @_setup = true
+
+      DeltaTest.log('--- setup!')
+
+      @analyzer = Analyzer.new
+      @table    = DependenciesTable.load(DeltaTest.config.table_file_path)
+
+      @current_spec_file = nil
+
+      hook_on_exit { teardown! } if _auto_teardown
+    end
+
+    ###
+    # Start analyzer for the spec file
+    #
+    # @params {String} spec_file
+    ###
+    def start!(spec_file)
+      return unless DeltaTest.active?
+
+      DeltaTest.log('--- start!(%s)' % spec_file)
+
+      @current_spec_file = Utils.regulate_filepath(spec_file, DeltaTest.config.base_path).to_s
+      @analyzer.start
+    end
+
+    ###
+    # Stop analyzer and update table
+    ###
+    def stop!
+      return unless DeltaTest.active?
+
+      DeltaTest.log('--- stop!')
+
+      spec_file = @current_spec_file
+      @current_spec_file = nil
+
+      @analyzer.stop
+
+      if spec_file
+        @analyzer.related_source_files.each do |file|
+          @table.add(spec_file, file)
+        end
+      end
+    end
+
+    ###
+    # Save table to the file
+    ###
+    def teardown!
+      return unless @_setup
+      return if @_teardown
+      @_teardown = true
+
+      DeltaTest.log('--- teardown!')
+
+      @analyzer.stop
+      @table.dump(DeltaTest.config.table_file_path)
+    end
+
+
+  private
+
+    ###
+    # Handle exit event
+    ###
+    def hook_on_exit(&block)
+      at_exit do
+        if defined?(ParallelTests)
+          break unless ParallelTests.first_process?
+          ParallelTests.wait_for_other_processes_to_finish
+        end
+
+        block.call
+      end
+    end
+
+  end
+end

data/lib/delta_test/git.rb

@@ -0,0 +1,88 @@
+require 'open3'
+require 'shellwords'
+
+module DeltaTest
+  module Git
+    class << self
+
+      ###
+      # Check if in git managed directory
+      #
+      # @return {Boolean}
+      ###
+      def git_repo?
+        o, e, s = exec(%q{git rev-parse --is-inside-work-tree}) rescue []
+        !!s && s.success?
+      end
+
+      ###
+      # Get root directory of git
+      #
+      # @return {String}
+      ###
+      def root_dir
+        o, e, s = exec(%q{git rev-parse --show-toplevel})
+        s.success? ? o.strip : nil
+      end
+
+      ###
+      # Get commit id from rev name
+      #
+      # @params {String} rev - e.g., branch name
+      #
+      # @return {String}
+      ###
+      def rev_parse(rev)
+        o, e, s = exec(%q{git rev-parse %s}, rev)
+        s.success? ? o.strip : nil
+      end
+
+      ###
+      # Compare two rev names by their commit ids
+      #
+      # @params {String} r1
+      # @params {String} r2
+      #
+      # @return {Boolean}
+      ###
+      def same_commit?(r1, r2)
+        rev_parse(r1) == rev_parse(r2)
+      end
+
+      ###
+      # Get file list from git index
+      #
+      # @return {Array<String>}
+      ###
+      def ls_files
+        o, e, s = exec(%q{git ls-files -z})
+        s.success? ? o.split("\x0") : []
+      end
+
+      ###
+      # Get list of modified files in diff
+      #
+      # @params {String} base
+      # @params {String} head
+      #
+      # @return {Array<String>}
+      ###
+      def changed_files(base = 'master', head = 'HEAD')
+        o, e, s = exec(%q{git --no-pager diff --name-only -z %s %s}, base, head)
+        s.success? ? o.split("\x0") : []
+      end
+
+
+    private
+
+      ###
+      # Util for executing command
+      ###
+      def exec(command, *args)
+        args = args.map { |a| Shellwords.escape(a) }
+        Open3.capture3(command % args, chdir: DeltaTest.config.base_path)
+      end
+
+    end
+  end
+end

data/lib/delta_test/related_spec_list.rb

@@ -0,0 +1,64 @@
+require 'set'
+
+require_relative 'git'
+require_relative 'dependencies_table'
+
+module DeltaTest
+  class RelatedSpecList
+
+    attr_reader *%i[
+      table
+      changed_files
+    ]
+
+    ###
+    # Load table from the file
+    ###
+    def load_table!
+      unless File.exist?(DeltaTest.config.table_file_path)
+        raise TableNotFoundError.new(DeltaTest.config.table_file_path)
+      end
+
+      @table = DependenciesTable.load(DeltaTest.config.table_file_path)
+    end
+
+    ###
+    # Retrive changed files in git diff
+    #
+    # @params {String} base
+    # @params {String} head
+    ###
+    def retrive_changed_files!(base, head)
+      unless Git.git_repo?
+        raise NotInGitRepositoryError
+      end
+
+      @changed_files = Git.changed_files(base, head)
+    end
+
+    ###
+    # Calculate related spec files
+    #
+    # @return {Set<String>}
+    ###
+    def related_spec_files
+      spec_files = Set.new
+
+      @table.each do |spec_file, dependencies|
+        related = @changed_files.include?(spec_file) \
+          || (dependencies & @changed_files).any?
+
+        spec_files << spec_file if related
+      end
+
+      DeltaTest.config.custom_mappings.each do |spec_file, patterns|
+        if Utils.files_grep(@changed_files, patterns).any?
+          spec_files << spec_file
+        end
+      end
+
+      spec_files
+    end
+
+  end
+end

data/lib/delta_test/spec_helpers.rb

@@ -0,0 +1,42 @@
+require_relative 'generator'
+
+module DeltaTest
+  module SpecHelpers
+
+    ###
+    # Setup generator and hook analyzer on contexts
+    ###
+    def use_delta_test(example)
+      $delta_test_generator ||= DeltaTest::Generator.new
+      $delta_test_generator.setup!
+
+      example.before(:context) do
+        $delta_test_generator.start!(example.metadata[:file_path])
+      end
+
+      example.after(:context) do
+        $delta_test_generator.stop!
+      end
+    end
+
+    ###
+    # Extend
+    #
+    # @params {} example
+    ###
+    def self.extended(example)
+      example.use_delta_test(example)
+    end
+
+    ###
+    # Include
+    # calls `extend` internally
+    #
+    # @params {} example
+    ###
+    def self.included(example)
+      example.extend(self)
+    end
+
+  end
+end

data/lib/delta_test/utils.rb

@@ -0,0 +1,93 @@
+module DeltaTest
+  module Utils
+    class << self
+
+      ###
+      # Convert to relative and clean path
+      #
+      # @params {String|Pathname} file
+      # @params {Pathname} base_path
+      #
+      # @return {Pathname}
+      ###
+      def regulate_filepath(file, base_path)
+        file = Pathname.new(file)
+        file = file.relative_path_from(base_path) rescue file
+        file.cleanpath
+      end
+
+      ###
+      # Find file upward from pwd
+      #
+      # @params {String} file_names
+      #
+      # @return {String}
+      ###
+      def find_file_upward(*file_names)
+        pwd  = Dir.pwd
+        base = Hash.new { |h, k| h[k] = pwd }
+        file = {}
+
+        while base.values.all? { |b| '.' != b && '/' != b }
+          file_names.each do |name|
+            file[name] = File.join(base[name], name)
+            base[name] = File.dirname(base[name])
+
+            return file[name] if File.exists?(file[name])
+          end
+        end
+
+        nil
+      end
+
+      ###
+      # Wildcard pattern matching against a file list
+      #
+      # @params {Array<T as String|Pathname>} files
+      # @params {Array<String>} patterns
+      # @params {Array<String>} exclude_patterns
+      #
+      # @return {Array<T>}
+      ###
+      def files_grep(files, patterns = [], exclude_patterns = [])
+        patterns = patterns
+          .map { |p| grep_pattern_to_regexp(p) }
+        exclude_patterns = exclude_patterns
+          .map { |p| grep_pattern_to_regexp(p) }
+
+        any_patterns         = patterns.any?
+        any_exclude_patterns = exclude_patterns.any?
+
+        files.select do |file|
+          matcher = ->(p) { p === file.to_s }
+
+          (
+            !any_patterns || patterns.any?(&matcher)
+          ) && (
+            !any_exclude_patterns || !exclude_patterns.any?(&matcher)
+          )
+        end
+      end
+
+
+    private
+
+      ###
+      # Convert file wildcard pattern to a regular expression
+      #
+      # @params {String} pattern
+      #
+      # @return {String}
+      ###
+      def grep_pattern_to_regexp(pattern)
+        pattern = Regexp.escape(pattern)
+          .gsub('\*\*/', '.*/?')
+          .gsub('\*\*', '.*')
+          .gsub('\*', '[^/]*')
+
+        Regexp.new('^%s$' % pattern)
+      end
+
+    end
+  end
+end

data/lib/delta_test/version.rb

@@ -0,0 +1,9 @@
+module DeltaTest
+
+  MAJOR    = 0
+  MINOR    = 1
+  REVISION = 0
+
+  VERSION = [MAJOR, MINOR, REVISION].compact.join('.')
+
+end