surface_master 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5e7fbba40cb034f0db7198957749fc22fc7facee
-  data.tar.gz: bfd9dbc0e31d58f6983824d1ce9ce998a8308903
+  metadata.gz: 0809d0fe24d9da2f41becb4e27a0ec785019c029
+  data.tar.gz: 43919aa3d44ec3006953501bebf6f3d5a4010f76
 SHA512:
-  metadata.gz: ee30f694463a70d6ade774fdff8a5ab8d99492fedfd58dbdf519364a76e283f3db3b4f157a171acb6983c4c7507b1c7ed9103028923673fbf20a14821bedf76b
-  data.tar.gz: f0d1340826652776bd3c6a3faab9f0f859a5be96358489a122b9a3664e2624bb9e9927d602ed11a42eca6f6aa05cfd818d18b1763aef7746c87e67c045552dc4
+  metadata.gz: 0ab45e7ab7dc4761d108f5dd5dc758516bf35a93b6cc4ea0b5142ed80c2ac5a4c11469756762a57aea5de98a7821f79ed12ace9649bb4ec12ae85532b1bd4493
+  data.tar.gz: 4ede3f9b33450d69c3bcd250494426b4a66cda5d25c1907ce370fd4bc3a8c7a17cc1131d8d077c832fc4dad342854327c57440e25f522651a9a7593118ec2374

data/.rubocop.yml

@@ -0,0 +1,107 @@
+AllCops:
+  Include:
+    - '**/Gemfile'
+    - '**/Rakefile'
+    - '**/*.rake'
+    - '**/*.gemspec'
+  Exclude:
+    - tmp/**/*
+    - pkg/**/*
+
+Lint/FormatParameterMismatch:
+  Enabled: true
+
+# Lint/OptionHash:
+#   Enabled: true
+
+Metrics/LineLength:
+  Max: 100
+
+Metrics/MethodLength:
+  Exclude:
+  - 'db/migrate/*'
+
+Performance/StringReplacement:
+  Enabled: true
+
+Style/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Style/AlignHash:
+  EnforcedColonStyle: table
+  # TODO: Err, maybe keys here?
+  EnforcedLastArgumentHashStyle: ignore_implicit
+
+Style/CollectionMethods:
+  PreferredMethods:
+    find: detect
+    inject: reduce
+    collect: map
+    find_all: select
+
+# Allow comments to be aligned to one another.
+Style/CommentIndentation:
+  Enabled: false
+
+# Don't bother with class documentation for Rails application class, and DB
+# migrations.
+Style/Documentation:
+  Exclude:
+  - 'db/migrate/*'
+  - 'config/application.rb'
+
+# We like the truthiness operator.
+Style/DoubleNegation:
+  Enabled: false
+
+# Style/DotPosition:
+#   EnforcedStyle: trailing
+
+Style/EmptyLineBetweenDefs:
+  AllowAdjacentOneLineDefs: true
+
+Style/ExtraSpacing:
+  AllowForAlignment: true
+
+Style/FormatString:
+  EnforcedStyle: 'String#%'
+  SupportedStyles: 'String#%'
+
+# Style/GuardClause:
+#   Enabled: false
+
+Style/IfUnlessModifier:
+  Enabled: false
+
+Style/LineEndConcatenation:
+  Enabled: false
+
+Style/RegexpLiteral:
+  AllowInnerSlashes: false
+
+Style/RescueEnsureAlignment:
+  Enabled: true
+
+# Style/RescueModifier:
+#   Enabled: false
+
+# We like terse methods.
+Style/SingleLineMethods:
+  Enabled: false
+
+Style/SpaceAroundOperators:
+  MultiSpaceAllowedForOperators:
+    - '='
+    - '=>'
+    - '||='
+    - '+='
+    - '-='
+    - '*='
+    - '/='
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/TrailingComma:
+  EnforcedStyleForMultiline: comma
+  SupportedStyles: comma

