lerna 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b7d1d9ed67341c040754c33479daf18d66bd4fc7
+  data.tar.gz: fc89547a2e6c6e55f437a82ad08bbdfa6589db80
+SHA512:
+  metadata.gz: f8a4dd8509a4dd6771765971b1cfc2d6da6a877eb7f53f1a5641cb86631d0f4a06bf75570c8c796aa5c97a5c760457968b1ffe4f3c3900e78f040de6ca91e693
+  data.tar.gz: a54b275de9b370169e08117af82271f44b7c7f0227a589243dfa726b8604d490dadf6dce116c25cfbc20a3834240857c7b3eae276a6eb0e2f8cde19cdc7c28c4

data/README.md

@@ -0,0 +1,63 @@
+# Lerna
+
+> That creature, bred in the swamp of Lerna, used to go forth into the plain
+> and ravage both the cattle and the country. Now the hydra had a huge body,
+> with nine heads, eight mortal, but the middle one immortal.
+
+[Bibliotheca](http://www.perseus.tufts.edu/hopper/text?doc=Perseus%3Atext%3A1999.01.0022%3Atext%3DLibrary%3Abook%3D2%3Achapter%3D5%3Asection%3D2)
+
+## What
+
+Lerna is a tool to make itinerant computing easier.
+It watches for changes to the connected displays and configures X.org to use
+what it deems to be the best display.
+
+If
+
+* you use a Linux laptop,
+* you use an external monitor, and
+* you want to use a single display at a time
+
+then Lerna might be useful to you.
+If you want to use multiple displays, it won't be immediately useful, but it
+might still be a good starting point.
+
+## How
+
+```sh
+$ lerna
+```
+
+You'll see output something like this:
+
+    [2014-08-02T04:10:06.592689Z #13059] Switching to DP2
+    [2014-08-02T04:11:17.008609Z #13059] DP2 => disconnected
+    [2014-08-02T04:11:17.008764Z #13059] Switching to LVDS1
+    [2014-08-02T04:11:21.521592Z #13059] DP2 => connected
+    [2014-08-02T04:11:21.521679Z #13059] Switching to DP2
+
+To see more options, use:
+
+```sh
+$ lerna --help
+```
+
+An example Upstart script for Ubuntu (pre-15.04) is provided in the `support`
+directory.
+This assumes that `lerna` is in the path; if it's not, you'll need to adjust
+this.
+
+You can then use
+
+```sh
+$ start lerna
+```
+
+to start the job immediately; it should start and stop automatically with your
+desktop session thereafter.
+
+## Wanted
+
+* Example job for systemd
+* More strategies
+* Ability to read from a configuration file (and reload on change)

data/Rakefile

@@ -0,0 +1,16 @@
+require "rspec/core/rake_task"
+
+desc "Run the specs."
+RSpec::Core::RakeTask.new do |t|
+  t.pattern = "spec/**/*_spec.rb"
+  t.verbose = false
+end
+
+task :default => [:spec]
+
+if Gem.loaded_specs.key?('rubocop')
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+
+  task(:default).prerequisites << task(:rubocop)
+end

data/bin/lerna

@@ -0,0 +1,60 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+require 'lerna/runner'
+require 'lerna/strategy'
+
+LOGGER = lambda { |str|
+  time = Time.now.utc
+  timestamp = time.strftime('%Y-%m-%dT%H:%M:%S.') << '%06dZ' % time.usec
+  puts '[%s #%d] %s' % [timestamp, Process.pid, str]
+}
+
+options = {
+  strategies: %w[ dual-external external-digital-only internal-only ],
+  system: method(:system)
+}
+
+executable = File.basename(__FILE__)
+
+parser = OptionParser.new { |opts|
+  opts.banner = "Usage: #{executable} [options]"
+  opts.on(
+    '-s', '--strategies', String,
+    'Strategies in order of precedence, separated by commas',
+    "Default is #{options[:strategies].join(',')}",
+    "Available: #{Lerna::Strategy.registry.keys.join(' ')}"
+  ) do |str|
+    options[:strategies] = str.split(/,/)
+  end
+  opts.on(
+    '-d', '--dry-run',
+    'Just log the actions that would be taken'
+  ) do
+    options[:system] = ->(*args) { LOGGER.call(args.join(' ')) }
+  end
+  opts.on(
+    "-h", "--help",
+    "Display this help message and exit"
+  ) do
+    puts opts
+    exit
+  end
+}
+parser.parse!
+
+runner = Lerna::Runner.new(
+  logger: LOGGER,
+  strategies: options[:strategies],
+  system: options[:system]
+)
+
+trap('TERM') {
+  LOGGER.call('Exiting')
+  exit
+}
+
+loop do
+  runner.run
+  sleep 2
+end

data/lib/lerna/display.rb

@@ -0,0 +1,46 @@
+module Lerna
+  class Display
+    INTERNAL_TYPES = %w[ LVDS ]
+    DIGITAL_TYPES = %w[ LVDS DP HDMI DVI ]
+
+    def self.parse(line)
+      name, status, = line.split(/\s/)
+      new(name, status == 'connected')
+    end
+
+    def initialize(name, connected)
+      @name = name
+      @connected = connected
+    end
+
+    attr_reader :name
+
+    def connected?
+      @connected
+    end
+
+    def type
+      name.sub(/-?\d+$/, '')
+    end
+
+    def internal?
+      INTERNAL_TYPES.include?(type)
+    end
+
+    def external?
+      !internal?
+    end
+
+    def digital?
+      DIGITAL_TYPES.include?(type)
+    end
+
+    def analog?
+      !digital?
+    end
+
+    def ==(other)
+      [name, connected?] == [other.name, other.connected?]
+    end
+  end
+end

data/lib/lerna/display_enumerator.rb

@@ -0,0 +1,11 @@
+require 'lerna/display'
+
+module Lerna
+  class DisplayEnumerator
+    def call(xrandr_output = `LC_ALL=C xrandr`)
+      xrandr_output.
+        scan(/^(?:[A-Z\-]+\d+) (?:dis)?connected/).
+        map { |line| Display.parse(line) }
+    end
+  end
+end

data/lib/lerna/runner.rb

@@ -0,0 +1,56 @@
+require 'lerna/strategy_selector'
+require 'lerna/state'
+
+module Lerna
+  class Runner
+    def initialize(logger:, strategies:, system:, state: State.new,
+                   strategy_selector: StrategySelector.new)
+      @logger = logger
+      @strategies = strategies
+      @system = system
+      @state = state
+      @strategy_selector = strategy_selector
+    end
+
+    def run
+      state.scan!
+      return unless state.changed?
+
+      log state_summary
+      strategy = find_strategy
+      if strategy
+        log "Using #{strategy.class}"
+        apply_strategy strategy
+      else
+        log 'No applicable strategy found'
+      end
+    end
+
+  private
+
+    attr_reader :state, :strategy_selector, :strategies
+
+    def log(s)
+      @logger.call(s)
+    end
+
+    def state_summary
+      state.displays.
+        map { |d| "#{d.name}#{d.connected? ? '*' : ''}" }.
+        join(' ')
+    end
+
+    def find_strategy
+      strategy_selector.call(strategies, state.displays)
+    end
+
+    def apply_strategy(strategy)
+      system 'xrandr', *strategy.configuration
+      system 'xset dpms force on'
+    end
+
+    def system(*args)
+      @system.call(*args)
+    end
+  end
+end

data/lib/lerna/state.rb

@@ -0,0 +1,20 @@
+require 'lerna/display_enumerator'
+
+module Lerna
+  class State
+    def initialize(enumerator = DisplayEnumerator.new)
+      @enumerator = enumerator
+    end
+
+    attr_reader :displays
+
+    def scan!
+      @previous_displays = @displays
+      @displays = @enumerator.call
+    end
+
+    def changed?
+      @displays != @previous_displays
+    end
+  end
+end

data/lib/lerna/strategies.rb

@@ -0,0 +1,4 @@
+Dir[File.expand_path('../strategies/*.rb', __FILE__)].each do |path|
+  name = File.basename(path, '.rb')
+  require "lerna/strategies/#{name}"
+end

data/lib/lerna/strategies/dual_external.rb

@@ -0,0 +1,32 @@
+require 'lerna/strategy'
+
+module Lerna
+  module Strategies
+    class DualExternal < Strategy
+      def applicable?
+        wanted_displays.length == 2
+      end
+
+      def configuration
+        [].tap { |conf|
+          disconnected = displays - wanted_displays
+          disconnected.each do |d|
+            conf << '--output' << d.name << '--off'
+          end
+          conf << '--output' << wanted_displays[0].name << '--auto'
+          conf << '--output' << wanted_displays[1].name << '--auto' <<
+            '--right-of' << wanted_displays[0].name
+        }
+      end
+
+    private
+
+      def wanted_displays
+        displays.
+          select(&:connected?).
+          select { |d| d.external? && d.digital? }.
+          sort_by(&:name)
+      end
+    end
+  end
+end

data/lib/lerna/strategies/external_digital_only.rb

@@ -0,0 +1,27 @@
+require 'lerna/strategy'
+
+module Lerna
+  module Strategies
+    class ExternalDigitalOnly < Strategy
+      def applicable?
+        winner
+      end
+
+      def configuration
+        [].tap { |conf|
+          disconnected = displays - [winner]
+          disconnected.each do |d|
+            conf << '--output' << d.name << '--off'
+          end
+          conf << '--output' << winner.name << '--auto'
+        }
+      end
+
+    private
+
+      def winner
+        displays.select(&:connected?).find { |d| d.external? && d.digital? }
+      end
+    end
+  end
+end

data/lib/lerna/strategies/internal_only.rb

@@ -0,0 +1,22 @@
+require 'lerna/strategy'
+
+module Lerna
+  module Strategies
+    class InternalOnly < Strategy
+      def applicable?
+        displays.select(&:connected?).all?(&:internal?)
+      end
+
+      def configuration
+        [].tap { |conf|
+          displays.reject(&:connected?).each do |d|
+            conf << '--output' << d.name << '--off'
+          end
+          displays.select(&:connected?).each do |d|
+            conf << '--output' << d.name << '--auto'
+          end
+        }
+      end
+    end
+  end
+end

data/lib/lerna/strategy.rb

@@ -0,0 +1,21 @@
+module Lerna
+  class Strategy
+    def self.registry
+      @registry ||= {}
+    end
+
+    def self.inherited(subclass)
+      name = subclass.to_s.split(/::/).last
+      hyphenated = name.scan(/[A-Z][a-z_0-9]+/).map(&:downcase).join('-')
+      registry[hyphenated] = subclass
+    end
+
+    def initialize(displays)
+      @displays = displays
+    end
+
+  private
+
+    attr_reader :displays
+  end
+end

data/lib/lerna/strategy_selector.rb

@@ -0,0 +1,14 @@
+require 'lerna/strategies'
+
+module Lerna
+  class StrategySelector
+    def initialize(registry = Strategy.registry)
+      @registry = registry
+    end
+
+    def call(strategy_names, displays)
+      strategies = strategy_names.map { |s| @registry.fetch(s) }
+      strategies.map { |s| s.new(displays) }.find(&:applicable?)
+    end
+  end
+end

data/lib/lerna/version.rb

@@ -0,0 +1,3 @@
+module Lerna
+  VERSION = '0.1.0'
+end

data/spec/display_enumerator_spec.rb

@@ -0,0 +1,54 @@
+require 'lerna/display_enumerator'
+
+RSpec.describe Lerna::DisplayEnumerator do
+  subject {
+    described_class.new.call(xrandr_output)
+  }
+
+  context 'laptop with one external HDMI connected' do
+    let(:xrandr_output) {
+      <<END
+Screen 0: minimum 320 x 200, current 1920 x 1200, maximum 32767 x 32767
+LVDS1 connected (normal left inverted right x axis y axis)
+   1366x768       60.0 +
+   1360x768       59.8     60.0
+   1024x768       60.0
+   800x600        60.3     56.2
+   640x480        59.9
+VGA1 disconnected (normal left inverted right x axis y axis)
+HDMI1 connected 1920x1200+0+0 (normal left inverted right x axis y axis) 518mm x 324mm
+   1920x1200      60.0*+
+   1600x1200      60.0
+   1680x1050      59.9
+   1280x1024      60.0
+   1280x960       60.0
+   1024x768       60.0
+   800x600        60.3
+   640x480        60.0
+   720x400        70.1
+DP1 disconnected (normal left inverted right x axis y axis)
+HDMI2 disconnected (normal left inverted right x axis y axis)
+HDMI3 disconnected (normal left inverted right x axis y axis)
+DP2 disconnected (normal left inverted right x axis y axis)
+DP3 disconnected (normal left inverted right x axis y axis)
+VIRTUAL1 disconnected (normal left inverted right x axis y axis)
+END
+    }
+
+    it 'reports nine displays' do
+      expect(subject.length).to eq(9)
+    end
+
+    it 'reports display names' do
+      expect(subject.map(&:name)).to eq(%w[
+        LVDS1 VGA1 HDMI1 DP1 HDMI2 HDMI3 DP2 DP3 VIRTUAL1
+      ])
+    end
+
+    it 'reports connection status' do
+      expect(subject.map(&:connected?)).to eq([
+        true, false, true, false, false, false, false, false, false
+      ])
+    end
+  end
+end

data/spec/display_spec.rb

@@ -0,0 +1,117 @@
+require 'lerna/display'
+
+RSpec.describe Lerna::Display do
+  subject {
+    described_class.parse(xrandr_line)
+  }
+
+  context 'a connected LVDS display' do
+    let(:xrandr_line) {
+      'LVDS1 connected (normal left inverted right x axis y axis)'
+    }
+
+    it { is_expected.to be_connected }
+    it { is_expected.to be_internal }
+    it { is_expected.to be_digital }
+
+    it 'has a name' do
+      expect(subject.name).to eq('LVDS1')
+    end
+
+    it 'has a type' do
+      expect(subject.type).to eq('LVDS')
+    end
+  end
+
+  context 'a connected HDMI display' do
+    let(:xrandr_line) {
+      'HDMI1 connected 1920x1200+0+0 (normal left inverted right x axis y axis) 518mm x 324mm'
+    }
+
+    it { is_expected.to be_connected }
+    it { is_expected.not_to be_internal }
+    it { is_expected.to be_digital }
+
+    it 'has a name' do
+      expect(subject.name).to eq('HDMI1')
+    end
+
+    it 'has a type' do
+      expect(subject.type).to eq('HDMI')
+    end
+  end
+
+  context 'a disconnected DisplayPort display' do
+    let(:xrandr_line) {
+      'DP1 disconnected (normal left inverted right x axis y axis)'
+    }
+
+    it { is_expected.not_to be_connected }
+    it { is_expected.not_to be_internal }
+    it { is_expected.to be_digital }
+
+    it 'has a name' do
+      expect(subject.name).to eq('DP1')
+    end
+
+    it 'has a type' do
+      expect(subject.type).to eq('DP')
+    end
+  end
+
+  context 'a disconnected VGA display' do
+    let(:xrandr_line) {
+      'VGA1 disconnected (normal left inverted right x axis y axis)'
+    }
+
+    it { is_expected.not_to be_digital }
+  end
+
+  context 'a display with a hyphen in the type' do
+    let(:xrandr_line) {
+      'S-video disconnected (normal left inverted right x axis y axis)'
+    }
+
+    it 'has a name' do
+      expect(subject.name).to eq('S-video')
+    end
+
+    it 'has a type' do
+      expect(subject.type).to eq('S-video')
+    end
+  end
+
+  context 'a display with a hyphen before the number' do
+    let(:xrandr_line) {
+      'DVI-0 disconnected (normal left inverted right x axis y axis)'
+    }
+
+    it 'has a name' do
+      expect(subject.name).to eq('DVI-0')
+    end
+
+    it 'has a type' do
+      expect(subject.type).to eq('DVI')
+    end
+  end
+
+  context 'equality' do
+    it 'is true if displays have the same name and connectivity' do
+      a = described_class.new('HDMI1', true)
+      b = described_class.new('HDMI1', true)
+      expect(a).to eq(b)
+    end
+
+    it 'is false if displays have a different name' do
+      a = described_class.new('HDMI1', true)
+      b = described_class.new('VGA1', true)
+      expect(a).not_to eq(b)
+    end
+
+    it 'is false if displays have different connectivity' do
+      a = described_class.new('HDMI1', true)
+      b = described_class.new('HDMI1', false)
+      expect(a).not_to eq(b)
+    end
+  end
+end

data/spec/dual_external_strategy_spec.rb

@@ -0,0 +1,50 @@
+require 'lerna/strategies/dual_external'
+
+RSpec.describe Lerna::Strategies::DualExternal do
+  subject {
+    described_class.new(displays)
+  }
+
+  context 'when fewer than two external digital displays are connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', external?: false,
+               connected?: true, digital?: true),
+        double(name: 'DP1', external?: true,
+               connected?: true, digital?: true),
+        double(name: 'DP2', external?: true,
+               connected?: false, digital?: true),
+        double(name: 'VGA1', external?: true,
+               connected?: false, digital?: false)
+      ]
+    }
+
+    it { is_expected.not_to be_applicable }
+  end
+
+  context 'when two external digital displays are connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', external?: false,
+               connected?: true, digital?: true),
+        double(name: 'DP1', external?: true,
+               connected?: true, digital?: true),
+        double(name: 'DP2', external?: true,
+               connected?: true, digital?: true),
+        double(name: 'VGA1', external?: true,
+               connected?: false, digital?: false)
+      ]
+    }
+
+    it { is_expected.to be_applicable }
+
+    it 'configures the connected external display' do
+      expect(subject.configuration).to eq(%w[
+        --output LVDS1 --off
+        --output VGA1  --off
+        --output DP1   --auto
+        --output DP2   --auto --right-of DP1
+      ])
+    end
+  end
+end

