wavesync 1.0.0.alpha1

data/lib/wavesync/cli.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  class CLI
+    def self.start
+      command = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
+
+      case command
+      when 'sync'
+        start_sync
+      when 'analyze'
+        start_analyze
+      when 'set'
+        start_set
+      else
+        puts "Unknown command: #{command}"
+        puts 'Available commands: sync, analyze, set'
+        exit 1
+      end
+    end
+
+    def self.start_sync
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: wavesync sync [options]'
+
+        opts.on('-d', '--device NAME', 'Name of device to sync (as defined in config)') do |value|
+          options[:device] = value
+        end
+
+        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
+          options[:config] = value
+        end
+
+        opts.on('-p', '--pad', 'Pad tracks with silence so total length is a multiple of 64 bars (Octatrack only)') do
+          options[:pad] = true
+        end
+      end
+
+      parser.parse!
+
+      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
+      config = load_config(config_path)
+
+      device_configs = config.device_configs
+      if options[:device]
+        device_configs = device_configs.select { |device_config| device_config[:name] == options[:device] }
+        if device_configs.empty?
+          known = config.device_configs.map { |device_config| device_config[:name] }.join(', ')
+          puts "Unknown device \"#{options[:device]}\". Devices in config: #{known}"
+          exit 1
+        end
+      end
+
+      device_configs.each do |device_config|
+        next if Wavesync::Device.find_by(name: device_config[:model])
+
+        supported = Wavesync::Device.all.map(&:name).join(', ')
+        puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
+        exit 1
+      end
+
+      scanner = Wavesync::Scanner.new(config.library)
+
+      device_configs.each do |device_config|
+        scanner.sync(device_config[:path], Wavesync::Device.find_by(name: device_config[:model]),
+                     pad: options[:pad] || false)
+      end
+    end
+
+    def self.start_set
+      subcommand = ARGV.shift
+
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: wavesync set <subcommand> [options]'
+
+        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
+          options[:config] = value
+        end
+      end
+
+      parser.parse!
+
+      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
+      config = load_config(config_path)
+
+      case subcommand
+      when 'create'
+        name = require_set_name('create')
+        if Wavesync::Set.exists?(config.library, name)
+          puts "Set '#{name}' already exists. Use 'wavesync set edit #{name}' to edit it."
+          exit 1
+        end
+        set = Wavesync::Set.new(config.library, name)
+        Wavesync::SetEditor.new(set, config.library).run
+      when 'edit'
+        name = require_set_name('edit')
+        unless Wavesync::Set.exists?(config.library, name)
+          puts "Set '#{name}' not found. Use 'wavesync set create #{name}' to create it."
+          exit 1
+        end
+        set = Wavesync::Set.load(config.library, name)
+        Wavesync::SetEditor.new(set, config.library).run
+      when 'list'
+        sets = Wavesync::Set.all(config.library)
+        if sets.empty?
+          puts 'No sets found.'
+        else
+          sets.each { |s| puts "#{s.name} (#{s.tracks.size} tracks)" }
+        end
+      else
+        puts "Unknown subcommand: #{subcommand || '(none)'}"
+        puts 'Available subcommands: create, edit, list'
+        exit 1
+      end
+    end
+
+    def self.load_config(path)
+      Wavesync::Config.load(path)
+    rescue Wavesync::ConfigError => e
+      puts "Configuration error: #{e.message}"
+      exit 1
+    end
+
+    def self.require_set_name(subcommand)
+      name = ARGV.shift
+      unless name
+        puts "Usage: wavesync set #{subcommand} <name>"
+        exit 1
+      end
+      name
+    end
+
+    def self.start_analyze
+      options = {}
+      parser = OptionParser.new do |opts|
+        opts.banner = 'Usage: wavesync analyze [options]'
+
+        opts.on('-c', '--config PATH', 'Path to wavesync config YAML file') do |value|
+          options[:config] = value
+        end
+
+        opts.on('-f', '--force', 'Overwrite existing BPM values') do
+          options[:overwrite] = true
+        end
+      end
+
+      parser.parse!
+
+      config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
+      config = load_config(config_path)
+
+      Wavesync::Analyzer.new(config.library).analyze(overwrite: options[:overwrite] || false)
+    end
+  end
+end

