rmonitor 1.0.0

data/lib/rmonitor/helpers/profile_helpers.rb

@@ -0,0 +1,48 @@
+class RMonitor
+  module ProfileHelpers
+    def invokable?(devices, profile, verbose = false)
+      necessary_devices_present    = necessary_devices_present?(devices, profile)
+      user_defined_rules_satisfied = user_defined_rules_satisfied?(profile)
+
+      if necessary_devices_present && !user_defined_rules_satisfied && verbose
+        method = (profile[:options][:not_if] || profile[:options][:only_if]).name
+
+        puts "#{profile[:name].inspect} deemed not invokable due to #{method.inspect}."
+      end
+
+      necessary_devices_present && user_defined_rules_satisfied
+    end
+
+    def necessary_devices_present?(devices, profile)
+      profile[:devices].all? do |wanted_device|
+        device = devices.find { |d| d[:name] == wanted_device[:name] }
+
+        device and
+            has_matching_configuration(device,
+                                       wanted_device[:mode],
+                                       wanted_device[:rate])
+      end
+    end
+
+    def user_defined_rules_satisfied?(profile)
+      if profile[:options][:only_if]
+        profile[:options][:only_if].call
+      elsif profile[:options][:not_if]
+        !profile[:options][:not_if].call
+      else
+        true
+      end
+    end
+
+    def best_matching_configuration(device, mode, rate)
+      device[:configurations].find do |configuration|
+        (!mode or configuration[:mode] == mode) &&
+            (!rate or configuration[:rate] == rate)
+      end
+    end
+
+    def has_matching_configuration(device, mode, rate)
+      !best_matching_configuration(device, mode, rate).nil?
+    end
+  end
+end

data/lib/rmonitor/helpers/xrandr_read_helpers.rb

@@ -0,0 +1,75 @@
+class RMonitor
+  module XRandRReadHelpers
+    def split_blocks(devices_data)
+      block = /
+        ^[^\s] .+? \n (?=[^\s]|\Z)
+      /mx
+
+      devices_data.scan(block)
+    end
+
+    def collect_devices(blocks)
+      blocks.reject do |block|
+        block.match(/\AScreen/)
+      end
+    end
+
+    def extract_name(block)
+      block.split.first
+    end
+
+    def extract_pos(block)
+      if /\+(?<x_pos>\d+)\+(?<y_pos>\d+)/ =~ block
+        "#{x_pos}x#{y_pos}"
+      end
+    end
+
+    def extract_enabled(block)
+      block.match(/\d+x\d+\+\d+\+\d+/)
+    end
+
+    def extract_connected(block)
+      block.match(/(?<!dis)connected/)
+    end
+
+    def extract_configuration(block)
+      # Consider each line except the first
+      block.split("\n")[1..-1].each do |configuration_line|
+
+        # See if it contains any current configurations
+        if /(?<rate>\d+\.\d+)\*/ =~ configuration_line
+
+          # Extract the mode (resolution)
+          /(?<mode>\d+x\d+)/ =~ configuration_line
+          return {
+              :mode => mode,
+              :rate => rate,
+          }
+        end
+      end
+
+      nil
+    end
+
+    def extract_configurations(block)
+      configurations = []
+
+      # Consider each line except the first
+      block.split("\n")[1..-1].each do |configuration_block|
+
+        # Extract the mode (resolution)
+        /(?<mode>\d+x\d+)/ =~ configuration_block
+
+        # Extract each supported frame rate of that mode (resolution)
+        configuration_block.scan(/\d+\.\d+/).each do |rate|
+          configurations <<  {
+              :mode => mode,
+              :rate => rate,
+          }
+        end
+      end
+
+      configurations
+    end
+  end
+end

data/lib/rmonitor/helpers/xrandr_write_helpers.rb

@@ -0,0 +1,55 @@
+class RMonitor
+  module XRandRWriteHelpers
+    def turn_off(device)
+      "--output #{device} --off"
+    end
+
+    def turn_on(device, options)
+      on = '--output %s --mode %s --rate %s' % [
+          device,
+          options[:mode],
+          options[:rate],
+      ]
+
+      if options[:pos]
+        on << ' --pos '      << options[:pos]
+      elsif options[:left_of]
+        on << ' --left-of '  << options[:left_of]
+      elsif options[:right_of]
+        on << ' --right-of ' << options[:right_of]
+      elsif options[:above]
+        on << ' --above '    << options[:above]
+      elsif options[:below]
+        on << ' --below '    << options[:below]
+      elsif options[:same_as]
+        on << ' --same-as '  << options[:same_as]
+      end
+
+      if options[:rotate]
+        allowed_options = %w(normal inverted left right)
+
+        if allowed_options.include?(options[:rotate])
+          on << ' --rotate ' << options[:rotate]
+        else
+          raise XRandRArgumentError.new("Invalid argument for --rotate")
+        end
+      end
+
+      if options[:reflect]
+        allowed_options = %w(normal x y xy)
+
+        if allowed_options.include?(options[:reflect])
+          on << ' --reflect ' << options[:reflect]
+        else
+          raise XRandRArgumentError.new("Invalid argument for --reflect")
+        end
+      end
+
+      if options[:primary]
+        on << ' --primary'
+      end
+
+      on
+    end
+  end
+end

