autowow 0.3.0 → 0.4.0

data/lib/autowow/command.rb

@@ -1,78 +0,0 @@
-require 'open3'
-
-module Autowow
-  class Command
-
-    include EasyLogging
-
-    def self.run(*args)
-      Command.new(*args).check.explain.chronic_execute
-    end
-
-    def self.run_dry(*args)
-      Command.new(*args).silent_check.execute
-    end
-
-    def self.popen3_reader(*args)
-      args.each do |arg|
-        reader = <<-EOF
-          def #{arg}
-            @#{arg} = @#{arg}.read.rstrip unless @#{arg}.is_a?(String)
-            return @#{arg}
-          end
-        EOF
-        class_eval(reader)
-      end
-    end
-
-    popen3_reader :stdin, :stdout, :stderr
-    attr_reader :wait_thr
-
-    def initialize(*args)
-      @cmd = args
-    end
-
-    def explain
-      logger.debug(@cmd.join(' ')) unless @cmd.empty?
-      self
-    end
-
-    def execute
-      @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(*@cmd) unless @cmd.empty?
-      self
-    end
-
-    def chronic_execute
-      @stdin, @stdout, @stderr, @wait_thr = Open3.popen3(*@cmd) unless @cmd.empty?
-      logger.error(stderr) unless stderr.empty?
-      self
-    end
-
-    def silent_check
-      @stdin, @stdout, @stderr, @wait_thr = Open3.popen3('which', @cmd[0])
-      unless output_matches?(not_empty_matcher)
-        yield if block_given?
-        @cmd = []
-      end
-      self
-    end
-
-    def check
-      silent_check do
-        logger.info("Skipping '#{@cmd.join(' ')}' because command '#{@cmd[0]}' is not found.")
-      end
-    end
-
-    def output_matches?(matcher)
-      stdout.match(matcher)
-    end
-
-    def output_does_not_match?(matcher)
-      !output_matches?(matcher)
-    end
-
-    def not_empty_matcher
-      %r{.*\S.*}
-    end
-  end
-end

data/lib/autowow/fs.rb

@@ -1,41 +0,0 @@
-require_relative 'time_difference'
-
-module Autowow
-  class Fs
-    using RefinedTimeDifference
-
-    def self.ls_dirs
-      Dir.glob(File.expand_path('./*/')).select {|f| File.directory? f}
-    end
-
-    def self.latest(files)
-      files.sort_by{ |f| File.mtime(f) }.reverse!.first
-    end
-
-    def self.older_than(files, quantity, unit)
-      files.select do |dir|
-        TimeDifference.between(File.mtime(dir), Time.now).public_send("in_#{unit}") > quantity
-      end
-    end
-
-    def self.for_dirs(dirs)
-      dirs.each do |working_dir|
-        # TODO: add handling of directories via extra param to popen3
-        # https://stackoverflow.com/a/10148084/2771889
-        Dir.chdir(working_dir) do
-          yield working_dir
-        end
-      end
-    end
-
-    def self.in_place_or_subdirs(in_place)
-      if in_place
-        yield
-      else
-        for_dirs(ls_dirs) do
-          yield
-        end
-      end
-    end
-  end
-end

data/lib/autowow/gem.rb

@@ -1,32 +0,0 @@
-require_relative 'vcs'
-require_relative 'command'
-
-module Autowow
-  class Gem
-    include EasyLogging
-
-    def self.gem_release
-      start_status = Vcs.status
-      logger.info(start_status)
-      working_branch = Vcs.current_branch
-      logger.error("Not on master.") and return unless working_branch.eql?('master')
-      Vcs.push
-
-      Vcs.on_branch('release') do
-        Vcs.pull
-        Vcs.rebase(working_branch)
-        release
-      end
-
-      logger.info(Vcs.status)
-    end
-
-    def self.release
-      Command.run('rake', 'release')
-    end
-
-    def self.clean
-      Command.run('gem', 'clean')
-    end
-  end
-end

