wavesync 1.0.0.alpha3 → 1.0.0.beta1

data/lib/wavesync/scanner.rb

@@ -2,7 +2,9 @@
 # rbs_inline: enabled
 
 require 'fileutils'
-require 'streamio-ffmpeg'
+require 'pathname'
+require 'tempfile'
+require_relative 'logger'
 require_relative 'file_converter'
 
 module Wavesync
@@ -10,14 +12,16 @@ module Wavesync
     #: (String source_library_path) -> void
     def initialize(source_library_path)
       @source_library_path = File.expand_path(source_library_path) #: String
+      Logger.configure(@source_library_path)
       @audio_files = find_audio_files #: Array[String]
       @ui = Wavesync::UI.new #: UI
       @converter = FileConverter.new #: FileConverter
-      FFMPEG.logger = Logger.new(File::NULL)
     end
 
-    #: (String target_library_path, Device device, ?pad: bool) -> void
-    def sync(target_library_path, device, pad: false)
+    #: (String target_library_path, Device device, ?pad: bool, ?staged: bool, ?mp3_bitrate: Integer) ?{ (String) -> void } -> void
+    def sync(target_library_path, device, pad: false, staged: false, mp3_bitrate: 192, &on_file_synced)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      target_library_pathname = Pathname.new(target_library_path)
       path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
       skipped_count = 0
       conversion_count = 0
@@ -25,73 +29,114 @@ module Wavesync
 
       @audio_files.each_with_index do |file, index|
         audio = Audio.new(file)
+        bpm = audio.bpm
 
         source_format = audio.format
         target_format = device.target_format(source_format, file)
+        target_format = target_format.with(sample_rate: nil, bit_depth: nil) if source_format.file_type == 'mp3' && target_format.file_type.nil?
 
         padding_seconds = nil #: Numeric?
         original_bars = nil #: Integer?
         target_bars = nil #: Integer?
         if pad && device.bar_multiple
-          padding_seconds = TrackPadding.compute(audio.duration, audio.bpm, device.bar_multiple)
-          original_bars, target_bars = TrackPadding.bar_counts(audio.duration, audio.bpm, device.bar_multiple) unless padding_seconds.zero?
+          padding_seconds = TrackPadding.compute(audio.duration, bpm, device.bar_multiple)
+          original_bars, target_bars = TrackPadding.bar_counts(audio.duration, bpm, device.bar_multiple) unless padding_seconds.zero?
           padding_seconds = nil if padding_seconds.zero?
         end
 
-        @ui.bpm(audio.bpm, original_bars: original_bars, target_bars: target_bars)
+        @ui.bpm(bpm, original_bars: original_bars, target_bars: target_bars)
         @ui.file_progress(file)
 
-        if source_format.file_type == 'wav'
-          prospective_target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
-          if prospective_target_path.extname.downcase == '.wav' && prospective_target_path.exist?
-            target_cue_points = CueChunk.read(prospective_target_path.to_s)
-            if target_cue_points.any?
-              source_cue_points = audio.cue_points
-              audio.write_cue_points(target_cue_points) unless same_cue_points?(source_cue_points, target_cue_points)
-            end
-          end
-        end
-
         if target_format.file_type || target_format.sample_rate || target_format.bit_depth || padding_seconds
+          target_ext = target_format.file_type || source_format.file_type
+          transliterated_metadata = {} #: Hash[String, String]
+          transliterated_metadata = audio.transliterated_tag_changes if device.transliterate_metadata && target_ext == 'mp3'
           converted = @converter.convert(audio, file, path_resolver, source_format, target_format,
-                                         padding_seconds: padding_seconds) do
-            @ui.conversion_progress(source_format, target_format)
+                                         padding_seconds: padding_seconds,
+                                         metadata: transliterated_metadata,
+                                         mp3_bitrate: mp3_bitrate,
+                                         before_transcode: -> { @ui.conversion_progress(source_format, target_format, mp3_bitrate) }) do |local_temp_path|
+            inject_acid_bpm(local_temp_path, bpm, device)
+            inject_cue_points(local_temp_path, audio, source_format, target_format)
           end
-          target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          converted_target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          verify_written(converted_target_path, source: file) if converted
+          final_target_path = converted_target_path
         else
