snibbets 2.0.29 → 2.0.31

data/Snibbets.lbaction/Contents/Scripts/snibbets.rb

@@ -0,0 +1,420 @@
+#!/usr/bin/env ruby
+# Snibbets 2.0.0
+
+require 'optparse'
+require 'readline'
+require 'json'
+require 'cgi'
+require 'shellwords'
+
+$search_path = File.expand_path("~/Desktop/Code/Snippets")
+
+class String
+  # Are there multiple snippets (indicated by ATX headers)
+  def multiple?
+    return self.scan(/^#+/).length > 1
+  end
+
+  # Is the snippet in this block fenced?
+  def fenced?
+    count = self.scan(/^```/).length
+    return count > 1 && count.even?
+  end
+
+  def rx
+    return ".*" + self.gsub(/\s+/,'.*') + ".*"
+  end
+
+  # remove outside comments, fences, and indentation
+  def clean_code
+    block = self
+
+    # if it's a fenced code block, just discard the fence and everything
+    # outside it
+    if block.fenced?
+      return block.gsub(/(?:^|.*?\n)(`{3,})(\w+)?(.*?)\n\1.*/m) {|m| $3.strip }
+    end
+
+    # assume it's indented code, discard non-indented lines and outdent
+    # the rest
+    indent = nil
+    inblock = false
+    code = []
+    block.split(/\n/).each {|line|
+      if line =~ /^\s*$/ && inblock
+        code.push(line)
+      elsif line =~ /^( {4,}|\t+)/
+        inblock = true
+        indent ||= Regexp.new("^#{$1}")
+        code.push(line.sub(indent,''))
+      else
+        inblock = false
+      end
+    }
+    code.join("\n")
+  end
+
+  # Returns an array of snippets. Single snippets are returned without a
+  # title, multiple snippets get titles from header lines
+  def snippets
+    content = self.dup
+    # If there's only one snippet, just clean it and return
+    unless self.multiple?
+      return [{"title" => "", "code" => content.clean_code.strip}]
+    end
+
+    # Split content by ATX headers. Everything on the line after the #
+    # becomes the title, code is gleaned from text between that and the
+    # next ATX header (or end)
+    sections = []
+    parts = content.split(/^#+/)
+    parts.shift
+
+    parts.each do |p|
+      lines = p.split(/\n/)
+      title = lines.shift.strip.sub(/[.:]$/, '')
+      block = lines.join("\n")
+      code = block.clean_code
+      next unless code && !code.empty?
+
+      sections << {
+        'title' => title,
+        'code' => code.strip
+      }
+    end
+    return sections
+  end
+end
+
+def gum_menu(executable, res, title)
+  options = res.map { |m| m['title'] }
+  puts title
+  selection = `echo #{Shellwords.escape(options.join("\n"))} | #{executable} choose --limit 1`.strip
+  Process.exit 1 if selection.empty?
+
+  res.select { |m| m['title'] =~ /#{selection}/ }[0]
+end
+
+def fzf_menu(executable, res, title)
+  options = res.map { |m| m['title'] }
+  args = [
+    "--height=#{options.count + 2}",
+    %(--prompt="#{title} > "),
+    '-1'
+  ]
+  selection = `echo #{Shellwords.escape(options.join("\n"))} | #{executable} #{args.join(' ')}`.strip
+  Process.exit 1 if selection.empty?
+
+  res.select { |m| m['title'] =~ /#{selection}/ }[0]
+end
+
+def menu(res, title = 'Select one')
+  fzf = `which fzf`.strip
+  return fzf_menu(fzf, res, title) unless fzf.empty?
+
+  gum = `which gum`.strip
+  return gum_menu(gum, res, title) unless gum.empty?
+
+  console_menu(res, title)
+end
+
+# Generate a numbered menu, items passed must have a title property
+def console_menu(res, title)
+  stty_save = `stty -g`.chomp
+
+  trap('INT') do
+    system('stty', stty_save)
+    Process.exit 1
+  end
+
+  # Generate a numbered menu, items passed must have a title property('INT') { system('stty', stty_save); exit }
+  counter = 1
+  $stderr.puts
+  res.each do |m|
+    $stderr.printf("%<counter>2d) %<title>s\n", counter: counter, title: m['title'])
+    counter += 1
+  end
+  $stderr.puts
+
+  begin
+    $stderr.printf(title.sub(/:?$/, ': '), res.length)
+    while (line = Readline.readline('', true))
+      unless line =~ /^[0-9]/
+        system('stty', stty_save) # Restore
+        exit
+      end
+      line = line.to_i
+      return res[line - 1] if line.positive? && line <= res.length
+
+      warn 'Out of range'
+      menu(res, title)
+    end
+  rescue Interrupt
+    system('stty', stty_save)
+    exit
+  end
+end
+
+# Search the snippets directory for query using find and grep
+def search(query, folder, try = 0)
+  # First try only search by filenames
+  # Second try search with grep
+  # Third try search with Spotlight name only
+  # Fourth try search with Spotlight all contents
+  cmd = case try
+        when 0
+          %(find "#{folder}" -iregex '#{query.rx}')
+        when 1
+          %(grep -iEl '#{query.rx}' "#{folder}/"*.md)
+        when 2
+          %(mdfind -onlyin "#{folder}" -name '#{query}' 2>/dev/null)
+        when 3
+          %(mdfind -onlyin "#{folder}" '#{query}' 2>/dev/null)
+        end
+
+  matches = `#{cmd}`.strip
+
+  results = []
+
+  if !matches.empty?
+    lines = matches.split(/\n/)
+    lines.each do |l|
+      results << {
+        'title' => File.basename(l, '.*'),
+        'path' => l
+      }
+    end
+    results
+  else
+    return [] if try > 2
+
+    # if no results on the first try, try again searching all text
+    search(query, folder, try + 1)
+  end
+end
+
+def highlight_pygments(executable, code, syntax, theme)
+  syntax = syntax.empty? ? '-g' : "-l #{syntax}"
+  `echo #{Shellwords.escape(code)} | #{executable} #{syntax}`
+end
+
+def highlight_skylight(executable, code, syntax, theme)
+  return code if syntax.empty?
+
+  `echo #{Shellwords.escape(code)} | #{executable} --syntax #{syntax}`
+end
+
+def highlight(code, filename, theme = 'monokai')
+  syntax = syntax_from_extension(filename)
+
+  skylight = `which skylighting`.strip
+  return highlight_skylight(skylight, code, syntax, theme) unless skylight.empty?
+
+  pygments = `which pygmentize`.strip
+  return highlight_pygments(pygments, code, syntax, theme) unless pygments.empty?
+
+  code
+end
+
+def ext_to_lang(ext)
+  case ext
+  when /^(as|applescript|scpt)$/
+    'applescript'
+  when /^m$/
+    'objective-c'
+  when /^(pl|perl)$/
+    'perl'
+  when /^py$/
+    'python'
+  when /^(js|jq(uery)?|jxa)$/
+    'javascript'
+  when /^rb$/
+    'ruby'
+  when /^cc$/
+    'c'
+  when /^(ba|fi|z|c)?sh$/
+    'bash'
+  when /^pl$/
+    'perl'
+  else
+    if %w[awk sed css sass scss less cpp php c sh swift html erb json xpath sql htaccess].include?(ext)
+      ext
+    else
+      ''
+    end
+  end
+end
+
+def syntax_from_extension(filename)
+  ext_to_lang(filename.split(/\./)[1])
+end
+
+options = {
+    interactive: true,
+    launchbar: false,
+    output: 'raw',
+    source: $search_path,
+    highlight: false,
+    all: false
+  }
+
+optparse = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename(__FILE__)} [options] query"
+
+  opts.on('-q', '--quiet', 'Skip menus and display first match') do
+    options[:interactive] = false
+    options[:launchbar] = false
+  end
+
+  opts.on('-a', '--all', 'If a file contains multiple snippets, output all of them (no menu)') do
+    options[:all] = true
+  end
+
+  opts.on('-o', '--output FORMAT', 'Output format (launchbar or raw)') do |outformat|
+    valid = %w[json launchbar lb raw]
+    if outformat.downcase =~ /(launchbar|lb)/
+      options[:launchbar] = true
+      options[:interactive] = false
+    elsif valid.include?(outformat.downcase)
+      options[:output] = outformat.downcase
+    end
+  end
+
+  opts.on('-s', '--source FOLDER', 'Snippets folder to search') do |folder|
+    options[:source] = File.expand_path(folder)
+  end
+
+  opts.on('--highlight', 'Use pygments or skylighting to syntax highlight (if installed)') do
+    options[:highlight] = true
+  end
+
+  opts.on('-h', '--help', 'Display this screen') do
+    puts optparse
+    Process.exit 0
+  end
+end
+
+optparse.parse!
+
+query = ''
+
+if options[:launchbar]
+  query = if $stdin.stat.size.positive?
+            $stdin.read.force_encoding('utf-8')
+          else
+            ARGV.join(' ')
+          end
+elsif ARGV.length
+  query = ARGV.join(' ')
+end
+
+query = CGI.unescape(query)
+
+if query.strip.empty?
+  puts 'No search query'
+  puts optparse
+  Process.exit 1
+end
+
+results = search(query, options[:source], 0)
+
+if options[:launchbar]
+  output = []
+
+  if results.empty?
+    out = {
+      'title' => 'No matching snippets found'
+    }.to_json
+    puts out
+    Process.exit
+  end
+
+  results.each do |result|
+    input = IO.read(result['path'])
+    snippets = input.snippets
+    next if snippets.empty?
+
+    children = []
+
+    if snippets.length == 1
+      output << {
+        'title' => result['title'],
+        'path' => result['path'],
+        'action' => 'copyIt',
+        'actionArgument' => snippets[0]['code'],
+        'label' => 'Copy'
+      }
+      next
+    end
+
+    snippets.each { |s|
+      children << {
+        'title' => s['title'],
+        'path' => result['path'],
+        'action' => 'copyIt',
+        'actionArgument' => s['code'],
+        'label' => 'Copy'
+      }
+    }
+
+    output << {
+      'title' => result['title'],
+      'path' => result['path'],
+      'children' => children
+    }
+  end
+
+  puts output.to_json
+else
+  filepath = nil
+  if results.empty?
+    warn 'No results'
+    Process.exit 0
+  elsif results.length == 1 || !options[:interactive]
+    filepath = results[0]['path']
+    input = IO.read(filepath)
+  else
+    answer = menu(results, 'Select a file')
+    filepath = answer['path']
+    input = IO.read(filepath)
+  end
+
+  snippets = input.snippets
+
+  if snippets.empty?
+    warn 'No snippets found'
+    Process.exit 0
+  elsif snippets.length == 1 || !options[:interactive]
+    if options[:output] == 'json'
+      $stdout.puts snippets.to_json
+    else
+      snippets.each do |snip|
+        code = snip['code']
+        code = highlight(code, filepath) if options[:highlight]
+        $stdout.puts code
+      end
+    end
+  elsif snippets.length > 1
+    if options[:all]
+      if options[:output] == 'json'
+        $stdout.puts snippets.to_json
+      else
+        snippets.each do |snippet|
+          $stdout.puts snippet['title']
+          $stdout.puts '------'
+          $stdout.puts snippet['code']
+          $stdout.puts
+        end
+      end
+    else
+      answer = menu(snippets, 'Select snippet')
+      if options[:output] == 'json'
+        $stdout.puts answer.to_json
+      else
+        code = answer['code']
+        code = highlight(code, filepath) if options[:highlight]
+        $stdout.puts code
+      end
+    end
+  end
+end

data/bin/snibbets

@@ -46,6 +46,10 @@ module Snibbets
           options[:name_only] = v
         end
 
+        opts.on('--[no-]notes', 'Display the full content of the snippet') do |v|
+          options[:all_notes] = v
+        end
+
         opts.on('-o', '--output FORMAT', 'Output format (json|launchbar|*raw)') do |outformat|
           valid = %w[json launchbar lb raw]
           if outformat.downcase =~ /(launchbar|lb)/

data/lib/snibbets/array.rb

@@ -4,6 +4,10 @@ module Snibbets
       select { |el| el =~ /^<block\d+>$/ }.count
     end
 
+    def notes
+      select { |el| el !~ /^<block\d+>$/ && el !~ /^```/ && !el.strip.empty? }.count
+    end
+
     def strip_empty
       remove_leading_empty_elements.remove_trailing_empty_elements
     end
@@ -17,7 +21,7 @@ module Snibbets
 
       in_leader = true
       each do |line|
-        if (line =~ /^\s*$/ || line.empty?) && in_leader
+        if (line.strip.empty?) && in_leader
           next
         else
           in_leader = false

data/lib/snibbets/config.rb

@@ -14,6 +14,7 @@ module Snibbets
 
     DEFAULT_OPTIONS = {
       all: false,
+      all_notes: false,
       copy: false,
       editor: nil,
       extension: 'md',

data/lib/snibbets/highlight.rb

@@ -41,8 +41,24 @@ module Snibbets
         # `echo #{Shellwords.escape(code)} | #{executable} #{theme}--syntax #{syntax}`
       end
 
+      def highlight_fences(code, filename, syntax)
+        content = code.dup
+
+        content.fences.each do |f|
+          rx = Regexp.new(Regexp.escape(f[:code]))
+          highlighted = highlight(f[:code].gsub(/\\k</, '\k\<'), filename, f[:lang] || syntax).strip
+          code.sub!(/#{rx}/, highlighted)
+        end
+
+        Snibbets.options[:all_notes] ? code.gsub(/k\\</, 'k<') : code.gsub(/k\\</, 'k<').clean_code
+      end
+
       def highlight(code, filename, syntax, theme = nil)
-        return code unless $stdout.isatty
+        unless $stdout.isatty
+          return Snibbets.options[:all_notes] && code.replace_blocks[0].notes? ? code : code.clean_code
+        end
+
+        return highlight_fences(code, filename, syntax) if code.fenced?
 
         theme ||= Snibbets.options[:highlight_theme] || 'monokai'
         syntax ||= Lexers.syntax_from_extension(filename)

data/lib/snibbets/menu.rb

@@ -14,9 +14,7 @@ module Snibbets
       def remove_items_without_query(filename, res, query)
         q = find_query_in_options(filename, res, query).split(/ /)
         res.delete_if do |opt|
-          q.none? do |word|
-            "#{filename} #{opt['title']}" =~ /#{word}/i
-          end
+          q.none? { |word| "#{filename} #{opt['title']}" =~ /#{word}/i }
         end
         res
       end
@@ -28,16 +26,14 @@ module Snibbets
         end
 
         if res.count.zero?
-          warn 'No matches found'
+          warn 'No matches found' if Snibbets.options[:interactive]
           Process.exit 1
         end
 
         options = res.map { |m| m['title'] }
 
         puts title
-        args = [
-          "--height=#{options.count}"
-        ]
+        args = ["--height=#{options.count}"]
         selection = `echo #{Shellwords.escape(options.join("\n"))} | #{executable} filter #{args.join(' ')}`.strip
         Process.exit 1 if selection.empty?
 
@@ -82,7 +78,7 @@ module Snibbets
         end
 
         if res.count.zero?
-          warn 'No matches found'
+          warn 'No matches found' if Snibbets.options[:interactive]
           Process.exit 1
         end
 

data/lib/snibbets/os.rb

@@ -31,12 +31,12 @@ module Snibbets
         os = RbConfig::CONFIG['target_os']
         case os
         when /darwin.*/i
-          `pbpaste -pboard general -Prefer txt`
+          `pbpaste -pboard general -Prefer txt`.strip_newlines
         else
           if TTY::Which.exist?('xclip')
-            `xclip -o -sel c`
+            `xclip -o -sel c`.strip_newlines
           elsif TTY::Which.exist('xsel')
-            `xsel -ob`
+            `xsel -ob`.strip_newlines
           else
             puts 'Paste not supported on this system, please install xclip or xsel.'
           end

data/lib/snibbets/string.rb

@@ -47,6 +47,28 @@ module Snibbets
       count > 1 && count.even?
     end
 
+    def blocks
+      replace_blocks[1].count
+    end
+
+    def blocks?
+      blocks.positive?
+    end
+
+    def notes?
+      replace_blocks[0].split("\n").notes.positive?
+    end
+
+    # Return array of fenced code blocks
+    def fences
+      return [] unless fenced?
+
+      rx = /(?mi)^(?<fence>`{3,})(?<lang> *\S+)? *\n(?<code>[\s\S]*?)\n\k<fence> *(?=\n|\Z)/
+      matches = []
+      scan(rx) { matches << Regexp.last_match }
+      matches.each_with_object([]) { |m, fenced| fenced.push({ code: m['code'], lang: m['lang'] }) }
+    end
+
     def indented?
       self =~ /^( {4,}|\t+)/
     end
@@ -90,11 +112,9 @@ module Snibbets
 
       indent = code[0].match(/^( {4,}|\t+)(?=\S)/)
 
-      if indent
-        code.map! { |line| line.sub(/(?mi)^#{indent[1]}/, '') }.join("\n")
-      else
-        self
-      end
+      return self if indent.nil?
+
+      code.map! { |line| line.sub(/(?mi)^#{indent[1]}/, '') }.join("\n")
     end
 
     def replace_blocks
@@ -129,50 +149,44 @@ module Snibbets
       [sans_blocks, code_blocks]
     end
 
-    # Returns an array of snippets. Single snippets are returned without a
-    # title, multiple snippets get titles from header lines
-    def snippets
-      content = dup.remove_meta
-      # If there's only one snippet, just clean it and return
-      # return [{ 'title' => '', 'code' => content.clean_code.strip }] unless multiple?
-
-      # Split content by ATX headers. Everything on the line after the #
-      # becomes the title, code is gleaned from text between that and the
-      # next ATX header (or end)
-      sections = []
-
-      sans_blocks, code_blocks = content.replace_blocks
-
-      content = []
-      if sans_blocks =~ /<block\d+>/
-        sans_blocks.each_line do |line|
-          content << line if line =~ /^#/ || line =~ /<block\d+>/
-        end
-
-        parts = content.join("\n").split(/^#+/)
-      else
-        parts = sans_blocks.gsub(/\n{2,}/, "\n\n").split(/^#+/)
+    def parse_lang_marker(block)
+      lang = nil
+      if block =~ /<lang:(.*?)>/
+        lang = Regexp.last_match(1)
+        block = block.gsub(/<lang:.*?>\n+/, '').strip_empty
       end
 
-      # parts.shift if parts.count > 1
+      [lang, block]
+    end
+
+    def restore_blocks(parts, code_blocks)
+      sections = []
 
       parts.each do |part|
         lines = part.split(/\n/).strip_empty
-        next if lines.blocks == 0
 
-        title = lines.count > 1 && lines[0] !~ /<block\d+>/ ? lines.shift.strip.sub(/[.:]$/, '') : 'Default snippet'
-        block = lines.join("\n").gsub(/<(block\d+)>/) { code_blocks[Regexp.last_match(1)] }
+        notes = part.notes?
+
+        next if lines.blocks.zero? && !notes
+
+        title = if lines.count > 1 && lines[0] !~ /<block\d+>/ && lines[0] =~ /^ +/
+                  lines.shift.strip.sub(/[.:]$/, '')
+                else
+                  'Default snippet'
+                end
 
-        lang = nil
-        if block =~ /<lang:(.*?)>/
-          lang = Regexp.last_match(1)
-          block.gsub!(/<lang:.*?>\n/, '')
+        block = lines.join("\n").gsub(/<(block\d+)>/) do
+          code = code_blocks[Regexp.last_match(1)].strip_empty
+          lang, code = parse_lang_marker(code)
+          "\n```#{lang}\n#{code.strip}\n```"
         end
 
-        code = block.clean_code
+        lang, code = parse_lang_marker(block)
 
         next unless code && !code.empty?
 
+        # code = code.clean_code unless notes || code.fences.count > 1
+
         sections << {
           'title' => title,
           'code' => code.strip_empty,
@@ -182,5 +196,32 @@ module Snibbets
 
       sections
     end
+
+    # Returns an array of snippets. Single snippets are returned without a
+    # title, multiple snippets get titles from header lines
+    def snippets
+      content = dup.remove_meta
+      # If there's only one snippet, just clean it and return
+      # return [{ 'title' => '', 'code' => content.clean_code.strip }] unless multiple?
+
+      # Split content by ATX headers. Everything on the line after the #
+      # becomes the title, code is gleaned from text between that and the
+      # next ATX header (or end)
+      sans_blocks, code_blocks = content.replace_blocks
+
+      parts = if Snibbets.options[:all_notes]
+                sans_blocks.split(/^#+/)
+              elsif sans_blocks =~ /<block\d+>/
+                sans_blocks.split(/\n/).each_with_object([]) do |line, arr|
+                  arr << line if line =~ /^#/ || line =~ /<block\d+>/
+                end.join("\n").split(/^#+/)
+              else
+                sans_blocks.gsub(/\n{2,}/, "\n\n").split(/^#+/)
+              end
+
+      # parts.shift if parts.count > 1
+
+      restore_blocks(parts, code_blocks)
+    end
   end
 end