snibbets 2.0.31 → 2.0.33

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 67e546441d5515f0c3d14e754843bfc3eed76a5129bff75b810c173d3e0161a8
-  data.tar.gz: 1e98fc1fb3326dd21dfb1ccecbf4c4b44b6a0f26df8053fc998fc80dc57428cd
+  metadata.gz: a04adb0bcd4439b3cd445b65bbfb4dc8494237cccca55fb6cc1a42c696e45864
+  data.tar.gz: 25099f85f797910222a321dbebd3e0db84098071b964f6d93e0d6ba19ef456c5
 SHA512:
-  metadata.gz: 32936396eb50e8b9186f15f12333c7603134fe5861d80c070bb0e96ef4e1d8b248103d46b4cba3cd97d8036e9bd0c82b4dc707911434b9fd7ea97282114e77ca
-  data.tar.gz: 0d22c987dc50165333bfd5d016f3c1d67bd64d842a968c35ec53a5cd2c5e94e95536fee25e54d3c32ba710a6189a84c573d49587baeb34f610f7f3ba6c552b73
+  metadata.gz: 7d06a635679db42ad3a53eb21b235e21d4057f189c77760edc373306909da795e306cb7c7992e564cc517831487620904485f2007f0631a6e55ba7c434606b95
+  data.tar.gz: 6b0f69d918b04ead612de23ba5d7c0b0044a137da79efc24b3037caa26f0f4d63055270499a6716c3c52e3a6bebbe3b12875db4dafbb7a7de8003559d58765ec

data/CHANGELOG.md

@@ -1,3 +1,26 @@
+### 2.0.33
+
+2023-04-26 10:23
+
+#### IMPROVED
+
+- More coloring for prompts and messages
+- Colorize headers in multi-snippet output
+- If skylighting highlighting is enabled and the specified
+- Add some normalization for some skylighting lexers
+
+#### FIXED
+
+- Highlighting returns empty if language contains non-alphanumeric characters
+
+### 2.0.32
+
+2023-04-25 17:14
+
+#### FIXED
+
+- Don't highlight code sent to `--copy`
+
 ### 2.0.31
 
 2023-04-20 10:20

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    snibbets (2.0.31)
+    snibbets (2.0.33)
       mdless (~> 1.0, >= 1.0.32)
       tty-reader (~> 0.9, >= 0.9.0)
       tty-which (~> 0.5, >= 0.5.0)

data/README.md

