Keyboard rewrite: select current layout on startup

.rubocop.yml

@@ -0,0 +1,12 @@
+# use the shared Yast defaults
+inherit_from:
+  /usr/share/YaST2/data/devtools/data/rubocop_yast_style.yml
+
+AllCops:
+  Exclude:
+    - 'keyboard/**/*'
+    - 'console/**/*'
+    - 'language/**/*'
+    - 'timezone/**/*'
+    - 'Rakefile'
+

TECHNICALDEBT.md

@@ -0,0 +1,7 @@
+**Keyboard rewrite tecnichal debt**
+============================
+
+**This file contains keep technical debt that should be fixed before finishing the project.**
+
+
+- [ ] ```require_relative``` are being used temporary, for example in ```y2_keyboard/clients/keyboard.rb```, it must be replaced with ```require```.

keyboard_rewrite/src/clients/keyboard.rb

@@ -0,0 +1,3 @@
+require_relative "../lib/y2keyboard/clients/keyboard"
+
+Y2Keyboard::Clients::Keyboard.run

keyboard_rewrite/src/lib/y2keyboard/clients/keyboard.rb

@@ -0,0 +1,14 @@
+require_relative "../dialogs/layout_selector"
+require_relative "../strategies/systemd_strategy"
+
+module Y2Keyboard
+  module Clients
+    # Simple client to run LayoutSelector.
+    class Keyboard
+      def self.run
+        systemd_strategy = Y2Keyboard::Strategies::SystemdStrategy.new
+        Y2Keyboard::Dialogs::LayoutSelector.new(systemd_strategy).run
+      end
+    end
+  end
+end

keyboard_rewrite/src/lib/y2keyboard/dialogs/layout_selector.rb

@@ -0,0 +1,84 @@
+require "yast"
+require "ui/dialog"
+
+Yast.import "UI"
+Yast.import "Popup"
+
+module Y2Keyboard
+  module Dialogs
+    # Main dialog where the layouts are listed and can change the keyboard layout
+    class LayoutSelector < UI::Dialog
+      def initialize(strategy)
+        textdomain "country"
+        @keyboard_layouts = strategy.all
+        @previous_selected_layout = strategy.current_layout
+        @strategy = strategy
+      end
+
+      def dialog_options
+        Opt(:decorated, :defaultsize)
+      end
+
+      def dialog_content
+        VBox(
+          HBox(
+            HWeight(20, HStretch()),
+            HWeight(50, layout_selection_box),
+            HWeight(20, HStretch())
+          ),
+          footer
+        )
+      end
+
+      def layout_selection_box
+        VBox(
+          SelectionBox(
+            Id(:layout_list),
+            Opt(:notify),
+            _("&Keyboard Layout"),
+            map_layout_items
+          ),
+          InputField(Opt(:hstretch), _("&Test"))
+        )
+      end
+
+      def map_layout_items
+        @keyboard_layouts.map do |layout|
+          Item(
+            Id(layout.code),
+            layout.description,
+            layout.code == @previous_selected_layout.code
+          )
+        end
+      end
+
+      def accept_handler
+        @strategy.apply_layout(selected_layout)
+        finish_dialog
+      end
+
+      def cancel_handler
+        @strategy.load_layout(@previous_selected_layout)
+        finish_dialog
+      end
+
+      def layout_list_handler
+        @strategy.load_layout(selected_layout)
+      end
+
+      def selected_layout
+        selected = Yast::UI.QueryWidget(:layout_list, :CurrentItem)
+        @keyboard_layouts.find { |x| x.code == selected }
+      end
+
+      def footer
+        HBox(
+          HSpacing(),
+          PushButton(Id(:cancel), Yast::Label.CancelButton),
+          PushButton(Id(:accept), Yast::Label.AcceptButton),
+          HSpacing()
+        )
+      end
+    end
+  end
+end

