jtag 0.2.0 → 1.0.0

data/lib/jtag/string.rb

@@ -1,48 +1,246 @@
-# encoding: utf-8
-class String
-  # convert "WikiLink" to "Wiki link"
-  def break_camel
-    return downcase if match(/\A[A-Z]+\z/)
-    gsub(/([A-Z]+)([A-Z][a-z])/, '\1 \2').
-    gsub(/([a-z])([A-Z])/, '\1 \2').
-    downcase
-  end
+# frozen_string_literal: true
 
-  def strip_markdown
-    # strip all Markdown and Liquid tags
-    gsub(/\{%.*?%\}/,'').
-    gsub(/\[\^.+?\](\: .*?$)?/,'').
-    gsub(/\s{0,2}\[.*?\]: .*?$/,'').
-    gsub(/\!\[.*?\][\[\(].*?[\]\)]/,"").
-    gsub(/\[(.*?)\][\[\(].*?[\]\)]/,"\\1").
-    gsub(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/,'').
-    gsub(/^\#{1,6}\s*/,'').
-    gsub(/(\*{1,2})(\S.*?\S)\1/,"\\2").
-    gsub(/(`{3,})(.*?)\1/m,"\\2").
-    gsub(/^-{3,}\s*$/,"").
-    gsub(/`(.+)`/,"\\1").
-    gsub(/\n{2,}/,"\n\n")
-  end
+module JekyllTag
+  ## String helpers
+  class ::String
+    ##
+    ## normalize bool string to symbo
+    ##
+    ## @return [Symbol] :and :or :not
+    ##
+    def to_bool
+      case self.downcase
+      when /^a/i
+        :and
+      when /^o/i
+        :or
+      when /^n/i
+        :not
+      else
+        raise ArgumentError, "Invalid boolean string: #{self}"
+      end
+    end
 
-  def strip_tags
-    return CGI.unescapeHTML(
-        gsub(/<(script|style|pre|code|figure).*?>.*?<\/\1>/im, '').
-        gsub(/<!--.*?-->/m, '').
-        gsub(/<(img|hr|br).*?>/i, " ").
-        gsub(/<(dd|a|h\d|p|small|b|i|blockquote|li)( [^>]*?)?>(.*?)<\/\1>/i, " \\3 ").
-        gsub(/<\/?(dt|a|ul|ol)( [^>]+)?>/i, " ").
-        gsub(/<[^>]+?>/, '').
-        gsub(/\[\d+\]/, '').
-        gsub(/&#8217;/,"'").gsub(/&.*?;/,' ').gsub(/;/,' ')
-    ).lstrip.gsub("\xE2\x80\x98","'").gsub("\xE2\x80\x99","'").gsub("\xCA\xBC","'").gsub("\xE2\x80\x9C",'"').gsub("\xE2\x80\x9D",'"').gsub("\xCB\xAE",'"').squeeze(" ")
-  end
+    ##
+    ## Convert a string to a format symbol (:list, :csv, :complete, :json, :plist, :yaml)
+    ##
+    ## @return [Symbol] format symbol
+    ##
+    def to_format
+      case self.downcase
+      when /^j/i
+        :json
+      when /^p/i
+        :plist
+      when /^y/i
+        :yaml
+      when /^cs/i
+        :csv
+      when /^c/i
+        :complete
+      when /^l/i
+        :list
+      else
+        raise ArgumentError, "Invalid format string: #{self}"
+      end
+    end
 
-  def strip_urls
-    gsub(/(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?/i,"")
-  end
+    ## Check if a string is a list of files
+    ##
+    ## @param null [Boolean] check for null-delimited list
+    ##
+    ## @example Check if a string is a list of files
+    ##   "file1\nfile2\nfile3".file_list?
+    ##   # => true
+    ##
+    ## @return [Boolean]
+    def file_list?(null = false)
+      self.strip.split(null ? "\x00" : "\n").each do |line|
+        return false unless File.exist?(line)
+      end
+      true
+    end
 
-  def strip_all
-    strip_tags.strip_markdown.strip
-  end
+    ##
+    ## Check if string is YAML
+    ##
+    ## @example Check if a string is YAML
+    ##   "tags:\n  - tag1\n  - tag2".yaml?
+    ##   # => true
+    ##
+    ## @example Check if a string is not YAML
+    ##   "test string".yaml?
+    ##   # => false
+    ##
+    ## @return [Boolean]
+    ##
+    def yaml?
+      begin
+        YAML.load(self)
+      rescue
+        return false
+      end
+      true
+    end
+
+    ##
+    ## Matches the string against a given keyword based on various options.
+    ##
+    ## @param keyword [String] the keyword to match against the string.
+    ## @param options [Hash] a hash of options to customize the matching behavior.
+    ## @option options [Boolean] :case_sensitive (false) whether the match should be case-sensitive.
+    ## @option options [Boolean] :starts_with (false) whether the match should check if the string starts with the keyword.
+    ## @option options [Boolean] :exact (false) whether the match should be exact.
+    ## @option options [Boolean] :fuzzy (true) whether the match should be fuzzy.
+    ## @option options [Integer] :distance (2) the maximum distance between characters for a fuzzy match.
+    ##
+    ## @return [Boolean] true if the string matches the keyword based on the given options, false otherwise.
+    ##
+    def match_keyword(keyword, options = {})
+      options = {
+        case_sensitive: false,
+        starts_with: false,
+        exact: false,
+        fuzzy: false,
+        contains: false,
+        distance: 2,
+      }.merge(options)
+
+      keyword = Regexp.escape(keyword)
+
+      if options[:exact]
+        re = "^#{keyword}$"
+      elsif options[:starts_with]
+        re = "^#{keyword}"
+      elsif options[:fuzzy]
+        re = ".*#{keyword.split(//).join(".{,#{options[:distance] - 1}}")}.*"
+      else
+        re = ".*#{keyword}.*"
+      end
+
+      if options[:case_sensitive]
+        self.match?(/#{re}/)
+      else
+        self.match?(/#{re}/i)
+      end
+    end
 
+    ##
+    ## Check if a string is JSON
+    ##
+    ## @example Check if a string is JSON
+    ##   '{"tags": ["tag1", "tag2"]}'.json?
+    ##   # => true
+    ##
+    ## @example Check if a string is not JSON
+    ##   "test string".json?
+    ##   # => false
+    ##
+    ## @return [Boolean]
+    ##
+    ## @note JSON must be a hash or array
+    ##
+    def json?
+      begin
+        JSON.parse(self).is_a?(Hash) || JSON.parse(self).is_a?(Array)
+      rescue
+        return false
+      end
+      true
+    end
+
+    ##
+    ## Convert parenthetical count to hash
+    ##
+    ## @example Convert a string to a hash
+    ##   "tag (5)".to_count
+    ##   # => { "name" => "tag", "count" => 5 }
+    ##
+    ## @example Convert a string to a hash with no count
+    ##   "tag".to_count
+    ##   # => { "name" => "tag", "count" => 0 }
+    ##
+    ## @return [Hash] hash with name and count
+    ##
+    def to_count
+      tag = dup.strip.sub(/^[[:punct:]] /, "")
+      if tag =~ /(.*) \((\d+)\)/
+        { "name" => $1, "count" => $2.to_i }
+      else
+        { "name" => tag, "count" => 0 }
+      end
+    end
+
+    ##
+    ## Check if a string is a list of tags
+    ##
+    ## @example Check if a string is a list of tags
+    ##   "tag1\ntag2".tag_list?
+    ##   # => true
+    ##
+    ## @return [Boolean]
+    ##
+    ## @note One tag per line
+    ##   Tags are assumed to be alphanumeric and lowercase
+    ##   (spaces, underscores, and dashes allowed) with no
+    ##   leading or preceding or trailing punctuation
+    ##
+    def tag_list?
+      self.strip.split("\n").each do |tag|
+        return false unless tag.match?(/^(?![[:punct:]] )[a-z0-9 -_]+(?<![[:punct:]]) *$/)
+      end
+      true
+    end
+
+    def root_words
+      words = break_camel.split("[\s-]")
+      words.delete_if { |word| word =~ /^[^a-z]+$/i || word.length < 4 }
+      words.map { |word| word = Text::PorterStemming.stem(word).downcase }.join(" ")
+    end
+
+    # convert "WikiLink" to "Wiki link"
+    def break_camel
+      return downcase if match(/\A[A-Z]+\z/)
+      gsub(/([A-Z]+)([A-Z][a-z])/, '\1 \2').
+        gsub(/([a-z])([A-Z])/, '\1 \2').
+        downcase
+    end
+
+    def strip_markdown
+      # strip all Markdown and Liquid tags
+      gsub(/\{%.*?%\}/, "").
+        gsub(/\[\^.+?\](\: .*?$)?/, "").
+        gsub(/\s{0,2}\[.*?\]: .*?$/, "").
+        gsub(/\!\[.*?\][\[\(].*?[\]\)]/, "").
+        gsub(/\[(.*?)\][\[\(].*?[\]\)]/, "\\1").
+        gsub(/^\s{1,2}\[(.*?)\]: (\S+)( ".*?")?\s*$/, "").
+        gsub(/^\#{1,6}\s*/, "").
+        gsub(/(\*{1,2})(\S.*?\S)\1/, "\\2").
+        gsub(/(`{3,})(.*?)\1/m, "\\2").
+        gsub(/^-{3,}\s*$/, "").
+        gsub(/`(.+)`/, "\\1").
+        gsub(/\n{2,}/, "\n\n")
+    end
+
+    def strip_tags
+      return CGI.unescapeHTML(
+               gsub(/<(script|style|pre|code|figure).*?>.*?<\/\1>/im, "").
+                 gsub(/<!--.*?-->/m, "").
+                 gsub(/<(img|hr|br).*?>/i, " ").
+                 gsub(/<(dd|a|h\d|p|small|b|i|blockquote|li)( [^>]*?)?>(.*?)<\/\1>/i, " \\3 ").
+                 gsub(/<\/?(dt|a|ul|ol)( [^>]+)?>/i, " ").
+                 gsub(/<[^>]+?>/, "").
+                 gsub(/\[\d+\]/, "").
+                 gsub(/&#8217;/, "'").gsub(/&.*?;/, " ").gsub(/;/, " ")
+             ).lstrip.gsub("\xE2\x80\x98", "'").gsub("\xE2\x80\x99", "'").gsub("\xCA\xBC", "'").gsub("\xE2\x80\x9C", '"').gsub("\xE2\x80\x9D", '"').gsub("\xCB\xAE", '"').squeeze(" ")
+    end
+
+    def strip_urls
+      gsub(/(https?:\/\/)?([\da-z\.-]+)\.([a-z\.]{2,6})([\/\w \.-]*)*\/?/i, "")
+    end
+
+    def strip_all
+      strip_tags.strip_markdown.strip
+    end
+  end
 end

data/lib/jtag/stupid_json.rb

@@ -0,0 +1,319 @@
+# 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"
+    }
+  }
+}