@@ -159,7 +159,7 @@ Snibbet's implementation of Skylighting has limited but better-looking themes, a
 ### Usage
 
 ```
-Snibbets v2.0.31
+Snibbets v2.0.33
 
 Usage: snibbets [options] query
     -a, --all                        If a file contains multiple snippets, output all of them (no menu)

data/bin/snibbets

@@ -26,6 +26,7 @@ module Snibbets
     def run
       options = Snibbets.options
       arguments = Snibbets.arguments
+      Color.coloring = $stdout.isatty
 
       optparse = OptionParser.new do |opts|
         opts.banner = "Usage: #{File.basename(__FILE__)} [options] query"
@@ -94,14 +95,14 @@ module Snibbets
         end
 
         opts.on('-h', '--help', 'Display this screen') do
-          puts "Snibbets v#{VERSION}"
+          puts "{by}Snibbets {w}v#{VERSION}".x
           puts
           puts optparse
           Process.exit 0
         end
 
         opts.on('-v', '--version', 'Display version information') do
-          puts "Snibbets v#{VERSION}"
+          puts "{by}Snibbets {w}v#{VERSION}".x
           Process.exit 0
         end
 
@@ -116,7 +117,7 @@ module Snibbets
       if arguments[:save_config]
         config = Snibbets::Config.new
         config.write_config
-        puts "Configuration saved to #{config.config_file}"
+        puts "{bg}Configuration saved to {w}#{config.config_file}".x
       end
 
       if arguments[:edit_config]
@@ -127,8 +128,8 @@ module Snibbets
       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.'
+        puts '{br}The Snippets folder doesn\'t exist, please configure it.'.x
+        puts '{bg}Run `{bw}snibbets --configure{bg}` to open the config file for editing.'.x
         Process.exit 1
       end
 
@@ -155,7 +156,7 @@ module Snibbets
         if arguments[:save_config]
           Process.exit 0
         else
-          puts 'No search query'
+          puts '{br}No search query'.x
           puts optparse
           Process.exit 1
         end

data/lib/snibbets/colors.rb

@@ -0,0 +1,329 @@
+# frozen_string_literal: true
+
+# Cribbed from <https://github.com/flori/term-ansicolor>
+module Snibbets
+  class ::String
+    def x
+      Color.template(self)
+    end
+
+    def uncolor
+      Color.uncolor(self)
+    end
+  end
+
+  # Terminal output color functions.
+  module Color
+    ESCAPE_REGEX = /(?<=\[)(?:(?:(?:[349]|10)[0-9]|[0-9])?;?)+(?=m)/.freeze
+    # All available color names. Available as methods and string extensions.
+    #
+    # @example Use a color as a method. Color reset will be added to end of string.
+    #   Color.yellow('This text is yellow') => "\e[33mThis text is yellow\e[0m"
+    #
+    # @example Use a color as a string extension. Color reset added automatically.
+    #   'This text is green'.green => "\e[1;32mThis text is green\e[0m"
+    #
+    # @example Send a text string as a color
+    #   Color.send('red') => "\e[31m"
+    ATTRIBUTES = [
+      [:clear,               0], # String#clear is already used to empty string in Ruby 1.9
+      [:reset,               0], # synonym for :clear
+      [:bold,                1],
+      [:dark,                2],
+      [:italic,              3], # not widely implemented
+      [:underline,           4],
+      [:underscore,          4], # synonym for :underline
+      [:blink,               5],
+      [:rapid_blink,         6], # not widely implemented
+      [:negative,            7], # no reverse because of String#reverse
+      [:concealed,           8],
+      [:strikethrough,       9], # not widely implemented
+      [:strike,              9], # not widely implemented
+      [:black,              30],
+      [:red,                31],
+      [:green,              32],
+      [:yellow,             33],
+      [:blue,               34],
+      [:magenta,            35],
+      [:purple,             35],
+      [:cyan,               36],
+      [:white,              37],
+      [:bgblack,            40],
+      [:bgred,              41],
+      [:bggreen,            42],
+      [:bgyellow,           43],
+      [:bgblue,             44],
+      [:bgmagenta,          45],
+      [:bgpurple,           45],
+      [:bgcyan,             46],
+      [:bgwhite,            47],
+      [:boldblack,          90],
+      [:boldred,            91],
+      [:boldgreen,          92],
+      [:boldyellow,         93],
+      [:boldblue,           94],
+      [:boldmagenta,        95],
+      [:boldpurple,         95],
+      [:boldcyan,           96],
+      [:boldwhite,          97],
+      [:boldbgblack,       100],
+      [:boldbgred,         101],
+      [:boldbggreen,       102],
+      [:boldbgyellow,      103],
+      [:boldbgblue,        104],
+      [:boldbgmagenta,     105],
+      [:boldbgpurple,      105],
+      [:boldbgcyan,        106],
+      [:boldbgwhite,       107],
+      [:softpurple,  '0;35;40'],
+      [:hotpants,    '7;34;40'],
+      [:knightrider, '7;30;40'],
+      [:flamingo,    '7;31;47'],
+      [:yeller,      '1;37;43'],
+      [:whiteboard,  '1;30;47'],
+      [:chalkboard,  '1;37;40'],
+      [:led,         '0;32;40'],
+      [:redacted,    '0;30;40'],
+      [:alert,       '1;31;43'],
+      [:error,       '1;37;41'],
+      [:default, '0;39']
+    ].map(&:freeze).freeze
+
+    ATTRIBUTE_NAMES = ATTRIBUTES.transpose.first
+
+    # Returns true if Snibbets::Color supports the +feature+.
+    #
+    # The feature :clear, that is mixing the clear color attribute into String,
+    # is only supported on ruby implementations, that do *not* already
+    # implement the String#clear method. It's better to use the reset color
+    # attribute instead.
+    def support?(feature)
+      case feature
+      when :clear
+        !String.instance_methods(false).map(&:to_sym).include?(:clear)
+      end
+    end
+
+    # Template coloring
+    class ::String
+      ##
+      ## Extract the longest valid %color name from a string.
+      ##
+      ## Allows %colors to bleed into other text and still
+      ## be recognized, e.g. %greensomething still finds
+      ## %green.
+      ##
+      ## @return     [String] a valid color name
+      ##
+      def validate_color
+        valid_color = nil
+        compiled = ''
+        normalize_color.split('').each do |char|
+          compiled += char
+          valid_color = compiled if Color.attributes.include?(compiled.to_sym) || compiled =~ /^([fb]g?)?#([a-f0-9]{6})$/i
+        end
+
+        valid_color
+      end
+
+      ##
+      ## Normalize a color name, removing underscores,
+      ## replacing "bright" with "bold", and converting
+      ## bgbold to boldbg
+      ##
+      ## @return     [String] Normalized color name
+      ##
+      def normalize_color
+        gsub(/_/, '').sub(/bright/i, 'bold').sub(/bgbold/, 'boldbg')
+      end
+
+      # Get the calculated ANSI color at the end of the
+      # string
+      #
+      # @return     ANSI escape sequence to match color
+      #
+      def last_color_code
+        m = scan(ESCAPE_REGEX)
+
+        em = ['0']
+        fg = nil
+        bg = nil
+        rgbf = nil
+        rgbb = nil
+
+        m.each do |c|
+          case c
+          when '0'
+            em = ['0']
+            fg, bg, rgbf, rgbb = nil
+          when /^[34]8/
+            case c
+            when /^3/
+              fg = nil
+              rgbf = c
+            when /^4/
+              bg = nil
+              rgbb = c
+            end
+          else
+            c.split(/;/).each do |i|
+              x = i.to_i
+              if x <= 9
+                em << x
+              elsif x >= 30 && x <= 39
+                rgbf = nil
+                fg = x
+              elsif x >= 40 && x <= 49
+                rgbb = nil
+                bg = x
+              elsif x >= 90 && x <= 97
+                rgbf = nil
+                fg = x
+              elsif x >= 100 && x <= 107
+                rgbb = nil
+                bg = x
+              end
+            end
+          end
+        end
+
+        escape = "\e[#{em.join(';')}m"
+        escape += "\e[#{rgbb}m" if rgbb
+        escape += "\e[#{rgbf}m" if rgbf
+        escape + "\e[#{[fg, bg].delete_if(&:nil?).join(';')}m"
+      end
+    end
+
+    class << self
+      # Returns true if the coloring function of this module
+      # is switched on, false otherwise.
+      def coloring?
+        @coloring
+      end
+
+      attr_writer :coloring
+
+      ##
+      ## Enables colored output
+      ##
+      ## @example Turn color on or off based on TTY
+      ##   Snibbets::Color.coloring = STDOUT.isatty
+      def coloring
+        @coloring ||= true
+      end
+
+      ##
+      ## Convert a template string to a colored string.
+      ## Colors are specified with single letters inside
+      ## curly braces. Uppercase changes background color.
+      ##
+      ## w: white, k: black, g: green, l: blue, y: yellow, c: cyan,
+      ## m: magenta, r: red, b: bold, u: underline, i: italic,
+      ## x: reset (remove background, color, emphasis)
+      ##
+      ## @example Convert a templated string
+      ##   Color.template('{Rwb}Warning:{x} {w}you look a little {g}ill{x}')
+      ##
+      ## @param      input  [String, Array] The template
+      ##                    string. If this is an array, the
+      ##                    elements will be joined with a
+      ##                    space.
+      ##
+      ## @return     [String] Colorized string
+      ##
+      def template(input)
+        input = input.join(' ') if input.is_a? Array
+        fmt = input.gsub(/%/, '%%')
+        fmt = fmt.gsub(/(?<!\\u|\$)\{(\w+)\}/i) do
+          Regexp.last_match(1).split('').map { |c| "%<#{c}>s" }.join('')
+        end
+
+        colors = { w: white, k: black, g: green, l: blue,
+                   y: yellow, c: cyan, m: magenta, r: red,
+                   W: bgwhite, K: bgblack, G: bggreen, L: bgblue,
+                   Y: bgyellow, C: bgcyan, M: bgmagenta, R: bgred,
+                   d: dark, b: bold, u: underline, i: italic, x: reset }
+
+        fmt.empty? ? input : format(fmt, colors)
+      end
+    end
+
+    ATTRIBUTES.each do |c, v|
+      new_method = <<-EOSCRIPT
+        def #{c}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Snibbets::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Snibbets::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+
+      next unless c =~ /bold/
+
+      # Accept brightwhite in addition to boldwhite
+      new_method = <<-EOSCRIPT
+        def #{c.to_s.sub(/bold/, 'bright')}(string = nil)
+          result = ''
+          result << "\e[#{v}m" if Snibbets::Color.coloring?
+          if block_given?
+            result << yield
+          elsif string.respond_to?(:to_str)
+            result << string.to_str
+          elsif respond_to?(:to_str)
+            result << to_str
+          else
+            return result #only switch on
+          end
+          result << "\e[0m" if Snibbets::Color.coloring?
+          result
+        end
+      EOSCRIPT
+
+      module_eval(new_method)
+    end
+
+    def rgb(hex)
+      is_bg = hex.match(/^bg?#/) ? true : false
+      hex_string = hex.sub(/^([fb]g?)?#/, '')
+
+      parts = hex_string.match(/(?<r>..)(?<g>..)(?<b>..)/)
+      t = []
+      %w[r g b].each do |e|
+        t << parts[e].hex
+      end
+      color =
+      "\e[#{is_bg ? '48' : '38'};2;#{t.join(';')}m"
+    end
+
+    # Returns an uncolored version of the string, that is all
+    # ANSI-sequences are stripped from the string.
+    def uncolor(string = nil) # :yields:
+      if block_given?
+        yield.to_str.gsub(ESCAPE_REGEX, '')
+      elsif string.respond_to?(:to_str)
+        string.to_str.gsub(ESCAPE_REGEX, '')
+      elsif respond_to?(:to_str)
+        to_str.gsub(ESCAPE_REGEX, '')
+      else
+        ''
+      end
+    end
+
+    # Returns an array of all Snibbets::Color attributes as symbols.
+    def attributes
+      ATTRIBUTE_NAMES
+    end
+    extend self
+  end
+end

data/lib/snibbets/highlight.rb

@@ -2,6 +2,7 @@ module Snibbets
   module Highlight
     class << self
       def run_command_with_input(*cmd, input: nil, fallback: nil)
+
         stdout, _stderr, status = Open3.capture3(*cmd, stdin_data: input)
         if status.success?
           stdout
@@ -35,10 +36,9 @@ module Snibbets
                 else
                   ''
                 end
-        return code if syntax.nil? || syntax.empty?
+        return code if syntax.nil? || syntax.empty? || !Lexers.skylight_lexer?(syntax)
 
         run_command_with_input("#{executable} #{theme}--syntax #{syntax}", input: code)
-        # `echo #{Shellwords.escape(code)} | #{executable} #{theme}--syntax #{syntax}`
       end
 
       def highlight_fences(code, filename, syntax)