data/lib/wavesync/config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Wavesync
+  class ConfigError < StandardError; end
+
+  class Config
+    DEFAULT_PATH = File.join(Dir.home, 'wavesync.yml')
+
+    SUPPORTED_KEYS = %w[library devices].freeze
+    DEVICE_SUPPORTED_KEYS = %w[name model path].freeze
+    DEVICE_REQUIRED_KEYS = %w[name model path].freeze
+
+    attr_reader :library, :device_configs
+
+    def self.load(path = DEFAULT_PATH)
+      expanded = File.expand_path(path)
+      begin
+        data = YAML.load_file(expanded)
+      rescue Errno::ENOENT
+        raise ConfigError, "Config file not found: #{path}"
+      rescue Psych::SyntaxError => e
+        raise ConfigError, "Invalid YAML in config file: #{e.message}"
+      end
+      new(data)
+    end
+
+    def initialize(data)
+      validate!(data)
+      @library = File.expand_path(data['library'])
+      @device_configs = data['devices'].each_with_index.map do |device, i|
+        validate_device!(device, i)
+        { name: device['name'], model: device['model'], path: File.expand_path(device['path']) }
+      end
+    end
+
+    private
+
+    def validate!(data)
+      raise ConfigError, 'Config file must contain a YAML mapping' unless data.is_a?(Hash)
+
+      unsupported = data.keys - SUPPORTED_KEYS
+      raise ConfigError, "Unsupported config keys: #{unsupported.join(', ')}" if unsupported.any?
+
+      %w[library devices].each do |key|
+        raise ConfigError, "Missing required config key: '#{key}'" unless data.key?(key)
+      end
+
+      raise ConfigError, "'library' must be a string" unless data['library'].is_a?(String)
+      raise ConfigError, "'devices' must be a list" unless data['devices'].is_a?(Array)
+      raise ConfigError, "'devices' must contain at least one device" if data['devices'].empty?
+    end
+
+    def validate_device!(device, index)
+      raise ConfigError, "Device #{index + 1} must be a YAML mapping" unless device.is_a?(Hash)
+
+      unsupported = device.keys - DEVICE_SUPPORTED_KEYS
+      raise ConfigError, "Unsupported keys in device #{index + 1}: #{unsupported.join(', ')}" if unsupported.any?
+
+      DEVICE_REQUIRED_KEYS.each do |key|
+        raise ConfigError, "Missing required key '#{key}' in device #{index + 1}" unless device.key?(key)
+      end
+
+      %w[name model path].each do |key|
+        raise ConfigError, "Device #{index + 1} '#{key}' must be a string" unless device[key].is_a?(String)
+      end
+    end
+  end
+end

data/lib/wavesync/device.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'yaml'
+module Wavesync
+  class Device
+    attr_reader :name, :sample_rates, :bit_depths, :file_types, :bpm_source, :bar_multiple
+
+    def initialize(name:, sample_rates:, bit_depths:, file_types:, bpm_source: nil, bar_multiple: nil)
+      @name = name
+      @sample_rates = sample_rates
+      @bit_depths = bit_depths
+      @file_types = file_types
+      @bpm_source = bpm_source
+      @bar_multiple = bar_multiple
+    end
+
+    def self.config_path
+      File.expand_path('../../config/devices.yml', __dir__)
+    end
+
+    def self.all
+      @all ||= load_from_yaml
+    end
+
+    def self.find_by(name:)
+      all.find { |device| device.name == name }
+    end
+
+    def self.load_from_yaml
+      data = YAML.load_file(config_path)
+      data.fetch('devices').map do |attrs|
+        new(
+          name: attrs['name'],
+          sample_rates: attrs['sample_rates'],
+          bit_depths: attrs['bit_depths'],
+          file_types: attrs['file_types'],
+          bpm_source: attrs['bpm_source']&.to_sym,
+          bar_multiple: attrs['bar_multiple']
+        )
+      end
+    end
+
+    def target_format(source_format, source_file_path)
+      AudioFormat.new(
+        file_type: target_file_type(source_file_path),
+        sample_rate: target_sample_rate(source_format.sample_rate),
+        bit_depth: target_bit_depth(source_format.bit_depth)
+      )
+    end
+
+    def target_file_type(source_file_path)
+      file_extension = File.extname(source_file_path).downcase[1..]
+      return nil if file_types.include?(file_extension)
+
+      file_types.first
+    end
+
+    def target_sample_rate(source_sample_rate)
+      return nil if sample_rates.include?(source_sample_rate)
+
+      sample_rates.min_by { |n| [(n - source_sample_rate).abs, -n] }
+    end
+
+    def target_bit_depth(source_bit_depth)
+      return nil if source_bit_depth.nil? || bit_depths.include?(source_bit_depth)
+
+      bit_depths.min_by { |n| [(n - source_bit_depth).abs, -n] }
+    end
+  end
+end