-          copied = copy_file(audio, file, path_resolver)
-          @ui.copy(source_format)
-          target_path = path_resolver.resolve(file, audio)
-        end
-
-        bpm = audio.bpm
-        if (copied || converted) && device.bpm_source == :acid_chunk && bpm && target_path.extname.downcase == '.wav'
-          temp_path = "#{target_path}.tmp"
-          AcidChunk.write_bpm(target_path.to_s, temp_path, bpm)
-          FileUtils.mv(temp_path, target_path.to_s)
-        end
-
-        if converted && source_format.file_type == 'wav' && target_path.extname.downcase == '.wav'
-          source_cue_points = audio.cue_points
-          if source_cue_points.any?
-            rescaled_cue_points = rescale_cue_points(source_cue_points, audio.sample_rate, target_format.sample_rate || audio.sample_rate)
-            temp_path = "#{target_path}.tmp"
-            CueChunk.write(target_path.to_s, temp_path, rescaled_cue_points)
-            FileUtils.mv(temp_path, target_path.to_s)
+          if device.bpm_source == :acid_chunk && bpm && File.extname(file).downcase == '.wav'
+            target_path = path_resolver.resolve(file, audio)
+            files_to_cleanup = path_resolver.find_files_to_cleanup(target_path, audio)
+            files_to_cleanup.each { |cleanup_file| FileUtils.rm_f(cleanup_file) }
+            if target_path.exist?
+              copied = false
+            else
+              target_path.dirname.mkpath
+              AcidChunk.write_bpm(file, target_path.to_s, bpm)
+              verify_written(target_path, source: file)
+              copied = true
+            end
+          else
+            copied = copy_file(audio, file, path_resolver)
+            target_path = path_resolver.resolve(file, audio)
+            if copied
+              verify_written(target_path, source: file)
+              inject_transliterated_metadata(target_path.to_s, device)
+            end
           end
+          final_target_path = target_path
+          @ui.copy(source_format)
         end
 
         if !copied && !converted
           skipped_count += 1
-          @ui.skip
+          @ui.skip(staged: staged)
         end
 
         conversion_count += 1 if converted
         @ui.sync_progress(index, @audio_files.size, device)
+
+        if on_file_synced && final_target_path
+          relative_path = final_target_path.relative_path_from(target_library_pathname).to_s
+          on_file_synced.call(relative_path)
+        end
+      end
+
+      puts
+      system('sync')
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      Logger.log_run_time(elapsed)
+    end
+
+    #: (String target_library_path, Device device) -> void
+    def pull_cue_points(target_library_path, device)
+      start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
+      @ui.pull_progress(0, @audio_files.size, device)
+
+      @audio_files.each_with_index do |file, index|
+        audio = Audio.new(file)
+        source_format = audio.format
+        @ui.file_progress(file)
+
+        if source_format.file_type == 'wav'
+          target_format = device.target_format(source_format, file)
+          target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+          if target_path.extname.downcase == '.wav' && target_path.exist?
+            target_cue_points = CueChunk.read(target_path.to_s)
+            if target_cue_points.any?
+              source_cue_points = audio.cue_points
+              audio.write_cue_points(target_cue_points) unless CueChunk.same?(source_cue_points, target_cue_points)
+            end
+          end
+        end
+
+        @ui.pull_progress(index, @audio_files.size, device)
       end
 
       puts
       system('sync')
+      elapsed = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+      Logger.log_run_time(elapsed)
     end
 
     private
@@ -116,15 +161,29 @@ module Wavesync
       end
     end
 
-    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points_a, Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points_b) -> bool
-    def same_cue_points?(cue_points_a, cue_points_b)
-      comparable_cue_points(cue_points_a) == comparable_cue_points(cue_points_b)
+    #: (String path, Device device) -> void
+    def inject_transliterated_metadata(path, device)
+      return unless device.transliterate_metadata
+
+      Audio.new(path).transliterate_tags
+    end
+
+    #: (String local_temp_path, (Integer | Float | String)? bpm, Device device) -> void
+    def inject_acid_bpm(local_temp_path, bpm, device)
+      return unless device.bpm_source == :acid_chunk && bpm && File.extname(local_temp_path).downcase == '.wav'
+
+      AcidChunk.write_bpm_in_place(local_temp_path, bpm)
     end
 
