open 0.1.30 → 0.2.22

data/lib/open/in_browser/in_browser.rb

@@ -4,6 +4,8 @@
 # =========================================================================== #
 # === Open::InBrowser
 #
+# This class has been re-written on the 16.06.2023.
+#
 # This class can be used to open something in the browser.
 #
 # The correct browser to use is, by default, the one that is stored in
@@ -18,8 +20,12 @@
 #   require 'open'
 #   Open::InBrowser.new(ARGV)
 #
+# Usage example:
+#
+#   Open::InBrowser.new(ARGV)
+#
 # =========================================================================== #
-# To open a remote webpage in firefox only, do:
+# To open a remote webpage in firefox only, you could use this code:
 #
 #   use_this_browser = 'firefox -new-tab'
 #    _ = use_this_browser
@@ -27,30 +33,39 @@
 #
 # =========================================================================== #
 # require 'open/in_browser/in_browser.rb'
+# Open.in_browser(ARGV)
+# Open::InBrowser.new(ARGV)
 # =========================================================================== #
 require 'open/base/base.rb'
 
 module Open
 
-class InBrowser < Base # === Open::InBrowser
+class InBrowser < ::Open::Base # === Open::InBrowser
 
   begin
     require 'studium/requires/return_remote_homepage_of_this_lecture.rb'
   rescue LoadError; end
 
+  # ========================================================================= #
+  # === ARRAY_TOKENS_THAT_REQUIRE_PADDING
+  # ========================================================================= #
+  ARRAY_TOKENS_THAT_REQUIRE_PADDING = ['#',';','(','&',')']
+
   # ========================================================================= #
   # === initialize
   #
-  # The first argument becomes the target URL that will be opened.
+  # The target URLs to be opened will be stored in the first argument,
+  # called commandline_arguments.
   # ========================================================================= #
   def initialize(
-      target_url  = '',
-      run_already = true
+      commandline_arguments = ARGV,
+      run_already           = true,
+      &block
     )
     register_sigint
     reset
