ruby-livesync 1.0.0.beta5 → 1.0.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 182e21dbd5e045ed2de4492cdefcd295dd92f9af62154ce4cfb7569610cd55ee
-  data.tar.gz: c3d0fe0760f40b408b9e3b72d0349dcf5a838f8aff1224ae2de424af508947fb
+  metadata.gz: f621a2ec4f634f6e4e7d2d46e463c99b83f34025c86a49e4047580ef478d3ff5
+  data.tar.gz: a818d9fc69caf291779641cf8fe0020bdff456cd3fe76bf7c09b5715b1c6c334
 SHA512:
-  metadata.gz: 76aa54c57ad5ee3b64fcee946432021d5e5e948125ffaf72c524bb81bd2abdfefbd53138a67772d05e557690b6ffb89cf608b6267ac124fcb3f0ecc84f59d9e1
-  data.tar.gz: b38edffeb1ae8e63d20346cebf2510da50950bd621d2bf8cf864d0975915b8ee91d823299449cc294225b9c657b966df9e2b934c5a22fe21a988c03e82b41e61
+  metadata.gz: df3f56a0cb1adc2079a7efc8f61d8acd31ba814e319295be5f8cc6b0f0926e05189c1f45eaf18015b1d01aca1459a45f1bf0266f1a99f43ccd4c5a82531182ba
+  data.tar.gz: e45f1394423c70d5922747012c1a8b42811c19f70a979173bb36a0796cc85766c8157763057b692b1badc6f2ba2b8d9e376e4de39dc7161f76c1d6895e64a9c4

data/config/sample.rb

@@ -14,15 +14,19 @@ sync '4tb' do
   # fork to user below, usually associated with private keys 
   user = :root
 
+  # interval to collect all watched events and run rsync
   delay = 5
 
   # event list from inotify
-  # full list at https://manpages.ubuntu.com/manpages/latest/en/man1/inotifywait.1.html#events
-  modes = %i[create modify]
+  # full list at https://man.archlinux.org/man/inotifywait.1#EVENTS
+  modes = %i[create modify delete]
 
   source = '/mnt/4tb/'
-  target rsync: 'root@bhavapower:/mnt/extensor/4tb' do
+  target rsync: 'user@remote:/mnt/4tb' do
     opts = '-ax --partial' # default
+
+    # enables bidirectional sync, using rsync's --update and a pyinotify based watcher
+    reverse_sync
   end
 
   # possible values are: true, false, :initial, :watched

data/lib/{ruby-livesync/live_sync → live_sync}/cmd_watcher.rb

@@ -4,6 +4,8 @@ module LiveSync
     class_attribute :base_cmd
     self.base_cmd = 'bash -s'
 
+    class_attribute :rsh
+
     class_attribute :script
     self.script = <<-HEREDOC
       tp=$(mktemp -u)
@@ -16,25 +18,33 @@ module LiveSync
       done
     HEREDOC
 
-    def watch path, *modes, **params
+    def watch path, *modes, delay: 1, **params, &block
       modes  = DEFAULT_MODES if modes.blank?
       script = self.script % parsed_params(path, *modes, **params)
+      log&.debug "#{self.class.name}: running #{base_cmd}"
       stdin, stdout, stderr, @wait_thr = Open3.popen3 base_cmd
       stdin.write script
       stdin.close
 
       Thread.new do
-        stdout.sync = true
-        stdout.each_line.each do |line|
-          file,events = parse line
-          yield [OpenStruct.new(absolute_name: file, flags: events)]
+        loop do
+          events = []
+          Timeout.timeout(delay){ stdout.each_line.each{ |l| events << l } } # accummulator
+          break if @wait_thr.join(0.1)
+        rescue Timeout::Error
+        ensure
+          notify events.map{ |l| parse l }, &block if events.present?
         end
       end
       Thread.new do
-        stderr.each_line.each{ |line| STDERR.puts line }
+        stderr.each_line.each{ |line| log&.error line }
       end
     end
 
