wavesync 1.0.0.alpha1 → 1.0.0.alpha2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5ba5ed4b274c7287903407029c902eeee5baeb3138f7f4fe19127a2ceca5329f
-  data.tar.gz: c2653fe2efc113dafd67814a7c653bc2f7a9c068369800775028397ecc963793
+  metadata.gz: 166c4643be69e020ac6ac73611146502faa4891ad35f60bd30f3143702113c14
+  data.tar.gz: f41b3be18c7f4014f892a19e27612a363502d1f70effe098e74d239b19d9d873
 SHA512:
-  metadata.gz: 846c29ec104723435dbb14bb4eb7902e17ed3276c322de9d82664ede303eb3878394bff44ee0769b934e3d39066ddc9d437656565f71c7ccf4ab8a956b42b2d0
-  data.tar.gz: a3b5135a634bf8d088cc8886e4244d62ddfddd7428f974781d47037432ca80476e92bb736d5fa0f0467e5d64c9d07b8fd73c331c78b031d395c25ce432095483
+  metadata.gz: d1df257786183fa8253036ca6e59b7b559bab4d82fba2da101aa86c58e91f56af272215fd406785e05c8eec6cb473c22ea8d90ff9fd4367f6894ae9916aef54a
+  data.tar.gz: b29f51c0a796aedddee42d219e042e02b150b89ec23775b40ca7c8d7e93b2b7c1dae438a240aa3e549e2e3f53318f3960d6305965d29a6199b29f62d99c1fa10

data/README.md

@@ -63,10 +63,17 @@ devices:
 
 Wavesync will exit with an error if a device model in the config is not supported.
 