data/lib/wavesync/file_converter.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Wavesync
+  class FileConverter
+    DURATION_TOLERANCE_SECONDS = 0.5
+
+    def convert(audio, source_file_path, path_resolver, source_format, target_format, padding_seconds: nil, &before_transcode)
+      needs_format_conversion = target_format.file_type || target_format.sample_rate || target_format.bit_depth
+      return false unless needs_format_conversion || padding_seconds&.positive?
+
+      target_path = path_resolver.resolve(source_file_path, audio, target_file_type: target_format.file_type)
+
+      files_to_cleanup = path_resolver.find_files_to_cleanup(target_path, audio)
+      files_to_cleanup.each { |file| FileUtils.rm_f(file) }
+
+      if target_format.file_type
+        source_converted_path = Pathname(source_file_path).sub_ext(".#{target_format.file_type}")
+        return false if source_converted_path.exist?
+      end
+
+      if target_path.exist?
+        existing_duration = Audio.new(target_path.to_s).duration
+        expected_duration = audio.duration + (padding_seconds || 0)
+        return false if (existing_duration - expected_duration).abs < DURATION_TOLERANCE_SECONDS
+
+        target_path.delete
+      end
+
+      target_path.dirname.mkpath
+      before_transcode&.call
+
+      audio.transcode(target_path.to_s, target_sample_rate: target_format.sample_rate,
+                                        target_file_type: target_format.file_type,
+                                        target_bit_depth: target_format.bit_depth || source_format.bit_depth,
+                                        padding_seconds: padding_seconds)
+
+      true
+    end
+  end
+end

data/lib/wavesync/path_resolver.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Wavesync
+  class PathResolver
+    BPM_PATTERN = / \d+ bpm/
+
+    def initialize(source_library_path, target_library_path, device)
+      @source_library_path = Pathname(File.expand_path(source_library_path))
+      @target_library_path = Pathname(File.expand_path(target_library_path))
+      @device = device
+    end
+
+    def resolve(source_file_path, audio, target_file_type: nil)
+      relative_path = Pathname(source_file_path).relative_path_from(@source_library_path)
+      target_path = @target_library_path.join(relative_path)
+
+      target_path = target_path.sub_ext(".#{target_file_type}") if target_file_type
+
+      target_path = add_bpm_to_filename(target_path, audio.bpm) if @device.bpm_source == :filename && audio.bpm
+
+      target_path
+    end
+
+    def find_files_to_cleanup(target_path, audio)
+      return [] unless @device.bpm_source == :filename && audio.bpm
+
+      ext = target_path.extname
+      basename = target_path.basename(ext).to_s.gsub(BPM_PATTERN, '')
+
+      pattern = target_path.dirname.join("#{basename}{, * bpm}#{ext}")
+      Dir.glob(pattern.to_s).map { |f| Pathname(f) }
+         .reject { |path| path == target_path }
+    end
+
+    private
+
+    def add_bpm_to_filename(path, bpm)
+      ext = path.extname
+      basename = path.basename(ext).to_s
+
+      basename = basename.gsub(BPM_PATTERN, '')
+
+      new_basename = "#{basename} #{bpm} bpm#{ext}"
+      path.dirname.join(new_basename)
+    end
+
+    def remove_bpm_from_filename(path)
+      ext = path.extname
+      basename = path.basename(ext).to_s
+      basename_without_bpm = basename.gsub(BPM_PATTERN, '')
+
+      path.dirname.join("#{basename_without_bpm}#{ext}")
+    end
+  end
+end

