sapristi 0.1.0

data/lib/sapristi/attribute_normalizer.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class AttributeNormalizer
+    def initialize(key, raw, monitor)
+      @key = key
+      @raw = raw
+      @monitor = monitor
+    end
+
+    def normalize
+      if percentage?
+        apply_percentage
+      elsif not_a_percentage_but_includes_symbol?
+        raise Error, "key=#{key}, invalid percentage=#{raw}"
+      elsif numeric_field?
+        raw&.to_i
+      else
+        raw
+      end
+    end
+
+    private
+
+    attr_reader :key, :raw, :monitor
+
+    def percentage?
+      raw&.to_s&.match(/^([0-9]+)%$/)
+    end
+
+    def not_a_percentage_but_includes_symbol?
+      raw.to_s.include?('%')
+    end
+
+    def numeric_field?
+      Definition::NUMERIC_FIELDS.include?(key)
+    end
+
+    def apply_percentage
+      validate_percentage_field
+
+      (monitor_absolute * percentage).to_i + offset
+    end
+
+    def offset
+      work_area = monitor['work_area']
+
+      case key
+      when 'X-position'
+        work_area[0]
+      when 'Y-position'
+        work_area[1]
+      else
+        0
+      end
+    end
+
+    def monitor_absolute
+      translated_key = Definition::TRANSLATIONS[key]
+      monitor[translated_key]
+    end
+
+    def percentage
+      value = raw.to_s.match(/^([0-9]+)%$/)[1].to_i
+      value / 100.0
+    end
+
+    def validate_percentage_field
+      min_percentage = { 'V-size' => 0.05, 'H-size' => 0.05 }.fetch(key, 0)
+      unless Definition::TRANSLATIONS.include? key
+        raise "#{key}=#{raw}, using percentage in invalid field, valid=#{Definition::TRANSLATIONS.keys.join(', ')}"
+      end
+
+      raise Error, "#{key} percentage is invalid=#{raw}, valid=5%-100%" if percentage < min_percentage || percentage > 1
+    end
+  end
+end

data/lib/sapristi/configuration_loader.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'csv'
+
+module Sapristi
+  class ConfigurationLoader
+    SEPARATOR = ','
+    def initialize
+      @definition_parser = DefinitionParser.new
+    end
+
+    def load(file_path)
+      csv_rows = load_csv(file_path)
+
+      parse_rows(csv_rows, file_path)
+    end
+
+    def create_empty_configuration(conf_file)
+      raise Error, "Trying to write empty configuration on existing file #{conf_file}" if File.exist? conf_file
+
+      File.write(conf_file, Definition::HEADERS.join(SEPARATOR))
+    end
+
+    def save(conf_file, definitions)
+      raise Error, "Trying to write configuration on existing file #{conf_file}" if File.exist? conf_file
+
+      serialized = definitions.map { |definition| serialize definition }
+
+      write_to_csv conf_file, serialized
+    end
+
+    private
+
+    def write_to_csv(conf_file, serialized)
+      CSV.open(conf_file, 'wb', write_headers: true, headers: Definition::HEADERS, col_sep: SEPARATOR) do |csv|
+        serialized.each { |definition| csv << definition }
+      end
+    end
+
+    def serialize(definition)
+      Definition::HEADERS.map do |field|
+        definition.raw_definition[field]
+      end
+    end
+
+    def parse_rows(csv_rows, file)
+      csv_rows.each_with_index.map do |definition, line|
+        @definition_parser.parse(definition)
+      rescue Error => e
+        raise Error, "Invalid configuration file: #{e.message}, line=#{line}, file=#{file}"
+      rescue StandardError => e
+        raise Error, "Unable to process configuration file: #{file}, line=#{line}, error=#{e.message}"
+      end
+    end
+
+    def load_csv(csv_file)
+      table = CSV.read(csv_file, headers: true, col_sep: SEPARATOR)
+    rescue Errno::ENOENT
+      raise Error, "Configuration file not found: #{csv_file}"
+    else
+      raise Error, "Invalid configuration file: Empty file #{csv_file}" if table.eql? []
+
+      table.map(&:to_h)
+    end
+  end
+end

