rmonitor 1.0.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: efcffcebb400746bb0999ba82e922c65bf21d2e5
-  data.tar.gz: 570c8a906f8a604302d2ef869988b8a9542fbd01
+  metadata.gz: 39988281a286deee26d615bb35fb4023b5bca9e0
+  data.tar.gz: 1b09ddd2c01ad30a7f31c75bcd2baf06624b1a90
 SHA512:
-  metadata.gz: cb68858d52f4ee76132da86e9ea23cf3676bc9720fec28f4098c389eb26dc5914fdd014df856e61e566ad4e96a8bf7a925bc1e9d0041ab63c74acbadf388aaf4
-  data.tar.gz: 8e0f383749c28649738cecaea38bc6a9ee5ffe241b18c39091cb1d655b3aa471235f80bb6b841d8da51ca7c6df7352cdb2ebec6cfd7b21a26478e387a641ab96
+  metadata.gz: 249da323f0ac72f0e52fee4f39cc55cb6d8702e7d098625362874a947dab993d71b2f299e85fbf15f732d6acc67543695de4868ab614e45f5623afeb225d2b68
+  data.tar.gz: a96ea8f0a0f87f286e882e1ea186b60600b9df3cfc3fee2bdf9a93004ff71f48373c48b5979d5d96ac8d8b88eedf00a1c0e8affa92e37d17804fcdc8f612600a

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2013 Jonas Amundsen
+Copyright 2015 Jonas Amundsen
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,12 +1,13 @@
 ## RMonitor
 
 [![Build Status](https://travis-ci.org/badeball/rmonitor.png)](https://travis-ci.org/badeball/rmonitor)
+[![Code Climate](https://codeclimate.com/github/badeball/rmonitor/badges/gpa.svg)](https://codeclimate.com/github/badeball/rmonitor)
+[![Test Coverage](https://codeclimate.com/github/badeball/rmonitor/badges/coverage.svg)](https://codeclimate.com/github/badeball/rmonitor/coverage)
 
-RMonitor is a tool for creating monitor profiles that are easily invoked. This
-is useful when you often find yourself in situations with different monitor
-configurations. It consists of one executable and a ruby configuration file.
-The following example shows a configuration containing monitor profiles
-representing three different monitor setups.
+RMonitor is a tool for defining monitor profiles that can be invoked. This is
+useful when you often find yourself in situations with different monitor
+configurations. The following example shows a configuration containing monitor
+profiles representing three different setups.
 
 ```ruby
 profile "docked" do
@@ -24,66 +25,59 @@ profile "default" do
 end
 ```
 
-Usage:
+A configuration is parsed and considered from top to bottom. The first profile
+that is currently invokable (ie. the requested devices with modes and rates are
+available) is preferred. Profiles can also be invoked by name. `xrandr` is used
+behind the scenes to read devices and perform changes.
 
-```
-Usage: rmonitor [option]
-    -c, --create [NAME]              Create and output a profile with an optional name
-    -i, --invoke NAME                Invoke a profile with a given name
-    -u, --update                     Invoke the most preferable profile
-    -v, --verbose                    Verbose output
-    -d, --dry-run                    Do everything except actually update
-        --config-path PATH           Specify the path to the configuration file (defaults to ~/.config/rmonitor/config.rb
-    -h, --help                       Show this message
-        --version                    Print the version number of rmonitor
-```
-
-### --create [NAME]
+## Installation
 
-Outputs a profile for your current setup.
+The utility can be installed using `gem`.
 
 ```
-$ rmonitor --create "docked"
-profile "docked" do
-  device "HDMI1", :mode => "1920x1080", :rate => "60.0", :pos => "0x0"
-  device "HDMI2", :mode => "1920x1080", :rate => "60.0", :pos => "1920x0"
-end
+$ gem install rmonitor
 ```
 
-### --invoke NAME
+It can be installed system-wide using the following options.
 
-Invokes a monitor profile by generating an xrandr query.
+```
+$ gem install --no-user-install -i "$(ruby -e'puts Gem.default_dir')" -n /usr/local/bin rmonitor
+```
 
-### --update
+It is also packaged for Arch Linux.
 
-Parses the configuration file from top to bottom and invokes the first
-invokable profile based on what devices that are currently connected. This is
-likely the most used option and may for instance be used to automatically
-configure your screens upon startup.
+```
+$ yaourt -S ruby-rmonitor
+```
 
-## Installation
+## Usage
 
-The utility can be installed using `gem`, but is also packaged for Arch Linux.
+The executable contains three sub-commands. `invoke` will invoke a monitor
+profile by name.
 
 ```
-$ gem install rmonitor
+$ rmonitor invoke --name "docked"
 ```
 
-It can be installed system-wide using the following options.
+The `update` command will invoke the most preferred monitor profile. This
+command can be mapped to XF86Display to achieve the functionality that one can
+see in eg, windows or apple machines.
 
 ```
-$ gem install --no-user-install -i "$(ruby -e'puts Gem.default_dir')" -n /usr/bin rmonitor
+$ rmonitor update
 ```
 
-### Arch Linux
+Lastly there is `list` which just list all defined monitor profiles.
 
 ```
-$ yaourt -Syua ruby-rmonitor
+$ rmonitor list
 ```
 
 ## Configurable options
 
-The following examples shows how RMonitor can be configured.
+The following examples shows how RMonitor can be configured. The default
+configuration path is `~/.config/rmonitor/config.rb`, but can be configured
+using the `--config-path` argument.
 
 ```ruby
 # Specify device location with position
@@ -136,6 +130,21 @@ end
 
 ## Changelog
 
+### 2.0.0
+
+* Re-implementing the --config-path option.
+* Re-implementing the :dpi profile option.
+
+### 2.0.0.rc2
+
+* Relaxing the regular expression for matching device names. Previously it
+  would not match eg. `DP1-1`, but now it does.
+
+### 2.0.0.rc1
+
+* Complete revamp of the codebase. Test coverage is wastly better. The code is
+  more maintainable and ready for change.
+
 ### 1.0.0
 
 * The -a option is removed.

data/bin/rmonitor

@@ -1,112 +1,50 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'rmonitor'
-require 'rmonitor/version'
-
-RMonitor.config_path = File.join(Dir.home, '.config', 'rmonitor', 'config.rb')
-
-class << self
-  attr_accessor :options
+require "commander/import"
+require "rmonitor"
+require "rmonitor/version"
+
+program :name, "rmonitor"
+program :version, RMonitor::VERSION
+program :description, "A tool for creating monitor profiles that are easily invoked."
+
+global_option "-c", "--config-path PATH", <<DESC.strip do |path|
+  Specify the path to the configuration file (defaults to ~/.config/rmonitor/config.rb)
+DESC
+  RMonitor::Config.config_path = path
 end
 
-self.options = { :action => :create }
-
-OptionParser.new do |opts|
-  opts.banner = "Usage: rmonitor [option]"
-
-  opts.on("-c", "--create [NAME]", String, "Create and output a profile with an optional name") do |name|
-    options[:action] = :create
-    options[:name] = name
-  end
-
-  opts.on("-i", "--invoke NAME", String, "Invoke a profile with a given name") do |name|
-    options[:action] = :invoke
-    options[:name] = name
-  end
-
-  opts.on("-u", "--update", "Invoke the most preferable profile") do
-    options[:action] = :update
-  end
-
-  opts.on("-v", "--verbose", "Verbose output") do
-    options[:verbose] = true
-  end
-
-  opts.on("-d", "--dry-run", "Do everything except actually update (implies -v)") do
-    options[:dry_run] = true
-    options[:verbose] = true
-  end
-
-  opts.on("--config-path PATH", String, "Specify the path to the configuration file (defaults to ~/.config/rmonitor/config.rb") do |config_path|
-    RMonitor.config_path = config_path
+command :invoke do |c|
+  c.syntax = "invoke [options]"
+  c.description = "invoke a profile by name"
+  c.option "-n", "--name NAME", String
+  c.option "--dry-run", "don't run any destructive commands"
+  c.option "--verbose", "print every command ran"
+  c.action do |_, options|
+    RMonitor::Commands::CL::Invoke.new(
+      :verbose => options.verbose,
+      :dry_run => options.dry_run
+    ).execute(options.name)
   end
-
-  opts.on_tail("-h", "--help", "Show this message") do
-    puts opts
-    exit
-  end
-
-  opts.on_tail("--version", "Print the version number of rmonitor") do
-    puts "rmonitor #{RMonitor::VERSION}"
-    exit
-  end
-end.parse!
-
-def v_puts(content)
-  if options[:verbose]
-    puts content
-  end
-end
-
-def exit_with(content)
-  $stderr.puts content
-  exit! 1
 end
 
-rm = RMonitor.load
-
-if options[:action] == :update
-  # Find the first invokable profile
-  profile = rm.profiles.find do |profile|
-    RMonitor::Profiles.invokable?(rm.devices, profile)
-  end
-
-  if profile
-    v_puts "Found #{profile[:name].inspect} that is invokable."
-    options[:name] = profile[:name]
-    options[:action] = :invoke
-  else
-    exit_with 'no invokable profile exists'
+command :list do |c|
+  c.syntax = "list"
+  c.description = "lists all available profiles"
+  c.action do
+    RMonitor::Commands::CL::List.new.execute
   end
 end
 
-if options[:action] == :invoke
-  profile = rm.profiles.find { |p| p[:name] == options[:name] }
-
-  if profile
-    if RMonitor::Profiles.invokable?(rm.devices, profile)
-      command = RMonitor::Profiles.to_xrandr(rm.devices, profile)
-      v_puts "Invoking #{profile[:name].inspect} by running #{command.inspect}."
-      exec(command) unless options[:dry_run]
-    else
-      exit_with 'this profile is not invokable'
-    end
-  else
-    exit_with 'no profile with that name exists'
-  end
-
-elsif options[:action] == :create
-  puts "profile #{(options[:name] || 'My profile').inspect} do"
-  rm.devices.each do |device|
-    if device[:enabled]
-      puts '  device %s, :mode => %s, :rate => %s, :pos => %s' % [
-          device[:name].inspect,
-          device[:configuration][:mode].inspect,
-          device[:configuration][:rate].inspect,
-          device[:pos].inspect,
-      ]
-    end
+command :update do |c|
+  c.syntax = "update"
+  c.description = "invokes the most preferred profile"
+  c.option "--dry-run", "don't run any destructive commands"
+  c.option "--verbose", "print every command ran"
+  c.action do |_, options|
+    RMonitor::Commands::CL::Update.new(
+      :verbose => options.verbose,
+      :dry_run => options.dry_run
+    ).execute
   end
-  puts 'end'
 end

data/lib/rmonitor.rb

@@ -1,23 +1,20 @@
-require 'fileutils'
-
-require 'rmonitor/devices'
-require 'rmonitor/profiles'
+require "rmonitor/commands/cl/invoke"
+require "rmonitor/commands/cl/list"
+require "rmonitor/commands/cl/update"
+require "rmonitor/strategies/optimistic"
+require "rmonitor/strategies/pessimistic"
+require "rmonitor/actions"
+require "rmonitor/cache"
+require "rmonitor/capabilities"
+require "rmonitor/config"
+require "rmonitor/invoker"
+require "rmonitor/matcher"
+require "rmonitor/selector"
+require "rmonitor/transformer"
+require "rmonitor/xrandr"
 
 class RMonitor
-  class XRandRArgumentError < ArgumentError; end
-
-  class << self
-    attr_accessor :config_path
-  end
-
-  attr_accessor :devices, :profiles
-
-  def initialize(raw_devices_data, raw_profiles_data)
-    @devices  = Devices.parse(raw_devices_data)
-    @profiles = Profiles.parse(raw_profiles_data)
-  end
-
-  def self.load
-    self.new(`xrandr -q`, File.new(config_path).read)
-  end
+  class UnknownProfileError < StandardError; end
+  class UninvokableProfileError < StandardError; end
+  class NoInvokableProfileError < StandardError; end
 end

data/lib/rmonitor/actions.rb

@@ -0,0 +1,30 @@
+require "rmonitor/actions/builder"
+
+class RMonitor
+  class Actions
+    def initialize(options = {})
+      @capabilities = options[:capabilities] || Capabilities.new(options).parse
+    end
+
+    def create(profile)
+      actions = []
+
+      @avaialble_devices = @capabilities.map { |capability| capability[:name] }.uniq
+      @desired_devices = profile[:devices].map { |device| device[:name] }
+
+      (@avaialble_devices - @desired_devices).each do |device|
+        actions << {:action => :off, :name => device}
+      end
+
+      if profile[:dpi]
+        actions << {:action => :option, :name => :dpi, :value => profile[:dpi]}
+      end
+
+      profile[:devices].each do |device|
+        actions << device.merge(:action => :on)
+      end
+
+      actions
+    end
+  end
+end

data/lib/rmonitor/actions/builder.rb

@@ -0,0 +1,15 @@
+require "rmonitor/actions/dsl"
+
+class RMonitor
+  class Actions
+    class Builder
+      class << self
+        def define(&block)
+          dsl = RMonitor::Actions::DSL.new
+          dsl.instance_eval(&block)
+          dsl.actions
+        end
+      end
+    end
+  end
+end

data/lib/rmonitor/actions/dsl.rb

@@ -0,0 +1,23 @@
+class RMonitor
+  class Actions
+    class DSL
+      attr_accessor :actions
+
+      def initialize
+        @actions = []
+      end
+
+      def off(name)
+        @actions << {:action => :off, :name => name}
+      end
+
+      def on(name, options = {})
+        @actions << options.merge(:action => :on, :name => name)
+      end
+
+      def dpi(value)
+        @actions << {:action => :option, :name => :dpi, :value => value}
+      end
+    end
+  end
+end

data/lib/rmonitor/cache.rb

@@ -0,0 +1,12 @@
+class RMonitor
+  class Cache
+    def initialize(options = {})
+      @output = {}
+      @invoker = options[:invoker] || Invoker.new(options)
+    end
+
+    def invoke(command)
+      @output[command] ||= @invoker.invoke(command)
+    end
+  end
+end

data/lib/rmonitor/capabilities.rb

@@ -0,0 +1,38 @@
+require "rmonitor/capabilities/builder"
+
+class RMonitor
+  class Capabilities
+    def initialize(options = {})
+      @xrandr = options[:xrandr] || XRandR.new(options)
+    end
+
+    def parse(input = @xrandr.invoke)
+      capabilities = []
+      current_name = nil
+
+      input = input.split("\n").tap(&:shift).map(&:strip)
+
+      input.each do |line|
+        if /(?<name>[\w\d-]+) (dis)?connected/ =~ line
+          current_name = name
+        end
+
+        if /(?<mode>\d+x\d+)/ =~ line
+          line.scan(/\s(\d+(?:\.\d+)?)(?:( |\*)( |\+)?)?/) do |rate, native, current|
+            capabilities << {:name => current_name, :mode => mode, :rate => rate}
+
+            if native == "*"
+              capabilities.last[:native] = true
+            end
+
+            if current == "+"
+              capabilities.last[:current] = true
+            end
+          end
+        end
+      end
+
+      capabilities
+    end
+  end
+end