data/spec/external_digital_only_strategy_spec.rb

@@ -0,0 +1,50 @@
+require 'lerna/strategies/external_digital_only'
+
+RSpec.describe Lerna::Strategies::ExternalDigitalOnly do
+  subject {
+    described_class.new(displays)
+  }
+
+  context 'when only one external digital display is connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', external?: false,
+               connected?: true, digital?: true),
+        double(name: 'DP1', external?: true,
+               connected?: true, digital?: true),
+        double(name: 'DP2', external?: true,
+               connected?: false, digital?: true),
+        double(name: 'VGA1', external?: true,
+               connected?: false, digital?: false)
+      ]
+    }
+
+    it { is_expected.to be_applicable }
+
+    it 'configures the connected external display' do
+      expect(subject.configuration).to eq(%w[
+        --output LVDS1 --off
+        --output DP2   --off
+        --output VGA1  --off
+        --output DP1   --auto
+      ])
+    end
+  end
+
+  context 'when no external digital display is connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', external?: false,
+               connected?: true, digital?: true),
+        double(name: 'DP1', external?: true,
+               connected?: false, digital?: true),
+        double(name: 'DP2', external?: true,
+               connected?: false, digital?: true),
+        double(name: 'VGA1', external?: true,
+               connected?: true, digital?: false)
+      ]
+    }
+
+    it { is_expected.not_to be_applicable }
+  end
+end

