upstreamwatchr 0.0.42

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e1ec7dfa70e08c99094546080e6180ea953a033e
+  data.tar.gz: 8acfdf0d9507374a9cd4258b1855ba7659c312a8
+SHA512:
+  metadata.gz: 8fd2ea5f6c64dcc7069e51e85cd0ca3f0869d4a249281f301c7d472d85abd37981cfd41aa123be80e9801b81bb187538d61d2ce8b6b755cb8b59c1da8686dd88
+  data.tar.gz: 368f85a18be9087b18e205ba12e885849d1c43c39ca38e24a945243a9488514a5c16a56c82f5e83a1d5df1c1e4feb1dc0ad108b091c220b93e3c886e67b3f2eb

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,31 @@
+# UpstreamWatchr
+makes it easy to keep track of changes in the upstream repositories of your forks by comparing two git remotes and creating an issue on your fork if it is out of sync.
+
+
+Currently only GitLab is supported (api wise). This means that it will fail (horribly) if you are using something else for your repos. It also has some requirements on your projects, such as that its needs a hyperlink in your projects `description` to find the upstream repository. Also your project should allow upstreamwatchr's user to read the code and create issues. If your project is not setup this way, UpstreamWatchr will fail, again, horribly.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'upstreamwatchr'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install upstreamwatchr
+
+## Usage
+
+Set `ENV['GITLAB_API_ENDPOINT']` and `ENV['GITLAB_API_PRIVATE_TOKEN']` and use the "binary":
+```
+# Check a single project
+GITLAB_API_ENDPOINT=https://git.acme.com/ GITLAB_API_PRIVATE_TOKEN=abcdefg123456 upstreamwatchr git@githost.acme.com:/path/repo.git
+```
+```
+# Check all available projects
+GITLAB_API_ENDPOINT=https://git.acme.com/ GITLAB_API_PRIVATE_TOKEN=abcdefg123456 upstreamwatchr"
+```

data/bin/upstreamwatchr

@@ -0,0 +1,43 @@
+#! ruby
+require 'rainbow/ext/string'
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'upstreamwatchr'
+
+unless ENV['GITLAB_API_ENDPOINT'] && ENV['GITLAB_API_PRIVATE_TOKEN']
+  puts "Usage:
+GITLAB_API_ENDPOINT=https://git.acme.com/ GITLAB_API_PRIVATE_TOKEN=abcdefg123456 upstreamwatchr git@githost.acme.com:/path/repo.git
+or to check all available projects:
+GITLAB_API_ENDPOINT=https://git.acme.com/ GITLAB_API_PRIVATE_TOKEN=abcdefg123456 upstreamwatchr"
+  exit 1
+end
+
+if not ARGV[0]
+   puts "Debug: Not called with a specific project. Checking all I can haz access to!" if ENV['DEBUG']
+   projects = Gitlab.projects(:per_page => 10000)
+   my_uid = Gitlab.user.id
+   projects.select! {|p| ((not p.owner) || p.owner.id != my_uid)}
+   projects.each do |project|
+      begin
+        watch = UpstreamWatchr::GitLabWatchr.new(project.ssh_url_to_repo)
+        info = "Info: #{project.name} (#{project.ssh_url_to_repo}): #{watch.comparator.to_s}"
+        if watch.comparator.has_changes?
+          puts info.color(:red)
+          watch.grumble_in_issue
+        else
+          puts info.color(:green)
+        end
+      rescue => e
+        STDERR.puts "Warn: Failed to check #{project.name} (#{project.ssh_url_to_repo}!"
+        require 'pry'; binding.pry if ENV['DEBUG']
+        STDERR.puts e
+      end
+   end
+else
+  watch = UpstreamWatchr::GitLabWatchr.new(ARGV[0])
+  puts "Debug: #{project.comparator.to_s}" if ENV['DEBUG']
+  if watch.comparator.has_changes?
+    watch.grumble_in_issue
+  end
+end

data/lib/UpstreamWatchr.rb

@@ -0,0 +1,8 @@
+require "UpstreamWatchr/gitremotes"
+require "UpstreamWatchr/gitlabcheck"
+#require "UpstreamWatchr/version"
+
+
+module UpstreamWatchr
+  # Your code goes here...
+end

data/lib/UpstreamWatchr/gitlabcheck.rb