-    #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points) -> Array[{sample_offset: Integer, label: String?}]
-    def comparable_cue_points(cue_points)
-      mapped = cue_points.map { |cp| { sample_offset: cp[:sample_offset], label: cp[:label] } } #: Array[{sample_offset: Integer, label: String?}]
-      mapped.sort_by { |cp| cp[:sample_offset] }
+    #: (String local_temp_path, Audio audio, AudioFormat source_format, AudioFormat target_format) -> void
+    def inject_cue_points(local_temp_path, audio, source_format, target_format)
+      return unless source_format.file_type == 'wav' && File.extname(local_temp_path).downcase == '.wav'
+
+      source_cue_points = audio.cue_points
+      return unless source_cue_points.any?
+
+      rescaled_cue_points = rescale_cue_points(source_cue_points, audio.sample_rate, target_format.sample_rate || audio.sample_rate)
+      CueChunk.append_to_file(local_temp_path, rescaled_cue_points)
     end
 
     #: (Array[{identifier: Integer, sample_offset: Integer, label: String?}] cue_points, Integer? source_sample_rate, Integer? target_sample_rate) -> Array[{identifier: Integer, sample_offset: Integer, label: String?}]
@@ -139,8 +198,16 @@ module Wavesync
     #: (String source, Pathname target) -> void
     def safe_copy(source, target)
       FileUtils.install(source, target)
-    rescue Errno::ENOENT
-      puts 'Errno::ENOENT'
+    rescue Errno::ENOENT => e
+      Logger.log_error(e, call_site: 'Scanner#safe_copy', arguments: { source:, target: })
+    end
+
+    #: (Pathname target_path, source: String) -> void
+    def verify_written(target_path, source:)
+      return if target_path.exist?
+
+      error = RuntimeError.new('target file missing after write')
+      Logger.log_error(error, call_site: 'Scanner#verify_written', arguments: { source:, target: target_path.to_s })
     end
   end
 end

data/lib/wavesync/{set.rb → setlist.rb}

@@ -5,32 +5,32 @@ require 'yaml'
 require 'fileutils'
 
 module Wavesync
-  class Set
-    SETS_FOLDER = '.sets'
+  class Setlist
+    SETLISTS_FOLDER = '.setlists'
 
     attr_reader :name #: String
     attr_reader :tracks #: Array[String]
     attr_reader :library_path #: String
 
     #: (String library_path) -> String
-    def self.sets_path(library_path)
-      File.join(library_path, SETS_FOLDER)
+    def self.setlists_path(library_path)
+      File.join(library_path, SETLISTS_FOLDER)
     end
 
     #: (String library_path, String name) -> String
-    def self.set_path(library_path, name)
-      File.join(sets_path(library_path), "#{name}.yml")
+    def self.setlist_path(library_path, name)
+      File.join(setlists_path(library_path), "#{name}.yml")
     end
 
-    #: (String library_path, String name) -> Set
+    #: (String library_path, String name) -> Setlist
     def self.load(library_path, name)
-      data = YAML.load_file(set_path(library_path, name))
+      data = YAML.load_file(setlist_path(library_path, name))
       new(library_path, data['name'], expand_tracks(library_path, data['tracks']))
     end
 
-    #: (String library_path) -> Array[Set]
+    #: (String library_path) -> Array[Setlist]
     def self.all(library_path)
-      path = sets_path(library_path)
+      path = setlists_path(library_path)
       return [] unless Dir.exist?(path)
 
       Dir.glob(File.join(path, '*.yml')).map do |file|
@@ -41,7 +41,7 @@ module Wavesync
 
     #: (String library_path, String name) -> bool
     def self.exists?(library_path, name)
-      File.exist?(set_path(library_path, name))
+      File.exist?(setlist_path(library_path, name))
     end
 
     #: (String library_path, String name, ?Array[String] tracks) -> void
@@ -77,8 +77,8 @@ module Wavesync
 
     #: () -> void
     def save
-      FileUtils.mkdir_p(self.class.sets_path(@library_path))
-      File.write(self.class.set_path(@library_path, @name), to_yaml)
+      FileUtils.mkdir_p(self.class.setlists_path(@library_path))
+      File.write(self.class.setlist_path(@library_path, @name), to_yaml)
     end
 
     private

