open 0.1.30 → 0.2.22

data/lib/open/in_editor/in_editor.rb

@@ -6,12 +6,16 @@
 #
 # This class can specifically be used to open a local file via your 
 # favourite editor. This is admittedly more useful for GUI-based editors
-# such as "geany" or "gedit" than, say, "vim" or "nano".
+# such as "geany" or "gedit" than, say, "vim" or "nano". Nonetheless
+# I also use this class as base-class for class Open::NanoOpen - that is,
+# opening a local file via the nano editor.
 #
-# If the file was not found, and BeautifulUrl is available, then it will
-# be called, to see whether that leads to a file that can be found, and
-# if it still can not be found than "dfind" is used, which is based on
-# "locate / updatedb".
+# If the file at hand was not found, and BeautifulUrl is available, then this
+# class will tap into the functionality made available by BeautifulUrl, in
+# order to see whether that leads to a file that can be found. If the file
+# can not be found then "dfind" will be tried, as last attempt, which in
+# turn is based on "locate / updatedb" - so it only works on Linux systems
+# really or some UNIX-variants.
 #
 # Usage example:
 #
@@ -33,20 +37,28 @@ class InEditor < Base # === Open::InEditor
   # The first argument should be the name of the file that we wish to open.
   # ========================================================================= #
   def initialize(
-      i           = nil,
-      run_already = true
+      commandline_arguments = ARGV,
+      run_already           = true
     )
     register_sigint
     reset
-    set_input(i)
+    commandline_arguments = [commandline_arguments].flatten.compact
+    set_commandline_arguments(
+      commandline_arguments
+    )
+    set_work_on_these_files(
+      commandline_arguments.reject {|entry|
+        entry.start_with?('--')
+      }
+    )
     # ======================================================================= #
     # === Handle blocks next
     # ======================================================================= #
     if block_given?
       yielded = yield
-      # ===================================================================== #
+      # ======================================================================= #
       # === Handle Hashes next
-      # ===================================================================== #
+      # ======================================================================= #
       if yielded.is_a? Hash
         # =================================================================== #
         # === :use_this_editor
@@ -61,7 +73,7 @@ class InEditor < Base # === Open::InEditor
         # =================================================================== #
         if yielded.has_key? :this_file
           _ = yielded[:this_file]
-          set_input(_)
+          set_work_on_these_files(_)
         end
       end
     end
@@ -73,158 +85,377 @@ class InEditor < Base # === Open::InEditor
   # ========================================================================= #
   def reset
     super()
+    infer_the_namespace
+    # ======================================================================= #
+    # === @internal_hash
     # ======================================================================= #
-    # === @use_this_editor
+    reset_the_internal_hash
     # ======================================================================= #
-    @use_this_editor = use_which_editor?
+    # === :use_this_editor
+    # ======================================================================= #
+    set_use_this_editor(:use_the_default_editor_from_the_yaml_file)
+    # ======================================================================= #
+    # === :work_on_these_files
+    #
+    # This variable must be nil initially.
+    # ======================================================================= #
+    @internal_hash[:work_on_these_files] = nil
   end
 
   # ========================================================================= #
-  # === use_this_editor?
+  # === start_the_editor_in_the_background
   # ========================================================================= #
-  def use_this_editor?
-    @use_this_editor
-  end; alias editor? use_this_editor? # === editor?
+  def start_the_editor_in_the_background
+    system "#{use_which_editor?} &"
+  end; alias start_editor_in_background start_the_editor_in_the_background # === start_editor_in_background
 
   # ========================================================================= #