data/lib/sapristi/definition.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class Definition
+    TRANSLATIONS = {
+      'H-size' => 'work_area_width', 'V-size' => 'work_area_height',
+      'X-position' => 'work_area_width', 'Y-position' => 'work_area_height'
+    }.freeze
+    NUMERIC_FIELDS = (TRANSLATIONS.keys + %w[Workspace]).freeze
+
+    def initialize(definition_hash)
+      validate_raw definition_hash
+      @raw_definition = definition_hash.to_h.clone
+
+      @monitor = MonitorManager.new.get_monitor_or_main definition_hash['Monitor']
+      @workspace = WindowManager.new.find_workspace_or_current definition_hash['Workspace']&.to_i
+      normalize_variables
+    end
+
+    def to_s
+      HEADERS.map { |key| "#{key}: #{raw_definition[key]}" }.join(', ')
+    end
+
+    attr_reader :raw_definition, :monitor, :x_position, :y_position, :v_size, :h_size, :workspace, :command, :title
+
+    def hash
+      state.hash
+    end
+
+    def ==(other)
+      other.class == self.class && state == other.state
+    end
+
+    alias eql? ==
+
+    protected
+
+    def state
+      raw_definition
+    end
+
+    private
+
+    def normalize_variables
+      %w[Title Command X-position Y-position H-size V-size].each do |key|
+        name = key.downcase.gsub(/-/, '_')
+        value = AttributeNormalizer.new(key, @raw_definition[key], @monitor).normalize
+        instance_variable_set "@#{name}".to_sym, value
+      end
+    end
+
+    def validate_raw(definition)
+      validate_headers(definition)
+      raise Error, 'No command or window title specified' unless definition['Command'] || definition['Title']
+
+      validate_geometry(definition)
+
+      raise Error, "Invalid monitor=#{definition['Monitor']}" if definition['Monitor']&.to_i&.negative?
+    end
+
+    def validate_geometry(definition)
+      geometry_field_nil = %w[H-size V-size X-position Y-position].find { |key| definition[key].nil? }
+      raise Error, "No #{geometry_field_nil} specified" if geometry_field_nil
+    end
+
+    HEADERS = %w[Title Command Monitor Workspace X-position Y-position H-size V-size].freeze
+
+    def validate_headers(definition)
+      headers = definition.keys
+      return if Set.new(HEADERS).superset?(Set.new(headers))
+
+      actual_headers = headers.join(', ')
+      expected_headers = HEADERS.join(', ')
+      raise Error, "Invalid configuration file: invalid headers=#{actual_headers}, valid=#{expected_headers}"
+    end
+  end
+end

data/lib/sapristi/definition_parser.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class DefinitionParser
+    def initialize
+      @monitor_manager = MonitorManager.new
+      @window_manager = WindowManager.new
+    end
+
+    def parse(definition_hash)
+      definition = Definition.new(definition_hash)
+
+      validate definition
+      definition
+    end
+
+    private
+
+    def validate(definition)
+      validate_monitor(definition)
+      validate_window_min_size(definition)
+    end
+
+    def validate_monitor(definition)
+      monitor = definition.monitor
+      monitor_width = monitor['x']
+      monitor_height = monitor['y']
+
+      validate_monitor_dimensions(definition, monitor_width, monitor_height)
+      validate_work_area(definition, monitor_width, monitor_height)
+    end
+
+    def validate_monitor_dimensions(normalized, monitor_width, monitor_height)
+      x_pos = normalized.x_position
+      y_pos = normalized.y_position
+      unless (0...monitor_width).include? x_pos
+        raise Error, "x=#{x_pos} is outside of monitor width dimension=0..#{monitor_width - 1}"
+      end
+      unless (0...monitor_height).include? y_pos
+        raise Error, "y=#{y_pos} is outside of monitor height dimension=0..#{monitor_height - 1}"
+      end
+    end
+
+    def validate_work_area(normalized, monitor_width, monitor_height)
+      x_pos = normalized.x_position
+      y_pos = normalized.y_position
+      x_end = x_pos + normalized.h_size
+      y_end = y_pos + normalized.v_size
+      if x_end >= monitor_width
+        raise Error, "window x dimensions: [#{x_pos}, #{x_end}] exceeds monitor width [0..#{monitor_width - 1}]"
+      end
+      if y_end >= monitor_height
+        raise Error, "window y dimensions: [#{y_pos}, #{y_end}] exceeds monitor height [0..#{monitor_height - 1}]"
+      end
+    end
+
+    MIN_X_SIZE = 50
+    MIN_Y_SIZE = 50
+    def validate_window_min_size(normalized)
+      window_width = normalized.h_size
+      window_height = normalized.v_size
+      raise Error, "window x size=#{window_width} less than #{MIN_X_SIZE}" if window_width < MIN_X_SIZE
+      raise Error, "window y size=#{window_height} less than #{MIN_Y_SIZE}" if window_height < MIN_Y_SIZE
+    end
+  end
+end