@@ -0,0 +1,96 @@
+require 'gitlab'
+
+module UpstreamWatchr
+  class GitLabWatchr
+    attr_reader :origin_url, :origin_project, :comparator
+
+    def initialize(origin_url, branch = 'master')
+      @origin_url = origin_url
+      @branch = branch
+      @comparator = GitRemotes.new(@origin_url, upstream_url)
+    end
+
+    def origin_project
+      @origin_project ||= Gitlab.projects(:per_page => 10000).find {|p| p.ssh_url_to_repo == @origin_url || p.http_url_to_repo == @origin_url || p.web_url == @origin_url }
+    end
+
+    def upstream_url
+      @upstream_url ||= origin_project.description.match(/^Upstream: (\S*)$/)[1]
+    end
+
+    def create_fork
+      puts "Forking #{origin_project.name}..."
+      Gitlab.create_fork(@origin_project.id)
+    rescue Gitlab::Error::Conflict
+      puts "Fork of #{origin_project.name} already exists."
+    end
+
+    def fork
+      @fork ||= (Gitlab.projects(:per_page => 10000).find {|p| p.forked_from_project && p.forked_from_project.id == @origin_project.id } || create_fork)
+    end
+
+    def create_merge_request
+      @comparator.push_to_my_fork(fork.ssh_url_to_repo)
+
+      puts "Creating merge request on #{origin_project.name}..."
+      Gitlab.create_merge_request(fork.id,
+        'UpstreamWatcher detected new upstream changes!',
+        :source_branch => @branch,
+        :target_branch => @branch,
+        :target_project_id => origin_project.id
+        )
+    rescue Gitlab::Error::Conflict
+      puts "Merge request seems to be already there. Good. Previous MR updated with even more upstream changes!"
+    end
+
+    def issue_title
+      "UpstreamWatchr: #{@comparator.upstream_ahead} change(s) to fetch from your upstream project!"
+    end
+
+    def issue_description
+      "UpstreamWatchr noted that your branch '#{@branch}' is #{@comparator.upstream_ahead} commits behind `#{upstream_url}`'s #{@branch}.
+
+  Whenenver you feel confident pulling the upstream changes onto your branch, you can use these git commands:
+
+  ```
+  git checkout #{@branch}
+  git pull #{upstream_url} #{@branch}
+  git push origin #{@branch}
+  ```
+
+
+  Sincerly, UpstreamWatchr"
+    end
+
+    def issue
+      @issue ||= find_issue || create_issue
+    end
+
+    def find_issue
+       Gitlab.issues(@origin_project.id, :per_page => 1000).find {|i| i.state != 'closed' && i.author.id == Gitlab.user.id && i.title =~ /^UpstreamWatchr:/}
+    end
+
+    def create_issue
+      puts "Warn: Creating new issue '#{issue_title}'"
+      Gitlab.create_issue(@origin_project.id,
+        issue_title,
+        {:description => issue_description}
+      )
+    end
+
+    def update_issue
+      puts "Debug: Updating issue '#{issue_title}'" if ENV['DEBUG']
+      Gitlab.edit_issue(@origin_project.id, issue.id, :title => issue_title)
+    end
+
+    def grumble_in_issue
+      changes_in_title = issue.title.match(/(\d+)/)[1].to_i
+      puts "Debug: Issue states '#{changes_in_title} changes'" if ENV['DEBUG']
+      unless changes_in_title == @comparator.upstream_ahead
+        puts "Warn: Going to update issue to '#{issue_title}'"
+        update_issue
+      end
+    end
+
+  end
+end

data/lib/UpstreamWatchr/gitremotes.rb