-  # === set_input
-  # ========================================================================= #
-  def set_input(i = '')
-    if i.is_a? String
-      i = [i]
-    end # At this point, we have an array
-    i = i.flatten if i.is_a? Array
-    i.map! {|entry|
-      dataset = nil
-      # ===================================================================== #
-      # Next get rid of components past a '#' token.
-      # ===================================================================== #
-      entry = entry[0, entry.index('#')] if entry.include? '#'
-      # ===================================================================== #
-      # === Handle fake "Symbols" next:
-      # ===================================================================== #
-      if entry.start_with? ':' # If this is a "symbol" we assume to do a special action.
-        name = entry[1 .. -1]
-        # =================================================================== #
-        # Since as of March 2023 we will distinguish two use cases:
-        #
-        #   (1) first, we will try to use the dataset in the file called
-        #       shortcuts.yml. If the input is part of a key in that file
-        #       then the key will be fetched, and the associated files
-        #       will be opened in the editor
-        #
-        #   (2) otherwise we will look through RUBY_SRC and simply open
-        #       the project-specific .rb file instead
-        #
-        # =================================================================== #
-        base_dir = RUBY_SRC+name
-        if File.exist?(FILE_SHORTCUTS)
-          dataset = YAML.load_file(FILE_SHORTCUTS)
-        end
-        if dataset and dataset.has_key?(name) # Invoke via: openineditors :gamebooks
-          entry = dataset[name]
-        elsif File.directory? base_dir
-          target = base_dir+'/lib/'+name+'/*.rb' # This is, sort of, the special action.
-          entry = Dir[target]
-        end
-      end
-      if entry.include? '#' # Then chop off. It is probably not necessary, though.
-        entry = entry[0..entry.index('#')]
-      end
-      if entry.respond_to?(:start_with?) and entry.start_with?('file://')
-        entry[0, 'file://'.size] = ''
-      end
-      entry
-    } if i.is_a? Array
-    i = i.flatten if i.is_a? Array
-    @input = i # Must be an Array.
-  end
+  # === set_work_on_these_files
+  #
+  # The variable has to be an Array at all times.
+  # ========================================================================= #
+  def set_work_on_these_files(i)
+    i = [i].flatten.compact.reject {|entry| entry.start_with?('--') }
+    @internal_hash[:work_on_these_files] = i
+  end; alias set_work_on_this_file set_work_on_these_files # === set_work_on_this_file
+
+  # ========================================================================= #
+  # === work_on_these_files?
+  # ========================================================================= #
+  def work_on_these_files?
+    @internal_hash[:work_on_these_files]
+  end; alias work_on_this_file? work_on_these_files? # === work_on_this_file?
+       alias input?             work_on_these_files? # === input?
 
   # ========================================================================= #
   # === try_to_find_expanded_alias_for
   #
-  # We delegate towards FindExpandedAlias
+  # We delegate towards FindExpandedAlias here.
   # ========================================================================= #
   def try_to_find_expanded_alias_for(i)
-    result = false # Default.
+    result = false # Default return value.
+    if i and i.include?('$')
+      i = sanitize_global_environment(i)
+    end
+    if i.include? ' ' # For instance, when it includes a ' &'
+      i = i[0, i.index(' ')]
+    end if i
     if Object.const_defined?(:Roebe) and
        Roebe.const_defined?(:FindExpandedAlias)
-      _ = ::Roebe::FindExpandedAlias[i]
-      result = sanitize(_)
+      expanded_alias = Roebe::FindExpandedAlias.new(i) { :be_quiet }
+      if expanded_alias.does_include?(i)
+        result = true
+      end
     end
-    if result.include? ' ' # For instance, when it includes a ' &'
-      result = result[0, result.index(' ')]
-    end if result
     return result
   end
+    
+  # ========================================================================= #
+  # === use_this_editor?
+  # ========================================================================= #
+  def use_this_editor?
+    @internal_hash[:use_this_editor]
+  end; alias editor?           use_this_editor? # === editor?
+       alias use_which_editor? use_this_editor? # === use_which_editor?
+
+  # ========================================================================= #
+  # === set_editor
+  # ========================================================================= #
+  def set_editor(
+      i = :use_the_default_editor_from_the_yaml_file
+    )
+    case i
+    # ======================================================================= #
+    # === :use_the_default_editor_from_the_yaml_file
+    # ======================================================================= #
+    when :use_the_default_editor_from_the_yaml_file
+      i = file_load_default_editor?
+    end
+    @internal_hash[:use_this_editor] = i
+  end; alias editor=             set_editor # === editor=
+       alias set_use_this_editor set_editor # === set_use_this_editor
+
+  # ========================================================================= #
+  # === do_save_this_file_into_a_local_yaml_file
+  #
+  # Since as of August 2019, this will also be logged into a local file,
+  # if we are on a roebe-system.
+  # ========================================================================= #
+  def do_save_this_file_into_a_local_yaml_file(i)
+    if File.file?(i) and
+       Object.const_defined?(:Roebe) and
+       File.directory?(Roebe.log_dir?) and
+       is_on_roebe?
+      into = "#{Roebe.log_dir?}opened_files.yml"
+      array = []
+      if File.exist? into
+        array << YAML.load_file(into)
+      end
+      array.flatten!
+      array << i unless array.include?(i)
+      what = YAML.dump(array)
+      unless Object.const_defined?(:SaveFile)
+        require 'save_file'
+      end
+      SaveFile.write_what_into(what, into)
+    end
+  end
+
+  # ========================================================================= #
+  # === verbose_notify_the_user_that_a_default_delay_will_be_used_next
+  # ========================================================================= #
+  def verbose_notify_the_user_that_a_default_delay_will_be_used_next
+    opne "More than #{steelblue('3 arguments')} were given, thus we will "\
+         "use a small delay of #{simp(N_DELAY.to_s)} seconds."
+  end
+
+  # ========================================================================= #
+  # === menu                                                       (menu tag)
+  # ========================================================================= #
+  def menu(
+      i = commandline_arguments?
+    )
+    if i.is_a? Array
+      i.each {|entry| menu(entry) }
+    else
+      case i # (case tag)
+      # ======================================================================= #
+      # === open_in_editor --show-help
+      # ======================================================================= #
+      when /help$/
+        show_help
+        exit
+      # ======================================================================= #
+      # === open_in_editor --editor?
+      # ======================================================================= #
+      when /^-?-?editor\??$/i
+        show_the_editor_in_use
+        exit
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === show_the_editor_in_use
+  #
+  # Invocation example:
+  #
+  #   open_in_editor --editor?
+  #
+  # ========================================================================= #
+  def show_the_editor_in_use
+    e steelblue(::Open.editor?)
+  end
 
   # ========================================================================= #