data/lib/wavesync/{set_editor.rb → setlist_editor.rb}

@@ -4,9 +4,10 @@
 require 'tty-prompt'
 require 'io/console'
 require 'stringio'
+require_relative 'logger'
 
 module Wavesync
-  class SetEditor
+  class SetlistEditor
     KEY_MAP = {
       'a' => :add,
       'u' => :move_up,
@@ -20,16 +21,17 @@ module Wavesync
     }.freeze
 
     attr_accessor :player_state #: Symbol
-    attr_reader :selected, :set, :ui #: untyped
-    attr_writer :player_track, :player_index, :player_offset, :player_started_at
+    attr_reader :selected, :setlist, :ui #: untyped
+    attr_writer :player_track, :player_index, :player_offset, :player_started_at, :player_pid
 
-    #: (Set set, String library_path) -> void
-    def initialize(set, library_path)
-      @set = set #: Set
+    #: (Setlist setlist, String library_path) -> void
+    def initialize(setlist, library_path)
+      @setlist = setlist #: Setlist
       @library_path = library_path #: String
+      Logger.configure(@library_path)
       @prompt = TTY::Prompt.new(interrupt: :exit, active_color: :red) #: untyped
       @ui = UI.new #: UI
-      @selected = @set.tracks.empty? ? nil : 0 #: Integer?
+      @selected = @setlist.tracks.empty? ? nil : 0 #: Integer?
       @player_pid = nil #: Integer?
       @player_track = nil #: String?
       @player_index = nil #: Integer?
@@ -64,7 +66,8 @@ module Wavesync
 
       @track_bpms[path] = begin
         Audio.new(path).bpm
-      rescue StandardError
+      rescue StandardError => e
+        Logger.log_error(e, call_site: 'SetlistEditor#track_bpm', arguments: { path: })
         nil
       end
     end
@@ -78,7 +81,8 @@ module Wavesync
 
       @track_durations[path] = begin
         Audio.new(path).duration
-      rescue StandardError
+      rescue StandardError => e
+        Logger.log_error(e, call_site: 'SetlistEditor#track_duration', arguments: { path: })
         nil
       end
     end
@@ -99,7 +103,8 @@ module Wavesync
         else
           [] #: Array[Float]
         end
-      rescue StandardError
+      rescue StandardError => e
+        Logger.log_error(e, call_site: 'SetlistEditor#track_cue_fractions', arguments: { path: })
         [] #: Array[Float]
       end
     end
@@ -249,22 +254,22 @@ module Wavesync
     end
 
     #: (?String title) -> void
-    def render(title = "wavesync set #{@set.name}")
+    def render(title = "wavesync setlist #{@setlist.name}")
       buffer = StringIO.new
       $stdout = buffer
 
       header = @ui.color(title, :primary)
-      total_duration = @set.tracks.sum { |track_path| track_duration(track_path) || 0.0 }
+      total_duration = @setlist.tracks.sum { |track_path| track_duration(track_path) || 0.0 }
 
-      duration_widths = @set.tracks.map { |track_path| format_duration(track_duration(track_path))&.length || 0 }
+      duration_widths = @setlist.tracks.map { |track_path| format_duration(track_duration(track_path))&.length || 0 }
       duration_widths << (format_duration(total_duration)&.length || 0)
-      player_duration = @player_index ? track_duration(@set.tracks[@player_index]) : nil
+      player_duration = @player_index ? track_duration(@setlist.tracks[@player_index]) : nil
       duration_widths << remaining_display(0.0, player_duration).length if player_duration
       duration_col_width = duration_widths.max || 0
 
-      if @set.tracks.any? && total_duration.positive?
-        track_label = @set.tracks.size == 1 ? 'track' : 'tracks'
-        track_count_part = @ui.color("#{@set.tracks.size} #{track_label}", :secondary)
+      if @setlist.tracks.any? && total_duration.positive?
+        track_label = @setlist.tracks.size == 1 ? 'track' : 'tracks'
+        track_count_part = @ui.color("#{@setlist.tracks.size} #{track_label}", :secondary)
         duration_part = @ui.color(format_duration(total_duration).to_s.rjust(duration_col_width), :secondary)
         summary = "#{track_count_part}   #{duration_part}"
         gap = [terminal_width - visible_length(header) - visible_length(summary), 2].max
