ssh-hull 1.0.0

data/lib/ssh-hull/ui/helpers/common/form_helper.rb

@@ -0,0 +1,169 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module FormHelper
+          module ClassMethods
+
+            def bind_menu_entries(entries)
+              entries.each do |f|
+                bind_template_child "menu_#{f}"
+              end
+            end
+
+
+            def bind_buttons(buttons)
+              buttons.each do |f|
+                bind_template_child "button_#{f}"
+              end
+            end
+
+
+            def bind_form_fields(fields)
+              fields.each do |f|
+                bind_template_child "label_#{f}"
+                bind_template_child "input_#{f}"
+              end
+            end
+
+          end
+
+          module InstanceMethods
+
+            def params
+              params = {}
+              form_fields.each do |field_name, opts|
+                # get input value
+                input  = "input_#{field_name}"
+                field  = __send__(input)
+                getter = getter_for(opts[:type])
+                value = field.__send__(getter)
+                params[field_name] = value
+              end
+              params
+            end
+
+
+            def bind_submit_button
+              button_submit.label = t('button.submit')
+              button_submit.signal_connect :clicked do
+                submit_form(params)
+              end
+            end
+
+
+            def submit_form(params)
+              form = form_object
+              form.submit(params)
+              if form.valid?
+                form.save
+                save_and_reload_view
+              else
+                render_form_errors(form.errors)
+              end
+            end
+
+
+            def form_object
+              raise NotImplementedError
+            end
+
+
+            def save_and_reload_view
+              raise NotImplementedError
+            end
+
+
+            def render_form_errors(errors)
+              form_fields.each do |field_name, _method|
+                has_errors = errors.of_kind?(field_name, :blank) || errors.of_kind?(field_name, :inclusion)
+                input = "input_#{field_name}"
+                field = __send__(input)
+                color = has_errors ? red : white
+                field.override_background_color(:normal, color)
+              end
+            end
+
+
+            def red
+              Gdk::RGBA.new(255, 0, 0)
+            end
+
+
+            def white
+              Gdk::RGBA.new(255, 255, 255)
+            end
+
+
+            def restore_form_values(model)
+              form_fields.each do |field_name, opts|
+                restore_form_value(model, field_name, opts)
+              end
+            end
+
+
+            def restore_form_value(model, field_name, opts)
+              # get model value
+              value = model.__send__(field_name)
+
+              # set input form
+              input  = "input_#{field_name}"
+              field  = __send__(input)
+              setter = setter_for(opts[:type])
+
+              if opts[:type] == :file && value.nil?
+                field.unselect_all
+              else
+                field.__send__(setter, value)
+              end
+            end
+
+
+            INPUT_TYPES = {
+              text: {
+                getter: :text,
+                setter: :text=,
+              },
+              select: {
+                getter: :active_id,
+                setter: :active_id=,
+              },
+              file: {
+                getter: :filename,
+                setter: :filename=,
+              },
+              checkbox: {
+                getter: :active?,
+                setter: :active=,
+              },
+            }.freeze
+            private_constant :INPUT_TYPES
+
+
+            def setter_for(input_type)
+              INPUT_TYPES.dig(input_type, :setter)
+            end
+
+
+            def getter_for(input_type)
+              INPUT_TYPES.dig(input_type, :getter)
+            end
+
+
+            def set_input_labels(scope:)
+              form_fields.each do |field_name, _method|
+                label  = "label_#{field_name}"
+                field  = __send__(label)
+                value  = t("form.#{scope}.#{field_name}")
+                field.text = value
+              end
+            end
+
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/common/minimize_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module MinimizeHelper
+
+          def initialize(*)
+            super
+
+            # Set instance variables
+            @minimized = false
+          end
+
+
+          def minimized?
+            @minimized
+          end
+
+
+          def minimize!
+            @minimized = true
+            hide
+          end
+
+
+          def maximize!
+            @minimized = false
+            show
+          end
+
+
+          def toggle!
+            if minimized?
+              maximize!
+            else
+              minimize!
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/common/modal_helper.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module ModalHelper
+
+          def initialize(application, window, *)
+            super application: application
+
+            # Set instance variables
+            @application = application
+            @window      = window
+
+            # Bind listeners
+            bind_submit_button
+            bind_cancel_button
+          end
+
+
+          private
+
+            def bind_cancel_button
+              # Not all modals have a cancel button
+              if respond_to?(:button_cancel)
+                button_cancel.label = t('button.cancel')
+                button_cancel.signal_connect :clicked do
+                  close
+                end
+              end
+
+              # Bind escape key stroke
+              signal_connect :key_press_event do |_widget, event|
+                event.keyval == 65_307 ? close : false
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/common/toolbar_helper.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module ToolbarHelper
+
+          def initialize(*)
+            super
+
+            # Bind listeners
+            bind_menu_entries
+            bind_toolbar_buttons
+          end
+
+
+          private
+
+
+            def bind_menu_entries
+              signal_connect :destroy do
+                @application.quit
+              end
+
+              menu_quit.label = t('menu.quit')
+              menu_quit.signal_connect :activate do
+                @application.quit
+              end
+
+              menu_about.label = t('menu.about')
+              menu_about.signal_connect :activate do
+                window = SSHTunnel::UI::Windows::AboutWindow.new(@application)
+                window.present
+              end
+            end
+
+
+            def bind_toolbar_buttons
+              bind_toolbar_button_add
+              bind_toolbar_button_edit
+              bind_toolbar_button_remove
+              bind_toolbar_button_start
+              bind_toolbar_button_stop
+            end
+
+
+            def bind_toolbar_button_add
+              button_add.tooltip_text = t('tooltip.host.add')
+              button_add.signal_connect :clicked do
+                with_new_host_model do |object|
+                  window = SSHTunnel::UI::Windows::Hosts::NewWindow.new(@application, self, object)
+                  window.present
+                end
+              end
+            end
+
+
+            def bind_toolbar_button_edit
+              button_edit.tooltip_text = t('tooltip.host.edit')
+              button_edit.signal_connect :clicked do
+                with_host_model do |object|
+                  window = SSHTunnel::UI::Windows::Hosts::EditWindow.new(@application, self, object)
+                  window.present
+                end
+              end
+            end
+
+
+            def bind_toolbar_button_remove
+              button_remove.tooltip_text = t('tooltip.host.remove')
+              button_remove.signal_connect :clicked do
+                with_host_model do |object|
+                  window = SSHTunnel::UI::Windows::Hosts::DeleteWindow.new(@application, self, object)
+                  window.present
+                end
+              end
+            end
+
+
+            def bind_toolbar_button_start
+              button_start.tooltip_text = t('tooltip.tunnel.start')
+              button_start.signal_connect :clicked do
+                with_host_model do |object|
+                  object.start_tunnels!
+                  reload_hosts_treeview
+                end
+              end
+            end
+
+
+            def bind_toolbar_button_stop
+              button_stop.tooltip_text = t('tooltip.tunnel.stop')
+              button_stop.signal_connect :clicked do
+                with_host_model do |object|
+                  object.stop_tunnels!
+                  reload_hosts_treeview
+                end
+              end
+            end
+
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/common/translation_helper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module TranslationHelper
+          extend ActiveSupport::Concern
+
+          ruby2_keywords def t(*args)
+            I18n.t(*args)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/common/tree_view_helper.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module Common
+        module TreeViewHelper
+
+          def add_text_column(treeview, label, attributes)
+            renderer = Gtk::CellRendererText.new
+            add_column(treeview, renderer, label, attributes)
+          end
+
+
+          def add_image_column(treeview, label, attributes)
+            renderer = Gtk::CellRendererPixbuf.new
+            add_column(treeview, renderer, label, attributes)
+          end
+
+
+          def add_column(treeview, renderer, label, attributes)
+            visible  = attributes.delete(:visible) { true }
+            sortable = attributes.delete(:sortable) { true }
+
+            column = Gtk::TreeViewColumn.new(label, renderer, attributes)
+            column.visible = visible
+
+            if sortable
+              column.clickable = true
+              column.sort_column_id = attributes[:text] if attributes[:text]
+            end
+
+            treeview.append_column(column)
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/ssh-hull/ui/helpers/host_window_helper.rb