data/spec/internal_only_strategy_spec.rb

@@ -0,0 +1,36 @@
+require 'lerna/strategies/internal_only'
+
+RSpec.describe Lerna::Strategies::InternalOnly do
+  subject {
+    described_class.new(displays)
+  }
+
+  context 'when only the internal display is connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', internal?: true, connected?: true),
+        double(name: 'DP1', internal?: false, connected?: false)
+      ]
+    }
+
+    it { is_expected.to be_applicable }
+
+    it 'configures the internal display' do
+      expect(subject.configuration).to eq(%w[
+        --output DP1 --off
+        --output LVDS1 --auto
+      ])
+    end
+  end
+
+  context 'when an internal and an external display are connected' do
+    let(:displays) {
+      [
+        double(name: 'LVDS1', internal?: true, connected?: true),
+        double(name: 'DP1', internal?: false, connected?: true)
+      ]
+    }
+
+    it { is_expected.not_to be_applicable }
+  end
+end

data/spec/runner_spec.rb

@@ -0,0 +1,77 @@
+require 'lerna/runner'
+
+RSpec.describe Lerna::Runner do
+  subject {
+    described_class.new(
+      logger: logger,
+      system: system,
+      strategies: strategies,
+      state: state,
+      strategy_selector: strategy_selector
+    )
+  }
+  let(:logger) { double('logger', call: nil) }
+  let(:system) { double('system', call: nil) }
+  let(:strategies) { double('strategies') }
+  let(:strategy_selector) { double('strategy_selector', call: nil) }
+
+  after do
+    subject.run
+  end
+
+  context 'when the state has not changed' do
+    let(:state) { double('state', scan!: nil, changed?: false) }
+
+    it 'scans' do
+      expect(state).to receive(:scan!)
+    end
+
+    it 'does nothing' do
+      expect(system).not_to receive(:call)
+    end
+  end
+
+  context 'when the state has changed' do
+    let(:state) {
+      double('state', scan!: nil, changed?: true, displays: displays)
+    }
+    let(:displays) {
+      [double('display', name: 'ABC1', connected?: true)]
+    }
+
+    it 'scans' do
+      expect(state).to receive(:scan!)
+    end
+
+    it 'asks the strategy_selector for a strategy' do
+      expect(strategy_selector).to receive(:call).
+        with(strategies, displays).
+        and_return(nil)
+    end
+
+    context 'when a strategy is found' do
+      let(:strategy) {
+        double('strategy', configuration: %w[ --option --another ])
+      }
+      let(:strategy_selector) {
+        double('strategy_selector', call: strategy)
+      }
+
+      it 'calls xrandr with the strategy configuration' do
+        expect(system).to receive(:call).
+          with('xrandr', '--option', '--another')
+      end
+
+      it 'resets dpms' do
+        expect(system).to receive(:call).
+          with('xset dpms force on')
+      end
+    end
+
+    context 'when no strategy is found' do
+      it 'does nothing' do
+        expect(system).not_to receive(:call)
+      end
+    end
+  end
+end

