git-repo-watch

A node utility to sync git repositories and get notifications using RxJS.

There are 2 operations modes:

• Sync (simple git pull)
• Sync Fork (pull source remote -> rebase -> push fork remote)

Sync

The Sync method is straight forward, you have a git repository with 1 remote.

Sync Fork

The Sync Fork method is used when you have a remote that was forked and you want to get notified when the fork changes and sync the 2.

It is usually referred to as origin and upstream.

Example: This is the material2 repository: https://github.com/angular/material2

Forking it to my own github account: https://github.com/shlomiassaf/material2

Running git remote -v:

origin	https://github.com/shlomiassaf/material2.git (fetch)
upstream	https://github.com/angular/material2.git (fetch)

The origin remote is my fork, the upstream remote is the source for updates.

API

The GitWatcher class is used to watch repositories.

import { GitWatcher } from 'git-repo-watch'

// TypeScript:
// import { GitWatcher, RepoResult } from './src'; 

const watcher = new GitWatcher();

GitWatcher

• watch(info: RepoWatchConfig): void
  Start watching a repository.

• unwatch(info: RepoWatchConfig): void
  Stop watching a repository

• check$: Observable
  Notification stream triggered before a git repository starts a sync check.

• result$: Observable
  Notification stream triggered after a git repository sync check as ended.

RepoWatchConfig

• path: string
  The file system path where the repository is.

• poll: number
  The time in seconds between each check
  Optional, Default: 1 hour

• remote: string
  The remote name to sync in sync mode In Sync Fork mode this is the fork to update to.
  Optional, Default: origin

• branch: string
  The branch name to sync in sync mode
  In Sync Fork mode this is the fork to update to.
  Optional, Default: master

• strict: boolean
  Run only if the current branch matches the branch defined.

• sync Sync Fork mode definition, sync a remote branch into the origin branch.
  i.e: Pulling an "upstream" remote "master" into the "origin" master.
  Optional, Default: undefined (sync mode)

  • remote: string
    The remote name to pull from
    e.g: upstream

  • branch: string
    The branch name to pull from
    e.g: master

  • rebase: boolean
    If true rebase is used (rebasing from upstream), otherwise a merge Optional, Default: false

  • push?: boolean
    If true, push the changes to the forked remote (origin) Optional, Default: false }

RepoResult

• config: RepoWatchConfig The config object for this instance.

• error: Error If an error occurred this will be the Error object.

• changed: boolean True if the pull was different, i.e: the source repo was updated. Irrelevant when an error has occurred.

Example (TypeScript)

import { GitWatcher, RepoResult } from './src';

const gw = new GitWatcher();

// Use Sync Fork to check for changes in the upstream an update.
gw.watch({
  path: '/repos/forks/material2',
  remote: 'origin',
  branch: 'master',
  strict: true,
  sync: {
    remote: 'upstream',
    branch: 'master',
    rebase: true,
    push: true
  }
});

gw.check$.subscribe( info => {
  // will fire every check.
});

gw.result$.subscribe( (result: RepoResult) => {
  // will fire once a check is finished.
  // When using Sync Fork the origin is now updated (and local ofcourse)
  
  if (result.error) {   
   gw.unwatch(result.config);
   // don't forget to unsubscrive...
  } else {
    if (result.checked === true) {
      // new version, we can build it, publish to a site... whatever.
    }
  }   
});