+    def watching?
+      @wait_thr
+    end
+
     def parsed_params path, *modes, recursive: true, delay: 1, excludes: [], **params
       opts  = '-r' if recursive
       {
@@ -49,7 +59,7 @@ module LiveSync
     def parse line
       events,file = line.split ' ', 2
       events = events.split(',').map(&:downcase).map(&:to_sym)
-      [file.chomp, events]
+      OpenStruct.new absolute_name: file.chomp, flags: events
     end
 
   end

data/lib/{ruby-livesync/live_sync → live_sync}/daemon.rb

@@ -1,6 +1,9 @@
 module LiveSync
   class Daemon
 
+    class_attribute :dry
+    self.dry = !!ENV['DRY']
+
     def self.start config
       new(config).start
     end
@@ -9,6 +12,7 @@ module LiveSync
 
     def initialize config
       @config = config
+      $config = config
       @pids   = []
       @syncs  = Hash.new{ |h, k| h[k] = [] }
     end

data/lib/live_sync/dsl.rb

@@ -0,0 +1,47 @@
+module LiveSync
+  module DSL
+
+    extend ActiveSupport::Concern
+
+    included do
+
+      class_attribute :ctx
+
+      class_attribute :attrs
+      self.attrs = []
+
+      def self.dsl attr, default: nil, enum: nil, type: nil, &block
+        self.attrs << attr
+
+        define_method attr do |sv=nil, &ablock|
+          v   = instance_variable_get "@#{attr}"
+          v ||= if block
+            then instance_exec sv || default.dup, ablock, &block
+            else sv || default.dup end
+          instance_variable_set "@#{attr}", v if v
+          return v if sv.nil? # getter
+
+          # setter validation
+          raise "#{ctx}/#{attr}: incorrect type of #{v.inspect}" if type and !v.is_a? type
+          raise "#{ctx}/#{attr}: value not one of following #{enum}" if enum and !v.in? enum
+
+          v
+        end
+      end
+
+      def dsl_apply &block
+        if b = binding and bs = block.source.match(/do(.+)end$/m)&.captures&.first
+          b.eval bs, $config
+          attrs.each do |a|
+            next unless a.in? b.local_variables
+            send a, b.local_variable_get(a)
+          end
+        else
+          instance_exec &block
+        end
+      end
+
+    end
+
+  end
+end

data/lib/live_sync/py/inotify.py

@@ -0,0 +1,57 @@
+import pyinotify
+import os
+import time
+import sys
+
+class EventHandler(pyinotify.ProcessEvent):
+    def process_default(self, event):
+        full_path  = event.pathname
+        event_desc = event.maskname
+        print(f"{event_desc} {full_path}", flush=True)
+
+def watch_path(path, excludes, recursive, mask, base_device):
+    wm       = pyinotify.WatchManager()
+    handler  = EventHandler()
+    notifier = pyinotify.Notifier(wm, handler)
+    
+    def add_watch(path):
+        if os.path.isdir(path) and not any(exclude in path for exclude in excludes):
+            try:
+                if os.stat(path).st_dev == base_device:
+                    wm.add_watch(path, mask, auto_add=recursive)
+                else:
+                    print(f"Skipping {path} (different device)", file=sys.stderr)
+            except Exception as e:
+                print(f"Error adding watch on {path}: {e}", file=sys.stderr)
+    
+    if recursive:
+        for root, dirs, _ in os.walk(path):
+            add_watch(root)
+            for dir in dirs:
+                add_watch(os.path.join(root, dir))
+    else:
+        add_watch(path)
+    
+    try:
+        while True:
+            notifier.process_events()
+            if notifier.check_events():
+                notifier.read_events()
+            time.sleep(%{delay})
+    except KeyboardInterrupt:
+        notifier.stop()
+
+# Configuration
+path        = '%{path}'
+excludes    = [%{excludes}]
+recursive   = %{recursive}
+event_mask  = pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_DELETE
+base_device = os.stat(path).st_dev
+
+try:
+    import setproctitle
+    setproctitle.setproctitle(f'livesync/py_inotify: {path}')
+except ImportError: pass
+
+watch_path(path, excludes, recursive, event_mask, base_device)
+

data/lib/{ruby-livesync/live_sync → live_sync}/py/watchdog.py

@@ -41,6 +41,11 @@ observer = Observer()
 event_handler = MyEventHandler(observer, excludes)
 event_handler.schedule_directory(path)
 
+try:
+    import setproctitle
+    setproctitle.setproctitle('livesync/py_watchdog: %{path}')
+except ImportError: pass
+
 observer.start()
 try:
     while True:

data/lib/{ruby-livesync/live_sync → live_sync}/py_inotify_watcher.rb

@@ -15,5 +15,9 @@ module LiveSync
       }
     end
 