data/.travis.yml

@@ -1,8 +1,7 @@
 language: ruby
 rvm:
-  - 1.8.7
-  - 1.9.3
-  - 2.0.0
+  - 2.2.0
+  - 2.2.3
 before_install:
   - sudo apt-get update
   - sudo apt-get install libportmidi-dev

data/CHANGELOG.md

@@ -0,0 +1,16 @@
+# Changes
+
+## v0.2.1
+
+* Missed a file rename.
+* Remove some broken/not-quite-supported, and no longer particurly useful features from Novation Launchpad support.  (Specifically, column-wise/row-wise/board-wise changing of lights in paletted mode.)
+* Fix test suite.
+* Break apart a lot of complexity.
+* Apply style guide (mostly).
+
+
+## v0.2.0
+
+* Initial release, based on [launchpad](https://github.com/thomasjachmann/launchpad) gem.
+* Almost full support for Novation Launchpad Mark 2 (the one with RGB LEDs), missing flashing/pulsing of lights, etc.
+* Partial support for Numark Orbit.

data/Gemfile

@@ -1,13 +1,17 @@
+# rubocop:disable Style/LeadingCommentSpace
 #ruby-gemset=surface_master
+# rubocop:enable Style/LeadingCommentSpace
 ruby "2.2.3"
 source "https://rubygems.org"
 
-# Specify your gem's dependencies in launchpad.gemspec
+# Specify your gem's dependencies in surface_master.gemspec
 gemspec
 
 group :development do
   gem "rake",               require: false
   gem "minitest-reporters", require: false
   gem "mocha",              require: false
+  gem "bundler-audit",      require: false
+  gem "rubocop",            require: false
   gem "pry"
 end

data/Rakefile

@@ -1,10 +1,78 @@
-require 'bundler/gem_tasks'
+require "bundler/gem_tasks"
 
-require 'rake/testtask'
+require "rake/testtask"
 Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
+  test.libs << "lib" << "test"
+  test.pattern = "test/**/test_*.rb"
   test.verbose = true
 end
 
-task :default => :test
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+task_dir        = File.expand_path("../tasks", __FILE__)
+raw_task_files  = FileList["#{task_dir}/**/*.rake"] +
+                  FileList["tasks/**/*.rake"]
+raw_task_files
+  .map { |fname| File.expand_path(fname) }
+  .sort
+  .each do |fname|
+    load fname
+  end
+
+# Define a task named `name` that runs all tasks under an identically
+# named `namespace`.
+def parent_task(name)
+  task name do
+    ::Rake::Task
+      .tasks
+      .select { |t| t.name =~ /^#{name}:/ }
+      .sort { |a, b| a.name <=> b.name }
+      .each(&:execute)
+  end
+end
+
+desc "Open a Ruby console to Pry."
+task :console do
+  # rubocop:disable Lint/Debugger
+  require "pry"
+  binding.pry
+  # rubocop:enable Lint/Debugger
+end
+
+namespace :lint do
+  desc "Run Rubocop against the codebase."
+  task :rubocop do
+    require "yaml"
+    sh "rubocop --display-cop-names"
+  end
+
+  desc "Run bundler-audit against the Gemfile."
+  task :'bundler-audit' do
+    require "bundler/audit/cli"
+
+    %w(update check).each do |command|
+      Bundler::Audit::CLI.start [command]
+    end
+  end
+
+  have_cloc = `which cloc`.strip != ""
+  if have_cloc
+    desc "Show LOC metrics for project using cloc."
+    task :cloc do
+      sh "cloc . --exclude-dir=pkg,.bundle,tmp"
+    end
+  end
+
+  desc "Check for outdated gems."
+  task :bundler do
+    # Don't error-out if this fails, since we may not be able to update some
+    # deps.
+    sh "bundle outdated || true"
+  end
+end
+
+desc "Run all lint checks against the code."
+parent_task :lint
+
+task default: [:test, :lint]

data/debug_tools/decode.rb

@@ -1,6 +1,6 @@
 #!/usr/bin/env ruby
 fname = ARGV.shift
-raise "Must specify filename." unless fname
+fail "Must specify filename." unless fname
 outname = fname.gsub(/\.raw/, ".txt")
 
 bytes   = File.read(fname).bytes.map { |x| "0x%02X" % x }

data/examples/launchpad_testbed.rb

@@ -21,34 +21,68 @@ QUADRANTS = [
   [{ red: 0x00, green: 0x00, blue: 0x2F }, { red: 0x2F, green: 0x2F, blue: 0x00 }],
 ]
 FLIPPED = [[false, false], [false, false]]
-PRESSED = (0..7).map { |x| (0..7).map { |y| false } }
+PRESSED = (0..7).map { |_x| (0..7).map { |_y| false } }
 NOW     = [Time.now.to_f]
 
 # Helpers
-CC      = %i(up down left right session user1 user2 scene1 scene2 scene3 scene4 scene5 scene6 scene7 scene8)
+CC      = %i(up down left right session user1 user2 scene1 scene2 scene3 scene4 scene5 scene6 scene7
+             scene8)
 GRID    = (0..7).map { |x| (0..7).map { |y| { grid: [x, y] } } }.flatten
 WHITE   = { red: 0x3F, green: 0x3F, blue: 0x3F }
+BLACK   = { red: 0x00, green: 0x00, blue: 0x00 }
 
 def clamp(val); (val > 0x3F) ? 0x3F : val; end
 
-def base_color(x, y)
-  return nil if PRESSED[x][y]
+def quad_for(x, y)
   quad_x  = x / 4
   quad_y  = 1 - (y / 4)
-  quad    = QUADRANTS[quad_y][quad_x]
-  s_t     = (Math.sin(NOW[0] * TIME_SCALE) * 0.5) + 0.5
-  tmp     = { red:    0x00        + quad[:red] + (s_t * 0x3F).round,
-              green:  (x * SCALE) + quad[:green],
-              blue:   (y * SCALE) + quad[:blue] }
-  if FLIPPED[quad_y][quad_x]
-    carry       = tmp[:red]
-    tmp[:red]   = tmp[:green]
-    tmp[:green] = tmp[:blue]
-    tmp[:blue]  = carry
+  [QUADRANTS[quad_y][quad_x], FLIPPED[quad_y][quad_x]]
+end
+
+def positional_color(x, y)
+  { red:   0x00,
+    green: (x * SCALE),
+    blue:  (y * SCALE) }
+end
+
+def temporal_color(_x, _y)
+  s_t = (Math.sin(NOW[0] * TIME_SCALE) * 0.5) + 0.5
+  { red:   (s_t * 0x3F).round,
+    green: 0x00,
+    blue:  0x00 }
+end
+
+def clamp_color(color)
+  { red:   clamp(color[:red]),
+    green: clamp(color[:green]),
+    blue:  clamp(color[:blue]) }
+end
+
+def apply_flip!(flipped, color)
+  return unless flipped
+  carry         = color[:red]
+  color[:red]   = color[:green]
+  color[:green] = color[:blue]
+  color[:blue]  = carry
+end
+
+def add_colors(*colors)
+  result = {}
+  %i(red green blue).each do |component|
+    result[component] = colors.inject(0) { |a, e| a + e[component] }
   end
-  { red:    clamp(tmp[:red]),
-    green:  clamp(tmp[:green]),
-    blue:   clamp(tmp[:blue]) }
+  result
+end
+
+def base_color(x, y)
+  return nil if PRESSED[x][y]
+  quad, flipped = quad_for(x, y)
+  p_color       = positional_color(x, y)
+  t_color       = temporal_color(x, y)
+  tmp           = add_colors(quad, p_color, t_color)
+  apply_flip!(flipped, tmp)
+
+  clamp_color(tmp)
 end
 
 def init_board(interaction)
@@ -60,17 +94,13 @@ def init_board(interaction)
   interaction.changes(values.compact)
 end
 
-def set_grid_rgb(interaction, red:, green:, blue: )
+def set_grid_rgb(interaction, red:, green:, blue:)
   values = GRID.map { |value| value.merge(red: red, green: green, blue: blue) }
   interaction.changes(values)
 end
 
 def goodbye(interaction)
-  interaction.changes([{ red: 0x00, green: 0x00, blue: 0x00, cc: :mixer },
-                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene1 },
-                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene2 },
-                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene3 },
-                       { red: 0x00, green: 0x00, blue: 0x00, cc: :scene4 }])
+  buttons_off(interaction)
   (0..63).step(2).each do |i|
     ii = (63 - i) - 1
     set_grid_rgb(interaction, red: ii, green: 0x00, blue: ii)