@@ -46,7 +46,8 @@ module Snibbets
 
         content.fences.each do |f|
           rx = Regexp.new(Regexp.escape(f[:code]))
-          highlighted = highlight(f[:code].gsub(/\\k</, '\k\<'), filename, f[:lang] || syntax).strip
+          syn = Lexers.normalize_lexer(f[:lang] || syntax)
+          highlighted = highlight(f[:code].gsub(/\\k</, '\k\<'), filename, syn).strip
           code.sub!(/#{rx}/, highlighted)
         end
 
@@ -62,6 +63,7 @@ module Snibbets
 
         theme ||= Snibbets.options[:highlight_theme] || 'monokai'
         syntax ||= Lexers.syntax_from_extension(filename)
+        syntax = Lexers.normalize_lexer(syntax)
 
         return code if ['text'].include?(syntax)
 
@@ -69,7 +71,11 @@ module Snibbets
         pygments = TTY::Which.which('pygmentize')
 
         if Snibbets.options[:highlighter] =~ /^s/ && !skylight.nil?
-          return highlight_skylight(skylight, code, syntax, theme)
+          if !Lexers.skylight_lexer?(syntax) && !pygments.nil?
+            return highlight_pygments(pygments, code, syntax, 'monokai')
+          else
+            return highlight_skylight(skylight, code, syntax, theme)
+          end
         elsif Snibbets.options[:highlighter] =~ /^p/ && !pygments.nil?
           return highlight_pygments(pygments, code, syntax, theme)
         elsif !skylight.nil?

data/lib/snibbets/lexers.rb

@@ -27,6 +27,15 @@ module Snibbets
         lex
       end
 
+      def skylight_lexer?(lexer)
+        SKYLIGHT_LEXERS_DB.split(/\n/).include?(lexer)
+      end
+
+      def normalize_lexer(lexer)
+        matches = LEXER_NORMALIZERS.select { |k, v| v.include? lexer }
+        matches.count.positive? ? matches.keys[0] : lexer
+      end
+
       def ext_to_lang(ext)
         return nil if ext.nil?
 

data/lib/snibbets/lexers_db.rb

@@ -233,7 +233,7 @@ nsis, nsi, nsh [nsi, nsh]
 nusmv [smv]
 objdump [objdump]
 objective-c++, objectivec++, obj-c++, objc++ [mm, hh]
-objective-c, objectivec, obj-c, objc [m, h]
+objectivec, objective-c, obj-c, objc [m, h]
 objective-j, objectivej, obj-j, objj [j]
 ocaml [ml, mli, mll, mly]
 odin [odin]
@@ -377,3 +377,164 @@ bro [bro]
 zephir [zep]
 zig [zig]
 EOLEXERS
+
+SKYLIGHT_LEXERS_DB=<<EOSKYLEX
+abc
+asn1
+asp
+ats
+awk
+actionscript
+ada
+agda
+alert
+apache
+bash
+bibtex
+boo
+c
+cs
+cpp
+cmake
+css
+changelog
+clojure
+coffee
+coldfusion
+comments
+commonlisp
+curry
+d
+dtd
+default
+diff
+djangotemplate
+dockerfile
+doxygen
+doxygenlua
+eiffel
+elixir
+elm
+email
+erlang
+fsharp
+fortranfixed
+fortranfree
+gcc
+glsl
+gnuassembler
+m4
+go
+graphql
+groovy
+html
+hamlet
+haskell
+haxe
+ini
+isocpp
+idris
+fasm
+nasm
+j
+json
+jsp
+java
+javascript
+javascriptreact
+javadoc
+julia
+kotlin
+llvm
+latex
+lex
+lilypond
+literatecurry
+literatehaskell
+lua
+mips
+makefile
+markdown
+mathematica
+matlab
+maxima
+mediawiki
+metafont
+modelines
+modula2
+modula3
+monobasic
+mustache
+nim
+nix
+ocaml
+objectivec
+objectivecpp
+octave
+opencl
+orgmode
+php
+povray
+pascal
+perl
+pike
+postscript
+powershell
+prolog
+protobuf
+pure
+purebasic
+python
+qml
+r
+relaxng
+raku
+relaxngcompact
+roff
+ruby
+rhtml
+rust
+sass
+scss
+sgml
+sml
+spdxcomments
+sql
+sqlmysql
+sqlpostgresql
+scala
+scheme
+stan
+stata
+swift
+systemverilog
+toml
+tcl
+tcsh
+texinfo
+mandoc
+typescript
+vhdl
+verilog
+xml
+xul
+yaml
+yacc
+zsh
+dot
+noweb
+rest
+sci
+sed
+xorg
+xslt
+EOSKYLEX
+
+LEXER_NORMALIZERS = {
+  'objectivec' => %w[objective-c obj-c],
+  'markdown' => %w[md mmd mkdn multimarkdown],
+  'bash' => %w[csh sh shell],
+  'javascript' => %w[js],
+  'javascriptreact' => %w[react],
+  'yaml' => %w[yml]
+}.freeze

data/lib/snibbets/os.rb

@@ -12,12 +12,12 @@ module Snibbets
         os = RbConfig::CONFIG['target_os']
         case os
         when /darwin.*/i
-          `echo #{Shellwords.escape(text)} | pbcopy`
+          `echo #{Shellwords.escape(text.uncolor)} | pbcopy`
         else
           if TTY::Which.exist?('xclip')
-            `echo #{Shellwords.escape(text)} | xclip -sel c`
+            `echo #{Shellwords.escape(text.uncolor)} | xclip -sel c`
           elsif TTY::Which.exist('xsel')
-            `echo #{Shellwords.escape(text)} | xsel -ib`
+            `echo #{Shellwords.escape(text.uncolor)} | xsel -ib`
           else
             puts 'Copy not supported on this system, please install xclip or xsel.'
           end

data/lib/snibbets/string.rb

@@ -84,7 +84,7 @@ module Snibbets
       # if it's a fenced code block, just discard the fence and everything
       # outside it
       if block.fenced?
-        code_blocks = block.scan(/(`{3,})(\w+)?\s*\n(.*?)\n\1/m)
+        code_blocks = block.scan(/(`{3,})(\S+)?\s*\n(.*?)\n\1/m)
         code_blocks.map! { |b| b[2].strip }
         return code_blocks.join("\n\n")
       end

data/lib/snibbets/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Snibbets
-  VERSION = '2.0.31'
+  VERSION = '2.0.33'
 end

data/lib/snibbets.rb

@@ -12,6 +12,7 @@ require 'tty-reader'
 require 'tty-which'
 require 'yaml'
 require_relative 'snibbets/version'
+require_relative 'snibbets/colors'
 require_relative 'snibbets/config'
 require_relative 'snibbets/which'
 require_relative 'snibbets/string'
@@ -84,7 +85,7 @@ module Snibbets
             end
 
       if try == 2 && cmd.nil?
-        puts "No search method available on this system. Please install ripgrep, silver surfer, ack, or grep."
+        puts "{br}No search method available on this system. Please install ripgrep, silver surfer, ack, or grep.".x
         Process.exit 1
       end
 
@@ -138,14 +139,14 @@ module Snibbets
             editor = TTY::Which.which(editor)
             system %(#{editor} "#{filepath}") if editor
           else
-            puts "No editor configured, or editor is missing"
+            puts "{br}No editor configured, or editor is missing".x
             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"
+          puts "{br}No editor configured, or editor is missing".x
           Process.exit 1
         end
       end
@@ -163,12 +164,12 @@ module Snibbets
       reader = TTY::Reader.new
 
       # printf 'What does this snippet do? '
-      input = reader.read_line('What does this snippet do? ').strip
+      input = reader.read_line('{by}What does this snippet do{bw}? '.x).strip
       # 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 = reader.read_line('What language(s) does it use (separate with spaces, full names or file extensions will work)? ').strip
+      input = reader.read_line('{by}What language(s) does it use ({xw}separate with spaces, full names or file extensions{by}){bw}? '.x).strip
       # input = $stdin.gets.chomp
       langs = input.split(/ +/).map(&:strip) unless input.empty?
       exts = langs.map { |lang| Lexers.lang_to_ext(lang) }.delete_if(&:nil?)
@@ -176,7 +177,7 @@ module Snibbets
 
       exts = langs if exts.empty?
 
-      filename = "#{title}#{exts.map { |x| ".#{x}"}.join('')}.#{Snibbets.options[:extension]}"
+      filename = "#{title}#{exts.map { |x| ".#{x}" }.join('')}.#{Snibbets.options[:extension]}"
       filepath = File.join(File.expand_path(Snibbets.options[:source]), filename)
       File.open(filepath, 'w') do |f|
         f.puts "tags: #{tags.join(', ')}
@@ -186,7 +187,7 @@ module Snibbets
 ```"
       end
 
-      puts "New snippet written to #{filename}."
+      puts "{bg}New snippet written to {bw}#{filename}.".x
 
       open_snippet_in_editor(filepath) if Snibbets.arguments[:edit_snippet]
       open_snippet_in_nvultra(filepath) if Snibbets.arguments[:nvultra]
@@ -280,12 +281,13 @@ module Snibbets
             snippets.each do |snip|
               header = File.basename(filepath, '.md')
               if $stdout.isatty
-                puts header
-                puts '-' * header.length
+                puts "{bw}#{header}{x}".x
+                puts "{dw}#{'-' * header.length}{x}".x
                 puts ''
               end
               code = snip['code']
               lang = snip['language']
+
               print(code, filepath, lang)
             end
           end
@@ -310,8 +312,8 @@ module Snibbets
         else
           if $stdout.isatty
             header = File.basename(filepath, '.md')
-            warn header
-            warn '=' * header.length
+            warn "{bw}#{header}{x}".x
+            warn "{dw}#{'=' * header.length}{x}".x
             warn ''
           end
           print_all(snippets, filepath)
@@ -320,7 +322,7 @@ module Snibbets
         print(answer.to_json, filepath)
       else
         if $stdout.isatty
-          header = "#{File.basename(filepath, '.md')}: #{answer['title']}"
+          header = "{bw}#{File.basename(filepath, '.md')}: {c}#{answer['title']}{x}".x
           warn header
           warn '-' * header.length
           warn ''
@@ -339,7 +341,7 @@ module Snibbets
         snippets.each do |snippet|
           lang = snippet['language']
 
-          puts "### #{snippet['title']} ###"
+          puts "{dw}### {xbw}#{snippet['title']} {xdw}### {x}".x
           puts ''
 
           print(snippet['code'], filepath, lang)
@@ -349,15 +351,15 @@ module Snibbets
     end
 
     def print(output, filepath, syntax = nil)
+      if Snibbets.options[:copy]
+        OS.copy(Snibbets.options[:all_notes] ? output : output.clean_code)
+        warn 'Copied to clipboard'
+      end
       if Snibbets.options[:highlight] && Snibbets.options[:output] == 'raw'
         $stdout.puts(Highlight.highlight(output, filepath, syntax))
       else
         $stdout.puts(Snibbets.options[:all_notes] ? output : output.clean_code)
       end
-      if Snibbets.options[:copy]
-        OS.copy(output)
-        $stderr.puts "Copied to clipboard"
-      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: snibbets
 version: !ruby/object:Gem::Version
-  version: 2.0.31
+  version: 2.0.33
 platform: ruby
 authors:
 - Brett Terpstra
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-04-20 00:00:00.000000000 Z
+date: 2023-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -257,6 +257,7 @@ files:
 - bin/snibbets
 - lib/snibbets.rb
 - lib/snibbets/array.rb
+- lib/snibbets/colors.rb
 - lib/snibbets/config.rb
 - lib/snibbets/hash.rb
 - lib/snibbets/highlight.rb