keyboard_rewrite/src/lib/y2keyboard/keyboard_layout.rb

@@ -0,0 +1,12 @@
+module Y2Keyboard
+  # This class represents a keyboard layout. Also have methods to interact with the system.
+  class KeyboardLayout
+    attr_reader :code
+    attr_reader :description
+
+    def initialize(code, description)
+      @code = code
+      @description = description
+    end
+  end
+end

keyboard_rewrite/src/lib/y2keyboard/strategies/systemd_strategy.rb

@@ -0,0 +1,54 @@
+require "cheetah"
+require_relative "../keyboard_layout"
+
+module Y2Keyboard
+  module Strategies
+    # Class to deal with systemd keyboard configuration
+    class SystemdStrategy
+      include Yast::Logger
+
+      LAYOUT_CODE_DESCRIPTIONS = {
+        "gb" => "English (UK)",
+        "es" => "Spanish",
+        "fr" => "French",
+        "us" => "English (US)"
+      }.freeze
+
+      def all
+        raw_layouts = Cheetah.run("localectl", "list-keymaps", stdout: :capture)
+        codes = raw_layouts.lines.map(&:strip)
+        codes_with_description = codes.select { |code| LAYOUT_CODE_DESCRIPTIONS.key?(code) }
+        codes_with_description.map { |x| KeyboardLayout.new(x, LAYOUT_CODE_DESCRIPTIONS[x]) }
+      end
+
+      def apply_layout(keyboard_layout)
+        Cheetah.run("localectl", "set-keymap", keyboard_layout.code)
+      end
+
+      def load_layout(keyboard_layout)
+        Cheetah.run("setxkbmap", keyboard_layout.code) if !Yast::UI.TextMode
+        begin
+          Cheetah.run("loadkeys", keyboard_layout.code) if Yast::UI.TextMode
+        rescue Cheetah::ExecutionFailed => e
+          log.info(e.message)
+          log.info("Error output:    #{e.stderr}")
+        end
+      end
+
+      def current_layout
+        find_layout_with(current_layout_code)
+      end
+
+      def find_layout_with(code)
+        all.find { |x| x.code == code }
+      end
+
+      def current_layout_code
+        output = Cheetah.run("localectl", "status", stdout: :capture)
+        output.lines.map(&:strip).find { |x| x.start_with?("VC Keymap:") }.split.last
+      end
+
+      private :current_layout_code, :find_layout_with
+    end
+  end
+end

keyboard_rewrite/test/keyboard_spec_helper.rb

@@ -0,0 +1,62 @@
+# Spec helper for keyboard module tests
+module KeyboardSpecHelper
+  def mock_ui_events(*events)
+    allow(Yast::UI).to receive(:UserInput).and_return(*events)
+  end
+
+  def given_layouts(layouts_to_return)
+    allow(Cheetah).to receive(:run).with(
+      "localectl", "list-keymaps", stdout: :capture
+    ).and_return(layouts_to_return.join("\n"))
+  end
+
+  def given_a_current_layout(code)
+    allow(Cheetah).to receive(:run)
+      .with("localectl", "status", stdout: :capture)
+      .and_return(
+        "   System Locale: LANG=en_US.UTF-8\n" \
+        "       VC Keymap: #{code}\n" \
+        "       X11 Layout: #{code}\n" \
+        "       X11 Model: microsoftpro\n" \
+        "       X11 Options: terminate:ctrl_alt_bksp\n"
+      )
+  end
+
+  def selecting_layout_from_list(layout)
+    allow(Yast::UI).to receive(:QueryWidget)
+      .with(:layout_list, :CurrentItem)
+      .and_return(layout.code)
+  end
+
+  def loadkeys_error
+    Cheetah::ExecutionFailed.new(
+      "loadkeys es",
+      "Execution of \"loadkeys es\" failed with status 1: " \
+      "Couldn't get a file descriptor referring to the console.",
+      "",
+      "Couldn't get a file descriptor referring to the console"
+    )
+  end
+
+  def expect_display_layouts(layouts)
+    allow(Yast::Term).to receive(:new).and_call_original
+    layouts.each do |layout|
+      expect(Yast::Term).to receive(:new).with(
+        :item,
+        Id(layout.code),
+        layout.description,
+        boolean
+      )
+    end
+  end
+
+  def expect_create_list_with_current_layout(layout)
+    allow(Yast::Term).to receive(:new).and_call_original
+    expect(Yast::Term).to receive(:new).with(
+      :item,
+      Id(layout.code),
+      layout.description,
+      true
+    )
+  end
+end