@@ -79,6 +109,14 @@ def goodbye(interaction)
   interaction.close
 end
 
+def buttons_off(interaction)
+  interaction.changes([BLACK.merge(cc: :mixer),
+                       BLACK.merge(cc: :scene1),
+                       BLACK.merge(cc: :scene2),
+                       BLACK.merge(cc: :scene3),
+                       BLACK.merge(cc: :scene4)])
+end
+
 SurfaceMaster.init!
 interaction = SurfaceMaster::Launchpad::Interaction.new
 interaction.response_to(:grid) do |inter, action|
@@ -91,7 +129,7 @@ interaction.response_to(:grid) do |inter, action|
 end
 
 def flip_quad!(inter, cc, quad_x, quad_y)
-  FLIPPED[quad_y][quad_x]   = !FLIPPED[quad_y][quad_x]
+  FLIPPED[quad_y][quad_x] = !FLIPPED[quad_y][quad_x]
   if FLIPPED[quad_y][quad_x]
     color = { red: 0x1F, green: 0x1F, blue: 0x1F }
   else
@@ -113,11 +151,12 @@ interaction.response_to(:scene4, :down) do |inter, action|
   flip_quad!(inter, action[:type], 1, 1)
 end
 
-interaction.response_to(:mixer, :down) do |_interaction, action|
+interaction.response_to(:mixer, :down) do |_interaction, _action|
   interaction.stop
 end
