rmonitor 1.0.1 → 2.0.0

data/.rspec

@@ -1 +0,0 @@
---require spec_helper

data/Gemfile

@@ -1,3 +0,0 @@
-source 'https://rubygems.org'
-
-gemspec

data/Gemfile.lock

@@ -1,24 +0,0 @@
-PATH
-  remote: .
-  specs:
-    rmonitor (1.0.1)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    diff-lcs (1.2.4)
-    rspec (2.13.0)
-      rspec-core (~> 2.13.0)
-      rspec-expectations (~> 2.13.0)
-      rspec-mocks (~> 2.13.0)
-    rspec-core (2.13.1)
-    rspec-expectations (2.13.0)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.13.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  rmonitor!
-  rspec

data/lib/rmonitor/devices.rb

@@ -1,29 +0,0 @@
-require 'rmonitor/helpers/xrandr_read_helpers'
-
-class RMonitor
-  class Devices
-    extend XRandRReadHelpers
-
-    def self.parse(devices_data)
-      # Split the blocks of XRandR output
-      blocks  = split_blocks(devices_data)
-
-      # Filter out blocks that are not devices
-      devices = collect_devices(blocks)
-
-      # Create a data structure for each block
-      devices.map! do |device|
-        {
-            :name           => extract_name(device),
-            :pos            => extract_pos(device),
-            :connected      => extract_connected(device),
-            :enabled        => extract_enabled(device),
-            :configuration  => extract_configuration(device),
-            :configurations => extract_configurations(device),
-        }
-      end
-
-      devices
-    end
-  end
-end

data/lib/rmonitor/helpers/dsl_helpers.rb

@@ -1,38 +0,0 @@
-class RMonitor
-  module DSLHelpers
-    class ProfileBuilder
-      attr_accessor :profiles
-
-      def initialize
-        @profiles = []
-      end
-
-      def profile(name, options = {}, &block)
-        device_builder = DeviceBuilder.new
-        device_builder.instance_eval(&block)
-
-        if options[:only_if]
-          options[:only_if] = method(options[:only_if])
-        elsif options[:not_if]
-          options[:not_if] = method(options[:not_if])
-        end
-
-        @profiles << { :name => name,
-                       :options => options,
-                       :devices => device_builder.devices }
-      end
-    end
-
-    class DeviceBuilder
-      attr_accessor :devices
-
-      def initialize
-        @devices = []
-      end
-
-      def device(name, options = {})
-        @devices << { :name => name }.merge(options)
-      end
-    end
-  end
-end

data/lib/rmonitor/helpers/profile_helpers.rb

@@ -1,48 +0,0 @@
-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

@@ -1,75 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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/rmonitor.gemspec

@@ -1,44 +0,0 @@
-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.homepage    = 'https://github.com/badeball/rmonitor'
-
-  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

@@ -1,29 +0,0 @@
-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

@@ -1,138 +0,0 @@
-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