-  # === start_editor_in_background
+  # === show_help                                                  (help tag)
   # ========================================================================= #
-  def start_editor_in_background
-    system "#{@use_this_editor} &"
+  def show_help
+    e 'The following help-options are documented:'
+    e
+    e '  --editor? # show the current main editor in use'
+    e
   end
 
   # ========================================================================= #
-  # === use_which_delay?
+  # === consider_opening_files
   # ========================================================================= #
-  def use_which_delay?
-    Open.use_which_delay?.to_f
+  def consider_opening_files(
+      array                     = work_on_these_files?,
+      use_this_delay_by_default = 0
+    )
+    if array.empty?
+      opne 'No argument was given - thus, starting the primary editor in the background.'
+      start_the_editor_in_the_background
+    else
+      if array.size > 3
+        verbose_notify_the_user_that_a_default_delay_will_be_used_next
+        use_this_delay_by_default = N_DELAY
+        # Old code in use prior to the rewrite in June 2023 was:
+        #   case use_this_editor?
+        #   when 'bluefish' 
+        #     sleep(use_which_delay?) if array.size > 3 # To prevent bluefish from acting silly.
+        #   end
+      end
+      array.each {|entry|
+        open_this_file_in_the_editor(entry, use_this_delay_by_default)
+      }
+    end
   end
 
   # ========================================================================= #
-  # === open_in_editor
+  # === open_this_file_in_the_editor
   #
   # The optional second argument allows us to wait a little before 
   # opening something in the editor.
   # ========================================================================= #