-    set_target_url(
-      target_url
+    set_commandline_arguments(
+      commandline_arguments
     )
     # ======================================================================= #
     # === Handle blocks given next
@@ -65,12 +80,21 @@ class InBrowser < Base # === Open::InBrowser
       # part of the opened URL.
       # ===================================================================== #
       when :no_localhost
-        @internal_hash[:use_localhost_URLs] = false
+        do_not_use_localhost
       # ===================================================================== #
       # === :try_to_use_localhost_URLs
       # ===================================================================== #
       when :try_to_use_localhost_URLs
-        @internal_hash[:use_localhost_URLs] = true
+        do_use_localhost
+      # ===================================================================== #
+      # === be_silent
+      #
+      # This entry point will make this class be quiet, that is, not display
+      # the actual command that is used.
+      # ===================================================================== #
+      when :be_silent,
+           :be_quiet
+        do_not_show_the_sys_command_that_is_used
       # ===================================================================== #
       # === :open_in_background
       # ===================================================================== #
@@ -81,20 +105,11 @@ class InBrowser < Base # === Open::InBrowser
       #
       # This clause can be entered by code such as the following:
       #
-      #   Open.open_in_browser(port: 8080,) { :use_launchy }
+      #   Open.in_browser(port: 8080) { :use_launchy }
       #
       # ===================================================================== #
       when :use_launchy
         set_use_launchy(true)
-      # ===================================================================== #
-      # === be_silent
-      #
-      # This entry point will make this class be quiet, that is, not display
-      # the actual command that is used.
-      # ===================================================================== #
-      when :be_silent,
-           :be_quiet
-        @internal_hash[:show_the_sys_command_that_is_used] = false
       else
         # =================================================================== #
         # Handle Hashes next:
@@ -111,9 +126,25 @@ class InBrowser < Base # === Open::InBrowser
           if yielded.has_key? :use_this_browser
             set_use_this_browser(yielded[:use_this_browser])
           end
+          # ================================================================= #
+          # === :remaining_commandline_arguments
+          # ================================================================= #
+          if yielded.has_key? :remaining_commandline_arguments
+            _ = yielded[:remaining_commandline_arguments]
+            if _
+              append_array_to_commandline_arguments(_)
+            end
+          end
         end
       end
     end
+    case run_already
+    # ======================================================================= #
+    # === :do_not_run_yet
+    # ======================================================================= #
+    when :do_not_run_yet
+      run_already = false
+    end
     run if run_already
   end
 
@@ -121,7 +152,6 @@ class InBrowser < Base # === Open::InBrowser
   # === reset                                                     (reset tag)
   # ========================================================================= #
   def reset
-    super()
     # ======================================================================= #
     # === @internal_hash
     # ======================================================================= #
@@ -131,12 +161,16 @@ class InBrowser < Base # === Open::InBrowser
     #
     # This variable will keep track as to which browser will be used.
     # ======================================================================= #
-    @internal_hash[:use_this_browser] = ::Open.use_which_browser?
+    @internal_hash[:use_this_browser] = determine_which_browser_to_use_then_return_the_result
     # ======================================================================= #
     # === :open_in_background
     # ======================================================================= #
     @internal_hash[:open_in_background] = false
     # ======================================================================= #
+    # === :show_the_sys_command_that_is_used
+    # ======================================================================= #
+    @internal_hash[:show_the_sys_command_that_is_used] = true
+    # ======================================================================= #
     # === :use_launchy
     #
     # This variable will make use of the launchy gem rather than the
@@ -144,54 +178,53 @@ class InBrowser < Base # === Open::InBrowser
     # way, in particular for windows, to open remote URLs. That way
     # we can query for the windows operating system and silently
     # delegate onto the launchy gem, if need be. The default value
-    # is false, though, so most users of this class have to enable
-    # this on their own.
+    # for this setting is false, though, so most users of this
+    # class have to enable this on their own.
     # ======================================================================= #
     @internal_hash[:use_launchy] = false
     # ======================================================================= #
-    # === :show_the_sys_command_that_is_used
+    # === :work_on_these_URLs
+    #
+    # The following variable must be kept as Array at all times.
     # ======================================================================= #
-    @internal_hash[:show_the_sys_command_that_is_used] = true
+    @internal_hash[:work_on_these_URLs] = []
     # ======================================================================= #
     # === :append_this_string
     # ======================================================================= #
     @internal_hash[:append_this_string] = ''.dup
     # ======================================================================= #
-    # === :use_localhost_URLs
+    # === :use_localhost
+    #
+    # If this variable is true then we will try to use 'localhost'
+    # entries, at the least on roebe-system.
     #
-    # By default we will not use localhost-URLs. If we are on a roebe-system,
-    # however had, we will use localhost URLs.
+    # By default the class will try to use localhost-URLs. Use the
+    # commandline flag --do-not-use-localhost if you dislike or
+    # do not need this feature.
     # ======================================================================= #
-    @internal_hash[:use_localhost_URLs] = false
+    @internal_hash[:use_localhost] = true
   end
 
   # ========================================================================= #
-  # === set_open_in_background
+  # === do_use_localhost
   # ========================================================================= #
-  def set_open_in_background(i = true)
-    @internal_hash[:open_in_background] = i
+  def do_use_localhost
+    @internal_hash[:use_localhost] = true
   end
 
   # ========================================================================= #
-  # === set_use_launchy
+  # === do_not_use_localhost
   # ========================================================================= #
-  def set_use_launchy(i = false)
-    @internal_hash[:use_launchy] = i
+  def do_not_use_localhost
+    @internal_hash[:use_localhost] = false
   end
 
   # ========================================================================= #
-  # === show_the_sys_command_that_is_used?
+  # === use_localhost?
   # ========================================================================= #
-  def show_the_sys_command_that_is_used?
-    @internal_hash[:show_the_sys_command_that_is_used]
-  end
-
-  # ========================================================================= #
-  # === use_launchy?
-  # ========================================================================= #
-  def use_launchy?
-    @internal_hash[:use_launchy]
-  end
+  def use_localhost?
+    @internal_hash[:use_localhost]
+  end; alias use_localhost_URLs? use_localhost? # === use_localhost_URLs?
 
   # ========================================================================= #
   # === check_for_intralink
@@ -204,10 +237,9 @@ class InBrowser < Base # === Open::InBrowser
       use_this_token_to_replace_empty_spaces = '_'
     )
     if i
-      if i.is_a? Array
-        i = i.join(' ').tr(' ', use_this_token_to_replace_empty_spaces)
-      end
+      i = i.join(' ') if i.is_a? Array
       i = i.to_s # Ensure that we have a String at this point.
+      i.tr!(' ', use_this_token_to_replace_empty_spaces) if i.include?(' ')
       unless i.empty?
         @internal_hash[:append_this_string] << i
       end
@@ -215,132 +247,41 @@ class InBrowser < Base # === Open::InBrowser
   end
 
   # ========================================================================= #