data/spec/state_spec.rb

@@ -0,0 +1,67 @@
+require 'lerna/state'
+
+RSpec.describe Lerna::State do
+  subject { described_class.new(enumerator) }
+
+  let(:enumerator) { -> { enumerations.shift } }
+
+  context 'after the first scan' do
+    let(:enumerations) {
+      [
+        [Lerna::Display.new('HDMI1', false)]
+      ]
+    }
+
+    before do
+      subject.scan!
+    end
+
+    it { is_expected.to be_changed }
+
+    it 'lists the current displays' do
+      expect(subject.displays).to eq([Lerna::Display.new('HDMI1', false)])
+    end
+  end
+
+  context 'when the connections have changed' do
+    let(:enumerations) {
+      [
+        [Lerna::Display.new('HDMI1', false)],
+        [Lerna::Display.new('HDMI1', true)]
+      ]
+    }
+
+    before do
+      2.times do
+        subject.scan!
+      end
+    end
+
+    it { is_expected.to be_changed }
+
+    it 'lists the current displays' do
+      expect(subject.displays).to eq([Lerna::Display.new('HDMI1', true)])
+    end
+  end
+
+  context 'when the connections have not changed' do
+    let(:enumerations) {
+      [
+        [Lerna::Display.new('HDMI1', true)],
+        [Lerna::Display.new('HDMI1', true)]
+      ]
+    }
+
+    before do
+      2.times do
+        subject.scan!
+      end
+    end
+
+    it { is_expected.not_to be_changed }
+
+    it 'lists the current displays' do
+      expect(subject.displays).to eq([Lerna::Display.new('HDMI1', true)])
+    end
+  end
+end

