open 0.1.30

data/lib/open/in_editor/in_editor.rb

@@ -0,0 +1,341 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Open::InEditor
+#
+# 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".
+#
+# 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".
+#
+# Usage example:
+#
+#   require 'open/in_editor/in_editor.rb'
+#   Open.in_editor(ARGV)
+#
+# =========================================================================== #
+# require 'open/in_editor/in_editor.rb'
+# =========================================================================== #
+require 'open/base/base.rb'
+
+module Open
+
+class InEditor < Base # === Open::InEditor
+
+  # ========================================================================= #
+  # === initialize
+  #
+  # The first argument should be the name of the file that we wish to open.
+  # ========================================================================= #
+  def initialize(
+      i           = nil,
+      run_already = true
+    )
+    register_sigint
+    reset
+    set_input(i)
+    # ======================================================================= #
+    # === Handle blocks next
+    # ======================================================================= #
+    if block_given?
+      yielded = yield
+      # ===================================================================== #
+      # === Handle Hashes next
+      # ===================================================================== #
+      if yielded.is_a? Hash
+        # =================================================================== #
+        # === :use_this_editor
+        # =================================================================== #
+        if yielded.has_key? :use_this_editor
+          set_editor(
+            yielded[:use_this_editor]
+          )
+        end
+        # =================================================================== #
+        # === :this_file
+        # =================================================================== #
+        if yielded.has_key? :this_file
+          _ = yielded[:this_file]
+          set_input(_)
+        end
+      end
+    end
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @use_this_editor
+    # ======================================================================= #
+    @use_this_editor = use_which_editor?
+  end
+
+  # ========================================================================= #
+  # === use_this_editor?
+  # ========================================================================= #
+  def use_this_editor?
+    @use_this_editor
+  end; alias editor? use_this_editor? # === editor?
+
+  # ========================================================================= #
+  # === 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
+
+  # ========================================================================= #
+  # === try_to_find_expanded_alias_for
+  #
+  # We delegate towards FindExpandedAlias
+  # ========================================================================= #
+  def try_to_find_expanded_alias_for(i)
+    result = false # Default.
+    if Object.const_defined?(:Roebe) and
+       Roebe.const_defined?(:FindExpandedAlias)
+      _ = ::Roebe::FindExpandedAlias[i]
+      result = sanitize(_)
+    end
+    if result.include? ' ' # For instance, when it includes a ' &'
+      result = result[0, result.index(' ')]
+    end if result
+    return result
+  end
+
+  # ========================================================================= #
+  # === start_editor_in_background
+  # ========================================================================= #
+  def start_editor_in_background
+    system "#{@use_this_editor} &"
+  end
+
+  # ========================================================================= #
+  # === use_which_delay?
+  # ========================================================================= #
+  def use_which_delay?
+    Open.use_which_delay?.to_f
+  end
+
+  # ========================================================================= #
+  # === open_in_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
+    )
+    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
+      }
+    else
+      i = i.to_s.dup # So to avoid frozen strings here.
+      if i.include? 'localhost'
+        i.gsub!(/^http\:\/\/localhost\//, MY_DATA+'/')
+      end
+      if i.end_with?(':') and !File.exist?(i)
+        i[-1,1] = ''
+      elsif i =~ /(:\d+)/ # Has a : and a number
+        i.gsub!(/#{$1.to_s.dup}/,'')
+      end
+      i = sanitize(i) if i.include? '$'
+      if i.count('/home') > 1
+        i.gsub!(/#{MY_DATA}#{MY_DATA}/, MY_DATA)
+      end
+      if i.start_with?('http:') and !File.exist?(i)
+        i.delete_prefix!('http:')
+      end
+      if File.exist? i
+        # =================================================================== #
+        # e 'Yes file exists here, we can thus open it.'
+        # =================================================================== #
+        esystem "#{editor?} #{i}"
+      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
+        # ================================================================= #
+        # 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'
+          open_in_editor(beautiful_url(i))
+        else # Ok we really did not find it.
+          cmd = USERFIND+' '+i
+          # e cmd # Whether we wish to output this command or not.
+          result = `#{cmd}`.chomp
+          if result.empty?
+            this_file_was_not_found(i)
+          else # else, we did indeed find it.
+            open_in_editor(result)
+          end
+        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
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    consider_opening_files
+  end
+
+  # ========================================================================= #
+  # === Open::InEditor[]
+  #
+  # This method can also pass blocks to the initializer.
+  # ========================================================================= #
+  def self.[](i, &block)
+    new(i, &block)
+  end
+
+end
+
+# =========================================================================== #
+# === Open.in_editor
+#
+# Usage examples:
+#
+#   Open.in_editor('/home/x/programming/ruby/src/open/open.gemspec')
+#
+# Or theb lock variant:
+#
+#   Open.in_editor {{
+#     this_file:       first_argument?,
+#     use_this_editor: :nano
+#   }}
+#
+# =========================================================================== #
+def self.in_editor(
+    i = ARGV, &block
+  )
+  ::Open::InEditor.new(i, &block)
+end
+
+end
+
+# =========================================================================== #
+# === open_in_editor
+# =========================================================================== #
+def open_in_editor(i, &block)
+  Open.in_editor(i, &block)
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Open::InEditor.new(ARGV)  
+end # openineditor rorg

data/lib/open/last/last.rb

@@ -0,0 +1,143 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Open::Last
+#
+# This class can be used to open the most recent program.
+#
+# Usage example:
+#
+#   Open::Last.new(ARGV)
+#
+# =========================================================================== #
+# require 'open/last/last.rb'
+# =========================================================================== #
+require 'open/base/base.rb'
+
+module Open
+
+class Last < Base # === Open::Last
+
+  require 'open/in_editor/in_editor.rb'
+
+  # ========================================================================= #
+  # === NAMESPACE
+  # ========================================================================= #
+  NAMESPACE = inspect
+
+  # ========================================================================= #
+  # === BY_DEFAULT_OPEN_N_FILES
+  # ========================================================================= #
+  BY_DEFAULT_OPEN_N_FILES = 1
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      i           = BY_DEFAULT_OPEN_N_FILES,
+      run_already = true
+    )
+    reset
+    set_input(i)
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+    # ======================================================================= #
+    # === @namespace
+    # ======================================================================= #
+    @namespace = NAMESPACE
+  end
+
+  # ========================================================================= #
+  # === set_input
+  # ========================================================================= #
+  def set_input(
+      i = BY_DEFAULT_OPEN_N_FILES
+    )
+    i = i.first if i.is_a? Array
+    i = BY_DEFAULT_OPEN_N_FILES if i.nil?
+    i = i.to_s.dup
+    @input = i
+  end
+
+  # ========================================================================= #
+  # === open_n_files?
+  # ========================================================================= #
+  def open_n_files?
+    @input # To-go for variable, for now at the last.
+  end
+
+  # ========================================================================= #
+  # === input?
+  # ========================================================================= #
+  def input?
+    @input
+  end
+
+  # ========================================================================= #
+  # === open_these_target_files
+  # ========================================================================= #
+  def open_these_target_files(
+      i = @target_files
+    )
+    if i.is_a? Array
+      i.each {|entry| open_these_target_files(entry) }
+    else
+      opnn; e "Now opening `#{sfile(i)}`."
+      Open.in_editor(i)
+    end
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    # ======================================================================= #
+    # Sort by date next. Could also use a pure ruby implementation there.
+    # ======================================================================= #
+    result = `ls -tl --quoting-style=literal`.split("\n")
+    result.reject! {|entry| entry.include? 'total' }
+    result.map! {|entry|
+      if entry.include? ' '
+        splitted = entry.split(' ')
+        # =================================================================== #
+        # We are only interested in the last part, as that will contain the
+        # filename.
+        # =================================================================== #
+        entry = splitted.last
+      end
+      entry
+    }
+    result.select! {|entry| File.file? entry }
+    open_these_entries = result[0 .. (open_n_files?.to_i - 1) ]
+    @target_files = open_these_entries
+    open_these_target_files(@target_files)
+  end
+
+  # ========================================================================= #
+  # === Open::Last[]
+  # ========================================================================= #
+  def self.[](i = '')
+    new(i)
+  end
+
+end
+
+# =========================================================================== #
+# === Open.open_last
+# =========================================================================== #
+def self.open_last(i = ARGV)
+  ::Open::Last.new(i)
+end
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Open::Last.new(ARGV)
+end # openlast

data/lib/open/last_url/last_url.rb

@@ -0,0 +1,151 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Open::LastUrl
+#
+# This class has been created in order to open the content of the
+# xorg-buffer via the browser, e. g. via palemoon, firefox or any
+# other browser (defined elsewhere). The assumption here is that
+# at the time of calling this class, the xorg-buffer contains a
+# remote URL.
+#
+# No arguments have to be given to this class because it will simply
+# fetch the URL by using the external program called `xclip`.
+#
+# Usage example from ruby code:
+#
+#   Open::LastUrl.new(ARGV)
+#
+# =========================================================================== #
+# require 'open/last_url/last_url.rb'
+# =========================================================================== #
+require 'open/base/base.rb'
+
+module Open
+
+class LastUrl < Base # === Open::LastUrl
+
+  require 'open/in_browser/in_browser.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      commandline_arguments = ARGV,
+      run_already           = true
+    )
+    reset
+    menu(
+      commandline_arguments
+    )
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+  end
+
+  # ========================================================================= #
+  # === menu                                                       (menu tag)
+  # ========================================================================= #
+  def menu(i)
+    if i.is_a? Array
+      i.each {|entry| menu(entry) }
+    else
+      case i
+      # ===================================================================== #
+      # === :quiet
+      # ===================================================================== #
+      when :quiet,
+           :silent,
+           :be_quiet
+        @be_verbose = false
+      end
+    end
+  end
+
+  # ========================================================================= #
+  # === determine_xorg_buffer
+  #
+  # This method depends on the binary called "xsel".
+  # ========================================================================= #
+  def determine_xorg_buffer
+    # @xorg_buffer = `xclip -o` # Get the content of the Xorg Buffer here.
+    @xorg_buffer = `xsel -o` # Get the content of the Xorg Buffer here.
+    sanitize_xorg_buffer
+  end
+
+  # ========================================================================= #
+  # === sanitize_xorg_buffer
+  # ========================================================================= #
+  def sanitize_xorg_buffer
+    @xorg_buffer = @xorg_buffer.chomp
+  end
+
+  # ========================================================================= #
+  # === open_the_xorg_buffer_in_the_browser
+  # ========================================================================= #
+  def open_the_xorg_buffer_in_the_browser
+    _ = @xorg_buffer
+    _ = _.split('|') if _.include? '|'
+    if _.include?(' ') or _.include?(';') # As otherwise we could not really open it from the terminal.
+      _ = '"'+_+'"'
+    end
+    ::Open.in_browser(_) # This method is defined in open_in_browser.rb
+  end
+
+  # ========================================================================= #
+  # === output_xorg_buffer
+  # ========================================================================= #
+  def output_xorg_buffer
+    _ = @xorg_buffer
+    if @be_verbose
+      e "#{rev}Next trying to show the #{simp('Xorg-Buffer')} that "\
+        "will be used:"
+      e
+      e "  #{sfancy(_)}"
+      e
+    end
+  end
+
+  # ========================================================================= #
+  # === run_everything
+  # ========================================================================= #
+  def run_everything
+    determine_xorg_buffer
+    output_xorg_buffer
+    open_the_xorg_buffer_in_the_browser
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    run_everything
+  end
+
+  # ========================================================================= #
+  # === Open::LastUrl[]
+  # ========================================================================= #
+  def self.[](i = ARGV)
+    new(i)
+  end
+
+end
+
+# =========================================================================== #
+# === Open.last_url
+# =========================================================================== #
+def self.last_url(optional_arguments = ARGV)
+  ::Open::LastUrl[optional_arguments]
+end; self.instance_eval { alias open_last_url last_url } # === Open.open_last_url
+
+end
+
+if __FILE__ == $PROGRAM_NAME
+  Open::LastUrl.new(ARGV)
+end # ola

data/lib/open/nano_open/nano_open.rb

@@ -0,0 +1,73 @@
+#!/usr/bin/ruby -w
+# Encoding: UTF-8
+# frozen_string_literal: true
+# =========================================================================== #
+# === Open::NanoOpen
+#
+# Usage example:
+#
+#   Open::NanoOpen.new
+#
+# =========================================================================== #
+# require 'open/nano_open/nano_open.rb'
+# Open::NanoOpen.new(ARGV)
+# =========================================================================== #
+require 'open/base/base.rb'
+
+module Open
+
+class NanoOpen < Base # === Open::NanoOpen
+
+  require 'open/in_editor/in_editor.rb'
+
+  # ========================================================================= #
+  # === initialize
+  # ========================================================================= #
+  def initialize(
+      commandline_arguments = nil,
+      run_already           = true
+    )
+    reset
+    set_commandline_arguments(
+      commandline_arguments
+    )
+    run if run_already
+  end
+
+  # ========================================================================= #
+  # === reset                                                     (reset tag)
+  # ========================================================================= #
+  def reset
+    super()
+  end
+
+  # ========================================================================= #
+  # === run                                                         (run tag)
+  # ========================================================================= #
+  def run
+    _ = first_argument?
+    if is_on_roebe?
+      require 'studium'
+      new_target = Studium.find_corresponding_exam_topic(_)
+      unless new_target == _
+        _ = Studium.directory_to_the_exam_topics+new_target
+      end 
+    end
+    ::Open.in_editor {{
+      this_file:       _,
+      use_this_editor: :nano
+    }}
+  end
+
+  # ========================================================================= #
+  # === Open::NanoOpen[]
+  # ========================================================================= #
+  def self.[](i = '')
+    new(i)
+  end
+
+end; end
+
+if __FILE__ == $PROGRAM_NAME
+  Open::NanoOpen.new(ARGV)
+end # nanoopen