+## Help
+
+```bash
+wavesync help
+```
+
 ## Usage
 
 ```bash
-# Sync library to all devices (uses default config at ~/wavesync.yml)
+# Sync library (uses default config at ~/wavesync.yml)
+# If multiple devices are configured, you will be prompted to select one
 wavesync sync
 
 # Use a config at a specific path
@@ -133,3 +140,17 @@ Example: If a 96kHz file is synced to an Octatrack (which only supports 44.1kHz)
 ```bash
 rake test
 ```
+
+### Running RuboCop
+
+```bash
+bundle exec rubocop
+```
+
+### Releasing
+
+```bash
+rake release:publish
+```
+
+This tags the current version, pushes the tag to origin, builds the gem, and publishes it to RubyGems.

data/lib/wavesync/analyzer.rb

@@ -2,6 +2,8 @@
 
 module Wavesync
   class Analyzer
+    CONFIRM_MESSAGE = 'wavesync analyze will add bpm meta data to files in library. Continue? [y/N] '
+
     def initialize(library_path)
       @library_path = File.expand_path(library_path)
       @audio_files = find_audio_files
@@ -14,6 +16,8 @@ module Wavesync
         exit 1
       end
 
+      return unless @ui.confirm(CONFIRM_MESSAGE)
+
       @audio_files.each_with_index do |file, index|
         audio = Audio.new(file)
 

data/lib/wavesync/cli.rb

@@ -1,159 +1,20 @@
 # frozen_string_literal: true
 
-require 'optparse'
+require_relative 'commands'
 
 module Wavesync
   class CLI
     def self.start
-      command = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
+      command_name = ARGV.first && !ARGV.first.start_with?('-') ? ARGV.shift : 'sync'
+      command_class = Commands::ALL.find { |cmd| command_name == cmd.name }
 
-      case command
-      when 'sync'
-        start_sync
-      when 'analyze'
-        start_analyze
-      when 'set'
-        start_set
+      if command_class
+        command_class.new.run
       else
-        puts "Unknown command: #{command}"
-        puts 'Available commands: sync, analyze, set'
+        puts "Unknown command: #{command_name}"
+        puts "Available commands: #{Commands::ALL.map(&:name).join(', ')}"
         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/commands/analyze.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Analyze < Command
+      FORCE_OPTION = Option.new(short: '-f', long: '--force', description: 'Overwrite existing BPM values')
+
+      self.name = 'analyze'
+      self.description = 'Detect and write BPM metadata to library tracks'
+      self.options = [FORCE_OPTION].freeze
+
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync analyze [options]') do |opts, opts_hash|
+          opts.on(*FORCE_OPTION.to_a) { opts_hash[:overwrite] = true }
+        end
+
+        Wavesync::Analyzer.new(config.library).analyze(overwrite: options[:overwrite] || false)
+      end
+    end
+  end
+end

data/lib/wavesync/commands/command.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Command
+      class << self
+        attr_accessor :name, :description
+        attr_writer :options, :subcommands
+
+        def options = @options || []
+        def subcommands = @subcommands || []
+      end
+
+      def parse_options(banner:)
+        options = {}
+        OptionParser.new do |opts|
+          opts.banner = banner
+          opts.on(*CONFIG_OPTION.to_a) { |value| options[:config] = value }
+          yield opts, options if block_given?
+        end.parse!
+        config_path = options[:config] || Wavesync::Config::DEFAULT_PATH
+        config = Commands.load_config(config_path)
+        [options, config]
+      end
+    end
+  end
+end

data/lib/wavesync/commands/help.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'optparse'
+require 'rainbow'
+
+module Wavesync
+  module Commands
+    class Help < Command
+      self.name = 'help'
+      self.description = 'Show this help message'
+
+      DESCRIPTION_COLUMN = 23
+
+      def run
+        subcommand_name = ARGV.shift
+
+        if subcommand_name
+          command = ALL.find { |cmd| subcommand_name == cmd.name }
+          if command
+            show_command_help(command)
+          else
+            puts "Unknown command: #{subcommand_name}"
+            puts "Available commands: #{ALL.map(&:name).reject { |cmd_name| cmd_name == self.class.name }.join(', ')}"
+            exit 1
+          end
+        else
+          show_general_help
+        end
+      end
+
+      private
+
+      def show_general_help
+        puts 'Usage: wavesync [command] [options]'
+        puts ''
+        puts 'Commands:'
+        ALL.each do |command|
+          if command.subcommands.any?
+            command.subcommands.each { |subcommand| puts format_command_line(subcommand.usage, subcommand.description) }
+          else
+            puts format_command_line(command.name, command.description)
+            command.options.each { |option| puts format_option_line(option, indent: 4) }
+          end
+          puts ''
+        end
+        puts 'Options:'
+        GLOBAL_OPTIONS.each { |option| puts format_option_line(option, indent: 2) }
+      end
+
+      def show_command_help(command)
+        if command.subcommands.any?
+          puts "Usage: wavesync #{command.name} <subcommand> [options]"
+          puts ''
+          puts 'Subcommands:'
+          command.subcommands.each do |subcommand|
+            subcommand_key = subcommand.usage.delete_prefix("#{command.name} ")
+            puts "  #{subcommand_key.ljust(DESCRIPTION_COLUMN - 2)}#{subcommand.description}"
+          end
+          puts ''
+          puts 'Options:'
+          GLOBAL_OPTIONS.each { |option| puts "  #{option.short}, #{option.long}  #{option.description}" }
+        else
+          OptionParser.new do |opts|
+            opts.banner = "Usage: wavesync #{command.name} [options]"
+            (command.options + GLOBAL_OPTIONS).each { |option| opts.on(*option.to_a) }
+            puts opts
+          end
+        end
+      end
+
+      def format_command_line(name, description)
+        "  #{name.ljust(DESCRIPTION_COLUMN - 2)}#{description}"
+      end
+
+      def format_option_line(option, indent:)
+        key = "#{option.short}, #{option.long}"
+        Rainbow("#{' ' * indent}#{key.ljust(DESCRIPTION_COLUMN - indent)}#{option.description}").darkgray
+      end
+    end
+  end
+end

data/lib/wavesync/commands/set.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Set < Command
+      self.name = 'set'
+      self.subcommands = [
+        Subcommand.new(usage: 'set create NAME', description: 'Create a new track set'),
+        Subcommand.new(usage: 'set edit NAME', description: 'Edit an existing track set'),
+        Subcommand.new(usage: 'set list', description: 'List all track sets')
+      ].freeze
+
+      def run
+        subcommand = ARGV.shift
+
+        _options, config = parse_options(banner: 'Usage: wavesync set <subcommand> [options]')
+
+        case subcommand
+        when 'create'
+          name = require_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_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 { |set| puts "#{set.name} (#{set.tracks.size} tracks)" }
+          end
+        else
+          puts "Unknown subcommand: #{subcommand || '(none)'}"
+          puts 'Available subcommands: create, edit, list'
+          exit 1
+        end
+      end
+
+      private
+
+      def require_name(subcommand)
+        name = ARGV.shift
+        unless name
+          puts "Usage: wavesync set #{subcommand} <name>"
+          exit 1
+        end
+        name
+      end
+    end
+  end
+end

data/lib/wavesync/commands/sync.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Wavesync
+  module Commands
+    class Sync < Command
+      DEVICE_OPTION = Option.new(short: '-d', long: '--device NAME', description: 'Name of device to sync (as defined in config)')
+      PAD_OPTION = Option.new(short: '-p', long: '--pad', description: 'Pad tracks with silence so total length is a multiple of 64 bars (Octatrack only)')
+
+      self.name = 'sync'
+      self.description = 'Sync music library to a device'
+      self.options = [DEVICE_OPTION, PAD_OPTION].freeze
+
+      def run
+        options, config = parse_options(banner: 'Usage: wavesync sync [options]') do |opts, opts_hash|
+          opts.on(*DEVICE_OPTION.to_a) { |value| opts_hash[:device] = value }
+          opts.on(*PAD_OPTION.to_a) { opts_hash[:pad] = true }
+        end
+
+        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
+        elsif device_configs.size > 1
+          device_names = device_configs.map { |device_config| device_config[:name] }
+          selected_name = Wavesync::UI.new.select('Select device', device_names)
+          device_configs = device_configs.select { |device_config| device_config[:name] == selected_name }
+        end
+
+        device_pairs = device_configs.map do |device_config|
+          device = Wavesync::Device.find_by(name: device_config[:model])
+          unless device
+            supported = Wavesync::Device.all.map(&:name).join(', ')
+            puts "Unknown device model \"#{device_config[:model]}\" in config. Supported models: #{supported}"
+            exit 1
+          end
+          [device_config, device]
+        end
+
+        scanner = Wavesync::Scanner.new(config.library)
+
+        device_pairs.each do |device_config, device|
+          scanner.sync(device_config[:path], device, pad: options[:pad] || false)
+        end
+      end
+    end
+  end
+end

data/lib/wavesync/commands.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Wavesync
+  module Commands
+    Option = Struct.new(:short, :long, :description, keyword_init: true)
+    Subcommand = Struct.new(:usage, :description, keyword_init: true)
+
+    CONFIG_OPTION = Option.new(short: '-c', long: '--config PATH', description: 'Path to wavesync config YAML file')
+    GLOBAL_OPTIONS = [CONFIG_OPTION].freeze
+
+    def self.load_config(path)
+      Wavesync::Config.load(path)
+    rescue Wavesync::ConfigError => e
+      puts "Configuration error: #{e.message}"
+      exit 1
+    end
+  end
+end
+
+require_relative 'commands/command'
+require_relative 'commands/sync'
+require_relative 'commands/analyze'
+require_relative 'commands/set'
+require_relative 'commands/help'
+
+module Wavesync
+  module Commands
+    ALL = [Sync, Analyze, Set, Help].freeze
+  end
+end

data/lib/wavesync/ui.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'tty-cursor'
+require 'tty-prompt'
 require 'rainbow'
 
 module Wavesync
@@ -17,6 +18,7 @@ module Wavesync
     def initialize
       @cursor = TTY::Cursor
       @sticky_lines = []
+      @prompt = TTY::Prompt.new(interrupt: :exit, active_color: :red)
     end
 
     def file_progress(filename)
@@ -86,6 +88,16 @@ module Wavesync
       set_analyze_file_stickies(file, label)
     end
 
+    def confirm(message)
+      print in_color(message, :secondary)
+      response = $stdin.gets.to_s.strip.downcase
+      response == 'y'
+    end
+
+    def select(label, options)
+      @prompt.select(label, options, cycle: true)
+    end
+
     def color(text, key)
       in_color(text, key)
     end

data/lib/wavesync/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Wavesync
-  VERSION = '1.0.0.alpha1'
+  VERSION = '1.0.0.alpha2'
 end

data/lib/wavesync.rb

@@ -18,4 +18,5 @@ require 'wavesync/bpm_detector'
 require 'wavesync/analyzer'
 require 'wavesync/set'
 require 'wavesync/set_editor'
+require 'wavesync/commands'
 require 'wavesync/cli'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: wavesync
 version: !ruby/object:Gem::Version
-  version: 1.0.0.alpha1
+  version: 1.0.0.alpha2
 platform: ruby
 authors:
 - Andreas Zecher
@@ -109,6 +109,12 @@ files:
 - lib/wavesync/audio_format.rb
 - lib/wavesync/bpm_detector.rb
 - lib/wavesync/cli.rb
+- lib/wavesync/commands.rb
+- lib/wavesync/commands/analyze.rb
+- lib/wavesync/commands/command.rb
+- lib/wavesync/commands/help.rb
+- lib/wavesync/commands/set.rb
+- lib/wavesync/commands/sync.rb
 - lib/wavesync/config.rb
 - lib/wavesync/device.rb
 - lib/wavesync/file_converter.rb
@@ -122,7 +128,9 @@ files:
 homepage: https://github.com/pixelate/wavesync
 licenses:
 - MIT
-metadata: {}
+metadata:
+  documentation_uri: https://github.com/pixelate/wavesync?tab=readme-ov-file#wavesync
+  rubygems_mfa_required: 'true'
 rdoc_options: []
 require_paths:
 - lib
@@ -130,7 +138,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.0'
+      version: '3.3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="