data/spec/strategy_selector_spec.rb

@@ -0,0 +1,30 @@
+require 'lerna/strategy_selector'
+
+RSpec.describe Lerna::StrategySelector do
+  subject {
+    described_class.new(
+      'strategy_a' => strategy_a_class,
+      'strategy_b' => strategy_b_class
+    )
+  }
+
+  let(:strategy_a_class) { double('StrategyA', new: strategy_a) }
+  let(:strategy_b_class) { double('StrategyB', new: strategy_b) }
+  let(:strategy_a) { double('strategy_a', applicable?: false) }
+  let(:strategy_b) { double('strategy_b', applicable?: true) }
+  let(:displays) { double('displays') }
+
+  it 'instantiates each class with the displays' do
+    expect(strategy_a_class).to receive(:new).with(displays).and_return(strategy_a)
+    expect(strategy_b_class).to receive(:new).with(displays).and_return(strategy_b)
+    subject.call(%w[ strategy_a strategy_b ], displays)
+  end
+
+  it 'returns the first applicable instance' do
+    expect(subject.call(%w[ strategy_a strategy_b ], displays)).to eq(strategy_b)
+  end
+
+  it 'returns nil if there is no applicable instance' do
+    expect(subject.call(%w[ strategy_a ], displays)).to be_nil
+  end
+end