@@ -0,0 +1,103 @@
+require 'rugged'
+require 'tmpdir'
+
+module UpstreamWatchr
+  class GitRemotes
+
+    def initialize(origin, upstream, main_branch = 'master')
+      @origin = origin
+      @upstream = upstream
+      @main_branch = main_branch
+
+      begin
+        @repo = Rugged::Repository.clone_at(@origin, clone_path, {:bare => true, :credentials => ssh_agent})
+        puts "Debug: cloned #{@origin} to #{clone_path}" if ENV['DEBUG']
+      rescue Rugged::InvalidError
+        puts "Debug: didn't clone (#{@origin} to #{clone_path}), local repo already there." if ENV['DEBUG']
+        @repo = Rugged::Repository.new(clone_path)
+        @repo.remotes['origin'].fetch({:credentials => ssh_agent})
+        @repo.remotes['origin'].save
+        puts "Debug: fetched 'origin' from #{origin}" if ENV['DEBUG']
+      end
+
+      @repo.remotes.create('upstream', @upstream) unless @repo.remotes['upstream']
+      fail "Can not read from upstream. Something seems off with remote #{@upstream}" unless @repo.remotes['upstream'].check_connection(:fetch, {:credentials => ssh_agent})
+      @repo.remotes['upstream'].fetch({:credentials => ssh_agent})
+      @repo.remotes['upstream'].save
+      puts "Debug: fetched 'upstream' from #{@upstream}" if ENV['DEBUG']
+    end
+
+    def ssh_agent
+      lambda { |_, username, _| Rugged::Credentials::SshKeyFromAgent.new(username: username)}
+    end
+
+    def clone_path
+      File.join(Dir.tmpdir, @origin.split('/').last)
+    end
+
+    def push_to_my_fork(my_fork_url, branch = nil)
+      branch ||= @main_branch
+      @repo.remotes.create('my_fork', my_fork_url) unless @repo.remotes['my_fork']
+
+      @repo.reset("upstream/#{branch}", :soft)
+      @repo.remotes["my_fork"].push("refs/heads/#{branch}", {:credentials => ssh_agent})
+    end
+
+    def diff(branch = nil)
+      branch ||= @main_branch
+      origin_target = @repo.references["refs/remotes/origin/#{branch}"].target
+      puts "Debug: origin has its #{branch} at #{origin_target}" if ENV['DEBUG']
+      upstream_target = @repo.references["refs/remotes/upstream/#{branch}"].target
+      puts "Debug: upstream has its #{branch} at #{upstream_target}" if ENV['DEBUG']
+      @repo.diff(origin_target, upstream_target)
+    end
+
+    def ahead_behind(branch = nil)
+      branch ||= @main_branch
+      @repo.ahead_behind(@repo.references["refs/remotes/origin/#{branch}"].target, @repo.references["refs/remotes/upstream/#{branch}"].target)
+    end
+
+    def upstream_ahead
+      ahead_behind[1]
+    end
+
+    def upstream_behind
+      ahead_behind[0]
+    end
+
+    def trees(branch = nil)
+      branch ||= @main_branch
+      [@repo.references["refs/remotes/origin/#{branch}"].target.tree, @repo.references["refs/remotes/upstream/#{branch}"].target.tree]
+    end
+
+    def origin_tree_size(branch = nil)
+      branch ||= @main_branch
+      trees(branch)[0].count
+    end
+
+    def upstream_tree_size(branch = nil)
+      branch ||= @main_branch
+      trees(branch)[1].count
+    end
+
+    def tree_size_diff(branch = nil)
+      branch ||= @main_branch
+      upstream_tree_size(branch) - origin_tree_size(branch)
+    end
+
+    def has_changes?
+      ahead_behind != [0,0]
+    end
+
+    def to_s(branch = nil)
+      branch ||= @main_branch
+      a_b = ahead_behind(branch)
+      if a_b == [0,0]
+        "origin/#{branch} is up-to-date with 'upstream/#{branch}'"
+      else
+        "upstream/#{branch} is #{upstream_ahead} ahead and #{upstream_behind} behind 'origin/#{branch}'"
+      end
+    end
+
+  end
+end

data/lib/UpstreamWatchr/version.rb

@@ -0,0 +1,3 @@
+module UpstreamWatchr
+  VERSION = "0.0.42"
+end

data/upstreamwatchr.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'upstreamwatchr/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "upstreamwatchr"
+  spec.version       = UpstreamWatchr::VERSION
+  spec.authors       = ["Marvin Frick"]
+  spec.email         = ["marvin.frick@sinnerschrader.com"]
+  spec.summary       = %q{watches "upstream" repositories for changes}
+  spec.description   = %q{upstreamwatchr makes it easy to keep track of changes in the upstream repositories of your forks by comparing two git remotes and creating an issue on your fork if it is out of sync.}
+  spec.homepage      = "https://github.com/MrMarvin/upstreamwatchr"
+  spec.license       = "BSD"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+  spec.add_development_dependency 'pry', '0.10.1'
+  spec.add_runtime_dependency 'rugged', '0.22.2'
+  spec.add_runtime_dependency 'gitlab', '3.4.0'
+  spec.add_runtime_dependency 'rainbow', '2.0.0'
+end

metadata

@@ -0,0 +1,112 @@
+--- !ruby/object:Gem::Specification
+name: upstreamwatchr
+version: !ruby/object:Gem::Version
+  version: 0.0.42
+platform: ruby
+authors:
+- Marvin Frick
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.1
+- !ruby/object:Gem::Dependency
+  name: rugged
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.22.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.22.2
+- !ruby/object:Gem::Dependency
+  name: gitlab
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 3.4.0
+- !ruby/object:Gem::Dependency
+  name: rainbow
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: upstreamwatchr makes it easy to keep track of changes in the upstream
+  repositories of your forks by comparing two git remotes and creating an issue on
+  your fork if it is out of sync.
+email:
+- marvin.frick@sinnerschrader.com
+executables:
+- upstreamwatchr
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- bin/upstreamwatchr
+- lib/UpstreamWatchr.rb
+- lib/UpstreamWatchr/gitlabcheck.rb
+- lib/UpstreamWatchr/gitremotes.rb
+- lib/UpstreamWatchr/version.rb
+- upstreamwatchr.gemspec
+homepage: https://github.com/MrMarvin/upstreamwatchr
+licenses:
+- BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: watches "upstream" repositories for changes
+test_files: []