-  def open_in_editor(
-      i, optional_delay = nil
+  def open_this_file_in_the_editor(
+      i,
+      optional_delay = nil
     )
+    use_this_editor = use_which_editor?
+    i = i.to_s.dup  # So to avoid frozen strings here.
+    i = sanitize_global_environment(i) if i.include? '$'
+    i = rds(i) # Get rid of // again, just in case.
+    # ======================================================================= #
+    # Next, we chop off '?' characters. This is, however had, not good if
+    # this is part of the filename. So we must check if the file exists,
+    # prior to doing this check.
+    # ======================================================================= #
+    if i.include?('?') and !File.exist?(i)
+      i = i[0..i.index('?')]
+    end
+    # ======================================================================= #
+    # === Handle fake "Symbols" next:
+    # ======================================================================= #
+    if i.start_with?(':') # If this is a "symbol" we assume to do a special action.
+      name = i[1 .. -1] # Get rid of the leading ':' here.
+      # ======================================================================= #
+      # Since as of March 2023 we will distinguish two use cases here
+      # for such fake-symbols:
+      #
+      #   (1) first, we will try to use the dataset in the file called
+      #       shortcuts.yml. If the input is part of a key in that file
+      #       then the key will be fetched, and the associated files
+      #       will be opened in the editor
+      #
+      #   (2) otherwise we will look through RUBY_SRC and simply open
+      #       the project-specific .rb file instead
+      #
+      # These shortcuts are defined in the .yml file at:
+      #
+      #   open/yaml/shortcuts.yml
+      #
+      # ======================================================================= #
+      base_dir = RUBY_SRC+name
+      if File.exist?(FILE_SHORTCUTS) # Load the dataset next.
+        dataset = YAML.load_file(FILE_SHORTCUTS)
+      end
+      # ======================================================================= #
+      # The next clause may turn i into an Array - both if and elsif
+      # clauses:
+      # ======================================================================= #
+      if dataset and dataset.has_key?(name) # Invoke via: openineditors :gamebooks
+        i = dataset[name]
+      elsif File.directory? base_dir
+        target = base_dir+'/lib/'+name+'/*.rb' # This is, sort of, the special action.
+        i = Dir[target] # This will make it an Array.
+      end
+    end
     if i.is_a? Array
-      i.each {|entry|
-        open_in_editor(entry, optional_delay)
-        if @use_this_editor == 'bluefish'
-          sleep(use_which_delay?) if i.size > 3 # To prevent bluefish from acting silly.
-        end
-      }
+      use_this_delay = 0
+      if i.size > 3
+        verbose_notify_the_user_that_a_default_delay_will_be_used_next
+        use_this_delay = N_DELAY
+      end
+      i.each {|entry| open_this_file_in_the_editor(entry, use_this_delay) }
     else
-      i = i.to_s.dup # So to avoid frozen strings here.
+      # ======================================================================= #
+      # We never want to have localhost entries:
+      # ======================================================================= #
       if i.include? 'localhost'
-        i.gsub!(/^http\:\/\/localhost\//, MY_DATA+'/')
+        i.sub!(/^http\:\/\/localhost\//, MY_DATA+'/')
+      end
+      if i.respond_to?(:start_with?) and i.start_with?('file://')
+        i[0, 'file://'.size] = ''
       end
       if i.end_with?(':') and !File.exist?(i)
-        i[-1,1] = ''
-      elsif i =~ /(:\d+)/ # Has a : and a number
+        i.chop! # Chop off the last character in this case.
+      elsif i =~ /(:\d+)/ # Has a : and also number, such as ":5".
         i.gsub!(/#{$1.to_s.dup}/,'')
       end
-      i = sanitize(i) if i.include? '$'
-      if i.count('/home') > 1
+      if i.include? '#' # Then chop off. It is probably not necessary, though.
+        # =================================================================== #
+        # In December 2023 it was noticed that there may be files that
+        # are called "foo#bar.itm". So we need to make a check, for the
+        # file existing or not. If it exists then we will not truncate
+        # it.
+        # =================================================================== #
+        i = i[0 .. i.index('#')] unless File.exist?(i)
+      end
+      if i.count('/home') > 1 # We have more than one entry of '/home'.
         i.gsub!(/#{MY_DATA}#{MY_DATA}/, MY_DATA)
       end
       if i.start_with?('http:') and !File.exist?(i)
         i.delete_prefix!('http:')
       end
+      # ======================================================================= #
+      # First check whether the file at `i` exists or whether it does not.
+      # ======================================================================= #
       if File.exist? i
         # =================================================================== #
-        # e 'Yes file exists here, we can thus open it.'
+        # The file exists, so we can open it in our editor next. We will
+        # work on the absolute path to it since as of June 2023.
         # =================================================================== #
-        esystem "#{editor?} #{i}"
+        i = File.absolute_path(i)
+        # =================================================================== #
+        # Make an exception for .cpp files but only for roebe-systems:
+        # =================================================================== #
+        case File.extname(i).delete('.')
+        when 'cpp'
+          if is_on_roebe?
+            if ENV.has_key?('CPP_EDITOR')
+              use_this_editor = ENV['CPP_EDITOR'].to_s.dup
+            else
+              use_this_editor = 'geany' # We use geany for cpp files.
+            end
+          end
+        end
+        if i.include?("'") and !i.include?('"')
+          i = '"'+i+'"'
+        end
+        if i.include? '('
+          i = '"'+i+'"'
+        end
+        esystem "#{use_this_editor} #{i}"
+        do_save_this_file_into_a_local_yaml_file(i) # Only on roebe-systems though.
+        sleep(optional_delay) if optional_delay # In this case we will also sleep.
       else # Ok, the file does not exist at this point.
-        # First try a purl.
-        _ = BeautifulUrl::BeautifulUrl.new(i, replace: true)
-        if _.url_was_found
-          esystem "#{editor?} #{_.url_as_string}"
-        elsif Dir[i+'*'].size > 0 # Try to find matches
-          e 'Did not find '+sfile(i)+' but we may have found '+
-            'at least one other entry.'
-          open_in_editor(Dir[i+'*'].reject {|entry| File.directory? entry })
-        elsif result = try_to_find_expanded_alias_for(i)
-          open_in_editor(result) if result
-        # ================================================================= #
+        # ======================================================================= #
+        # Next assume it is a local link.
+        # ======================================================================= #
+        if BeautifulUrl.is_a_local_link?(i)
+          i = BeautifulUrl.local_menu(i)
+        else
+          # ================================================================= #
+          # First try a purl.
+          # ================================================================= #
+          _ = BeautifulUrl::BeautifulUrl.new(i, replace: true)
+        end
+        if _ and _.url_was_found
+          esystem "#{use_this_editor} #{_.url_as_string}"
+        elsif Dir["#{i}*"].size > 0 # Try to find matches.
+          # ================================================================= #
+          # Here we have to be careful, as we may hit an infinite loop:
+          # ================================================================= #
+          opne "#{rev}Did not find #{sfile(i)}#{rev}"
+          opne "#{rev}but we may have found at least one other entry."
+          new_selection = Dir["#{i}*"].reject {|entry|
+            File.directory?(entry) or
+            entry.include?('.tar')
+          }
+          # ================================================================= #
+          # We will thus select one random entry:
+          # ================================================================= #
+          open_in_editor(new_selection.sample)
+        # =================================================================== #
+        # === Run through the expanded-aliases next:
+        # =================================================================== #
+        elsif try_to_find_expanded_alias_for(i)
+          i = sanitize_global_environment(i) if i and i.include?('$')
+          if i.include? ' ' # For instance, when it includes a ' &'.
+            i = i[0, i.index(' ')]
+          end if i
+          if Object.const_defined?(:Roebe) and
+             Roebe.const_defined?(:FindExpandedAlias)
+            expanded_alias = Roebe::FindExpandedAlias.new(i) { :be_quiet }
+            i = expanded_alias[i]
+          end
+          open_in_editor(i) if i and !i.empty? # Recursive call.
+        # =================================================================== #
         # Now the string can include 'project_', in which case we
         # will handle it in a special way.
-        # ================================================================= #
+        # =================================================================== #
         elsif i.include? 'project_'
           i.gsub!(/project_/,'')
           i << 'task'
@@ -241,57 +472,13 @@ class InEditor < Base # === Open::InEditor
         end
       end
     end
-    sleep(optional_delay) if optional_delay
-  end
-
-  # ========================================================================= #
-  # === set_editor
-  # ========================================================================= #
-  def set_editor(i = use_which_editor?)
-    @use_this_editor = i
-  end; alias editor= set_editor # === editor=
-
-  # ========================================================================= #
-  # === input?
-  # ========================================================================= #
-  def input?
-    @input
-  end
-
-  # ========================================================================= #
-  # === consider_opening_files
-  # ========================================================================= #
-  def consider_opening_files(
-      i = input?
-    )
-    if i.is_a? Array
-      i.flatten!
-      i.map! {|file|
-        file.chop! if file.end_with? ':'
-        file
-      }
-      if i.empty?
-        start_editor_in_background
-      else
-        optional_delay = 0
-        if i.size > 3
-          opn; e "More than 3 arguments were given, thus we will use "\
-                 "a delay of #{simp(N_DELAY.to_s)} seconds."
-          optional_delay = N_DELAY
-        end
-        i.each {|entry|
-          open_in_editor(entry, optional_delay)
-        }
-      end
-    else
-      open_in_editor(i)
-    end
-  end
+  end; alias open_in_editor open_this_file_in_the_editor # === open_in_editor
 
   # ========================================================================= #
   # === run                                                         (run tag)
   # ========================================================================= #
   def run
+    menu
     consider_opening_files
   end
 
@@ -309,21 +496,39 @@ end
 # =========================================================================== #
 # === Open.in_editor
 #
+# Note that the behaviour of Open.in_editor() is in-sync with the
+# method Open.in_browser(), 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_editor().
+#
 # Usage examples:
 #
 #   Open.in_editor('/home/x/programming/ruby/src/open/open.gemspec')
 #
-# Or theb lock variant:
+# Or the lock variant:
 #
 #   Open.in_editor {{
 #     this_file:       first_argument?,
 #     use_this_editor: :nano
 #   }}
 #
+# Which may also look like this:
+#
+#    ::Open.in_editor {{
+#      this_file:       _,
+#      use_this_editor: :bluefish
+#    }}
+#
 # =========================================================================== #
 def self.in_editor(
-    i = ARGV, &block
+    i = ARGV,
+    &block
   )
+  if i.respond_to? :join
+    i.join(' ').strip
+  end
   ::Open::InEditor.new(i, &block)
 end
 
@@ -333,9 +538,9 @@ end
 # === open_in_editor
 # =========================================================================== #
 def open_in_editor(i, &block)
-  Open.in_editor(i, &block)
+  ::Open.in_editor(i, &block)
 end
 
 if __FILE__ == $PROGRAM_NAME
-  Open::InEditor.new(ARGV)  
-end # openineditor rorg
+  ARGV.each {|entry| Open.in_editor(entry) } 
+end # openineditor localruby