data/lib/rmonitor/profiles.rb

@@ -0,0 +1,51 @@
+require 'rmonitor/helpers/dsl_helpers'
+require 'rmonitor/helpers/profile_helpers'
+require 'rmonitor/helpers/xrandr_write_helpers'
+
+class RMonitor
+  class Profiles
+    include DSLHelpers
+    extend ProfileHelpers
+    extend XRandRWriteHelpers
+
+    def self.parse(config_data)
+      profile_builder = ProfileBuilder.new
+      profile_builder.instance_eval(config_data)
+      profile_builder.profiles
+    end
+
+    def self.to_xrandr(devices, profile)
+      xrandr = 'xrandr'
+
+      # Devices that are currently enabled, but not contained in the profile
+      to_disable = devices.select { |d| d[:enabled ]}.map { |d| d[:name] } -
+          profile[:devices].map { |d| d[:name] }
+
+      unless to_disable.empty?
+        to_disable.each do |name|
+          xrandr << ' ' << turn_off(name)
+        end
+
+        xrandr << ' && xrandr'
+      end
+
+      if profile[:options] and profile[:options][:dpi]
+        xrandr << ' --dpi ' << profile[:options][:dpi].to_s
+      end
+
+      # The devices contained in the profile are to be turned on and configured
+      profile[:devices].each do |wanted_device|
+        device = devices.find { |d| d[:name] == wanted_device[:name] }
+
+        configuration = best_matching_configuration(device,
+                                                    wanted_device[:mode],
+                                                    wanted_device[:rate])
+
+        xrandr << ' ' << turn_on(device[:name],
+                                 configuration.merge(wanted_device))
+      end
+
+      xrandr
+    end
+  end
+end

data/lib/rmonitor/version.rb

@@ -0,0 +1,3 @@
+class RMonitor
+  VERSION = '1.0.0'
+end

data/rmonitor.gemspec

@@ -0,0 +1,43 @@
+require File.join(File.dirname(__FILE__), 'lib', 'rmonitor', 'version')
+
+Gem::Specification.new do |s|
+  s.name        = 'rmonitor'
+  s.version     = RMonitor::VERSION
+  s.license     = 'MIT'
+  s.date        = '2014-08-14'
+
+  s.summary     = 'A tool for creating monitor profiles that are easily invoked.'
+  s.description = '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.'
+
+  s.authors     = ['Jonas Amundsen']
+  s.email       = ['jonasba+gem@gmail.com']
+
+  s.executables = 'rmonitor'
+
+  s.files       = %w[
+    bin/rmonitor
+    lib/rmonitor/helpers/dsl_helpers.rb
+    lib/rmonitor/helpers/profile_helpers.rb
+    lib/rmonitor/helpers/xrandr_read_helpers.rb
+    lib/rmonitor/helpers/xrandr_write_helpers.rb
+    lib/rmonitor/devices.rb
+    lib/rmonitor/profiles.rb
+    lib/rmonitor/version.rb
+    lib/rmonitor.rb
+    spec/lib/helpers/dsl_helper_spec.rb
+    spec/lib/helpers/profile_helpers_spec.rb
+    spec/lib/helpers/xrandr_read_helpers_spec.rb
+    spec/lib/helpers/xrandr_write_helpers_spec.rb
+    spec/support/device_helper.rb
+    spec/support/profile_helper.rb
+    spec/support/string_helpers.rb
+    .rspec
+    Gemfile
+    Gemfile.lock
+    LICENSE
+    README.md
+    rmonitor.gemspec
+  ]
+
+  s.add_development_dependency('rspec')
+end

data/spec/lib/helpers/dsl_helper_spec.rb

@@ -0,0 +1,29 @@
+require 'rmonitor/helpers/dsl_helpers'
+
+describe RMonitor::DSLHelpers::ProfileBuilder do
+  context "with :only_if being present" do
+    it "should replace the symbol with the respective method proc" do
+      profile_parser = RMonitor::DSLHelpers::ProfileBuilder.new
+
+      profile_parser.define_singleton_method(:user_defined_rule) do
+        # No operation
+      end
+
+      profile_parser.profile("dummy profile", :only_if => :user_defined_rule) do end
+      profile_parser.profiles.first[:options][:only_if].is_a?(Method).should be_true
+    end
+  end
+
+  context "with :not_if being present" do
+    it "should replace the symbol with the respective method proc" do
+      profile_parser = RMonitor::DSLHelpers::ProfileBuilder.new
+
+      profile_parser.define_singleton_method(:user_defined_rule) do
+        # No operation
+      end
+
+      profile_parser.profile("dummy profile", :not_if => :user_defined_rule) do end
+      profile_parser.profiles.first[:options][:not_if].is_a?(Method).should be_true
+    end
+  end
+end