data/lib/sapristi/definition_processor.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class DefinitionProcessor
+    def initialize(window_manager = WindowManager.new, process_manager = NewProcessWindowDetector.new)
+      @window_manager = window_manager
+      @process_manager = process_manager
+    end
+
+    def process_definition(definition)
+      window = get_window definition.title, definition.command
+
+      @window_manager.move_resize(window,
+                                  definition.x_position, definition.y_position,
+                                  definition.h_size, definition.v_size)
+    end
+
+    private
+
+    def get_window(title, command)
+      (title && find_one_by_title(title)) ||
+        (command && @process_manager.detect_window_for_process(command)) ||
+        raise(Error, "Couldn't produce a window for this definition")
+    end
+
+    def find_one_by_title(title)
+      windows = @window_manager.find_window(/#{title}/)
+      raise Error, "#{windows.size} windows have the same title: #{title}" if windows.size > 1
+
+      if windows.size.eql? 1
+        ::Sapristi.logger.info "Found existing window pid=#{windows[0].pid} title=#{windows[0].title}"
+      end
+      windows[0]
+    end
+  end
+end

data/lib/sapristi/monitor.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class Monitor
+    def initialize(data)
+      data.each { |key, value| instance_variable_set "@#{key}".to_sym, value }
+    end
+
+    def [](key)
+      instance_variable_get "@#{key}"
+    end
+
+    ATTRIBUTES = %i[id main name x y offset_x offset_y work_area work_area_width work_area_height].freeze
+
+    attr_reader(*ATTRIBUTES)
+
+    def hash
+      state.hash
+    end
+
+    def ==(other)
+      other.class == self.class && state == other.state
+    end
+
+    alias eql? ==
+
+    protected
+
+    def state
+      ATTRIBUTES.map { |attribute| send attribute }
+    end
+  end
+end

data/lib/sapristi/monitor_manager.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'gtk3'
+
+# https://specifications.freedesktop.org/wm-spec/1.4/ar01s03.html
+# https://linux.die.net/man/1/xprop
+
+module Sapristi
+  class MonitorManager
+    def initialize
+      @os_manager = Linux::MonitorManager.new
+    end
+
+    def get_monitor_or_main(name)
+      return monitors[name] if monitor_present?(name)
+
+      use_main_monitor name
+    end
+
+    def monitors
+      @os_manager.monitors
+    end
+
+    private
+
+    def monitor_present?(name)
+      monitors.key? name
+    end
+
+    def use_main_monitor(name)
+      main = monitors.values.find { |monitor| monitor['main'] }
+      if name
+        aval_names = monitors.keys.join(', ')
+        ::Sapristi.logger.warn "Monitor #{name} not found. Using #{main['name']}, available=#{aval_names}"
+      end
+      main
+    end
+  end
+end

data/lib/sapristi/new_process_window_detector.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Sapristi
+  class NewProcessWindowDetector
+    def initialize
+      @display = WMCtrl.display
+      @process_manager = Linux::ProcessManager.new
+    end
+
+    def detect_window_for_process(command, timeout_in_seconds = 30)
+      save_pids_and_windows
+
+      process_window = wait_for_window(command, timeout_in_seconds)
+
+      if process_window
+        ::Sapristi.logger.info "  Found window title=#{process_window.title} for process=#{process_window.pid}!"
+      end
+
+      process_window
+    end
+
+    private
+
+    attr_reader :previous_windows_ids, :previous_pids, :process_manager
+
+    def save_pids_and_windows
+      @previous_windows_ids = @display.windows.map { |window| window[:id] }
+      @previous_pids = process_manager.class.user_pids
+    end
+
+    def wait_for_window(command, timeout_in_seconds)
+      program = command.split[0]
+      waiter = process_manager.execute_and_detach command
+
+      window = discover_window(waiter, program, timeout_in_seconds)
+      return window if window
+
+      raise Error, 'Error executing process, is dead' unless waiter.alive?
+
+      process_manager.kill waiter
+    end
+
+    def discover_window(waiter, program, timeout_in_seconds)
+      start_time = Time.now
+      while Time.now - start_time < timeout_in_seconds # && waiter.alive?
+        process_window = detect_new_windows.find do |window|
+          window_for_waiter?(waiter, window) || window_for_command?(waiter, window, program)
+        end
+
+        return process_window if process_window
+
+        sleep 0.5
+      end
+    end
+
+    def window_for_waiter?(waiter, window)
+      waiter.alive? && window.pid.eql?(waiter.pid)
+    end
+
+    def window_for_command?(waiter, window, program)
+      !waiter.alive? && process_manager.cmd_for_pid(window.pid).start_with?(program)
+    end
+
+    def detect_new_windows
+      new_windows = @display.windows.filter { |window| new_window?(window) }
+
+      new_windows.each { |window| ::Sapristi.logger.debug "  Found new window=#{window.pid}: #{window.title}" }
+    end
+
+    def new_window?(window)
+      !previous_windows_ids.include?(window.id)
+    end
+  end
+end