hookapp 0.0.3 → 2.0.3

data/lib/hook/hooker.rb

@@ -1,313 +1,6 @@
 # frozen_string_literal: true
 
-# String helpers
-class String
-  def split_hook
-    elements = split(/\|\|/)
-    {
-      name: elements[0],
-      url: elements[1],
-      path: elements[2]
-    }
-  end
-
-  def split_hooks
-    split(/\^\^/).map(&:split_hook)
-  end
-
-  def valid_hook
-    if File.exist?(self)
-      File.expand_path(self)
-    elsif self =~ /\S+:\/\//
-      self
-    else
-      if self =~ /^\[.*?\]\((.*?)\)$/
-        mdlink = $1
-        mdlink.valid_hook
-      else
-        nil
-      end
-    end
-  end
-
-  def valid_hook!
-    replace valid_hook
-  end
-end
-
 # Hook.app CLI interface
 class Hooker
-  def initialize(global_args)
-    @global_args = global_args
-  end
-
-  def validate_format(fmt, options)
-    valid_format_rx = options.map { |fmt| fmt.sub(/^(.)(.*)$/, '^\1(\2)?$') }
-    valid_format = false
-    valid_format_rx.each_with_index do |rx, i|
-      cmp = Regexp.new(rx, 'i')
-      next unless fmt =~ cmp
-      valid_format = options[i]
-      break
-    end
-    return valid_format
-  end
-
-  def bookmark_for(url)
-    url.valid_hook!
-    raise "Invalid target: #{url}" unless url
-
-    mark = `osascript <<'APPLESCRIPT'
-      tell application "Hook"
-        set _hook to bookmark from URL "#{url}"
-        return title of _hook & "||" & address of _hook & "||" & path of _hook
-      end tell
-    APPLESCRIPT`.strip
-    mark.split_hook
-  end
-
-  def get_hooks(url)
-    url.valid_hook!
-    raise "Invalid target: #{url}" unless url
-
-    hooks = `osascript <<'APPLESCRIPT'
-      tell application "Hook"
-        set _mark to bookmark from URL "#{url}"
-        if _mark is {} then return ""
-        set _hooks to bookmarks hooked to _mark
-        set _out to {}
-        repeat with _hook in _hooks
-          set _out to _out & (title of _hook & "||" & address of _hook & "||" & path of _hook)
-        end repeat
-        set {astid, AppleScript's text item delimiters} to {AppleScript's text item delimiters, "^^"}
-        set _output to _out as string
-        set AppleScript's text item delimiters to astid
-        return _output
-      end tell
-    APPLESCRIPT`.strip
-    hooks.split_hooks
-  end
-
-  def copy_bookmark(url, opts)
-    mark = bookmark_for(url)
-    output = if opts[:markdown]
-               "[#{mark[:name]}](#{mark[:url]})"
-             else
-               mark[:url]
-             end
-    `/bin/echo -n #{Shellwords.escape(output)} | pbcopy`
-    %(Copied #{opts[:markdown] ? 'Markdown link' : 'Hook URL'} for '#{mark[:name]}' to clipboard)
-  end
-
-  def select_hook(marks)
-    intpad = marks.length.to_s.length + 1
-    marks.each_with_index do |mark, i|
-      STDERR.printf "%#{intpad}d) %s\n", i + 1, mark[:name]
-    end
-    STDERR.print 'Open which bookmark: '
-    sel = STDIN.gets.strip.to_i
-    if sel.positive? && sel <= marks.length
-      marks[sel - 1]
-    else
-      warn 'Invalid selection'
-      Process.exit 1
-    end
-  end
-
-  def open_gui(url)
-    `osascript <<'APPLESCRIPT'
-    tell application "Hook"
-      set _mark to bookmark from URL "#{url.valid_hook}"
-      invoke on _mark
-    end tell
-    APPLESCRIPT`
-  end
-
-  def open_linked(url)
-    marks = get_hooks(url)
-    if marks.empty?
-      warn "No hooks found for #{url}"
-    else
-      res = select_hook(marks)
-      `open '#{res[:url]}'`
-    end
-  end
-
-  def link_files(args)
-    target = args.pop
-    target.valid_hook!
-    raise "Invalid target: #{target}" unless target
-
-    args.each do |file|
-      file.valid_hook!
-      raise "Invalid target: #{file}" unless file
-
-      puts "Linking #{file} and #{target}..."
-      `osascript <<'APPLESCRIPT'
-        tell application "Hook"
-          set _mark1 to bookmark from URL "#{file}"
-          set _mark2 to bookmark from URL "#{target}"
-          hook together _mark1 and _mark2
-          return true
-        end tell
-      APPLESCRIPT`
-    end
-    "Linked #{args.length} files to #{target}"
-  end
-
-  def clone_hooks(args)
-    target = args.pop.valid_hook
-    source = args[0].valid_hook
-
-    if target && source
-      hooks = get_hooks(source)
-      hooks.each do |hook|
-        `osascript <<'APPLESCRIPT'
-          tell application "Hook"
-            set _mark1 to bookmark from URL "#{hook[:url]}"
-            set _mark2 to bookmark from URL "#{target}"
-            hook together _mark1 and _mark2
-            return true
-          end tell
-        APPLESCRIPT`
-      end
-      "Hooks from #{source} cloned to #{target}"
-    else
-      raise 'Invalid file specified'
-    end
-  end
-
-  def delete_all_hooks(url)
-    STDERR.print "Are you sure you want to delete ALL hooks from #{url} (y/N)? "
-    res = STDIN.gets.strip
-    if res =~ /^y/i
-      get_hooks(url).each do |hook|
-        `osascript <<'APPLESCRIPT'
-          tell application "Hook"
-            set _mark1 to bookmark from URL "#{hook[:url]}"
-            set _mark2 to bookmark from URL "#{url}"
-            remove hook between _mark1 and _mark2
-            return true
-          end tell
-        APPLESCRIPT`
-      end
-      "Removed all hooks from #{url}"
-    end
-  end
-
-  def delete_hooks(args, opts)
-    urls = args.map(&:valid_hook).delete_if { |url| !url }
-    output = []
-    if opts[:all]
-      urls.each_with_index do |url, i|
-        raise "Invalid target: #{args[i]}" unless url
-
-        output.push(delete_all_hooks(url))
-      end
-      return output.join("\n")
-    end
-
-    if urls.length == 2
-      source = urls[0]
-      target = urls[1]
-      `osascript <<'APPLESCRIPT'
-        tell application "Hook"
-          set _mark1 to bookmark from URL "#{source}"
-          set _mark2 to bookmark from URL "#{target}"
-          remove hook between _mark1 and _mark2
-          return true
-        end tell
-      APPLESCRIPT`
-      return "Hook removed between #{source} and #{target}"
-    else
-      raise "Invalid number of URLs or files specified"
-
-    end
-  end
-
-  def link_all(args)
-    args.each do |file|
-      source = file.valid_hook
-      link_to = args.dup.map(&:valid_url).reject { |url|
-        url == source
-      }
-      link_to.each do |url|
-        `osascript <<'APPLESCRIPT'
-          tell application "Hook"
-            set _mark1 to bookmark from URL "#{source}"
-            set _mark2 to bookmark from URL "#{url}"
-            hook together _mark1 and _mark2
-            return true
-          end tell
-        APPLESCRIPT`
-      end
-    end
-    "Linked #{args.length} files to each other"
-  end
-
-  def linked_bookmarks(args, opts)
-    result = []
-
-    separator = args.length == 1 && opts[:format] == 'paths' && opts[:null_separator] ? "\0" : "\n"
-
-    args.each do |url|
-      source_mark = bookmark_for(url)
-      filename = source_mark[:name]
-
-      case opts[:format]
-      when /^m/
-        filename = "[#{source_mark[:name]}](#{source_mark[:url]})"
-        filename += " <file://#{CGI.escape(source_mark[:path])}>" if source_mark[:path]
-      when /^p/
-        filename = "File: #{source_mark[:name]}"
-        filename += " (#{source_mark[:path]})" if source_mark[:path]
-      when /^h/
-        filename = "File: #{source_mark[:name]}"
-        filename += " (#{source_mark[:url]})" if source_mark[:url]
-      else
-        filename = "Bookmarks attached to #{source_mark[:path] || source_mark[:url]}"
-      end
-
-      hooks_arr = get_hooks(url)
-
-      if !hooks_arr.empty?
-        hooks_arr.reject! { |h| h[:path].nil? || h[:path] == '' } if opts[:files_only]
-
-        output = []
-
-        case opts[:format]
-        when /^m/
-          hooks_arr.each do |h|
-            output.push("- [#{h[:name]}](#{h[:url]})")
-          end
-        when /^p/
-          hooks_arr.each do |h|
-            output.push(h[:path].nil? ? h[:url] : h[:path])
-          end
-        when /^h/
-          hooks_arr.each do |h|
-            output.push(h[:url])
-          end
-        else
-          hooks_arr.each do |h|
-            output.push("Title: #{h[:name]}\nPath: #{h[:path]}\nAddress: #{h[:url]}\n---------------------")
-          end
-        end
-      else
-        output = ['No bookmarks']
-      end
-      result.push({ file: filename, links: output.join(separator) })
-    end
-
-    if result.length > 1 || opts[:format] == 'verbose'
-      result.map! do |res|
-        "#{res[:file]}\n\n#{res[:links]}\n"
-      end
-    else
-      result.map! do |res|
-        res[:links]
-      end
-    end
-    result.join(separator)
-  end
+  include HookApp
 end

data/lib/hook/markdown_document_listener.rb

@@ -0,0 +1,164 @@
+require 'stringio'
+require 'time'
+require 'fileutils'
+
+module GLI
+  module Commands
+    # DocumentListener class for GLI documentation generator
+    class MarkdownDocumentListener
+      def initialize(_global_options, _options, _arguments, app)
+        @exe = app.exe_name
+        if File.exist?('README.md') # Back up existing README
+          FileUtils.mv('README.md', 'README.bak')
+          $stderr.puts "Backing up existing README.md to README.bak"
+        end
+        @io = File.new('README.md', 'w')
+        @nest = '#'
+        @arg_name_formatter = GLI::Commands::HelpModules::ArgNameFormatter.new
+      end
+
+      def beginning
+      end
+
+      # Called when processing has completed
+      def ending
+        if File.exist?('CREDITS.md')
+          @io.puts IO.read('CREDITS.md')
+          @io.puts
+        end
+        if File.exist?('LICENSE.md')
+          @io.puts IO.read('LICENSE.md')
+          @io.puts
+        end
+        @io.puts
+        @io.puts "Documentation generated #{Time.now.strftime('%Y-%m-%d %H:%M')}"
+        @io.puts
+        @io.close
+      end
+
+      # Gives you the program description
+      def program_desc(desc)
+        @io.puts "# #{@exe} CLI"
+        @io.puts
+        @io.puts desc
+        @io.puts
+      end
+
+      def program_long_desc(desc)
+        @io.puts "> #{desc}"
+        @io.puts
+      end
+
+      # Gives you the program version
+      def version(version)
+        @io.puts "*v#{version}*"
+        @io.puts
+        # Hacking in the overview file
+        if File.exist?('OVERVIEW.md')
+          @io.puts IO.read('OVERVIEW.md')
+          @io.puts
+        end
+      end
+
+      def options
+        if @nest.size == 1
+          @io.puts "## Global Options"
+        else
+          @io.puts header("Options", 1)
+        end
+        @io.puts
+      end
+
+      # Gives you a flag in the current context
+      def flag(name, aliases, desc, long_desc, default_value, arg_name, must_match, _type)
+        invocations = ([name] + Array(aliases)).map { |_| "`" + add_dashes(_) + "`" }.join(' | ')
+        usage = "#{invocations} #{arg_name || 'arg'}"
+        @io.puts header(usage, 2)
+        @io.puts
+        @io.puts String(desc).strip
+        @io.puts "\n*Default Value:* `#{default_value || 'None'}`\n" unless default_value.nil?
+        @io.puts "\n*Must Match:* `#{must_match.to_s}`\n" unless must_match.nil?
+        cmd_desc = String(long_desc).strip
+        @io.puts "> #{cmd_desc}\n" unless cmd_desc.length == 0
+        @io.puts
+      end
+
+      # Gives you a switch in the current context
+      def switch(name, aliases, desc, long_desc, negatable)
+        if negatable
+          name = "[no-]#{name}" if name.to_s.length > 1
+          aliases = aliases.map { |_|  _.to_s.length > 1 ? "[no-]#{_}" : _ }
+        end
+        invocations = ([name] + aliases).map { |_| "`" + add_dashes(_) + "`" }.join('|')
+        @io.puts header("#{invocations}", 2)
+        @io.puts
+        @io.puts String(desc).strip
+        cmd_desc = String(long_desc).strip
+        @io.puts "\n> #{cmd_desc}\n" unless cmd_desc.length == 0
+        @io.puts
+      end
+
+      def end_options
+      end
+
+      def commands
+        @io.puts header("Commands", 1)
+        @io.puts
+        increment_nest
+      end
+
+      # Gives you a command in the current context and creates a new context of this command
+      def command(name, aliases, desc, long_desc, arg_name, arg_options)
+        arg_name_fmt = @arg_name_formatter.format(arg_name, arg_options, [])
+        @io.puts header("`$ #{@exe}` <mark>`#{([name] + aliases).join('|')}`</mark> `#{arg_name_fmt}`", 1)
+        @io.puts
+        @io.puts "*#{String(desc).strip}*"
+        @io.puts
+        cmd_desc = String(long_desc).strip.split("\n").map { |_| "> #{_}" }.join("\n")
+        @io.puts "#{cmd_desc}\n\n" unless cmd_desc.length == 0
+        increment_nest
+      end
+
+      # Ends a command, and "pops" you back up one context
+      def end_command(_name)
+        decrement_nest
+        @io.puts "* * * * * *\n\n" unless @nest.size > 2
+      end
+
+      # Gives you the name of the current command in the current context
+      def default_command(name)
+        @io.puts "#### [Default Command] #{name}" unless name.nil?
+      end
+
+      def end_commands
+        decrement_nest
+      end
+
+      private
+
+      def add_dashes(name)
+        name = "-#{name}"
+        name = "-#{name}" if name.length > 2
+        name
+      end
+
+      def header(content, increment)
+        if @nest.size + increment > 6
+          "**#{content}**"
+        else
+          "#{@nest}#{'#'*increment} #{content}"
+        end
+      end
+
+      def increment_nest(increment=1)
+        @nest = "#{@nest}#{'#'*increment}"
+      end
+
+      def decrement_nest(increment=1)
+        @nest.gsub!(/#{'#'*increment}$/, '')
+      end
+    end
+  end
+end
+
+GLI::Commands::Doc::FORMATS['markdown'] = GLI::Commands::MarkdownDocumentListener