-interaction.change({ red: 0x03, green: 0x00, blue: 0x00, cc: :mixer })
-interaction.changes(%i(scene1 scene2 scene3 scene4).map { |cc| { red: 0x03, green: 0x03, blue: 0x03, cc: cc } })
+interaction.change(red: 0x03, green: 0x00, blue: 0x00, cc: :mixer)
+BTN_COL = { red: 0x03, green: 0x03, blue: 0x03, cc: cc }
+interaction.changes(%i(scene1 scene2 scene3 scene4).map { |cc| BTN_COL.merge(cc: cc) })
 
 init_board(interaction)
 input_thread = Thread.new do
@@ -128,7 +167,7 @@ animation_thread = Thread.new do
     begin
       NOW[0] = Time.now.to_f
       init_board(interaction)
-    rescue Exception => e
+    rescue StandardError => e
       puts e.inspect
       puts e.backtrace.join("\n")
     end

data/examples/monitor.rb

@@ -16,19 +16,31 @@ def goodbye(interaction)
   interaction.changes(data)
 end
 
-def bar(interaction, x, val, r, g, b)
-  data = []
-  (0..val).each do |y|
-    data << { x: x, y: y, red: r, green: g, blue: b }
+# Janky bar-graph widget.
+class Bar
+  BLACK = { red: 0x00, green: 0x00, blue: 0x00 }
+  def initialize(interaction, x, color)
+    @interaction  = interaction
+    @x            = x
+    @color        = color
   end