data/lib/autowow/ruby.rb

@@ -1,38 +0,0 @@
-module Autowow
-  class Ruby
-    include EasyLogging
-
-    def self.used_versions
-      rubies = []
-      Fs.in_place_or_subdirs(Vcs.is_git?(Vcs.status_dry)) do
-        rubies.push(version)
-      end
-      rubies.uniq
-    end
-
-    def self.version
-      Command.run_dry('rbenv', 'local').stdout
-    end
-
-    def self.installed_versions
-      Command.run_dry('rbenv', 'versions', '--bare', '--skip-aliases').stdout.each_line.map(&:strip)
-    end
-
-    def self.aliases
-      aliases = {}
-      Command.run_dry('rbenv', 'alias').stdout.each_line do |line|
-        aliases[line.strip.split(' => ')[0]] = line.strip.split(' => ')[1]
-      end
-      aliases
-    end
-
-    def self.obsolete_versions
-      alias_map = aliases
-      used_versions_and_aliases = used_versions
-      used_versions.each do |v|
-        used_versions_and_aliases.push(alias_map[v]) if alias_map.has_key?(v)
-      end
-      installed_versions - used_versions_and_aliases
-    end
-  end
-end

data/lib/autowow/vcs.rb

@@ -1,304 +0,0 @@
-require 'uri'
-require 'net/https'
-require 'net/http'
-require 'json'
-require 'launchy'
-
-require_relative 'command'
-require_relative 'decorators/string_decorator'
-require_relative 'fs'
-require_relative 'time_difference'
-require_relative 'gem'
-require_relative 'ruby'
-
-module Autowow
-  class Vcs
-    include EasyLogging
-    include StringDecorator
-
-    using RefinedTimeDifference
-
-    def self.branch_merged
-      start_status = status
-      logger.info(start_status)
-      working_branch = current_branch
-      logger.error("Nothing to do.") and return if working_branch.eql?('master')
-
-      keep_changes do
-        checkout('master')
-        pull
-      end
-      branch_force_delete(working_branch)
-
-      logger.info(status)
-    end
-
-    def self.update_projects
-      Fs.in_place_or_subdirs(is_git?(status_dry)) do
-        update_project
-      end
-    end
-
-    def self.update_project
-      start_status = status_dry
-      return unless is_git?(start_status)
-      logger.info("Updating #{File.expand_path('.')} ...")
-      logger.warn("Skipped: uncommitted changes on master.") and return if uncommitted_changes?(start_status) and current_branch.eql?('master')
-
-      on_branch('master') do
-        has_upstream?(remotes.stdout) ? pull_upstream : pull
-      end
-    end
-
-    def self.clear_branches
-      logger.info(branch.stdout)
-      working_branch = current_branch
-      master_branch = 'master'
-
-      (branches - [master_branch, working_branch]).each do |branch|
-        branch_force_delete(branch) if branch_pushed(branch)
-      end
-
-      logger.info(branch.stdout)
-    end
-
-    def self.add_upstream
-      start_status = status_dry
-      logger.error("Not a git repository.") and return unless is_git?(start_status)
-      remote_list = remotes.stdout
-      logger.warn("Already has upstream.") and return if has_upstream?(remote_list)
-      logger.info(remote_list)
-
-      url = URI.parse(origin_push_url(remote_list))
-      host = "api.#{url.host}"
-      path = "/repos#{url.path}"
-      request = Net::HTTP.new(host, url.port)
-      request.verify_mode = OpenSSL::SSL::VERIFY_NONE
-      request.use_ssl = url.scheme == 'https'
-      response = request.get(path)
-
-      if response.kind_of?(Net::HTTPRedirection)
-        logger.error('Repository moved / renamed. Update remote or implement redirect handling. :)')
-      elsif response.kind_of?(Net::HTTPNotFound)
-        logger.error('Repository not found. Maybe it is private.')
-      elsif response.kind_of?(Net::HTTPSuccess)
-        parsed_response = JSON.parse(response.body)
-        logger.warn('Not a fork.') and return unless parsed_response['fork']
-        parent_url = parsed_response.dig('parent', 'html_url')
-        add_remote('upstream', parent_url) unless parent_url.to_s.empty?
-        logger.info(remotes.stdout)
-      else
-        logger.error("Github API (#{url.scheme}://#{host}#{path}) could not be reached: #{response.body}")
-      end
-    end
-
-    def self.greet(latest_project_info = nil)
-      logger.info("\nGood morning!\n\n")
-      if is_git?(status_dry)
-        logger.error('Inside repo, cannot show report about all repos.')
-      else
-        latest_project_info ||= get_latest_project_info
-        logger.info(latest_project_info)
-        check_projects_older_than(1, :months)
-      end
-      logger.info("\nThe following Ruby versions are not used by any projects, maybe consider removing them?\n  #{Ruby.obsolete_versions.join("\n  ")}")
-    end
-
-    def self.hi
-      logger.error("In a git repository. Try 1 level higher.") && return if is_git?(status_dry)
-      latest_project_info = get_latest_project_info
-      logger.info("\nHang on, updating your local projects and remote forks...\n\n")
-      git_projects.each do |project|
-        Dir.chdir(project) do
-          logger.info("\nGetting #{project} in shape...")
-          yield if block_given?
-          update_project
-        end
-      end
-      greet(latest_project_info)
-    end
-
-    def self.hi!
-      logger.error("In a git repository. Try 1 level higher.") && return if is_git?(status_dry)
-      hi do
-        logger.info('Removing unused branches...')
-        clear_branches
-        logger.info('Adding upstream...')
-        add_upstream
-        logger.info('Removing unused gems...')
-        logger.info(Gem.clean.stdout)
-      end
-    end
-
-    def self.open
-      Launchy.open(origin_push_url(remotes.stdout))
-    end
-
-    def self.get_latest_project_info
-      latest = latest_repo
-      time_diff = TimeDifference.between(File.mtime(latest), Time.now).humanize_higher_than(:days).downcase
-      time_diff_text = time_diff.empty? ? 'recently' : "#{time_diff} ago"
-      "It looks like you were working on #{File.basename(latest)} #{time_diff_text}.\n\n"
-    end
-
-    def self.latest_repo
-      Fs.latest(git_projects)
-    end
-
-    def self.check_projects_older_than(quantity, unit)
-      old_projects = Fs.older_than(git_projects, quantity, unit)
-      deprecated_projects = old_projects.reject do |project|
-        Dir.chdir(project) { branches.reject{ |branch| branch_pushed(branch) }.any? }
-      end
-
-      logger.info("The following projects have not been touched for more than #{quantity} #{unit} and all changes have been pushed, maybe consider removing them?") unless deprecated_projects.empty?
-      deprecated_projects.each do |project|
-        time_diff = TimeDifference.between(File.mtime(project), Time.now).humanize_higher_than(:weeks).downcase
-        logger.info("  #{File.basename(project)} (#{time_diff})")
-      end
-    end
-
-    def self.stash
-      Command.run('git', 'stash').output_does_not_match?(%r{No local changes to save})
-    end
-
-    def self.current_branch
-      Command.run_dry('git', 'symbolic-ref', '--short', 'HEAD').stdout
-    end
-
-    def self.status
-      status = Command.run('git', 'status')
-      status.stdout + status.stderr
-    end
-
-    def self.status_dry
-      status = Command.run_dry('git', 'status')
-      status.stdout + status.stderr
-    end
-
-    def self.checkout(existing_branch)
-      Command.run('git', 'checkout', existing_branch)
-    end
-
-    def self.create(branch)
-      Command.run('git', 'checkout', '-b', branch)
-      Command.run('git', 'push', '--set-upstream', 'origin', branch)
-    end
-
-    def self.pull
-      Command.run('git', 'pull')
-    end
-
-    def self.pull_upstream
-      Command.run('git', 'fetch', 'upstream')
-      Command.run('git', 'merge', 'upstream/master')
-      Command.run('git', 'push', 'origin', 'master')
-    end
-
-    def self.branch
-      Command.run('git', 'branch')
-    end
-
-    def self.stash_pop
-      Command.run('git', 'stash', 'pop')
-    end
-
-    def self.branch_force_delete(branch)
-      Command.run('git', 'branch', '-D', branch)
-    end
-
-    def self.remotes
-      Command.run_dry('git', 'remote', '-v')
-    end
-
-    def self.has_upstream?(remotes)
-      remotes.include?('upstream')
-    end
-
-    def self.uncommitted_changes?(start_status)
-      !(start_status.include?('nothing to commit, working tree clean') or start_status.include?('nothing added to commit but untracked files present'))
-    end
-
-    def self.is_git?(start_status)
-      !start_status.include?('Not a git repository')
-    end
-
-    def self.origin_push_url(remotes)
-      # Order is important: first try to match "url" in "#{url}.git" as non-dot_git matchers would include ".git" in the match
-      origin_push_url_ssl_dot_git(remotes) or
-          origin_push_url_ssl(remotes)or
-          origin_push_url_https_dot_git(remotes) or
-          origin_push_url_https(remotes)
-    end
-
-    def self.origin_push_url_https(remotes)
-      remotes[%r{(?<=origin(\s))http(s?)://[a-zA-Z\-_./]*(?=(\s)\(push\))}]
-    end
-
-    def self.origin_push_url_https_dot_git(remotes)
-      remotes[%r{(?<=origin(\s))http(s?)://[a-zA-Z\-_./]*(?=(\.)git(\s)\(push\))}]
-    end
-
-    def self.origin_push_url_ssl_dot_git(remotes)
-      url = remotes[%r{(?<=origin(\s)git@)[a-zA-Z\-_./:]*(?=(\.)git(\s)\(push\))}]
-      "https://#{url.gsub(':', '/')}" if url
-    end
-
-    def self.origin_push_url_ssl(remotes)
-      url = remotes[%r{(?<=origin(\s)git@)[a-zA-Z\-_./:]*(?=(\s)\(push\))}]
-      "https://#{url.gsub(':', '/')}" if url
-    end
-
-    def self.add_remote(name, url)
-      Command.run('git', 'remote', 'add', name, url)
-    end
-
-    def self.on_branch(branch)
-      keep_changes do
-        working_branch = current_branch
-        switch_needed = !working_branch.eql?(branch)
-        if switch_needed
-          result = checkout(branch)
-          create(branch) if result.stderr.eql?("error: pathspec '#{branch}' did not match any file(s) known to git.")
-        end
-
-        yield
-
-        checkout(working_branch) if switch_needed
-      end
-    end
-
-    def self.keep_changes
-      status = status_dry
-      pop_stash = uncommitted_changes?(status)
-      stash if pop_stash
-      yield
-      stash_pop if pop_stash
-    end
-
-    def self.git_projects
-      Fs.ls_dirs.select do |dir|
-        Dir.chdir(dir) do
-          is_git?(status_dry)
-        end
-      end
-    end
-
-    def self.branch_pushed(branch)
-      Command.run_dry('git', 'log', branch, '--not', '--remotes').stdout.empty?
-    end
-
-    def self.branches
-      branches = Command.run_dry('git', 'for-each-ref', "--format='%(refname)'", 'refs/heads/').stdout
-      branches.each_line.map { |line| line.strip[%r{(?<='refs/heads/)(.*)(?=')}] }
-    end
-
-    def self.push
-      Command.run('git', 'push')
-    end
-
-    def self.rebase(branch)
-      Command.run('git', 'rebase', branch)
-    end
-  end
-end