keyboard_rewrite/test/layout_selector_spec.rb

@@ -0,0 +1,106 @@
+require_relative "test_helper"
+require "y2keyboard/keyboard_layout"
+require "y2keyboard/dialogs/layout_selector"
+require "y2keyboard/strategies/systemd_strategy"
+
+describe Y2Keyboard::Dialogs::LayoutSelector do
+  english = Y2Keyboard::KeyboardLayout.new("en", "English")
+  spanish = Y2Keyboard::KeyboardLayout.new("es", "Spanish")
+  layouts = [english, spanish]
+  strategy = Y2Keyboard::Strategies::SystemdStrategy.new
+  subject(:layout_selector) { Y2Keyboard::Dialogs::LayoutSelector.new(strategy) }
+
+  before do
+    allow(Yast::UI).to receive(:OpenDialog).and_return(true)
+    allow(Yast::UI).to receive(:CloseDialog).and_return(true)
+    allow(strategy).to receive(:load_layout)
+    allow(strategy).to receive(:current_layout).and_return(english)
+    allow(strategy).to receive(:all).and_return(layouts)
+  end
+
+  describe "#run" do
+    before do
+      mock_ui_events(:cancel)
+    end
+
+    it "retrieve keyboard layouts from strategy" do
+      expect(strategy).to receive(:all)
+
+      layout_selector.run
+    end
+
+    it "lists the keyboard layouts" do
+      allow(strategy).to receive(:all).and_return(layouts)
+
+      expect_display_layouts(layouts)
+
+      layout_selector.run
+    end
+
+    it "select the current layout in the list" do
+      allow(strategy).to receive(:all).and_return(layouts)
+      allow(strategy).to receive(:current_layout).and_return(english)
+
+      expect_create_list_with_current_layout(english)
+
+      layout_selector.run
+    end
+  end
+
+  describe "#accept_handler" do
+    before do
+      mock_ui_events(:accept)
+    end
+
+    it "change the keymap to the selected layout" do
+      selecting_layout_from_list(spanish)
+
+      expect(strategy).to receive(:apply_layout).with(spanish)
+
+      layout_selector.run
+    end
+
+    it "closes the dialog" do
+      selecting_layout_from_list(spanish)
+      allow(strategy).to receive(:apply_layout)
+
+      expect(layout_selector).to receive(:finish_dialog).and_call_original
+
+      layout_selector.run
+    end
+  end
+
+  describe "#layout_list_handler" do
+    before do
+      mock_ui_events(:layout_list, :cancel)
+    end
+
+    it "change the keymap to the selected layout" do
+      selecting_layout_from_list(spanish)
+
+      expect(strategy).to receive(:load_layout).with(spanish)
+
+      layout_selector.run
+    end
+  end
+
+  describe "#cancel_handler" do
+    before do
+      mock_ui_events(:cancel)
+    end
+
+    it "closes the dialog" do
+      expect(layout_selector).to receive(:finish_dialog).and_call_original
+
+      layout_selector.run
+    end
+
+    it "restores the keyboard layout to the previous selected" do
+      allow(strategy).to receive(:current_layout).and_return(english)
+
+      expect(strategy).to receive(:load_layout).with(english)
+
+      layout_selector.run
+    end
+  end
+end