-  ((val+1)..7).each do |y|
-    data << { x: x, y: y, red: 0x00, green: 0x00, blue: 0x00 }
+
+  def update(val)
+    data = []
+    (0..val).each do |y|
+      data << @color.merge(grid: [@x, y])
+    end
+    ((val + 1)..7).each do |y|
+      data << BLACK.merge(grid: [@x, y])
+    end
+    @interaction.changes(data)
   end
-  interaction.changes(data)
 end
 
 interaction = SurfaceMaster::Launchpad::Interaction.new
-monitor = Thread.new do
+cpu_bar     = Bar.new(interaction, 0, red: 0x3F, green: 0x00, blue: 0x00)
+io_bar      = Bar.new(interaction, 0, red: 0x00, green: 0x3F, blue: 0x00)
+monitor     = Thread.new do
   loop do
     fields      = `iostat -c 2 disk0`.split(/\n/).last.strip.split(/\s+/)
     cpu_pct     = 100 - fields[-4].to_i
@@ -43,12 +55,12 @@ monitor = Thread.new do
 
     # TODO: Make block I/O not be a bar but a fill, with scale indicated by color...
 
-    bar(interaction, 0, cpu_usage, 0x3F, 0x00, 0x00)
-    bar(interaction, 1, disk_usage, 0x00, 0x3F, 0x00)
+    cpu_bar.update(cpu_usage)
+    io_bar.update(disk_usage)
   end
 end
 
-interaction.response_to(:mixer, :down) do |_interaction, action|
+interaction.response_to(:mixer, :down) do |_interaction, _action|
   puts "Shutting down"
   begin
     monitor.kill

data/examples/orbit_testbed.rb

@@ -6,18 +6,11 @@ Bundler.require(:default, :development)
 
 require "surface_master"
 
+# Monkey-patching to make debugging easier.
 class Fixnum
   def to_hex; "%02X" % self; end
 end
 
-# def debug(msg)
-#   STDERR.puts "DEBUG: #{msg}"
-# end
-
-# def fmt_message(message)
-#   message[:raw][:message].map(&:to_hex).join(' ')
-# end
-
 SurfaceMaster.init!
 device = SurfaceMaster::Orbit::Device.new
 loop do
@@ -26,37 +19,3 @@ loop do
   end
   sleep 0.1
 end
-
-# interaction = ControlCenter::Launchpad::Interaction.new
-# interaction.response_to(:grid) do |inter, action|
-#   x = action[:x]
-#   y = action[:y]
-#   PRESSED[x][y] = (action[:state] == :down)
-#   value         = base_color(x, y) || WHITE
-#   value[:grid]  = [x, y]
-#   inter.device.change(value)
-# end
-
-# interaction.device.change({ red: 0x03, green: 0x00, blue: 0x00, cc: :mixer })
-# interaction.device.changes(%i(scene1 scene2 scene3 scene4).map { |cc| { red: 0x03, green: 0x03, blue: 0x03, cc: cc } })
-
-# init_board(interaction)
-# input_thread = Thread.new do
-#   interaction.start
-# end
-# animation_thread = Thread.new do
-#   loop do
-#     begin
-#       NOW[0] = Time.now.to_f
-#       init_board(interaction)
-#     rescue Exception => e
-#       puts e.inspect
-#       puts e.backtrace.join("\n")
-#     end
-#     sleep 0.01
-#   end
-# end
-
-# input_thread.join
-# animation_thread.terminate
-# goodbye(interaction)

data/lib/surface_master/device.rb

@@ -7,21 +7,10 @@ module SurfaceMaster
     include Logging
 
     def initialize(opts = nil)
-      opts  = { input:  true,
-                output: true }
-              .merge(opts || {})
-
+      opts        = { input: true, output: true }.merge(opts || {})
       self.logger = opts[:logger]