data/spec/lib/helpers/profile_helpers_spec.rb

@@ -0,0 +1,138 @@
+require 'rmonitor/devices'
+require 'rmonitor/helpers/profile_helpers'
+
+describe RMonitor::ProfileHelpers do
+  include RMonitor::ProfileHelpers
+
+  describe :invokable? do
+    after do
+      rspec_reset
+    end
+
+    context "with necessary devices not being present" do
+      it "should return false" do
+        stub!(:necessary_devices_present?).and_return(false)
+        stub!(:user_defined_rules_satisfied?).and_return(true)
+
+        invokable?(nil, nil).should be_false
+      end
+    end
+
+    context "with user defined rules not being satisfied" do
+      it "should return false" do
+        stub!(:necessary_devices_present?).and_return(true)
+        stub!(:user_defined_rules_satisfied?).and_return(false)
+
+        invokable?(nil, nil).should be_false
+      end
+    end
+
+    context "with necessary devices being present and user defined rules being satisfied" do
+      it "should return true" do
+        stub!(:necessary_devices_present?).and_return(true)
+        stub!(:user_defined_rules_satisfied?).and_return(true)
+
+        invokable?(nil, nil).should be_true
+      end
+    end
+  end
+
+  describe :user_defined_rules_satisfied? do
+    context "with :only_if being present" do
+      it "should return what the user defined rule is returning" do
+        profile = {
+            :options => {
+                :only_if => Proc.new { true }
+            }
+        }
+
+        user_defined_rules_satisfied?(profile).should be_true
+      end
+    end
+
+    context "with :not_if being present" do
+      it "should return the opposite of what the user defined rule is returning" do
+        profile = {
+            :options => {
+                :not_if => Proc.new { true }
+            }
+        }
+
+        user_defined_rules_satisfied?(profile).should be_false
+      end
+    end
+  end
+
+  describe :best_matching_configuration do
+    context "no matching configuration" do
+      it "should return nil" do
+        device = parse_device <<-D.strip_heredoc
+          HDMI1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 477mm x 268mm
+             1920x1080      60.0*+
+             1280x1024      75.0     60.0
+             1152x864       75.0
+             1024x768       75.1     60.0
+             800x600        75.0     60.3
+             640x480        75.0     60.0
+             720x400        70.1
+        D
+
+        best_matching_configuration(device, "1280x768", nil).should == nil
+      end
+    end
+
+    context "one matching configuration" do
+      it "should return it" do
+        device = parse_device <<-D.strip_heredoc
+          HDMI1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 477mm x 268mm
+             1920x1080      60.0*+
+             1280x1024      75.0     60.0
+             1152x864       75.0
+             1024x768       75.1     60.0
+             800x600        75.0     60.3
+             640x480        75.0     60.0
+             720x400        70.1
+        D
+
+        best_matching_configuration(device, "1920x1080", nil).should == { :mode => "1920x1080",
+                                                                          :rate => "60.0" }
+      end
+    end
+
+    context "more matching configurations due to no rate specified" do
+      it "should return the 'best' configuration" do
+        device = parse_device <<-D.strip_heredoc
+          HDMI1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 477mm x 268mm
+             1920x1080      60.0*+
+             1280x1024      75.0     60.0
+             1152x864       75.0
+             1024x768       75.1     60.0
+             800x600        75.0     60.3
+             640x480        75.0     60.0
+             720x400        70.1
+        D
+
+        best_matching_configuration(device, "1280x1024", nil).should == { :mode => "1280x1024",
+                                                                          :rate => "75.0" }
+      end
+    end
+
+    context "more matching configurations due to no mode specified" do
+      it "should return the 'best' configuration" do
+        device = parse_device <<-D.strip_heredoc
+          HDMI1 connected 1920x1080+0+0 (normal left inverted right x axis y axis) 477mm x 268mm
+             1920x1080      60.0*+
+             1280x1024      75.0     60.0
+             1152x864       75.0
+             1024x768       75.1     60.0
+             800x600        75.0     60.3
+             640x480        75.0     60.0
+             720x400        70.1
+        D
+
+        best_matching_configuration(device, nil, "60.0").should == { :mode => "1920x1080",
+                                                                     :rate => "60.0" }
+      end
+    end
+  end
+end