data/spec/strategy_spec.rb

@@ -0,0 +1,9 @@
+require 'lerna/strategy'
+require 'lerna/strategies/external_digital_only'
+
+RSpec.describe Lerna::Strategy do
+  it 'registers subclasses' do
+    expect(described_class.registry.fetch('external-digital-only')).
+      to eq(Lerna::Strategies::ExternalDigitalOnly)
+  end
+end

data/support/lerna.conf

@@ -0,0 +1,18 @@
+# Run Lerna with Upstart on Ubuntu etc.
+# Copy to ~/.config/upstart
+
+description "Lerna multi-head automator"
+author "Paul Battley <pbattley@gmail.com>"
+
+# Start and stop with the desktop
+start on desktop-start
+stop on desktop-end
+
+# Automatically restart process if crashed
+respawn
+
+# Logs go to ~/.cache/upstart/lerna.log by default
+console log
+
+# Start in foreground mode so it can be properly managed
+exec lerna

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification
+name: lerna
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Paul Battley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.30.0
+description: Tame multi-head displays
+email: pbattley@gmail.com
+executables:
+- lerna
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- bin/lerna
+- lib/lerna/display.rb
+- lib/lerna/display_enumerator.rb
+- lib/lerna/runner.rb
+- lib/lerna/state.rb
+- lib/lerna/strategies.rb
+- lib/lerna/strategies/dual_external.rb
+- lib/lerna/strategies/external_digital_only.rb
+- lib/lerna/strategies/internal_only.rb
+- lib/lerna/strategy.rb
+- lib/lerna/strategy_selector.rb
+- lib/lerna/version.rb
+- spec/display_enumerator_spec.rb
+- spec/display_spec.rb
+- spec/dual_external_strategy_spec.rb
+- spec/external_digital_only_strategy_spec.rb
+- spec/internal_only_strategy_spec.rb
+- spec/runner_spec.rb
+- spec/state_spec.rb
+- spec/strategy_selector_spec.rb
+- spec/strategy_spec.rb
+- support/lerna.conf
+homepage: http://github.com/threedaymonk/lerna
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Linux display manager
+test_files: []