@@ -275,13 +280,13 @@ module Wavesync
 
       puts
 
-      if @set.tracks.empty?
+      if @setlist.tracks.empty?
         puts @ui.color('  (no tracks)', :secondary)
       else
-        @set.tracks.each_with_index do |track, i|
+        @setlist.tracks.each_with_index do |track, i|
           current_bpm = track_bpm(track)
           current_duration = track_duration(track)
-          pitch_shift = pitch_shift_semitones(current_bpm, track_bpm(@set.tracks[i + 1]))
+          pitch_shift = pitch_shift_semitones(current_bpm, track_bpm(@setlist.tracks[i + 1]))
           render_track(i, relative_path(track), i == @selected, i == @player_index,
                        bpm: current_bpm, pitch_shift: pitch_shift, duration: current_duration,
                        duration_col_width: duration_col_width, cue_fractions: track_cue_fractions(track))
@@ -357,10 +362,10 @@ module Wavesync
     def handle_action(action)
       case action
       when :cursor_up
-        @selected = [@selected - 1, 0].max unless @set.tracks.empty?
+        @selected = [@selected - 1, 0].max unless @setlist.tracks.empty?
         nil
       when :cursor_down
-        @selected = [@selected + 1, @set.tracks.size - 1].min unless @set.tracks.empty?
+        @selected = [@selected + 1, @setlist.tracks.size - 1].min unless @setlist.tracks.empty?
         nil
       when :toggle_play
         toggle_playback
@@ -381,7 +386,7 @@ module Wavesync
         jump_to_next_cue
         nil
       when :quit
-        @set.save
+        @setlist.save
         :quit
       end
     end
@@ -390,7 +395,7 @@ module Wavesync
     def toggle_playback
       return if @selected.nil?
 
-      track = @set.tracks[@selected]
+      track = @setlist.tracks[@selected]
 
       if @player_track == track
         case @player_state
@@ -409,7 +414,7 @@ module Wavesync
 
     #: (String track, ?Numeric offset, ?player_index: Integer?) -> void
     def start_player(track, offset = 0, player_index: @selected)
-      ffplay = FFMPEG.ffmpeg_binary.sub('ffmpeg', 'ffplay')
+      ffplay = Wavesync::FFMPEG.ffplay_binary
       args = [ffplay, '-nodisp', '-autoexit', '-loglevel', 'quiet', '-probesize', '32', '-analyzeduration', '0']
       args += ['-ss', offset.to_s] if offset.positive?
       args << track
@@ -444,9 +449,11 @@ module Wavesync
     def kill_player
       return unless @player_pid
 
+      player_pid = @player_pid
       Process.kill('TERM', @player_pid)
       @player_pid = nil
-    rescue Errno::ESRCH
+    rescue Errno::ESRCH => e
+      Logger.log_error(e, call_site: 'SetlistEditor#kill_player', arguments: { player_pid: })
       @player_pid = nil
     end
 
@@ -464,6 +471,7 @@ module Wavesync
     def check_player
       return unless @player_pid
 
+      player_pid = @player_pid
       result = Process.waitpid(@player_pid, Process::WNOHANG)
       return unless result
 
@@ -473,7 +481,8 @@ module Wavesync
       @player_state = :stopped
       @player_offset = 0
       advance_and_play
-    rescue Errno::ECHILD
+    rescue Errno::ECHILD => e
+      Logger.log_error(e, call_site: 'SetlistEditor#check_player', arguments: { player_pid: })
       @player_pid = nil
       @player_track = nil
       @player_index = nil
@@ -484,10 +493,10 @@ module Wavesync
 
     #: () -> void
     def advance_and_play
-      return if @selected.nil? || @selected >= @set.tracks.size - 1
+      return if @selected.nil? || @selected >= @setlist.tracks.size - 1
 
       @selected += 1
-      start_player(@set.tracks[@selected])
+      start_player(@setlist.tracks[@selected])
     end
 
     #: () -> Array[String]
@@ -505,43 +514,43 @@ module Wavesync
 
       choices = audio_files.map { |file| { name: relative_path(file), value: file } }
 