-  # === set_target_url                                              (URL tag)
-  #
-  # We prefer this to be an Array.
-  #
-  # Usage example:
-  #
-  #   Open::InBrowser.new('https://blog.fefe.de/') { :use_launchy }
-  #   Open::InBrowser.new('blog.fefe.de') { :use_launchy }
-  #
+  # === append_this_string?
   # ========================================================================= #
-  def set_target_url(
-      i = ''
-    )
-    if i.is_a? Array # This if-clause was added in May 2022.
-      i = i.join(' ').strip
-    end
-    possible_array = beautiful_url(i)
-    case i
-    # ======================================================================= #
-    # === rf HERE
-    # ======================================================================= #
-    when /HERE/
-      i = File.basename(return_pwd)
-      if is_on_roebe?
-        i = Studium.return_remote_homepage_of_this_lecture(i)
-      end
-    end
-    if possible_array.is_a?(Array) and (possible_array.size > 1)
-      i = possible_array
-    else
-      if i.is_a? Hash
-        # =================================================================== #
-        # === :use_launchy
-        # =================================================================== #
-        if i.has_key? :use_launchy
-          set_use_launchy(i.delete(:use_launchy))
-        end
-        # =================================================================== #
-        # === :with_localhost
-        #
-        # Example for this entry point:
-        #
-        #   Open::InBrowser.new(with_localhost: PORT_TO_USE)
-        #
-        # =================================================================== #
-        if i.has_key?(:with_localhost) and use_localhost_URLs?
-          i = "http://localhost:#{i.delete(:with_localhost)}/"
-        # =================================================================== #
-        # === :port
-        #
-        # Example for this entry point:
-        #
-        #   Open::InBrowser[port: 8080]
-        #
-        # =================================================================== #
-        elsif i.has_key? :port
-          i = "http://localhost:#{i.delete(:port)}/"
-        end
-      end
-    end
-    i = [i] unless i.is_a? Array
-    i.flatten! if i.is_a? Array
-    # ======================================================================= #
-    # Work over all members of this Array next.
-    # ======================================================================= #
-    i.map! {|entry|
-      case entry
-      when :default_sinatra_port
-        entry = 'http://localhost:4567/'
-      end
-      if Object.const_defined? :Studium
-        possible_link = Studium.return_remote_homepage_of_this_lecture(entry)
-        if possible_link == entry
-        else
-          entry = possible_link
-        end
-      end
-      if ::BeautifulUrl.is_a_local_link?(entry)
-        entry = ::BeautifulUrl.local_menu(entry)
-      else
-        entry = beautiful_url(entry).dup
-      end
-      entry = entry.first if entry.is_a? Array
-      if entry and File.exist?(entry)
-        entry = File.absolute_path(entry)
-      end
-      if entry and entry.start_with?('/home/x/') and !entry.include?('images/') and use_localhost_URLs?
-        entry.sub!(/\/home\/x\//,'http://localhost/')
-      end
-      # ===================================================================== #
-      # Perform some sanitize-operations next.
-      # ===================================================================== #
-      if entry and
-        ((entry.include?("'") and !entry.include?('"')) or
-          entry.include?(' ')
-        )
-        entry = '"'+entry+'"'
-      elsif entry and (entry.include?(';') or entry.include?('('))
-        entry = '"'+entry+'"'
-      end
-      unless entry and File.exist?(entry)
-        # =================================================================== #
-        # Try a trailing glob next. The idea here is to expand from e. g.
-        # "image3" towards "image3.jpg", if the latter file exists, and
-        # the former does NOT exist.
-        # =================================================================== #
-        possible_matches = Dir["#{entry}*"]
-        unless possible_matches.empty?
-          first = possible_matches.first
-          if File.exist? first
-            entry = first
-          end
-        end
-      end
-      entry
-    }
-    @internal_hash[:target_url] = i
+  def append_this_string?
+    @internal_hash[:append_this_string]
   end
 
   # ========================================================================= #
   # === target_url?
   # ========================================================================= #
   def target_url?
-    @internal_hash[:target_url]
-  end; alias target_URL? target_url? # === target_URL?
-       alias remote_URL? target_url? # === remote_URL?
+    @internal_hash[:work_on_these_URLs]
+  end; alias target_URL?         target_url? # === target_URL?
+       alias remote_URL?         target_url? # === remote_URL?
+       alias work_on_these_URLs? target_url? # === work_on_these_URLs?
+
+  # ========================================================================= #
+  # === set_use_launchy
+  # ========================================================================= #
+  def set_use_launchy(i = false)
+    @internal_hash[:use_launchy] = i
+  end
+
+  # ========================================================================= #
+  # === use_launchy?
+  # ========================================================================= #
+  def use_launchy?
+    @internal_hash[:use_launchy]
+  end
+
+  # ========================================================================= #
+  # === do_not_show_the_sys_command_that_is_used
+  # ========================================================================= #
+  def do_not_show_the_sys_command_that_is_used
+    @internal_hash[:show_the_sys_command_that_is_used] = false
+  end
 
   # ========================================================================= #
   # === first_remote_URL?
@@ -349,6 +290,51 @@ class InBrowser < Base # === Open::InBrowser
     remote_URL?.first
   end
 
+  # ========================================================================= #
+  # === open_in_background?
+  # ========================================================================= #
+  def open_in_background?
+    @internal_hash[:open_in_background]
+  end
+
+  # ========================================================================= #
+  # === set_open_in_background
+  # ========================================================================= #
+  def set_open_in_background(
+      i = true
+    )
+    @internal_hash[:open_in_background] = i
+  end
+
+  # ========================================================================= #
+  # === show_the_sys_command_that_is_used?
+  # ========================================================================= #
+  def show_the_sys_command_that_is_used?
+    @internal_hash[:show_the_sys_command_that_is_used]
+  end
+
+  # ========================================================================= #
+  # === determine_which_browser_to_use_then_return_the_result
+  # ========================================================================= #
+  def determine_which_browser_to_use_then_return_the_result
+    result = ::Open.use_which_browser? # Use the generic browser by default here.
+    if result.nil?
+      result = file_load_default_browser?
+    end
+    if is_on_windows?
+      case result
+      # ===================================================================== #
+      # === palemoon
+      # ===================================================================== #
+      when 'palemoon'
+        result.prepend(
+          "C:\\Program Files\\Pale Moon\\palemoon.exe"
+        )
+      end
+    end
+    return result
+  end
+
   # ========================================================================= #
   # === set_use_this_browser
   # ========================================================================= #
@@ -366,167 +352,344 @@ class InBrowser < Base # === Open::InBrowser
   end
 
   # ========================================================================= #
-  # === open_in_background?
+  # === menu                                                       (menu tag)
   # ========================================================================= #
-  def open_in_background?
-    @internal_hash[:open_in_background]
+  def menu(i)
+    if i.is_a? Array
+      i.each {|entry| menu(entry) }
+    else
+      case i
+      # ===================================================================== #
+      # === rf --do-use-localhost
+      # ===================================================================== #
+      when /^-?-?do(-|_)?use(-|_)?localhost$/i,
+           /^-?-?localhost$/i
+        do_use_localhost
+      # ===================================================================== #
+      # === rf --do-not-use-localhost
+      # ===================================================================== #
+      when /^-?-?do(-|_)?not(-|_)?use(-|_)?localhost$/i,
+           /^-?-?no(-|_)?localhost$/i
+        do_not_use_localhost
+      # ===================================================================== #
+      # === rf HERE
+      #
+      # This entry point is mostly only useful on my home system, where
+      # the instruction "rf HERE" will delegate towards the Studium
+      # namespace.
+      # ===================================================================== #
+      when /HERE/
+        i = File.basename(return_pwd)
+        if is_on_roebe?
+          i = Studium.return_remote_homepage_of_this_lecture(i)
+          @internal_hash[:work_on_these_URLs].each_with_index {|inner_entry, index|
+            case inner_entry
+            when /^HERE$/
+              @internal_hash[:work_on_these_URLs][index] = i
+            end
+          }
+        end
+      end
+    end
   end
 
   # ========================================================================= #
-  # === append_this_string?
+  # === could_there_be_a_potential_local_file_for?
   # ========================================================================= #
-  def append_this_string?
-    @internal_hash[:append_this_string]
+  def could_there_be_a_potential_local_file_for?(i)
+    # ======================================================================= #
+    # Try a trailing glob next. The idea here is to expand from e. g.
+    # "image3" towards "image3.jpg", if the latter file exists, and
+    # the former does NOT exist.
+    # ======================================================================= #
+    all_files = Dir["#{i}*"]
+    !all_files.empty?
   end
 
   # ========================================================================= #
-  # === use_localhost_URLs?
+  # === sanitize_work_on_these_URLs
   # ========================================================================= #
-  def use_localhost_URLs?
-    @internal_hash[:use_localhost_URLs]
+  def sanitize_work_on_these_URLs
+    if @internal_hash[:work_on_these_URLs]
+      @internal_hash[:work_on_these_URLs].map! {|entry|
+        # =================================================================== #
+        # First handle the case where we have a local link.
+        # =================================================================== #
+        if BeautifulUrl.is_a_local_link?(entry) and !File.exist?(entry)
+          entry = BeautifulUrl.local_menu(entry)
+        end
+        entry
+      }
+    end
   end
 
   # ========================================================================= #
-  # === open_in_browser
+  # === work_through_all_designated_URLs
   #
-  # This is the part that does the actual file-opening via the browser.
+  # This is the method that will batch-process the given input (as Array).
   # ========================================================================= #
-  def open_in_browser(
-      optional_append_this_string = append_this_string?
+  def work_through_all_designated_URLs(
+      i = @internal_hash[:work_on_these_URLs]
     )
-    _ = LOCATION_OF_BROWSER_YAML_FILE
-    browser = use_this_browser? # Use the generic browser by default.
+    i.each {|this_argument|
+      do_process_this_target_URL(this_argument)
+    }
+  end
+
+  # ========================================================================= #
+  # === do_process_this_target_URL                        (URL tag, main tag)
+  #
+  # This is the main method for this class - it will handle all given
+  # input properly.
+  # ========================================================================= #
+  def do_process_this_target_URL(
+      i,
+      optional_append_this_string = append_this_string?,
+      &block
+    )
+    i = i.first if i.is_a? Array # This is not necessary, but just in case.
+    if block_given?
+      yielded = yield
+      case yielded
+      # ===================================================================== #
+      # === :use_launchy
+      # ===================================================================== #
+      when :use_launchy
+        set_use_launchy(yielded.delete(:use_launchy))
+      end
+    end
+    if i.is_a? Symbol
+      case i
+      # ===================================================================== #
+      # === :default_sinatra_port
+      # ===================================================================== #
+      when :default_sinatra_port
+        i = 'http://localhost:4567/'
+      else
+        i = BeautifulUrl.menu(i)
+      end
+    end
+    if i.is_a? Array # This if-clause was added in May 2022.
+      i = i.join(' ').strip
+    end
+    if i.include?(' # ') # e. g. "https://moodle.univie.ac.at/course/view.php?id=415670 # 2023W"
+      i = i.split(' # ').first.to_s.strip
+    end
     # ======================================================================= #
-    # We must check first whether the file exists or not.
+    # The next clause may remove '#'. However had, this is not always a
+    # good idea, as these are also linked for intralinks - so for now this
+    # was changed June 2023. But, if the file exists locally, then we will
+    # simply prepend "file://" instead.
     # ======================================================================= #
-    if File.exist? _
-      browser = YAML.load_file(_).strip.dup # This variable holds which browser to use.
-      if is_on_windows?
-        case browser
-        # =================================================================== #
-        # === palemoon
-        # =================================================================== #
-        when 'palemoon'
-          browser.prepend(
-            "C:\\Program Files\\Pale Moon\\palemoon.exe"
-          )
+    if i.include?('#')
+      raw_file = i[0 .. (i.index('#') - 1)]
+      if File.exist?(raw_file)
+        i = i.dup
+        i.prepend('file://')
+      end
+    end
+    if optional_append_this_string.size > 0
+      # ===================================================================== #
+      # We prepend the '#' character before appending it, unless
+      # it starts with the '?' character.
+      # ===================================================================== #
+      unless optional_append_this_string.start_with? '?'
+        optional_append_this_string.prepend '#'
+      end
+      i = i.dup if i.frozen?
+      i << optional_append_this_string
+    end if optional_append_this_string
+    # ======================================================================= #
+    # We must check first whether the target file at hand exists or not.
+    # ======================================================================= #
+    if i.is_a?(String) and File.exist?(i)
+      unless i.include?('/')
+        i = File.absolute_path(i) # Always use the absolute path in this case.
+        if use_localhost? and
+           i.start_with?(HOME_DIRECTORY_OF_USER_X)
+          i.sub!(/#{HOME_DIRECTORY_OF_USER_X}/, 'http://localhost/')
         end
       end
+      open_this_in_the_browser(i) # If it exists then we can open it directly here.
+    else
       # ===================================================================== #
-      # Different browsers have different ways to open a new tab.
+      # First find out whether there could be a local file for this input.
+      #
+      # For instance, the input "image3" could match towards "image3.jpg".
+      # So if a file called "image3.jpg" were to exist locally then we
+      # will prioritize it next - that is the main point for the
+      # following clause.
       # ===================================================================== #
-      if browser.include? 'opera' # Perform some sanitizing in this case.
-        browser << ' -newtab'
+      if could_there_be_a_potential_local_file_for?(i)
+        i = Dir["#{i}*"].first
+      elsif is_beautiful_url_available?
+        # =================================================================== #
+        # else we will simply try to fetch an entry from BeautifulUrl.
+        # =================================================================== #
+        new_link = BeautifulUrl.menu(i)
+        case new_link
+        when i, nil
+          # ================================================================= #
+          # All is fine in this case.
+          # ================================================================= #
+        else
+          i = new_link
+        end
+      end
+      open_this_in_the_browser(i)
+    end
+  end
+
+  # ========================================================================= #
+  # === open_this_in_the_browser
+  #
+  # Usage example:
+  #
+  #   Open.in_browser('https://blog.fefe.de/') { :use_launchy }
+  #   Open.in_browser('blog.fefe.de') { :use_launchy }
+  #
+  # ========================================================================= #
+  def open_this_in_the_browser(i)
+    if i.is_a? Array
+      i.each {|entry| open_this_in_the_browser(entry) }
+    else
+      if i.is_a? Hash
         # =================================================================== #
-        # Or alternatively:
+        # === :with_localhost
+        #
+        # Example for this entry point:
         #
-        #   opera --remote 'openURL(<url>, new-page)'
+        #   Open::InBrowser.new(with_localhost: PORT_TO_USE)
         #
         # =================================================================== #
-      elsif browser.include? 'firefox'
-        browser << ' -new-tab'
-      elsif browser.include?('chromium') or
-            browser.include?('thorium') or
-            browser.include?('chrome')
+        if i.has_key?(:with_localhost) and use_localhost_URLs?
+          i = "http://localhost:#{i.delete(:with_localhost)}/"
         # =================================================================== #
-        # This is for chromium-based browsers, including chrome.
+        # === :port
+        #
+        # Example for this entry point:
+        #
+        #   Open::InBrowser[port: 8080]
+        #
         # =================================================================== #
-        browser << ' --no-sandbox --app-url '
+        elsif i.has_key? :port
+          i = "http://localhost:#{i.delete(:port)}/"
+        end
+      end
+      i = i.dup if i.frozen?
+      if i and i.include?('→')
+        i.delete!('→')
+        i.strip!
       end
-      [target_url?].flatten.each {|entry|
-        entry = entry.to_s.dup # .dup to avoid that it may be frozen.
-        real_filename = entry.dup
-        if real_filename.include?('#')
-          real_filename = real_filename[0 .. (real_filename.index('#')-1)]
+      if i.end_with?('.cgi')
+        if is_on_roebe? and
+           Dir.pwd.include?('/home/x/') and
+           !i.include?('/')
+          i = File.absolute_path(i)
         end
-        if optional_append_this_string.size > 0
-          # ================================================================= #
-          # We prepend the '#' character, unless it starts with the
-          # '?' character.
-          # ================================================================= #
-          unless optional_append_this_string.start_with? '?'
-            optional_append_this_string.prepend '#'
+        i.delete_prefix!(HOME_DIRECTORY_OF_USER_X)
+        if use_localhost?
+          i.prepend('http://localhost/') unless i.start_with?('http://localhost/')
+        else
+          if beautiful_url_is_available? and is_on_roebe?
+            i.prepend(HOME_DIRECTORY_OF_USER_X) unless i.start_with?(HOME_DIRECTORY_OF_USER_X)
           end
-          entry << optional_append_this_string
         end
+      end
+      unless i.empty?
+        # =================================================================== #
+        # Perform some sanitize-operations next.
+        # =================================================================== #
+        if ARRAY_TOKENS_THAT_REQUIRE_PADDING.any? {|this_token| i.include?(this_token) }
+          i = '"'+i+'"' unless i.start_with?('"')
+        end
+        cmd_to_use = "#{use_this_browser?}".dup
         # =================================================================== #
-        # Next, specifically handle the situation on my home system, when
-        # we are in a directory that includes a substring such as
-        # '/home/x/data/' and if the target file name ends with '.cgi'.
+        # Next, we must determine which options to pass to the browser at
+        # hand. Each browser may be different - for instance, firefox
+        # responds to a different set of commandline flags compared to
+        # chrome, and so forth.
         # =================================================================== #
-        if is_on_roebe? and
-           entry.end_with?('.cgi') and # Modify .cgi files
-          !entry.start_with?('http') and
-          !entry.start_with?('http://localhost/')
-          if return_pwd.include?(DATA_DIRECTORY_AT_HOME)
-            # ================================================================= #
-            # We need a target URL such as:
-            #   http://localhost/data/games/AITD/AITD.cgi
-            # in this case.
-            # ================================================================= #
-            unless entry.include? DATA_DIRECTORY_AT_HOME
-              entry.prepend(return_pwd)
-            end
-            entry.squeeze!('/')
-            quoted_regexp = Regexp.quote(DATA_DIRECTORY_AT_HOME)
-            entry.sub!(quoted_regexp, 'http://localhost/data/') if use_localhost_URLs?
-          elsif return_pwd.include?(PROGRAMMING_LANGUAGES_DIRECTORY_AT_HOME)
-            unless entry.include? PROGRAMMING_LANGUAGES_DIRECTORY_AT_HOME
-              entry.prepend(return_pwd)
-            end
-            entry.squeeze!('/')
-            quoted_regexp = Regexp.quote(PROGRAMMING_LANGUAGES_DIRECTORY_AT_HOME)
-            entry.sub!(quoted_regexp, 'http://localhost/programming/') if use_localhost_URLs?
-          end
+        case cmd_to_use
+        # =================================================================== #
+        # This is for chromium-based browsers, including thorium and chrome.
+        # =================================================================== #
+        when 'chromium',
+             /thorium$/i,
+             /chrome$/i
+          cmd_to_use << ' --no-sandbox --app-url'
+        # =================================================================== #
+        # Handle firefox next:
+        # =================================================================== #
+        when 'firefox'
+          cmd_to_use << ' -new-tab'
+        # =================================================================== #
+        # Handle opera next:
+        # =================================================================== #
+        when 'opera' # Perform some sanitizing in this case.
+          cmd_to_use << ' -newtab'
+          # ================================================================= #
+          # Or an alternative to the above would be:
+          #
+          #   opera --remote 'openURL(<url>, new-page)'
+          #
+          # I am not sure which variant to prefer, so I kind of chose one
+          # randomly for now.
+          # ================================================================= #
         end
+        # if cmd_to_use.include?(' ')
+        #   # ================================================================= #
+        #   # Pad it in this case:
+        #   # ================================================================= #
+        #   i = '"'+i.to_s+'"'
+        # end
+        cmd_to_use << " #{i}"
+        # =================================================================== #
+        # Finally pass it into the designated browser.
+        # =================================================================== #
         if open_in_background?
-          entry << '&'
-        end
-        if File.exist?(real_filename) and
-           !real_filename.start_with?('file://') and
-           !entry.include?('http://localhost/')
-          entry = entry.dup
-          entry.prepend('file://')
+          cmd_to_use << ' &'
         end
-        if entry.include? '&'
-          entry = '"'+entry+'"' unless entry.start_with? '"'
+        # =================================================================== #
+        # Check for the launchy gem next.
+        # =================================================================== #
+        if use_launchy?
+          cmd_to_use.prepend('launchy ')
         end
         # =================================================================== #
         # Handle windows next:
         # =================================================================== #
         if is_on_windows?
-          # start firefox -new-tab www.howtogeek.com
-          this_command = "start #{browser} -new-tab #{entry}"
-        else
-          this_command = "#{browser} #{entry}"
-        end
-        if show_the_sys_command_that_is_used?
-          e this_command
-        end
-        unless entry.empty?
           # ================================================================= #
-          # Finally run the system-command, unless we will use the
-          # launchy gem.
+          # Usage example for windows:
+          #
+          #   start firefox -new-tab www.howtogeek.com
+          #
           # ================================================================= #
-          if use_launchy?
-            cmd_to_use = 'launchy '+entry.to_s
-            e cmd_to_use
-            system(cmd_to_use)
-          else
-            system(this_command) # Here we always output.
-          end
+          cmd_to_use = cmd_to_use.dup if cmd_to_use.frozen?
+          cmd_to_use.prepend('start ')
         end
-      } unless target_url?.nil?
-    else
-      browser = 'firefox' # Else, default to this here as a generic fallback.
+        if show_the_sys_command_that_is_used?
+          e "#{rev}#{cmd_to_use}"
+        end
+        system "#{cmd_to_use}"
+      end
     end
-  end
+  end; alias open_in_browser open_this_in_the_browser # === open_in_browser
 
   # ========================================================================= #
   # === run                                                         (run tag)
   # ========================================================================= #
-  def run 
-    open_in_browser
+  def run
+    @internal_hash[:work_on_these_URLs] = commandline_arguments?
+    menu(
+      @internal_hash[:work_on_these_URLs]
+    )
+    @internal_hash[:work_on_these_URLs].reject! {|entry|
+      entry.start_with?('--') # Reject entries that start with '--'.
+    }
+    sanitize_work_on_these_URLs
+    work_through_all_designated_URLs
   end
 
   # ========================================================================= #
@@ -538,57 +701,75 @@ class InBrowser < Base # === Open::InBrowser
 
 end
 
+# =========================================================================== #
+# === Open.in_browser
+#
+# This method will always join the input-argument before passing it
+# to the class.
+#
+# Note that the behaviour of Open.in_browser() is in-sync with the
+# method Open.in_editor(), in regards to joinable arguments
+# (typically an Array as input). If you do not want this behaviour
+# then you may have to prepare for this in your own code, such
+# as by having an Array and iterating over it before passing
+# the individual entries into Open.in_browser().
+#
+# Note that this method needs to be somewhat flexible, as we can provide
+# varied input such as shown in the following examples:
+#
+#   Open.open_in_browser(port: 8080)
+#   Open.in_browser(remote_URL) {{ use_this_browser: :firefox }}
+#   Open.in_browser(:default_sinatra_port)
+#
+# =========================================================================== #
+def self.in_browser(
+    i = ARGV,
+    &block
+  )
+  if i.respond_to? :join
+    # ======================================================================= #
+    # This will only join entries that do not start with '--'.
+    # ======================================================================= #
+    entries_that_start_with_hyphens = i.select {|entry| entry.start_with?('--') }
+    i.reject! {|entry| entry.start_with?('--') }
+    new_array = []
+    new_array << i.join(' ').strip
+    new_array << entries_that_start_with_hyphens unless entries_that_start_with_hyphens.empty?
+    i = new_array
+  end
   # ========================================================================= #
-  # === Open.open_in_browser
-  #
-  # Note that this method needs to be somewhat flexible, as we can provide
-  # varied input such as:
-  #
-  #   Open.open_in_browser(port: 8080)
-  #   Open.in_browser(remote_URL) {{ use_this_browser: :firefox }}
-  #
+  # === Handle blocks next
   # ========================================================================= #
-  def self.open_in_browser(
-      i = ARGV,
-      &block
-    )
+  if block_given?
+    yielded = yield
     # ======================================================================= #
-    # === Handle blocks next
+    # === Handle Hashes next
     # ======================================================================= #
-    if block_given?
-      yielded = yield
+    if yielded.is_a? Hash
       # ===================================================================== #
-      # === Handle Hashes next
+      # === :delay
       # ===================================================================== #
-      if yielded.is_a? Hash
-        # =================================================================== #
-        # === Handle Hashes past this point
-        # =================================================================== #
-        # =================================================================== #
-        # === :delay
-        # =================================================================== #
-        if yielded.has_key? :delay
-          _ = yielded.delete(:delay)
-          if _.is_a? String
-            _ = _.sub(/ seconds/,'')
-            _ = _.sub(/ second/,'').to_f if _.include? ' second'
-            _ = _.to_f # Need a Float.
-          end
-          sleep(_)
+      if yielded.has_key? :delay
+        _ = yielded.delete(:delay)
+        if _.is_a? String
+          _ = _.sub(/ seconds/,'')
+          _ = _.sub(/ second/,'').to_f if _.include? ' second'
+          _ = _.to_f # Need a Float.
         end
+        sleep(_)
       end
-    # else
     end
-    ::Open::InBrowser.new(i, &block)
-  end; self.instance_eval { alias in_browser open_in_browser } # === Open.in_browser
-       self.instance_eval { alias open       open_in_browser } # === Open.open
+  end
+  return ::Open::InBrowser.new(i, &block)
+end; self.instance_eval { alias open_in_browser in_browser } # === Open.open_in_browser
+     self.instance_eval { alias open_browser    in_browser } # === Open.open_browser
 
 end
 
 # =========================================================================== #
 # === open_in_browser
 #
-# This method will open an URL in firefox.
+# This method will open an URL via the browser.
 #
 # Usage example in pure Ruby:
 #
@@ -603,12 +784,13 @@ def open_in_browser(
   # ========================================================================= #
   # Next, open the class that we defined above in this file here.
   # ========================================================================= #
-  _ = Open::InBrowser.new(url, false, &block)
+  _ = Open.in_browser(url, :do_not_run_yet, &block)
   _.check_for_intralink(optional_intralink)
   _.run
 end; alias oib open_in_browser # oib shortcut.
 
 if __FILE__ == $PROGRAM_NAME
-  open_in_browser(ARGV.first)
+  Open.in_browser(ARGV)
 end # inbrowser
-    # inbrowser https://distrowatch.com/dwres.php?resource=ratings&distro=antix
+    # inbrowser "https://distrowatch.com/dwres.php?resource=ratings&distro=antix"
+    # inbrowser /home/x/Temp/studium/html/timetable.html#today