data/lib/wavesync/scanner.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'streamio-ffmpeg'
+require_relative 'file_converter'
+
+module Wavesync
+  class Scanner
+    def initialize(source_library_path)
+      @source_library_path = File.expand_path(source_library_path)
+      @audio_files = find_audio_files
+      @ui = Wavesync::UI.new
+      @converter = FileConverter.new
+      FFMPEG.logger = Logger.new(File::NULL)
+    end
+
+    def sync(target_library_path, device, pad: false)
+      path_resolver = PathResolver.new(@source_library_path, target_library_path, device)
+      skipped_count = 0
+      conversion_count = 0
+      @ui.sync_progress(0, @audio_files.size, device)
+
+      @audio_files.each_with_index do |file, index|
+        audio = Audio.new(file)
+
+        source_format = audio.format
+        target_format = device.target_format(source_format, file)
+
+        padding_seconds = nil
+        original_bars = nil
+        target_bars = nil
+        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 = nil if padding_seconds.zero?
+        end
+
+        @ui.bpm(audio.bpm, original_bars: original_bars, target_bars: target_bars)
+        @ui.file_progress(file)
+
+        if target_format.file_type || target_format.sample_rate || target_format.bit_depth || padding_seconds
+          converted = @converter.convert(audio, file, path_resolver, source_format, target_format,
+                                         padding_seconds: padding_seconds) do
+            @ui.conversion_progress(source_format, target_format)
+          end
+          target_path = path_resolver.resolve(file, audio, target_file_type: target_format.file_type)
+        else
+          copied = copy_file(audio, file, path_resolver)
+          @ui.copy(source_format)
+          target_path = path_resolver.resolve(file, audio)
+        end
+
+        if (copied || converted) && device.bpm_source == :acid_chunk && audio.bpm && target_path.extname.downcase == '.wav'
+          temp_path = "#{target_path}.tmp"
+          AcidChunk.write_bpm(target_path.to_s, temp_path, audio.bpm)
+          FileUtils.mv(temp_path, target_path.to_s)
+        end
+
+        if !copied && !converted
+          skipped_count += 1
+          @ui.skip
+        end
+
+        conversion_count += 1 if converted
+        @ui.sync_progress(index, @audio_files.size, device)
+      end
+
+      puts
+    end
+
+    private
+
+    def find_audio_files
+      Audio.find_all(@source_library_path)
+    end
+
+    def copy_file(audio, source_file_path, path_resolver)
+      target_path = path_resolver.resolve(source_file_path, audio)
+
+      files_to_cleanup = path_resolver.find_files_to_cleanup(target_path, audio)
+      files_to_cleanup.each { |file| FileUtils.rm_f(file) }
+
+      if target_path.exist?
+        false
+      else
+        safe_copy(source_file_path, target_path)
+        true
+      end
+    end
+
+    def safe_copy(source, target)
+      FileUtils.install(source, target)
+    rescue Errno::ENOENT
+      puts 'Errno::ENOENT'
+    end
+  end
+end

data/lib/wavesync/set.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require 'fileutils'
+
+module Wavesync
+  class Set
+    SETS_FOLDER = '.sets'
+
+    attr_reader :name, :tracks, :library_path
+
+    def self.sets_path(library_path)
+      File.join(library_path, SETS_FOLDER)
+    end
+
+    def self.set_path(library_path, name)
+      File.join(sets_path(library_path), "#{name}.yml")
+    end
+
+    def self.load(library_path, name)
+      data = YAML.load_file(set_path(library_path, name))
+      new(library_path, data['name'], expand_tracks(library_path, data['tracks']))
+    end
+
+    def self.all(library_path)
+      path = sets_path(library_path)
+      return [] unless Dir.exist?(path)
+
+      Dir.glob(File.join(path, '*.yml')).map do |file|
+        data = YAML.load_file(file)
+        new(library_path, data['name'], expand_tracks(library_path, data['tracks']))
+      end.sort_by(&:name)
+    end
+
+    def self.exists?(library_path, name)
+      File.exist?(set_path(library_path, name))
+    end
+
+    def initialize(library_path, name, tracks = [])
+      @library_path = library_path
+      @name = name
+      @tracks = tracks.dup
+    end
+
+    def add_track(path)
+      @tracks << path
+    end
+
+    def remove_track(index)
+      @tracks.delete_at(index)
+    end
+
+    def move_up(index)
+      return if index <= 0
+
+      @tracks[index], @tracks[index - 1] = @tracks[index - 1], @tracks[index]
+    end
+
+    def move_down(index)
+      return if index >= @tracks.size - 1
+
+      @tracks[index], @tracks[index + 1] = @tracks[index + 1], @tracks[index]
+    end
+
+    def save
+      FileUtils.mkdir_p(self.class.sets_path(@library_path))
+      File.write(self.class.set_path(@library_path, @name), to_yaml)
+    end
+
+    private
+
+    def self.expand_tracks(library_path, tracks)
+      (tracks || []).map { |t| File.join(library_path, t) }
+    end
+    private_class_method :expand_tracks
+
+    def to_yaml
+      relative_tracks = @tracks.map { |t| t.sub("#{@library_path}/", '') }
+      { 'name' => @name, 'tracks' => relative_tracks }.to_yaml
+    end
+  end
+end