-      logger.debug "Initializing #{self.class}##{object_id} with #{opts.inspect}"
-
-      @input    = create_device!(Portmidi.input_devices,
-                                 Portmidi::Input,
-                                 id:   opts[:input_device_id],
-                                 name: opts[:device_name]) if opts[:input]
-      @output   = create_device!(Portmidi.output_devices,
-                                 Portmidi::Output,
-                                 id:   opts[:output_device_id],
-                                 name: opts[:device_name]) if opts[:output]
+      @input      = create_input_device(opts)
+      @output     = create_output_device(opts)
     end
 
     # Closes the device - nothing can be done with the device afterwards.
@@ -40,18 +29,15 @@ module SurfaceMaster
     def reset!; end
 
     def read
-      unless input_enabled?
-        logger.error "Trying to read from device that's not been initialized for input!"
-        raise SurfaceMaster::NoInputAllowedError
-      end
+      fail SurfaceMaster::NoInputAllowedError unless input_enabled?
 
       Array(@input.read(16)).collect do |midi_message|
         (code, note, velocity) = midi_message[:message]
-        { timestamp:  midi_message[:timestamp],
-          state:      (velocity == 127) ? :down : :up,
-          velocity:   velocity,
-          code:       code,
-          note:       note }
+        { timestamp: midi_message[:timestamp],
+          state:     (velocity == 127) ? :down : :up,
+          velocity:  velocity,
+          code:      code,
+          note:      note }
       end
     end
 
@@ -60,29 +46,44 @@ module SurfaceMaster
     def sysex_prefix; [0xF0]; end
     def sysex_suffix; 0xF7; end
     def sysex_msg(*payload); (sysex_prefix + [payload, sysex_suffix]).flatten.compact; end
+
     def sysex!(*payload)
+      fail NoOutputAllowedError unless output_enabled?
       msg = sysex_msg(payload)
-      logger.debug { "#{msg.length}: 0x#{msg.map(&:to_hex).join(", 0x")}" }
+      logger.debug { "#{msg.length}: 0x#{msg.map { |b| '%02X' % b }.join(' ')}" }
       @output.write_sysex(msg)
     end
 
-    def create_device!(devices, device_type, opts)
-      logger.debug "Creating #{device_type} with #{opts.inspect}, choosing from portmidi devices: #{devices.inspect}"
-      id = opts[:id]
-      if id.nil?
-        name    = opts[:name] || @name
-        device  = devices.select { |dev| dev.name == name }.first
-        id      = device.device_id unless device.nil?
-      end
-      if id.nil?
-        message = "MIDI Device `#{opts[:id] || opts[:name]}` doesn't exist!"
-        logger.fatal message
-        raise SurfaceMaster::NoSuchDeviceError.new(message)
-      end
+
+    def create_input_device(opts)
+      return nil unless opts[:input]
+      create_device(Portmidi.input_devices,
+                    Portmidi::Input,
+                    id:   opts[:input_device_id],
+                    name: opts[:device_name])
+    end
+
+    def create_output_device(opts)
+      return nil unless opts[:output]
+      create_device(Portmidi.output_devices,
+                    Portmidi::Output,
+                    id:   opts[:output_device_id],
+                    name: opts[:device_name])
+    end
+
+    def create_device(devices, device_type, opts)
+      id = opts[:id] || find_device_id(devices, opts[:name])
+      fail SurfaceMaster::NoSuchDeviceError if id.nil?
       device_type.new(id)
     rescue RuntimeError => e # TODO: Uh, this should be StandardException, perhaps?
-      logger.fatal "Error creating #{device_type}: #{e.inspect}"
-      raise SurfaceMaster::DeviceBusyError.new(e)
+      raise SurfaceMaster::DeviceBusyError, e
+    end
+
+    def find_device_id(devices, name)
+      name    ||= @name
+      device    = devices.find { |dev| dev.name == name }
+      id        = device.device_id unless device.nil?
+      id
     end
 
     def message(status, data1, data2); { message: [status, data1, data2], timestamp: 0 }; end