-      render("wavesync set #{@set.name} — add track")
+      render("wavesync setlist #{@setlist.name} — add track")
       puts
       picked = @prompt.select('Select a track to add:', choices, cycle: true, filter: true, per_page: 20)
 
       insert_at = @selected.nil? ? 0 : @selected + 1
-      @set.tracks.insert(insert_at, picked)
+      @setlist.tracks.insert(insert_at, picked)
       @selected = insert_at
     end
 
     #: () -> void
     def remove_track
-      return if @set.tracks.empty? || @selected.nil?
+      return if @setlist.tracks.empty? || @selected.nil?
 
-      stop_playback if @player_track == @set.tracks[@selected]
-      @set.remove_track(@selected)
-      @selected = if @set.tracks.empty?
+      stop_playback if @player_track == @setlist.tracks[@selected]
+      @setlist.remove_track(@selected)
+      @selected = if @setlist.tracks.empty?
                     nil
                   else
-                    [@selected, @set.tracks.size - 1].min
+                    [@selected, @setlist.tracks.size - 1].min
                   end
     end
 
     #: (Symbol direction) -> void
     def move_track(direction)
-      return if @set.tracks.size < 2 || @selected.nil?
+      return if @setlist.tracks.size < 2 || @selected.nil?
 
       if direction == :up
-        @set.move_up(@selected)
+        @setlist.move_up(@selected)
         @selected = [@selected - 1, 0].max
       else
-        @set.move_down(@selected)
-        @selected = [@selected + 1, @set.tracks.size - 1].min
+        @setlist.move_down(@selected)
+        @selected = [@selected + 1, @setlist.tracks.size - 1].min
       end
     end
 
-    public :handle_action, :advance_and_play, :display_name, :relative_path,
-           :format_duration, :playback_elapsed, :visible_length, :playback_bar,
-           :selected, :set, :ui
+    public :handle_action, :advance_and_play, :kill_player, :check_player,
+           :display_name, :relative_path, :format_duration, :playback_elapsed,
+           :visible_length, :playback_bar, :selected, :setlist, :ui
   end
 end

data/lib/wavesync/track_padding.rb

@@ -11,7 +11,7 @@ module Wavesync
 
       seconds_per_bar = BEATS_PER_BAR * 60.0 / bpm.to_f
       track_bars = (duration_seconds / seconds_per_bar).round(6)
-      target_bars = (track_bars / bar_multiple.to_f).ceil * bar_multiple.to_f
+      target_bars = next_power_of_two_multiple(track_bars, bar_multiple)
 
       padding = (target_bars * seconds_per_bar) - duration_seconds
       padding < 0.001 ? 0 : padding
@@ -23,8 +23,16 @@ module Wavesync
 
       seconds_per_bar = BEATS_PER_BAR * 60.0 / bpm.to_f
       original_bars = (duration_seconds / seconds_per_bar).round
-      target_bars = ((original_bars.to_f / bar_multiple).ceil * bar_multiple.to_f).to_i
+      target_bars = next_power_of_two_multiple(original_bars, bar_multiple).to_i
       [original_bars, target_bars]
     end
+
+    #: ((Float | Integer) value, (Float | Integer) base) -> Float
+    def self.next_power_of_two_multiple(value, base)
+      target = base.to_f
+      target *= 2 while target < value
+      target
+    end
+    private_class_method :next_power_of_two_multiple
   end
 end

data/lib/wavesync/transport/filesystem.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+# rbs_inline: enabled
+
+module Wavesync
+  module Transport
+    class Filesystem
+      attr_reader :working_directory #: String
+
+      #: ({ name: String, model: String, path: String, transport: String?, mp3_bitrate: Integer } device_config) -> void
+      def initialize(device_config)
+        @working_directory = device_config[:path]
+      end
+
+      #: () ?{ (Integer, Integer, String) -> void } -> void
+      def prepare!
+        # Filesystem destinations expose live device contents directly, so
+        # there is nothing to pull beforehand.
+      end
+
+      #: () ?{ (Integer, Integer, String) -> void } -> void
+      def commit!
+        # Filesystem destinations are written to directly during sync, so there
+        # is nothing to commit here.
+      end
+
+      #: () -> void
+      def begin_push!; end
+
+      #: (String relative_path) -> void
+      def push_file!(relative_path); end
+
+      #: () -> void
+      def finish_push!; end
+    end
+  end
+end