snibbets 2.0.7

data/bin/snibbets

@@ -0,0 +1,427 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift File.join(__dir__, '..', 'lib')
+require 'snibbets'
+
+module Snibbets
+  class << self
+    # Search the snippets directory for query using find and grep
+    def search(try: 0)
+      folder = Snibbets.options[:source]
+      # start by doing a spotlight search, if that fails, start trying:
+      # First try only search by filenames
+      # Second try search with grep
+      ext = Snibbets.options[:extension] || 'md'
+      cmd = case try
+            when 1
+              %(find "#{folder}" -iregex '#{@query.rx}' -name '*.#{ext}')
+            when 2
+              rg = TTY::Which.which('rg')
+              ag = TTY::Which.which('ag')
+              ack = TTY::Which.which('ack')
+              grep = TTY::Which.which('grep')
+              if Snibbets.options[:name_only]
+                nil
+              elsif !rg.empty?
+                %(#{rg} -li --color=never --glob='*.#{ext}' '#{@query.rx}' "#{folder}")
+              elsif !ag.empty?
+                %(#{ag} -li --nocolor -G '.*.#{ext}' '#{@query.rx}' "#{folder}")
+              elsif !ack.empty?
+                %(#{ack} -li --nocolor --markdown '#{@query.rx}' "#{folder}")
+              elsif !grep.empty?
+                %(#{grep} -iEl '#{@query.rx}' "#{folder}"/**/*.#{ext})
+              else
+                nil
+              end
+            else
+              mdfind = TTY::Which.which('mdfind')
+              if mdfind.empty?
+                nil
+              else
+                name_only = Snibbets.options[:name_only] ? '-name ' : ''
+                %(mdfind -onlyin #{folder} #{name_only}'#{@query} filename:.#{ext}' 2>/dev/null)
+              end
+            end
+
+      if try == 2 && cmd.nil?
+        puts "No search method available on this system. Please install ripgrep, silver surfer, ack, or grep."
+        Process.exit 1
+      end
+
+      res = cmd.nil? ? '' : `#{cmd}`.strip
+
+      matches = []
+
+      unless res.empty?
+        lines = res.split(/\n/)
+        lines.each do |l|
+          matches << {
+            'title' => File.basename(l, '.*'),
+            'path' => l
+          }
+        end
+
+        matches.sort_by! { |a| a['title'] }.uniq!
+
+        return matches unless matches.empty?
+      end
+
+      return matches if try == 2
+
+      # if no results on the first try, try again searching all text
+      search(try: try + 1) if matches.empty?
+    end
+
+    def open_snippet_in_editor(filepath)
+      editor = Snibbets.options[:editor] || Snibbets::Config.best_editor
+
+      os = RbConfig::CONFIG['target_os']
+
+      if editor.nil?
+        OS.open(filepath)
+      else
+        if os =~ /darwin.*/i
+          if editor =~ /^TextEdit/
+            `open -a TextEdit "#{filepath}"`
+          elsif TTY::Which.bundle_id?(editor)
+            `open -b "#{editor}" "#{filepath}"`
+          elsif TTY::Which.app?(editor)
+            `open -a "#{editor}" "#{filepath}"`
+          elsif TTY::Which.exist?(editor)
+            editor = TTY::Which.which(editor)
+            system %(#{editor} "#{filepath}") if editor
+          else
+            puts "No editor configured, or editor is missing"
+            Process.exit 1
+          end
+        elsif TTY::Which.exist?(editor)
+          editor = TTY::Which.which(editor)
+          system %(#{editor} "#{filepath}") if editor
+        else
+          puts "No editor configured, or editor is missing"
+          Process.exit 1
+        end
+      end
+    end
+
+    def new_snippet_from_clipboard
+      trap('SIGINT') do
+        Howzit.console.info "\nCancelled"
+        exit!
+      end
+
+      build_lexers
+
+      pb = OS.paste.outdent
+
+      printf 'What does this snippet do? '
+      input = $stdin.gets.chomp
+      title = input unless input.empty?
+
+      printf 'What language(s) does it use (separate with spaces, full names or file extensions will work)? '
+      input = $stdin.gets.chomp
+      langs = input.split(/ +/).map(&:strip) unless input.empty?
+      exts = langs.map { |lang| Snibbets::Lexers.lang_to_ext(lang) }
+      tags = langs.map { |lang| Snibbets::Lexers.ext_to_lang(lang) }.concat(langs).sort.uniq
+
+      filename ="#{title}.#{exts.join('.')}.#{Snibbets.options[:extension]}"
+
+      File.open(File.join(Snibbets.options[:source], filename), 'w') do |f|
+        f.puts "tags: #{tags.join(', ')}
+
+    ```
+    #{pb}
+    ```"
+      end
+
+      puts "New snippet written to #{filename}."
+    end
+
+    def handle_launchbar(results)
+      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
+    end
+
+    def handle_results(results)
+      if Snibbets.options[:launchbar]
+        handle_launchbar(results)
+      else
+        filepath = nil
+        if results.empty?
+          warn 'No results'
+          Process.exit 0
+        elsif results.length == 1 || !Snibbets.options[:interactive]
+          filepath = results[0]['path']
+          input = IO.read(filepath)
+        else
+          answer = Snibbets::Menu.menu(results, title: 'Select a file')
+          filepath = answer['path']
+          input = IO.read(filepath)
+        end
+
+        if @arguments[:edit_snippet]
+          open_snippet_in_editor(filepath)
+          Process.exit 0
+        end
+
+        snippets = input.snippets
+
+        if snippets.empty?
+          warn 'No snippets found'
+          Process.exit 0
+        elsif snippets.length == 1 || !Snibbets.options[:interactive]
+          if Snibbets.options[:output] == 'json'
+            print(snippets.to_json)
+          else
+            snippets.each do |snip|
+              header = File.basename(filepath, '.md')
+              warn header
+              warn '-' * header.length
+              code = snip['code']
+              code = highlight(code, filepath) if Snibbets.options[:highlight]
+              print(code)
+            end
+          end
+        elsif snippets.length > 1
+          if Snibbets.options[:all]
+            if Snibbets.options[:output] == 'json'
+              print(snippets.to_json)
+            else
+              output = []
+              snippets.each do |snippet|
+                output << snippet['title']
+                output << '-' * snippet['title'].length
+                output << snippet['code']
+                output << "\n"
+              end
+              print(output.join("\n"))
+            end
+          else
+            snippets.push({ 'title' => 'All snippets', 'code' => '' })
+
+            answer = Snibbets::Menu.menu(snippets, filename: File.basename(filepath, '.md'), title: 'Select snippet', query: @query)
+
+            if answer['title'] == 'All snippets'
+              snippets.delete_if { |s| s['title'] == 'All snippets'}
+              if Snibbets.options[:output] == 'json'
+                print(snippets.to_json)
+              else
+                header = File.basename(filepath, '.md')
+                warn header
+                warn '=' * header.length
+                output = []
+                snippets.each do |snippet|
+                  output << snippet['title']
+                  output << '-' * snippet['title'].length
+                  output << snippet['code']
+                  output << "\n"
+                end
+                print(output.join("\n"))
+              end
+            elsif Snibbets.options[:output] == 'json'
+              print(answer.to_json)
+            else
+              header = "#{File.basename(filepath, '.md')}: #{answer['title']}"
+              warn header
+              warn '-' * header.length
+              code = answer['code']
+              code = highlight(code, filepath) if Snibbets.options[:highlight]
+              print(code)
+            end
+          end
+        end
+      end
+    end
+
+    def print(output)
+      $stdout.puts(output)
+      if Snibbets.options[:copy]
+        OS.copy(output)
+        $stderr.puts "Copied to clipboard"
+      end
+    end
+  end
+end
+
+module Snibbets
+  class << self
+    attr_reader :arguments, :query
+
+    def run
+      options = Snibbets.config.options
+
+      @arguments = {
+        save_config: false,
+        edit_config: false,
+        edit_snippet: false,
+        paste_snippet: false
+      }
+
+      optparse = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename(__FILE__)} [options] query"
+
+        opts.on('-a', '--all', 'If a file contains multiple snippets, output all of them (no menu)') do
+          options[:all] = true
+        end
+
+        opts.on('-c', '--[no-]copy', 'Copy the output to the clibpoard (also displays on STDOUT)') do |v|
+          options[:copy] = v
+        end
+
+        opts.on('-e', '--edit', 'Open the selected snippet in your configured editor') do
+          @arguments[:edit_snippet] = true
+        end
+
+        opts.on('-n', '--[no-]name-only', 'Only search file names, not content') do |v|
+          options[:name_only] = 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)/
+            options[:launchbar] = true
+            options[:interactive] = false
+          elsif valid.include?(outformat.downcase)
+            options[:output] = outformat.downcase
+          end
+        end
+
+        opts.on('-p', '--paste', '--new', 'Interactively create a new snippet from clipboard contents (Mac only)') do
+          @arguments[:paste_snippet] = true
+        end
+
+        opts.on('-q', '--quiet', 'Skip menus and display first match') do
+          options[:interactive] = false
+          options[:launchbar] = false
+        end
+
+        opts.on('-s', '--source FOLDER', 'Snippets folder to search') do |folder|
+          options[:source] = File.expand_path(folder)
+        end
+
+        opts.on('--configure', 'Open the configuration file in your default editor') do
+          @arguments[:edit_config] = true
+        end
+
+        opts.on('--highlight', 'Use pygments or skylighting to syntax highlight (if installed)') do
+          options[:highlight] = true
+        end
+
+        opts.on('--save', 'Save the current command line options to the YAML configuration') do
+          @arguments[:save_config] = true
+        end
+
+        opts.on('-h', '--help', 'Display this screen') do
+          puts "Snibbets v#{VERSION}"
+          puts
+          puts optparse
+          Process.exit 0
+        end
+
+        opts.on('-v', '--version', 'Display version information') do
+          puts "Snibbets v#{VERSION}"
+          Process.exit 0
+        end
+      end
+
+      optparse.parse!
+
+      if @arguments[:save_config]
+        config = Snibbets::Config.new
+        config.write_config
+        puts "Configuration saved to #{config.config_file}"
+      end
+
+      if @arguments[:edit_config]
+        config = Snibbets::Config.new
+        config.write_config
+        open_snippet_in_editor(config.config_file)
+        Process.exit 0
+      end
+
+      unless File.directory?(options[:source])
+        puts 'The Snippets folder doesn\'t exist, please configure it.'
+        puts 'Run `snibbets --configure` to open the config file for editing.'
+        Process.exit 1
+      end
+
+      if @arguments[:paste_snippet]
+        Snibbets.new_snippet_from_clipboard
+        Process.exit 0
+      end
+
+      @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?
+        if @arguments[:save_config]
+          Process.exit 0
+        else
+          puts 'No search query'
+          puts optparse
+          Process.exit 1
+        end
+      end
+
+      handle_results(search(try: 0))
+    end
+  end
+end
+
+Snibbets.run

data/buildnotes.md

@@ -0,0 +1,39 @@
+template: gem, git, gli, project
+executable: na
+readme: README.md
+changelog: CHANGELOG.md
+project: snibbets
+
+# Snibbets
+
+A plain text snippet manager
+
+## Test
+
+@run(bundle exec bin/snibbets $@)
+
+## Deploy
+
+You no longer need to manually bump the version, it will be incremented when this task runs.
+
+```run Update Changelog and README
+#!/bin/bash
+
+changelog -u
+# scripts/fixreadme.rb
+changelog | git commit -a -F -
+git pull
+git push
+```
+
+@include(gem:Release Gem) Release Gem
+@include(project:Update Blog Project) Update Blog Project
+@run(rake bump[patch]) Bump Version
+
+@after
+Don't forget to publish the website!
+@end
+
+## Plans
+
+

data/lib/snibbets/config.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Snibbets
+  class Config
+    attr_accessor :options
+
+    DEFAULT_OPTIONS = {
+      all: false,
+      copy: false,
+      editor: nil,
+      extension: 'md',
+      highlight: false,
+      interactive: true,
+      launchbar: false,
+      name_only: false,
+      output: 'raw',
+      source: File.expand_path('~/Dropbox/Snippets')
+    }.freeze
+
+    def initialize
+      custom_config = read_config
+      @options = DEFAULT_OPTIONS.merge(custom_config)
+      @options[:editor] ||= best_editor
+      write_config unless @options.equal?(custom_config)
+    end
+
+    def best_editor
+      if ENV['EDITOR']
+        ENV['EDITOR']
+      elsif ENV['GIT_EDITOR']
+        ENV['GIT_EDITOR']
+      else
+        return TTY::Which.which('code') if TTY::Which.exist?('code')
+
+        return TTY::Which.which('subl') if TTY::Which.exist?('subl')
+
+        return TTY::Which.which('bbedit') if TTY::Which.exist?('bbedit')
+
+        return TTY::Which.which('nano') if TTY::Which.exist?('nano')
+
+        return TTY::Which.which('vim') if TTY::Which.exist?('vim')
+
+        'TextEdit'
+      end
+    end
+
+    def config_dir
+      File.expand_path('~/.config/snibbets')
+    end
+
+    def config_file
+      File.join(config_dir, 'snibbets.yml')
+    end
+
+    def read_config
+      if File.exist?(config_file)
+        YAML.safe_load(IO.read(config_file)).symbolize_keys
+      else
+        {}
+      end
+    end
+
+    def write_config
+      raise 'Error creating config directory, file exists' if File.exist?(config_dir) && !File.directory?(config_dir)
+
+      FileUtils.mkdir_p(config_dir) unless File.directory?(config_dir)
+      File.open(config_file, 'w') { |f| f.puts(YAML.dump(@options.stringify_keys)) }
+    end
+  end
+end

data/lib/snibbets/hash.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Snibbets
+  class ::Hash
+    # Turn all keys into string
+    #
+    # Return a copy of the hash where all its keys are strings
+    def stringify_keys
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_s] = v.is_a?(Hash) ? v.stringify_keys : v }
+    end
+
+    # Turn all keys into symbols
+    def symbolize_keys
+      each_with_object({}) { |(k, v), hsh| hsh[k.to_sym] = v.is_a?(Hash) ? v.symbolize_keys : v }
+    end
+  end
+end

data/lib/snibbets/highlight.rb

@@ -0,0 +1,26 @@
+module Snibbets
+  class Highlight
+    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 = TTY::Which.which('skylighting')
+      return highlight_skylight(skylight, code, syntax, theme) unless skylight.empty?
+
+      pygments = TTY::Which.which('pygmentize')
+      return highlight_pygments(pygments, code, syntax, theme) unless pygments.empty?
+
+      code
+    end
+  end
+end

data/lib/snibbets/lexers.rb

@@ -0,0 +1,34 @@
+module Snibbets
+  class Lexers
+    attr_accessor :lexers
+
+    def build_lexers
+      IO.read('lexers_db.txt').split(/\n/).each do |line|
+        key = line.match(/(?mi)^((, )?[^,]+?)+?(?=\[)/)[0]
+        keys = key.split(/,/).map(&:strip)
+        value = line.match(/\[(.*?)\]/)[1]
+        values = value.split(/,/).map(&:strip)
+
+        @lexers << {
+          lexer: keys.shift,
+          aliases: keys,
+          extensions: values
+        }
+      end
+    end
+
+    def ext_to_lang(ext)
+      matches = @lexers.select { |lex| lex[:extensions].map(&:downcase).include?(ext.downcase) }
+      matches.map { |lex| lex[:lexer] }.first
+    end
+
+    def lang_to_ext(lexer)
+      matches = @lexers.select { |lex| lex[:lexer] == lexer || lex[:aliases].map(&:downcase).include?(lexer.downcase) }
+      matches.map { |lex| lex[:extensions].first }.first
+    end
+
+    def syntax_from_extension(filename)
+      ext_to_lang(filename.split(/\./)[1])
+    end
+  end
+end