conjoiner 0.1.0

data/README.md

@@ -0,0 +1,87 @@
+# Conjoiner
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/conjoiner`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'conjoiner'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install conjoiner
+
+## Usage
+
+After installing you can initialize the `prime` aspect with:
+
+```
+conjoiner init_aspect
+```
+
+This will create the dated repositories (gpx, log, misc) for the current year
+and the `prime` aspect.
+
+You can then manually synchronize those repositories with:
+```
+conjoiner sync
+```
+
+And show the status of the repositories with:
+```
+conjoiner show
+```
+
+### Enable the synchronization deaemon on with systemd on Linux
+
+You can enable the automatic synchronization with the following script:
+```
+mkdir -p ~/.config/systemd/user
+cp conjoiner.service ~/.config/systemd/user
+systemctl --user daemon-reload
+systemctl --user enable conjoiner
+systemctl --user start conjoiner
+```
+
+You can the use journalctl to view the logging with:
+```
+journalctl --user --unit=conjoiner --follow
+```
+
+### Enable the synchronization deaemon on with launchd on OSX
+
+You can enable the automatic synchronization with the following script:
+```
+mkdir -p ~/Library/LaunchAgents
+cp ca.andrewsullivancant.conjoiner.plist ~/Library/LaunchAgents
+launchctl load ~/Library/LaunchAgents/ca.andrewsullivancant.conjoiner.plist
+```
+
+You should be able to see logging with `Console.app`.
+
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and merge requests are welcome on Gitlab at https://gitlab.com/acant/conjoiner.
+
+## License
+
+Released under the [AGPLv3 license](https://www.gnu.org/licenses/agpl-3.0.en.html).
+
+Copyright 2021 [Andrew Sullivan Cant](https://andrewsullivancant.ca)
+

data/Rakefile

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop) do |task|
+  FileUtils.mkdir_p('tmp')
+  task.options = %w[--format progress --format simple --out tmp/rubocop.txt]
+end
+
+require 'cucumber/rake/task'
+Cucumber::Rake::Task.new
+
+require 'yard'
+YARD::Rake::YardocTask.new do |t|
+  t.files         = ['lib/**/*.rb']
+  t.stats_options = ['--list-undoc']
+end
+
+require 'bundler/audit/task'
+Bundler::Audit::Task.new
+
+task default: %i[spec cucumber rubocop yard]

data/bin/console

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'conjoiner'
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,9 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle config set path 'vendor/bundle'
+bundle install
+
+# Do any other automated setup that you need to do here

data/ca.andrewsullivancant.conjoiner.plist

@@ -0,0 +1,23 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+
+    <key>Label</key>
+    <string>ca.andrewsullivancant.conjoiner</string>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>ProgramArguments</key>
+    <array>
+      <string>/usr/bin/ruby</string>
+      <string>/usr/local/bin/conjoiner</string>
+      <string>syncer</string>
+    </array>
+
+  </dict>
+</plist>

data/conjoiner.gemspec

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+require_relative 'lib/conjoiner/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'conjoiner'
+  spec.version       = Conjoiner::VERSION
+  spec.authors       = ['Andrew Sullivan Cant']
+  spec.email         = ['mail@andrewsullivancant.ca']
+  spec.summary       = 'Tool for cloning and managing git repositories.'
+  spec.description   = 'Manager for cloned git reporitories, automatically sync some of those repositories.'
+  spec.homepage      = 'https://gitlab.com/acant/conjoiner'
+  spec.metadata      = {
+    'homepage_uri'    => spec.homepage,
+    'source_code_uri' => spec.homepage,
+    'changelog_uri'   => "#{spec.homepage}/CHANGELOG.md"
+  }
+  spec.license       = 'AGPL-3.0-or-later'
+  spec.files         =
+    Dir.chdir(File.expand_path(__dir__)) do
+      `git ls-files -z`.split("\x0").reject do |f|
+        f.match(%r{^(test|spec|features)/})
+      end
+    end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.required_ruby_version = Gem::Requirement.new('>= 2.5.0')
+
+  spec.add_dependency 'git',         '~> 1.9'
+  spec.add_dependency 'listen',      '~> 3.6'
+  spec.add_dependency 'table_print', '~> 1.5'
+  spec.add_dependency 'thor',        '~> 1.0'
+
+  spec.add_development_dependency 'aruba',     '~> 1.0'
+  spec.add_development_dependency 'cucumber',  '~> 5.3'
+  spec.add_development_dependency 'rspec',     '~> 3.10'
+  spec.add_development_dependency 'simplecov', '~> 0.21'
+
+  spec.add_development_dependency 'bundler-audit'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'rubocop-performance'
+  spec.add_development_dependency 'rubocop-rake'
+  spec.add_development_dependency 'rubocop-rspec'
+  spec.add_development_dependency 'yard'
+end

data/conjoiner.service

@@ -0,0 +1,9 @@
+[Unit]
+Description=Conjoiner synchronization
+
+[Install]
+WantedBy=default.target
+
+[Service]
+Restart=always
+ExecStart=/usr/bin/ruby /usr/local/bin/conjoiner syncer

data/cucumber.yml

@@ -0,0 +1 @@
+default: --publish-quiet

data/exe/conjoiner

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+# frozen_string_literal: true
+
+require 'conjoiner'
+
+Conjoiner::CLI.start(ARGV)

data/lib/conjoiner/cli.rb

@@ -0,0 +1,265 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'git'
+require 'pathname'
+require 'table_print'
+require 'ostruct'
+require 'listen'
+
+# HACK: Disable various length and complexity checks temporarily.
+# As I extract methods/class from CLI I will re-enable them.
+# rubocop:disable Metrics/ClassLength, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/BlockLength
+
+module Conjoiner
+  class CLI < Thor # rubocop:disable Style/Documentation
+    # TODO: desc 'join URL', 'clone the git repository into conjoiner'
+
+    desc 'init_aspect [ASPECT] [YEAR]', 'initialize aspect for a year'
+    options year: :integer
+    def init_aspect(aspect = nil, year = nil)
+      aspect ||= 'prime'
+      year   ||= Time.now.year
+
+      puts "init aspect #{aspect} #{year}"
+
+      home       = Pathname.new(Dir.home)
+      dated_root = home.join(
+        'joined',
+        'git.andrewcant.ca',
+        'andrew',
+        'aspects',
+        aspect,
+        'dated',
+        year.to_s
+      )
+
+      repository_names =
+        if aspect == 'prime'
+          %w[gpx log misc]
+        else
+          %w[log]
+        end
+
+      repository_names.each do |name|
+        repo = "gitolite@git.andrewcant.ca:andrew/aspects/#{aspect}/dated/#{year}/#{name}"
+        dir  = dated_root.join(name)
+
+        puts repo
+        puts dir
+
+        git =
+          if dir.exist?
+            begin
+              git_open = Git.open(dir)
+              puts "Open #{name}"
+              git_open
+            rescue Git::GitExecuteError
+              puts "Init #{name}"
+              Git.init(dir.to_s).tap do |git_init|
+                git_init.commit('Initial commit', allow_empty: true)
+              end
+            end
+          else
+            puts "Clone #{name}"
+            puts "  #{repo}"
+            puts "  #{dir}"
+
+            dir.mkpath
+            Git.clone(repo, dir)
+          end
+
+        # Add any existing files.
+        begin
+          git.add(all: true)
+          git.commit_all('Commit existing files')
+        rescue Git::GitExecuteError
+          # Nothing to do, continue with the rest of the sync.
+        end
+
+        # Ensure that the remote exists.
+        if git.remotes.empty?
+          puts 'Add remote....'
+          git.add_remote('origin', repo)
+        end
+
+        # TODO: should set upstream for regular commits
+
+        # Try synchronize the new commits with the remote origin.
+        begin
+          puts 'Rync with the remote'
+          git.pull('origin')
+          git.push('origin')
+        rescue Git::GitExecuteError
+          # Nothing to do, continue with the rest of the sync.
+        end
+      end
+    end
+
+    desc 'sync', 'run the repository synchronization once'
+    def sync(aspect = nil, year = nil)
+      aspect ||= 'prime'
+      year   ||= Time.now.year
+
+      home = Pathname.new(Dir.home)
+      joined_dir = home.join('joined')
+      root = joined_dir.join(
+        'git.andrewcant.ca',
+        'andrew',
+        'aspects',
+        aspect
+      )
+
+      gits =
+        [
+          root.join('dated', year.to_s),
+          root.join('dated', (year - 1).to_s),
+          root.join('gtd'),
+          root.join('wiki')
+        ].map { |x| x.glob('**/.git').map(&:dirname) }.flatten.map { |x| Git.open(x) }
+
+      gits.each do |git|
+        print '<'
+        # Add any existing files.
+        begin
+          git.add(all: true)
+          git.commit_all('auto commit')
+        rescue Git::GitExecuteError
+          # Nothing to do, continue with the rest of the sync.
+        end
+
+        print '.'
+
+        git.pull('origin')
+        git.push('origin')
+
+        print '>'
+      end
+      puts ''
+    end
+
+    desc 'syncer', 'keep the repositories synchroniztion'
+    def syncer
+      year   ||= Time.now.year
+
+      home = Pathname.new(Dir.home)
+      joined_dir   = home.join('joined')
+      aspects_root = joined_dir.join(
+        'git.andrewcant.ca',
+        'andrew',
+        'aspects'
+      )
+
+      current_aspects = %w[prime sugar]
+      listen_pathnames =
+        current_aspects.map do |aspect|
+          aspect_dir = aspects_root.join(aspect)
+          [
+            aspect_dir.join('dated', year.to_s),
+            aspect_dir.join('dated', (year - 1).to_s),
+            aspect_dir.join('gtd'),
+            aspect_dir.join('wiki')
+          ]
+        end
+      # Flatten and include only existing directories.
+      listen_pathnames =
+        listen_pathnames.flatten.compact.select(&:directory?)
+
+      # Find the repositories within those directories.
+      listen_repository_pathnames =
+        listen_pathnames.map { |x| x.glob('**/.git').map(&:dirname) }.flatten
+
+      puts 'For these aspects:'
+      current_aspects.each { |x| puts "  * #{x}" }
+      puts 'Watch the following repositories:'
+      listen_repository_pathnames.each { |x| puts "  * #{x}" }
+
+      listener =
+        Listen.to(
+          *listen_repository_pathnames.map(&:to_s),
+          ignore:         /#{File::SEPARATOR}\.git#{File::SEPARATOR}/o,
+          latency:        5,
+          wait_for_delay: 5
+        ) do |modified, added, removed|
+          changed_files = [modified, added, removed].flatten.compact.uniq
+          changed_files
+            .map { |file| listen_repository_pathnames.map(&:to_s).find { |repo| file.start_with?(repo) } }
+            .compact
+            .uniq
+            .map { |x| Git.open(x) }
+            .select { |x| x.status.added.any? || x.status.changed.any? || x.status.deleted.any? || x.status.untracked.any? } # rubocop:disable Layout/LineLength
+            .each do |git|
+              puts "Sync #{git.dir}"
+
+              # Add any existing files.
+              begin
+                git.add(all: true)
+                git.commit_all('auto commit')
+              rescue Git::GitExecuteError
+                # Nothing to do, continue with the rest of the sync.
+              end
+
+              # Sync the commits
+              # TODO: needs conflict handling. Review what is done in gitdocs.
+              begin
+                git.pull('origin')
+                git.push('origin')
+              rescue => e # rubocop:disable Style/RescueStandardError
+                puts "Error sycing #{git.dir}: #{e}"
+              end
+            end
+        end
+
+      listener.start
+      puts 'Start listening...'
+      begin
+        sleep
+      rescue Interrupt
+        puts 'Exit'
+        exit
+      rescue SignalException => e
+        puts "Exit on #{e}"
+        exit
+      end
+    end
+
+    desc 'show [PATH]', 'show the status of aspects and other repositories'
+    def show(aspect = nil, year = nil)
+      aspect ||= 'prime'
+      year   ||= Time.now.year
+
+      home = Pathname.new(Dir.home)
+      joined_dir = home.join('joined')
+      aspect_dir = joined_dir.join(
+        'git.andrewcant.ca',
+        'andrew',
+        'aspects',
+        aspect
+      )
+
+      gits =
+        [
+          aspect_dir.join('dated', year.to_s),
+          aspect_dir.join('dated', (year - 1).to_s),
+          aspect_dir.join('gtd'),
+          aspect_dir.join('wiki'),
+          aspect_dir.join('contacts'),
+          aspect_dir.join('password-store')
+        ].map { |x| x.glob('**/.git').map(&:dirname) }.flatten.map { |x| Git.open(x) }
+
+      output =
+        gits.map do |git|
+          additions = git.status.added.count + git.status.changed.count
+          OpenStruct.new(
+            path:   Pathname.new(git.dir.to_s).relative_path_from(joined_dir).to_s,
+            status: "+#{additions} -#{git.status.deleted.count} *#{git.status.untracked.count}"
+          )
+        end
+
+      tp.set(:max_width, 256)
+      tp(output, :path, :status)
+    end
+  end
+end
+
+# rubocop:enable Metrics/ClassLength, Metrics/AbcSize, Metrics/MethodLength, Metrics/PerceivedComplexity, Metrics/CyclomaticComplexity, Metrics/BlockLength

data/lib/conjoiner/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Conjoiner
+  VERSION = '0.1.0'
+end

data/lib/conjoiner.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+require 'conjoiner/version'
+require 'conjoiner/cli'
+
+module Conjoiner
+  class Error < StandardError; end
+  # Your code goes here...
+  #
+end