+    def flag_map e
+      e.to_s.gsub(/^in_/, '').to_sym
+    end
+
   end
 end

data/lib/{ruby-livesync/live_sync → live_sync}/rb_watcher.rb

@@ -6,7 +6,7 @@ module LiveSync
       modes  = DEFAULT_MODES if modes.blank?
       modes << :delete if sync&.delete&.in? [true, :watched]
 
-      tracker = Tracker.new path, delay, &block
+      tracker = Tracker.new self, path, delay, &block
       rtgts = glob path, recursive: recursive, excludes: excludes
       track(path, rtgts, *modes,
         delay:     1,
@@ -23,12 +23,12 @@ module LiveSync
     protected
 
     class Tracker
-      def initialize path, delay, &block
+      def initialize watcher, path, delay, &block
+        @watcher  = watcher
         @delay    = delay
         @block    = block
         @to_sync  = Set.new
         @notifier = INotify::Notifier.new
-        @pathname = Pathname.new path
       end
 
       def watch *args, &block
@@ -36,12 +36,12 @@ module LiveSync
       end
 
       def track event
-        @to_sync << Pathname.new(event.absolute_name).relative_path_from(@pathname).to_s
+        @to_sync << OpenStruct.new(absolute_name: event.absolute_name, flags: event.flags)
       end
 
       def check
         @notifier.process # calls track
-        @block.call @to_sync
+        @watcher.notify @to_sync, &@block
         @to_sync.clear
       ensure
         timeout_check

data/lib/live_sync/reverse_rsync.rb

@@ -0,0 +1,40 @@
+module LiveSync
+  class ReverseRsync < Rsync
+
+    dsl :watcher, default: :py_inotify do |name|
+      klass   = :"#{name.to_s.camelize}Watcher"
+      klass   = LiveSync.const_get klass
+      watcher = klass.new sync
+      raise "reverse_sync: provided #{name}, but it required a cmd watcher" unless watcher.is_a? CmdWatcher
+      watcher
+    end
+
+    attr_reader :parent
+    delegate :ssh, to: :parent
+
+    def initialize parent, &block
+      super parent.sync, parent.sync.dest, parent.sync.source, reverse: true
+
+      @parent = parent
+      opts << ' -u'
+      parent.opts << ' -u'
+
+    end
+    
+    def running?
+      @wait_thr or parent.running?
+    end
+
+    def initial
+      watcher.base_cmd = "#{rsh} #{userhost} setsid #{watcher.base_cmd}"
+      watch
+      sleep 1 while parent.running?
+      super
+    end
+
+    def start
+      # reuse parent's ssh
+    end
+
+  end
+end

data/lib/{ruby-livesync/live_sync → live_sync}/rsync.rb

@@ -3,12 +3,17 @@ module LiveSync
 
     dsl :opts, default: '-ax --partial', type: String
 
-    attr_reader :ssh
+    dsl :reverse_sync do |v, block|
+      ReverseRsync.new self, &block
+    end
+
+    attr_reader :ssh, :rprefix
 
-    def initialize *args, &block
-      super
-      # add trailing slash in case the dir is the same
-      sync.source File.join(sync.source, '') if File.basename(sync.source) == File.basename(@path)
+    def initialize *args, **params, &block
+      super *args, **params, &block
+      # add trailing slash in case the dir name is the same
+      @source  = File.join source, '' if File.basename(source) == File.basename(dest)
+      @rprefix = 'reverse: ' if reverse
     end
 
     def start
@@ -25,6 +30,8 @@ module LiveSync
       args  = []
       args << '--delete' if sync.delete.in? [true, :initial]
       run :initial, *args, loglevel: :info
+
+      @reverse_sync&.initial
     end
 
     def partial paths
@@ -39,20 +46,23 @@ module LiveSync
     protected
 
     def run type, *args, loglevel: :debug
-      cmd = "rsync -e '#{rsh}' #{opts} #{sync.source} #{dest} #{args.join ' '}"
+      cmd = "rsync -e '#{rsh}' #{opts} #{source} #{dest} #{args.join ' '}"
       sync.excludes.each{ |e| cmd << " --exclude='#{e}'" }
 
-      log.send loglevel, "#{type}: starting with cmd: #{cmd}"
+      log.send loglevel, "#{rprefix}#{type}: starting with cmd: #{cmd}"
+      return binding.pry if Daemon.dry
       stdin, stdout, stderr, @wait_thr = Open3.popen3 cmd
       yield stdin, stdout, stderr if block_given?
+
       Thread.new do
         Process.wait @wait_thr.pid rescue Errno::ECHILD; nil
         @wait_thr = nil
-        log.send loglevel, "#{type}: finished"
+        log.send loglevel, "#{rprefix}#{type}: finished"
       end
     end
 
     def rsh
+      # -t -t ensure the running process is killed with the client
       "ssh -o ControlPath=#{ssh.cpath}"
     end
 

data/lib/{ruby-livesync/live_sync → live_sync}/sync.rb

@@ -5,12 +5,10 @@ module LiveSync
 
     attr_reader :name
     attr_reader :log
-    attr_reader :watcher
-    attr_reader :target
 
     def initialize name = nil, &block
       fill_name name
-      source name if File.exist? name
+      source name if File.directory? name
       dsl_apply(&block)
     end
 
@@ -22,20 +20,23 @@ module LiveSync
 
     dsl :enabled, default: true
 
-    dsl :watcher, skip_set: true, default: :rb do |name|
+    dsl :watcher, default: :rb do |name|
       klass = :"#{name.to_s.camelize}Watcher"
-      @watcher_class = LiveSync.const_get klass
+      klass = LiveSync.const_get klass
+      klass.new self
     end
 
     dsl :user, default: :root
     dsl :source do |source|
       raise "#{ctx}: source isn't a directory" unless File.directory? source
-      fill_name source
-      @pathname = Pathname.new source
+      fill_name source if !name
+      source
     end
 
-    dsl :target, skip_set: true do |opts, &block|
-      @target = Rsync.new self, opts[:rsync], &block if opts[:rsync]
+    attr_reader :dest
+    dsl :target do |opts, block|
+      @dest = opts[:rsync]
+      Rsync.new self, source, @dest, &block
     end
 
     dsl :delay, default: 5, type: Integer
@@ -55,23 +56,12 @@ module LiveSync
     def guard
       fork do
         Process.setproctitle "livesync: sync #{ctx}"
-        @watcher = @watcher_class.new self
-
-        watch source
+        target.watch
         target.initial
         sleep 1.day while true
       end
     end
 
-    def watch dir
-      @watcher.watch dir, *modes, excludes: excludes, delay: delay, &method(:sync)
-    end
-
-    def sync paths
-      return if target.running?
-      target.partial paths
-    end
-
     protected
 
   end

data/lib/live_sync/target.rb

@@ -0,0 +1,60 @@
+module LiveSync
+  class Target
+
+    include DSL
+
+    attr_reader :sync
+    delegate :log, to: :sync
+
+    attr_reader :source, :dest
+    attr_reader :userhost, :localpath, :remotepath, :watchpath
+    attr_reader :reverse
+
+    delegate :watcher, :modes, :excludes, :delay, to: :sync
+
+    def initialize sync, source, dest, reverse: false, &block
+      @sync    = sync
+      @source  = source
+      @dest    = dest
+      @reverse = reverse
+      @to_sync = Set.new
+
+      @localpath = if reverse then dest else source end
+      @userhost, @remotepath = if reverse then source else dest end.split ':'
+      @watchpath = if reverse then @remotepath else @localpath end
+      raise "#{sync.ctx}: missing target path" unless @remotepath
+
+      dsl_apply &block if block
+    end
+
+    def watch
+      watcher.watch watchpath, *modes, excludes: excludes, delay: delay, &method(:on_notify)
+    end
+
+    def on_notify events
+      wpath = Pathname.new watchpath
+      paths = events.map{ |e| Pathname.new(e.absolute_name).relative_path_from(wpath).to_s }
+      @to_sync.merge paths
+      return if running?
+      partial @to_sync
+      @to_sync.clear
+    end
+
+    def start
+      false
+    end
+
+    def running?
+      false
+    end
+
+    def initial
+      raise 'not implemented'
+    end
+
+    def partial paths
+      raise 'not implemented'
+    end
+
+  end
+end

data/lib/live_sync/version.rb

@@ -0,0 +1,5 @@
+module LiveSync
+
+  VERSION = '1.0.0.rc1'
+
+end

data/lib/live_sync/watcher.rb

@@ -0,0 +1,31 @@
+module LiveSync
+  class Watcher
+
+    DEFAULT_MODES = %i[create modify]
+
+    attr_reader :sync
+    delegate :log, to: :sync, allow_nil: true
+
+    def initialize sync=nil
+      @sync = sync
+    end
+
+    def watch path, *modes, delay: 1, excludes: [], &block
+    end
+
+    def notify events, &block
+      log&.debug "NOTIFY: #{events.inspect}"
+      events.each{ |e| e.flags = e.flags.map{ |f| flag_map f } }
+      block.call Set.new events
+    end
+
+    def watching?
+      false
+    end
+
+    def flag_map e
+      e
+    end
+
+  end
+end

data/lib/{ruby-livesync/live_sync.rb → live_sync.rb}

@@ -15,5 +15,6 @@ require_relative 'live_sync/cmd_watcher'
 require_relative 'live_sync/py_inotify_watcher'
 require_relative 'live_sync/py_watchdog_watcher'
 require_relative 'live_sync/sync'
+require_relative 'live_sync/reverse_rsync'
 require_relative 'live_sync/daemon'
 

data/lib/ruby-livesync.rb

@@ -3,5 +3,5 @@ require 'active_support/all'
 
 require 'rb-inotify'
 
-require_relative 'ruby-livesync/live_sync'
+require_relative 'live_sync'
 

data/livesync.service

@@ -4,7 +4,6 @@ After=network-online.target
 Wants=network-online.target
 
 [Service]
-Type=Simple
 ExecStart=/usr/bin/livesync /etc/livesync/config.rb
 Restart=always
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-livesync
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta5
+  version: 1.0.0.rc1
 platform: ruby
 authors:
 - Braulio Oliveira
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-18 00:00:00.000000000 Z
+date: 2024-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -62,24 +62,25 @@ extra_rdoc_files: []
 files:
 - bin/livesync
 - config/sample.rb
+- lib/live_sync.rb
+- lib/live_sync/cmd_watcher.rb
+- lib/live_sync/daemon.rb
+- lib/live_sync/dsl.rb
+- lib/live_sync/log.rb
+- lib/live_sync/py/inotify.py
+- lib/live_sync/py/watchdog.py
+- lib/live_sync/py_inotify_watcher.rb
+- lib/live_sync/py_watchdog_watcher.rb
+- lib/live_sync/rb_watcher.rb
+- lib/live_sync/reverse_rsync.rb
+- lib/live_sync/rsync.rb
+- lib/live_sync/ssh.rb
+- lib/live_sync/sync.rb
+- lib/live_sync/target.rb
+- lib/live_sync/user.rb
+- lib/live_sync/version.rb
+- lib/live_sync/watcher.rb
 - lib/ruby-livesync.rb
-- lib/ruby-livesync/live_sync.rb
-- lib/ruby-livesync/live_sync/cmd_watcher.rb
-- lib/ruby-livesync/live_sync/daemon.rb
-- lib/ruby-livesync/live_sync/dsl.rb
-- lib/ruby-livesync/live_sync/log.rb
-- lib/ruby-livesync/live_sync/py/inotify.py
-- lib/ruby-livesync/live_sync/py/watchdog.py
-- lib/ruby-livesync/live_sync/py_inotify_watcher.rb
-- lib/ruby-livesync/live_sync/py_watchdog_watcher.rb
-- lib/ruby-livesync/live_sync/rb_watcher.rb
-- lib/ruby-livesync/live_sync/rsync.rb
-- lib/ruby-livesync/live_sync/ssh.rb
-- lib/ruby-livesync/live_sync/sync.rb
-- lib/ruby-livesync/live_sync/target.rb
-- lib/ruby-livesync/live_sync/user.rb
-- lib/ruby-livesync/live_sync/version.rb
-- lib/ruby-livesync/live_sync/watcher.rb
 - livesync.service
 homepage: https://github.com/brauliobo/ruby-livesync
 licenses:

data/lib/ruby-livesync/live_sync/dsl.rb

@@ -1,44 +0,0 @@
-module LiveSync
-  module DSL
-
-    extend ActiveSupport::Concern
-
-    included do
-
-      class_attribute :ctx
-
-      class_attribute :attrs
-      self.attrs = []
-
-      def self.dsl attr, default: nil, enum: nil,
-        type: nil, skip_set: false, &block
-        self.attrs << attr
-
-        define_method attr do |sv=nil, opts={}, &ablock|
-          sv = default if opts[:init]
-          (v = instance_variable_get("@#{attr}"); return(if v.nil? then default else v end)) if sv.nil?
-
-          raise "#{ctx}/#{attr}: incorrect type of #{sv.inspect}" if type and !sv.is_a? type
-          raise "#{ctx}/#{attr}: value not one of following #{enum}" if enum and !sv.in? enum
-
-          instance_variable_set "@#{attr}", sv unless skip_set
-          instance_exec sv, ablock, &block if block
-        end
-      end
-
-      def dsl_apply &block
-        if b = binding and bs = block.source.match(/do(.+)end$/m)&.captures&.first
-          b.eval bs
-          attrs.each do |a|
-            next send a, nil, {init: true} unless a.in? b.local_variables
-            send a, b.local_variable_get(a)
-          end
-        else
-          instance_exec &block
-        end
-      end
-
-    end
-
-  end
-end

data/lib/ruby-livesync/live_sync/py/inotify.py

@@ -1,64 +0,0 @@
-import pyinotify
-import os
-import time
-import sys
-
-class EventHandler(pyinotify.ProcessEvent):
-    def my_init(self, excludes, recursive, mask, base_device):
-        self.excludes = excludes
-        self.recursive = recursive
-        self.base_device = base_device
-        self.mask = mask
-        self.events = set()
-
-    def process_default(self, event):
-        full_path = event.pathname
-        if not any(exclude in full_path for exclude in self.excludes):
-            event_desc = event.maskname
-            self.events.add((event_desc, full_path))
-
-    def print_events(self):
-        if self.events:
-            for event_desc, full_path in self.events:
-                print(f"{event_desc} {full_path}", flush=True)
-            self.events.clear()
-
-    def watch_path(self, path):
-        if not any(exclude in path for exclude in self.excludes):
-            try:
-                if os.stat(path).st_dev == self.base_device:
-                    wm.add_watch(path, self.mask, auto_add=True)
-                else:
-                    print(f"Skipping {path} (different device)", file=sys.stderr)
-            except Exception as e:
-                print(f"Error adding watch on {path}: {e}", file=sys.stderr)
-
-    def add_watch(self, path):
-        if self.recursive:
-            for root, dirs, _ in os.walk(path):
-                self.watch_path(root)
-                for dir in dirs:
-                    self.watch_path(os.path.join(root, dir))
-        else:
-            self.watch_path(path)
-
-excludes    = [%{excludes}]
-recursive   = %{recursive}
-event_mask  = pyinotify.IN_CREATE | pyinotify.IN_MODIFY | pyinotify.IN_MOVED_TO | pyinotify.IN_DELETE  # Event mask
-base_device = os.stat('%{path}').st_dev
-
-wm = pyinotify.WatchManager()
-handler = EventHandler(excludes=excludes, recursive=recursive, mask=event_mask, base_device=base_device)
-notifier = pyinotify.Notifier(wm, handler)
-handler.add_watch('%{path}')
-
-try:
-    while True:
-        notifier.process_events()
-        if notifier.check_events():
-            notifier.read_events()
-        handler.print_events()
-        time.sleep(%{delay})
-except KeyboardInterrupt:
-    notifier.stop()
-

data/lib/ruby-livesync/live_sync/target.rb

@@ -1,36 +0,0 @@
-module LiveSync
-  class Target
-
-    include DSL
-
-    attr_reader :sync
-    delegate :log, to: :sync
-
-    attr_reader :dest, :path, :userhost
-
-    def initialize sync, dest, &block
-      @sync = sync
-      @dest = dest
-      @userhost, @path = dest.split ':'
-      raise "#{sync.ctx}: missing target path" unless @path
-      dsl_apply &block if block
-    end
-
-    def start
-      false
-    end
-
-    def running?
-      false
-    end
-
-    def initial
-      raise 'not implemented'
-    end
-
-    def partial paths
-      raise 'not implemented'
-    end
-
-  end
-end

data/lib/ruby-livesync/live_sync/version.rb

@@ -1,5 +0,0 @@
-module LiveSync
-
-  VERSION = '1.0.0.beta5'
-
-end

data/lib/ruby-livesync/live_sync/watcher.rb

@@ -1,16 +0,0 @@
-module LiveSync
-  class Watcher
-
-    DEFAULT_MODES = %i[create modify]
-
-    attr_reader :sync
-
-    def initialize sync=nil
-      @sync = sync
-    end
-
-    def watch path, *modes, delay: 1, excludes: [], &block
-    end
-
-  end
-end