jtag 0.1.19 → 0.1.21

data/jtag.completion.bash

@@ -0,0 +1,9 @@
+complete -F get_jtag_targets jtag
+function get_jtag_targets()
+{
+ if [ -z $2 ] ; then
+     COMPREPLY=(`jtag help -c`)
+ else
+     COMPREPLY=(`jtag help -c $2`)
+ fi
+}

data/jtag.gemspec

@@ -0,0 +1,25 @@
+# Ensure we require the local version and not one we might have installed already
+require "./lib/jtag/version.rb"
+spec = Gem::Specification.new do |s|
+  s.name = "jtag"
+  s.version = Jtag::VERSION
+  s.author = "Brett Terpstra"
+  s.email = "me@brettterpstra.com"
+  s.homepage = "http://brettterpstra.com"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Auto-tagging and tagging tools for Jekyll"
+  # Add your other files here if you make them
+  s.files = `git ls-files -z`.split("\x0").reject { |f| f.strip =~ %r{^((test|spec|features)/|\.git|buildnotes|.*\.taskpaper)} }
+
+  s.require_paths << "lib"
+  s.extra_rdoc_files = ["README.rdoc", "jtag.rdoc"]
+  s.rdoc_options << "--title" << "jtag" << "--main" << "README.rdoc"
+  s.bindir = "bin"
+  s.executables << "jtag"
+  s.add_development_dependency("rake")
+  s.add_development_dependency("rdoc")
+  s.add_development_dependency("aruba")
+  s.add_runtime_dependency("gli", "= 2.20.0")
+  s.add_runtime_dependency("plist")
+  s.add_runtime_dependency("csv")
+end

data/lib/jtag/array.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module JekyllTag
+  class ::Array
+    #
+    # Stringify keys in an array of hashes or arrays
+    #
+    # @return [Array] Array with nested hash keys stringified
+    #
+    def stringify_keys
+      each_with_object([]) do |v, arr|
+        arr << if v.is_a?(Hash)
+          v.stringify_keys
+        elsif v.is_a?(Array)
+          v.map { |x| x.is_a?(Hash) || x.is_a?(Array) ? x.stringify_keys : x }
+        else
+          v
+        end
+      end
+    end
+
+    #
+    # Symbolize keys in an array of hashes or arrays
+    #
+    # @return [Array] Array with nested hash keys symbolized
+    #
+    def symbolize_keys
+      each_with_object([]) do |v, arr|
+        arr << if v.is_a?(Hash)
+          v.symbolize_keys
+        elsif v.is_a?(Array)
+          v.map { |x| x.is_a?(Hash) || x.is_a?(Array) ? x.symbolize_keys : x }
+        else
+          v
+        end
+      end
+    end
+
+    def to_counts
+      map do |tag|
+        if tag.is_a?(String)
+          tag.to_count
+        else
+          tag
+        end
+      end
+    end
+  end
+end

data/lib/jtag/config_files/config.yml

@@ -1,5 +1,6 @@
 ---
-tags_location: localhost/data/tags.json
+tags_location: ~/Desktop/Code/jtag/test/test_data/tags.json
 min_matches: 2
-default_post_location:
+default_post_location: ~/Desktop/Code/jtag/test/test_posts/
 tags_key: tags
+post_extension: md

data/lib/jtag/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class FileNotFound < StandardError
+  def initialize(msg = "File not found")
+    super(msg)
+  end
+end
+
+class NoTagsFound < StandardError
+  def initialize(msg = "No tags found in input")
+    super(msg)
+  end
+end
+
+class NoResults < StandardError
+  def initialize(msg = "No results")
+    super(msg)
+  end
+end
+
+class NoValidFile < StandardError
+  def initialize(msg = "No valid filename in arguments")
+    super(msg)
+  end
+end
+
+class InvalidTagsFile < StandardError
+  def initialize(msg = "Invalid tags file")
+    super(msg)
+  end
+end

data/lib/jtag/hash.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module JekyllTag
+  class ::Hash
+    ## Turn all keys into string
+    ##
+    ## @return     [Hash] copy of the hash where all its keys are strings
+    ##
+    def stringify_keys
+      each_with_object({}) do |(k, v), hsh|
+        hsh[k.to_s] = if v.is_a?(Hash) || v.is_a?(Array)
+            v.stringify_keys
+          else
+            v
+          end
+      end
+    end
+
+    ##
+    ## Turn all keys into symbols
+    ##
+    ## @return [Hash] hash with symbolized keys
+    ##
+    def symbolize_keys
+      each_with_object({}) do |(k, v), hsh|
+        hsh[k.to_sym] = if v.is_a?(Hash) || v.is_a?(Array)
+            v.symbolize_keys
+          else
+            v
+          end
+      end
+    end
+
+    ##
+    ## Merge two hashes recursively (destructive)
+    ##
+    ## @see Hash#deep_merge
+    ##
+    ## @param [Hash] other hash to merge
+    ##
+    ## @return [Hash] merged hash
+    ##
+    def deep_merge!(other)
+      replace dup.deep_merge(other)
+    end
+
+    ##
+    ## Merge two hashes recursively
+    ##
+    ## @param [Hash] other hash to merge
+    ##
+    ## @return [Hash] merged hash
+    ##
+    ## @note This method is not the same as Hash#merge! because it merges recursively
+    ##
+    ## @example Merge two hashes
+    ##   { a: 1, b: { c: 2 } }.deep_merge({ b: { d: 3 } })
+    ##   # => { a: 1, b: { c: 2, d: 3 } }
+    ##
+    ## @example Merge two hashes with arrays
+    ##   { a: [1, 2] }.deep_merge({ a: [3] })
+    ##   # => { a: [1, 2, 3] }
+    ##
+    ## @example Merge two hashes with arrays and hashes
+    ##   { a: [1, 2], b: { c: 3 } }.deep_merge({ a: [3], b: { d: 4 } })
+    ##   # => { a: [1, 2, 3], b: { c: 3, d: 4 } }
+    ##
+    ## @example Merge two hashes with arrays and hashes and strings
+    ##   { a: [1, 2], b: { c: 3 } }.deep_merge({ a: [3], b: { d: 4 }, e: "string" })
+    ##   # => { a: [1, 2, 3], b: { c: 3, d: 4 }, e: "string" }
+    ##
+    ## @example Merge two hashes with arrays and hashes and strings and nil
+    ##   { a: [1, 2], b: { c: 3 } }.deep_merge({ a: [3], b: { d: 4 }, e: "string", f: nil })
+    ##   # => { a: [1, 2, 3], b: { c: 3, d: 4 }, e: "string", f: nil }
+    ##
+    ## @return [Hash]
+    ##
+    def deep_merge(other)
+      other.each_pair do |k, v|
+        tv = self[k]
+        self[k] = if tv.is_a?(Hash) && v.is_a?(Hash)
+            tv.deep_merge(v)
+          else
+            v
+          end
+      end
+      self
+    end
+
+    ##
+    ## Convert hash to array with parenthetical counts
+    ##
+    ## @return [Array] array of tags with parenthetical counts
+    ##
+    def to_counts
+      if key?("tag_counts")
+        self["tag_counts"]
+      elsif key?("tags")
+        self["tags"].map(&:to_count)
+      end
+    end
+  end
+end