@@ -0,0 +1,230 @@
+# frozen_string_literal: true
+
+module SSHTunnel
+  module UI
+    module Helpers
+      module HostWindowHelper
+
+        include SSHTunnel::UI::Helpers::Common::ModalHelper
+        include SSHTunnel::UI::Helpers::Common::TranslationHelper
+        include SSHTunnel::UI::Helpers::Common::TreeViewHelper
+        include SSHTunnel::UI::Helpers::Common::FormHelper::InstanceMethods
+
+        def self.included(base)
+          base.extend(ClassMethods)
+          base.extend(SSHTunnel::UI::Helpers::Common::FormHelper::ClassMethods)
+        end
+
+        FORM_BUTTONS = %w[submit cancel add edit remove reset_identity_file].freeze
+        FORM_FIELDS  = {
+          name: {
+            type: :text,
+          },
+          user: {
+            type: :text,
+          },
+          host: {
+            type: :text,
+          },
+          port: {
+            type: :text,
+          },
+          identity_file: {
+            type: :file,
+          },
+        }.freeze
+
+
+        module ClassMethods
+
+          def init
+            bind_buttons(FORM_BUTTONS)
+            bind_form_fields(FORM_FIELDS.keys)
+            bind_template_child 'tunnels_scrolled_window'
+          end
+
+        end
+
+
+        def initialize(application, window, host)
+          super
+
+          # Set instance variables
+          @host = host
+
+          # Bind listeners
+          set_input_labels(scope: :host)
+          bind_host_buttons
+          bind_tunnels_buttons
+
+          # Load tunnels treeview
+          load_tunnels_treeview(@host)
+        end
+
+
+        def load_tunnels_treeview(host)
+          # create treeview
+          treeview_model    = create_tunnels_treeview_model(host.tunnels)
+          @tunnels_treeview = create_tunnels_treeview(treeview_model)
+
+          # Render treeview
+          tunnels_scrolled_window.add(@tunnels_treeview)
+          @tunnels_treeview.show
+        end
+
+
+        def reload_tunnels_treeview(host)
+          @tunnels_treeview.destroy
+          load_tunnels_treeview(host)
+        end
+
+
+        private
+
+
+          TUNNEL_UUID_COLUMN        = 0
+          TUNNEL_NAME_COLUMN        = 1
+          TUNNEL_TYPE_COLUMN        = 2
+          TUNNEL_LOCAL_HOST_COLUMN  = 3
+          TUNNEL_LOCAL_PORT_COLUMN  = 4
+          TUNNEL_REMOTE_HOST_COLUMN = 5
+          TUNNEL_REMOTE_PORT_COLUMN = 6
+          TUNNEL_AUTO_START_COLUMN  = 7
+
+
+          def create_tunnels_treeview_model(tunnels)
+            model = Gtk::ListStore.new(String, String, String, String, String, String, String, String)
+
+            tunnels.each do |tunnel|
+              iter = model.append
+              iter.set_values([tunnel.uuid, tunnel.name, tunnel.type, tunnel.local_host, tunnel.local_port, tunnel.remote_host, tunnel.remote_port, tunnel.auto_start?.to_s])
+            end
+
+            model
+          end
+
+
+          def create_tunnels_treeview(model)
+            treeview = Gtk::TreeView.new(model)
+
+            # edit tunnel on double-click
+            tunnels_treeview_bind_double_click(treeview)
+
+            # add columns to the tree view
+            tunnels_treeview_add_columns(treeview)
+
+            treeview
+          end
+
+
+          def tunnels_treeview_bind_double_click(treeview)
+            treeview.signal_connect :row_activated do |_widget, path|
+              if path.to_s.include?(':')
+                false
+              else
+                with_tunnel_model do |object|
+                  window = SSHTunnel::UI::Windows::Tunnels::EditWindow.new(application, self, object)
+                  window.present
+                end
+              end
+            end
+          end
+
+
+          def tunnels_treeview_add_columns(treeview)
+            add_text_column treeview, t('view.tunnel.uuid'),        text: TUNNEL_UUID_COLUMN, visible: false
+            add_text_column treeview, t('view.tunnel.name'),        text: TUNNEL_NAME_COLUMN
+            add_text_column treeview, t('view.tunnel.type'),        text: TUNNEL_TYPE_COLUMN
+            add_text_column treeview, t('view.tunnel.local_host'),  text: TUNNEL_LOCAL_HOST_COLUMN
+            add_text_column treeview, t('view.tunnel.local_port'),  text: TUNNEL_LOCAL_PORT_COLUMN
+            add_text_column treeview, t('view.tunnel.remote_host'), text: TUNNEL_REMOTE_HOST_COLUMN
+            add_text_column treeview, t('view.tunnel.remote_port'), text: TUNNEL_REMOTE_PORT_COLUMN
+            add_text_column treeview, t('view.tunnel.auto_start'),  text: TUNNEL_AUTO_START_COLUMN
+          end
+
+
+          def bind_host_buttons
+            button_reset_identity_file.label = t('button.reset')
+            button_reset_identity_file.tooltip_text = t('tooltip.host.reset_identity_file')
+            button_reset_identity_file.signal_connect :clicked do
+              input_identity_file.unselect_all
+            end
+          end
+
+
+          # rubocop:disable Metrics/MethodLength
+          def bind_tunnels_buttons
+            button_add.label = t('button.add')
+            button_add.tooltip_text = t('tooltip.tunnel.add')
+            button_add.signal_connect :clicked do
+              with_new_tunnel_model do |object|
+                window = SSHTunnel::UI::Windows::Tunnels::NewWindow.new(application, self, object)
+                window.present
+              end
+            end
+
+            button_edit.label = t('button.edit')
+            button_edit.tooltip_text = t('tooltip.tunnel.edit')
+            button_edit.signal_connect :clicked do
+              with_tunnel_model do |object|
+                window = SSHTunnel::UI::Windows::Tunnels::EditWindow.new(application, self, object)
+                window.present
+              end
+            end
+
+            button_remove.label = t('button.remove')
+            button_remove.tooltip_text = t('tooltip.tunnel.remove')
+            button_remove.signal_connect :clicked do
+              with_tunnel_model do |object|
+                window = SSHTunnel::UI::Windows::Tunnels::DeleteWindow.new(application, self, object)
+                window.present
+              end
+            end
+          end
+          # rubocop:enable Metrics/MethodLength
+
+
+          def all_tunnels
+            @host.tunnels
+          end
+
+
+          def find_tunnel_model
+            return nil if @tunnels_treeview.selection.selected.blank?
+
+            uuid = @tunnels_treeview.selection.selected.get_value(TUNNEL_UUID_COLUMN)
+            all_tunnels.find { |t| t.uuid == uuid }
+          end
+
+
+          def with_tunnel_model
+            object = find_tunnel_model
+            yield object if object
+          end
+
+
+          def with_new_tunnel_model
+            yield SSHTunnel::UI::Models::Tunnel.new(parent: @host)
+          end
+
+
+          def form_fields
+            FORM_FIELDS
+          end
+
+
+          def form_object
+            SSHTunnel::UI::Forms::HostForm.new(@host)
+          end
+
+
+          def save_and_reload_view
+            @application.config.save!
+            close
+            @window.reload_hosts_treeview
+          end
+
+      end
+    end
+  end
+end