jtag 0.1.21 → 0.2.0

data/lib/jtag/stupid_json.rb

@@ -1,319 +0,0 @@
-# encoding: utf-8
-#
-## Stupid small pure Ruby JSON parser & generator.
-#
-# Copyright © 2013 Mislav Marohnić
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy of this
-# software and associated documentation files (the “Software”), to deal in the Software
-# without restriction, including without limitation the rights to use, copy, modify,
-# merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
-# permit persons to whom the Software is furnished to do so, subject to the following
-# conditions:
-#
-# The above copyright notice and this permission notice shall be included in all copies or
-# substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
-# INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
-# PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
-# OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
-# OTHER DEALINGS IN THE SOFTWARE.
-
-require 'strscan'
-require 'forwardable'
-
-# Usage:
-#
-#   JSON.parse(json_string) => Array/Hash
-#   JSON.generate(object)   => json string
-#
-# Run tests by executing this file directly. Pipe standard input to the script to have it
-# parsed as JSON and to display the result in Ruby.
-#
-class JSON
-  def self.parse(data) new(data).parse end
-
-  WSP = /\s+/
-  OBJ = /[{\[]/;    HEN = /\}/;  AEN = /\]/
-  COL = /\s*:\s*/;  KEY = /\s*,\s*/
-  NUM = /-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/
-  BOL = /true|false/;  NUL = /null/
-
-  extend Forwardable
-
-  attr_reader :scanner
-  alias_method :s, :scanner
-  def_delegators :scanner, :scan, :matched
-  private :s, :scan, :matched
-
-  def initialize data
-    @scanner = StringScanner.new data.to_s
-  end
-
-  def parse
-    space
-    object
-  end
-
-  private
-
-  def space() scan WSP end
-
-  def endkey() scan(KEY) or space end
-
-  def object
-    matched == '{' ? hash : array if scan(OBJ)
-  end
-
-  def value
-    object or string or
-      scan(NUL) ? nil :
-      scan(BOL) ? matched.size == 4:
-      scan(NUM) ? eval(matched) :
-      error
-  end
-
-  def hash
-    obj = {}
-    space
-    repeat_until(HEN) { k = string; scan(COL); obj[k] = value; endkey }
-    obj
-  end
-
-  def array
-    ary = []
-    space
-    repeat_until(AEN) { ary << value; endkey }
-    ary
-  end
-
-  SPEC = {'b' => "\b", 'f' => "\f", 'n' => "\n", 'r' => "\r", 't' => "\t"}
-  UNI = 'u'; CODE = /[a-fA-F0-9]{4}/
-  STR = /"/; STE = '"'
-  ESC = '\\'
-
-  def string
-    if scan(STR)
-      str, esc = '', false
-      while c = s.getch
-        if esc
-          str << (c == UNI ? (s.scan(CODE) || error).to_i(16).chr : SPEC[c] || c)
-          esc = false
-        else
-          case c
-          when ESC then esc = true
-          when STE then break
-          else str << c
-          end
-        end
-      end
-      str
-    end
-  end
-
-  def error
-    raise "parse error at: #{scan(/.{1,10}/m).inspect}"
-  end
-
-  def repeat_until reg
-    until scan(reg)
-      pos = s.pos
-      yield
-      error unless s.pos > pos
-    end
-  end
-
-  module Generator
-    def generate(obj)
-      raise ArgumentError unless obj.is_a? Array or obj.is_a? Hash
-      generate_type(obj)
-    end
-    alias dump generate
-
-    private
-
-    def generate_type(obj)
-      type = obj.is_a?(Numeric) ? :Numeric : obj.class.name
-      begin send(:"generate_#{type}", obj)
-      rescue NoMethodError; raise ArgumentError, "can't serialize #{type}"
-      end
-    end
-
-    ESC_MAP = Hash.new {|h,k| k }.update \
-      "\r" => 'r',
-      "\n" => 'n',
-      "\f" => 'f',
-      "\t" => 't',
-      "\b" => 'b'
-
-    def quote(str) %("#{str}") end
-
-    def generate_String(str)
-      quote str.gsub(/[\r\n\f\t\b"\\]/) { "\\#{ESC_MAP[$&]}"}
-    end
-
-    def generate_simple(obj) obj.inspect end
-    alias generate_Numeric generate_simple
-    alias generate_TrueClass generate_simple
-    alias generate_FalseClass generate_simple
-
-    def generate_Symbol(sym) generate_String(sym.to_s) end
-
-    def generate_Time(time)
-      quote time.strftime(time.utc? ? "%F %T UTC" : "%F %T %z")
-    end
-    def generate_Date(date) quote date.to_s end
-
-    def generate_NilClass(*) 'null' end
-
-    def generate_Array(ary) '[%s]' % ary.map {|o| generate_type(o) }.join(', ') end
-
-    def generate_Hash(hash)
-      '{%s}' % hash.map { |key, value|
-        "#{generate_String(key.to_s)}: #{generate_type(value)}"
-      }.join(', ')
-    end
-  end
-
-  extend Generator
-end
-
-if __FILE__ == $0
-if !$stdin.tty?
-  data = JSON.parse $stdin.read
-  require 'pp'
-  pp data
-else
-  require 'test/unit'
-  require 'date'
-  class ParserTest < Test::Unit::TestCase
-    PARSED = JSON.parse DATA.read
-    def parsed() PARSED end
-    def parse_string(str) JSON.parse(%(["#{str}"]).gsub('\\\\', '\\')).first end
-    def test_string
-      assert_equal "Pagination library for \"Rails 3\", Sinatra, Merb, DataMapper, and more",
-        parsed['head']['repository']['description']
-    end
-    def test_string_specials
-      assert_equal "\r\n\t\f\b", parse_string('\r\n\t\f\b')
-      assert_equal "aA", parse_string('\u0061\u0041')
-      assert_equal "\e", parse_string('\u001B')
-      assert_equal "xyz", parse_string('\x\y\z')
-      assert_equal '"\\/', parse_string('\"\\\\\\/')
-      assert_equal 'no #{interpolation}', parse_string('no #{interpolation}')
-    end
-    def test_hash
-      assert_equal %w[label ref repository sha user], parsed['head'].keys.sort
-    end
-    def test_number
-      assert_equal 124.3e2, parsed['head']['repository']['size']
-    end
-    def test_bool
-      assert_equal true, parsed['head']['repository']['fork']
-      assert_equal false, parsed['head']['repository']['private']
-    end
-    def test_nil
-      assert_nil parsed['head']['user']['company']
-    end
-    def test_array
-      assert_equal ["4438f", {"a" => "b"}], parsed['head']['sha']
-    end
-    def test_invalid
-      assert_raises(RuntimeError) { JSON.parse %({) }
-      assert_raises(RuntimeError) { JSON.parse %({ "foo": }) }
-      assert_raises(RuntimeError) { JSON.parse %([ "foo": "bar" ]) }
-      assert_raises(RuntimeError) { JSON.parse %([ ~"foo" ]) }
-      assert_raises(RuntimeError) { JSON.parse %([ "foo ]) }
-      assert_raises(RuntimeError) { JSON.parse %([ "foo\\" ]) }
-      assert_raises(RuntimeError) { JSON.parse %([ "foo\\uabGd" ]) }
-    end
-  end
-
-  class GeneratorTest < Test::Unit::TestCase
-    def generate(obj) JSON.generate(obj) end
-    def test_array
-      assert_equal %([1, 2, 3]), generate([1, 2, 3])
-    end
-    def test_bool
-      assert_equal %([true, false]), generate([true, false])
-    end
-    def test_null
-      assert_equal %([null]), generate([nil])
-    end
-    def test_string
-      assert_equal %(["abc\\n123"]), generate(["abc\n123"])
-    end
-    def test_string_unicode
-      assert_equal %(["ć\\"č\\nž\\tš\\\\đ"]), generate(["ć\"č\nž\tš\\đ"])
-    end
-    def test_time
-      time = Time.utc(2012, 04, 19, 1, 2, 3)
-      assert_equal %(["2012-04-19 01:02:03 UTC"]), generate([time])
-    end
-    def test_date
-      time = Date.new(2012, 04, 19)
-      assert_equal %(["2012-04-19"]), generate([time])
-    end
-    def test_symbol
-      assert_equal %(["abc"]), generate([:abc])
-    end
-    def test_hash
-      json = generate(:abc => 123, 123 => 'abc')
-      assert_match /^\{/, json
-      assert_match /\}$/, json
-      assert_equal [%("123": "abc"), %("abc": 123)], json[1...-1].split(', ').sort
-    end
-    def test_nested_structure
-      json = generate(:hash => {1=>2}, :array => [1,2])
-      assert json.include?(%("hash": {"1": 2}))
-      assert json.include?(%("array": [1, 2]))
-    end
-    def test_invalid_json
-      assert_raises(ArgumentError) { generate("abc") }
-    end
-    def test_invalid_object
-      err = assert_raises(ArgumentError) { generate("a" => Object.new) }
-      assert_equal "can't serialize Object", err.message
-    end
-  end
-end
-end
-
-__END__
-{
-  "head": {
-    "ref": "master",
-    "repository": {
-      "forks": 0,
-      "integrate_branch": "rails3",
-      "watchers": 1,
-      "language": "Ruby",
-      "description": "Pagination library for \"Rails 3\", Sinatra, Merb, DataMapper, and more",
-      "has_downloads": true,
-      "fork": true,
-      "created_at": "2011/10/24 03:20:48 -0700",
-      "homepage": "http://github.com/mislav/will_paginate/wikis",
-      "size": 124.3e2,
-      "private": false,
-      "has_wiki": true,
-      "name": "will_paginate",
-      "owner": "dbackeus",
-      "url": "https://github.com/dbackeus/will_paginate",
-      "has_issues": false,
-      "open_issues": 0,
-      "pushed_at": "2011/10/25 05:44:05 -0700"
-    },
-    "label": "dbackeus:master",
-    "sha": ["4438f", { "a" : "b" }],
-    "user": {
-      "name": "David Backeus",
-      "company": null,
-      "gravatar_id": "ebe96524f5db9e92188f0542dc9d1d1a",
-      "location": "Stockholm (Sweden)",
-      "type": "User",
-      "login": "dbackeus"
-    }
-  }
-}

data/lib/jtag/util.rb

@@ -1,237 +0,0 @@
-# frozen_string_literal: true
-
-module JekyllTag
-  # JTag utilities
-  class Util
-    attr_writer :debug_level
-    attr_writer :silent
-    attr_accessor :log
-    attr_accessor :config_target
-
-    DEBUG_LEVELS = {
-      :error => 0,
-      :warn => 1,
-      :info => 2,
-      :debug => 3,
-    }
-
-    CONFIG_FILES = %w{blacklist.txt config.yml stopwords.txt synonyms.yml}
-
-    ##
-    ## Output tags in the specified format
-    ##
-    ## @param tags [Array] array of tags
-    ## @param options [Hash] hash of options
-    ##
-    ## @option options :format [String] format to output tags in
-    ## @option options :print0 [Boolean] print tags with null delimiter
-    ## @option options :filename [String] filename to output
-    ## @option options :content [String] content to output for complete format
-    ## @option options :grouping [String] grouping key for YAML tags
-    ##
-    ## @return [void]
-    ##
-    def output_tags(tags, options)
-      # Determine the format for output, defaulting to "yaml" if not specified
-      format = options[:format]&.to_format || :yaml
-      # Determine if tags should be printed with a null delimiter
-      print0 = options[:print0] || false
-      # Determine the filename for output, if specified
-      filename = options[:filename] || false
-      # Content that was piped in
-      content = options[:content] || false
-
-      tags.sort!
-      tags.uniq!
-
-      case format
-      when "complete"
-        if filename || content
-          content = filename ? IO.read(File.expand_path(filename)) : content
-          parts = content.split(/---\s*\n/)
-          if parts.count < 2
-            console_log "No front matter found in #{filename}", level: :error, err: true
-            yaml = {}
-            body = content
-          else
-            yaml = YAML.load(parts[1])
-            body = parts[2..-1].join("\n")
-          end
-          options[:grouping] ||= "tags"
-          yaml[options[:grouping]] = tags
-          console_log "#{filename}", level: :info, err: true if filename
-          console_log yaml.to_yaml + "---\n" + body, level: :error, err: false
-        else
-          console_log tags.join("\n"), level: :error, err: false
-        end
-      when "list"
-        # Join tags with a null character delimiter
-        console_log tags.map(&:strip).join(print0 ? "\x00" : "\n"), level: :error, err: false, file: filename
-      when "csv"
-        # Log the tags in CSV format
-        console_log tags.to_csv
-      when "json"
-        # Create a hash with tags and optional filename, then log as JSON
-        out = {}
-        out["tags"] = tags
-        out["path"] = filename if filename
-        console_log out.to_json
-      when "plist"
-        # Create a hash with optional filename, then log as plist
-        out = {}
-        out["path"] = filename if filename
-        out["tags"] = tags
-        console_log out.to_plist
-      else
-        # Default to YAML format, create a hash with grouping and tags, then log as YAML
-        out = {}
-        options[:grouping] ||= "tags"
-        out[options[:grouping]] = tags
-        console_log out.to_yaml
-      end
-    end
-
-    ##
-    ## Logging
-    ##
-    ### Log levels
-    ## 0 = error
-    ## 1 = warn
-    ## 2 = info
-    ## 3 = debug
-    ##
-    ### Debug levels
-    ## 1 = errors only
-    ## 2 = errors and warnings
-    ## 3 = errors, warnings and info
-    ## 4 = errors, warnings, info and debug
-    ##
-    ### Test level < debug level (true = return, false = continue)
-    ## true = continue
-    ## false = return
-    ##
-    ### Examples
-    ## send info (2) and debug is errors and warnings (2) (2 < 2 = return)
-    ## send error (0) and debug is errors and warnings (2) (0 < 2 = continue)
-    ## send warning (1) and debug is errors only (1) (1 < 1 = return)
-    ## send error (0) and debug level is silent (0) (0 < 0 = return)
-    ## send debug (3) and debug level is info (3) (3 < 4 = return)
-    ## send debug (3) and debug level is debug (4) (3 < 4 = continue)
-    ##
-    ## @example Log an info message
-    ##   console_log("This is an info message", level: :info)
-    ##
-    ## @example Log a warning message and output to STDERR
-    ##   console_log("This is a warning message", level: :warn, err: true)
-    ##
-    ## @param msg [String] message to log
-    ## @param options [Hash] hash of options
-    ##
-    ## @option options :level [Symbol] level of message (info, warn, error, debug)
-    ## @option options :err [Boolean] print to STDERR
-    ## @option options :log [Boolean] write to log file
-    ## @option options :filename [String] write to file
-    ##
-    ## @return [void]
-    ##
-    def console_log(msg = "", options = {})
-      level = options[:level] || :info
-      err = options[:err] || false
-      options[:log] ||= false
-
-      return unless DEBUG_LEVELS[level.to_sym] < @debug_level
-
-      if options[:log]
-        if err
-          @log.warn(msg)
-        else
-          @log.info(msg)
-        end
-      end
-
-      if options[:filename]
-        File.open(options[:filename], "w") do |f|
-          f.puts msg
-        end
-      end
-
-      return if @silent
-
-      unless err
-        $stdout.puts msg
-      else
-        $stderr.puts msg
-      end
-    end
-
-    #
-    ## Write configuration files
-    ##
-    ## @param atomic [Boolean] force write of config files
-    ##
-    ## @example Write configuration files
-    ##   write_config
-    ##
-    ## @return [void]
-    ##
-    def write_config(atomic = false)
-      # Get the root path of the gem
-      jtag_gem = Gem.loaded_specs["jtag"]
-      gem_root = jtag_gem.full_gem_path || File.expand_path("../../", __dir__)
-      # Get the lib directory within the gem
-      gem_lib = File.join(gem_root, "lib")
-      # Define the source directory for the configuration files
-      config_source = File.join(gem_lib, "/jtag/config_files/")
-
-      FileUtils.rm_rf(@config_target) if File.directory?(@config_target) && atomic
-
-      # If the config target directory does not exist or atomic is true, copy the config files
-      if !File.directory?(@config_target)
-        # Ensure the target directory exists
-        FileUtils.mkdir_p(@config_target)
-        CONFIG_FILES.each do |file|
-          FileUtils.cp(File.join(config_source, file), @config_target)
-        end
-        # console_log "Configuration files written to #{@config_target}", level: :warn
-      end
-
-      # Iterate over each config file
-      CONFIG_FILES.each do |file|
-        # If the config file does not exist in the target directory, copy it from the source
-        unless File.exist?(File.join(@config_target, file))
-          # Define the source and target file paths
-          source_file = File.join(config_source, file)
-          target_file = File.join(@config_target, file)
-          # Copy the source file to the target location
-          FileUtils.cp(source_file, target_file)
-          # Log that the config file has been added
-          console_log "Config file #{file} added."
-        end
-      end
-
-      # Output the final location of the configuration files
-      console_log
-      console_log "Configuration files are located in the folder: " + @config_target
-      # Output a reminder to set the tags_location in the config.yml file
-      console_log %Q{Make sure that "tags_location" in the config.yml file is set to your tags json file.}
-    end
-
-    ## Check if all config files are present
-    ##
-    ## @example Check if all config files are present
-    ##   config_files_complete?
-    ##   # => true
-    ##
-    ## @return [Boolean]
-    def config_files_complete?
-      # Move ~/.jtag if needed
-      update_deprecated_config
-
-      # Check if all config files are present
-      CONFIG_FILES.each do |file|
-        return false unless File.exist?(File.join(@config_target, file))
-      end
-      true
-    end
-  end
-end

data/mise.toml

@@ -1,2 +0,0 @@
-[tools]
-ruby = "3.3.0"