ree_lib 1.0.0

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/truncate.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+class ReeString::Truncate
+  include Ree::FnDSL
+
+  fn :truncate
+
+  DEFAULT_OMISSION = "..."
+
+  doc(<<~DOC)
+    Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:
+    
+      truncate('Once upon a time in a world far far away', 27)
+      => "Once upon a time in a wo..."
+    
+    Pass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:
+    
+      truncate('Once upon a time in a world far far away', 27, separator: ' ')
+      => "Once upon a time in a..."
+    
+      truncate('Once upon a time in a world far far away', 27, separator: /\s/)
+      => "Once upon a time in a..."
+    
+    The last characters will be replaced with the <tt>:omission</tt> string (defaults to "...")
+    for a total length not exceeding <tt>length</tt>:
+    
+      truncate('And they found that many people were sleeping better.', 25, omission: '... (continued)')
+      => "And they f... (continued)"
+  DOC
+  contract(
+    String,
+    Integer,
+    Ksplat[
+      omission?: String,
+      separator?: Or[String, Regexp]
+    ] => String
+  )
+  def call(str, truncate_at, **opts)
+    return str.dup unless str.length > truncate_at
+
+    omission = opts[:omission] || DEFAULT_OMISSION
+    length_with_room_for_omission = truncate_at - omission.length
+    
+    stop = if opts[:separator]
+      str.rindex(opts[:separator], length_with_room_for_omission) || length_with_room_for_omission
+    else
+      length_with_room_for_omission
+    end
+
+    +"#{str[0, stop]}#{omission}"
+  end
+end

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/truncate_bytes.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+class ReeString::TruncateBytes
+  include Ree::FnDSL
+
+  fn :truncate_bytes
+
+  DEFAULT_OMISSION = "…"
+
+  doc(<<~DOC)
+    Truncates +text+ to at most <tt>bytesize</tt> bytes in length without
+    breaking string encoding by splitting multibyte characters or breaking
+    grapheme clusters ("perceptual characters") by truncating at combining
+    characters.
+    
+      >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".size
+      => 20
+      >> "🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪".bytesize
+      => 80
+      >> truncate_bytes("🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪🔪", 20)
+      => "🔪🔪🔪🔪…"
+    
+    The truncated text ends with the <tt>:omission</tt> string, defaulting
+    to "…", for a total length not exceeding <tt>bytesize</tt>.
+  DOC
+  contract(
+    String,
+    Integer,
+    Ksplat[
+      omission?: String,
+    ] => String
+  ).throws(ArgumentError)
+  def call(str, truncate_at, **opts)
+    str = str.dup
+    omission = opts[:omission] || DEFAULT_OMISSION
+
+    case
+    when str.bytesize <= truncate_at
+      str
+    when omission.bytesize > truncate_at
+      raise ArgumentError, "Omission #{omission.inspect} is #{omission.bytesize}, larger than the truncation length of #{truncate_at} bytes"
+    when omission.bytesize == truncate_at
+      omission.dup
+    else
+      String.new.tap do |cut|
+        cut_at = truncate_at - omission.bytesize
+
+        str.each_grapheme_cluster do |grapheme|
+          if cut.bytesize + grapheme.bytesize <= cut_at
+            cut << grapheme
+          else
+            break
+          end
+        end
+
+        cut << omission
+      end
+    end
+  end
+end

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/truncate_words.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+class ReeString::TruncateWords
+  include Ree::FnDSL
+
+  fn :truncate_words
+
+  DEFAULT_OMISSION = "..."
+
+  doc(<<~DOC)
+    Truncates a given +text+ after a given number of words (<tt>words_count</tt>):
+    
+      truncate_words('Once upon a time in a world far far away', 4)
+      # => "Once upon a time..."
+    
+    Pass a string or regexp <tt>:separator</tt> to specify a different separator of words:
+    
+      truncate_words('Once<br>upon<br>a<br>time<br>in<br>a<br>world', 5, separator: '<br>')
+      # => "Once<br>upon<br>a<br>time<br>in..."
+    
+    The last characters will be replaced with the <tt>:omission</tt> string (defaults to "..."):
+    
+      truncate_words('And they found that many people were sleeping better.', 5, omission: '... (continued)')
+      # => "And they found that many... (continued)"
+  DOC
+  contract(
+    String,
+    Integer,
+    Ksplat[
+      omission?: String,
+      separator?: Or[String, Regexp]
+    ] => String
+  )
+  def call(str, words_count, **opts)
+    str = str.dup
+    sep = opts[:separator] || /\s+/
+    sep = Regexp.escape(sep.to_s) unless Regexp === sep
+
+    if str =~ /\A((?>.+?#{sep}){#{words_count - 1}}.+?)#{sep}.*/m
+      $1 + (opts[:omission] || "...")
+    else
+      str
+    end
+  end
+end

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/underscore.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+class ReeString::Underscore
+  include Ree::FnDSL
+
+  fn :underscore do
+    link :acronyms_underscore_regex
+  end
+
+  doc(<<~DOC)
+    Makes an underscored, lowercase form from the expression in the string.
+    
+    Changes '::' to '/' to convert namespaces to paths.
+    
+      underscore('ActiveModel')               # => "active_model"
+      underscore('ActiveModel::Errors')       # => "active_model/errors"
+      underscore("NRIS", {acronyms: ['NRI']}) # => "nri_s"
+    
+    As a rule of thumb you can think of +underscore+ as the inverse of
+    #camelize, though there are cases where that does not hold:
+    
+      camelize(underscore('SSLError'))  # => "SslError"
+  DOC
+  contract(
+    String,
+    Ksplat[
+      acronyms?: ArrayOf[String]
+    ] => String
+  )
+  def call(camel_cased_word, **opts)
+    return camel_cased_word.to_s unless /[A-Z-]|::/.match?(camel_cased_word)
+
+    acronyms = opts[:acronyms] || []
+    regex = acronyms_underscore_regex(acronyms)
+
+    word = camel_cased_word.to_s.gsub("::", "/")
+    word.gsub!(regex) { "#{$1 && '_' }#{$2.downcase}" }
+    word.gsub!(/([A-Z]+)(?=[A-Z][a-z])|([a-z\d])(?=[A-Z])/) { ($1 || $2) << "_" }
+    word.tr!("-", "_")
+    word.downcase!
+    word
+  end
+end

data/lib/ree_lib/packages/ree_string/package/ree_string/functions/upcase_first.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+class ReeString::UpcaseFirst
+  include Ree::FnDSL
+
+  fn :upcase_first
+
+  doc(<<~DOC)
+    Converts just the first character to uppercase.
+    
+      upcase_first('what a Lovely Day') # => "What a Lovely Day"
+      upcase_first('w')                 # => "W"
+      upcase_first('')                  # => ""
+  DOC
+  contract(String => String)
+  def call(string)
+    string.length > 0 ? string[0].upcase.concat(string[1..-1]) : ""
+  end
+end

data/lib/ree_lib/packages/ree_string/package/ree_string.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module ReeString
+  include Ree::PackageDSL
+	
+  package do
+    depends_on :ree_text
+  end
+
+end

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/acronyms_camelize_regex.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "acronyms_camelize_regex",
+  "path": "packages/ree_string/package/ree_string/functions/acronyms_camelize_regex.rb",
+  "mount_as": "fn",
+  "class": "ReeString::AcronymsCamelizeRegex",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Regexp",
+      "args": [
+        {
+          "arg": "acronyms",
+          "type": "ArrayOf[String]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/acronyms_underscore_regex.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "acronyms_underscore_regex",
+  "path": "packages/ree_string/package/ree_string/functions/acronyms_underscore_regex.rb",
+  "mount_as": "fn",
+  "class": "ReeString::AcronymsUnderscoreRegex",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Regexp",
+      "args": [
+        {
+          "arg": "acronyms",
+          "type": "ArrayOf[String]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/camelize.schema.json

@@ -0,0 +1,38 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "camelize",
+  "path": "packages/ree_string/package/ree_string/functions/camelize.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Camelize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Converts strings to UpperCamelCase.\nIf the +uppercase_first_letter+ parameter is set to false, then produces\nlowerCamelCase.\n\nAlso converts '/' to '::' which is useful for converting\npaths to namespaces.\n\n  camelize('active_model')                # => \"ActiveModel\"\n  camelize('active_model', false)         # => \"activeModel\"\n  camelize('active_model/errors')         # => \"ActiveModel::Errors\"\n  camelize('active_model/errors', false)  # => \"activeModel::Errors\"\n\nAs a rule of thumb you can think of +camelize+ as the inverse of\n#underscore, though there are cases where that does not hold:\n\n  camelize(underscore('SSLError'))        # => \"SslError\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "str",
+          "type": "String"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:uppercase_first_letter? => Bool, :acronyms? => HashOf[String, String]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+    {
+      "target": "acronyms_camelize_regex",
+      "package_name": "ree_string",
+      "as": "acronyms_camelize_regex",
+      "imports": [
+
+      ]
+    }
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/dasherize.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "dasherize",
+  "path": "packages/ree_string/package/ree_string/functions/dasherize.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Dasherize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Replaces underscores with dashes in the string.\n\n  dasherize('puni_puni') # => \"puni-puni\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "underscored_word",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/deconstantize.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "deconstantize",
+  "path": "packages/ree_string/package/ree_string/functions/deconstantize.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Deconstantize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Removes the rightmost segment from the constant expression in the string.\n\n  deconstantize('Net::HTTP')   # => \"Net\"\n  deconstantize('::Net::HTTP') # => \"::Net\"\n  deconstantize('String')      # => \"\"\n  deconstantize('::String')    # => \"\"\n  deconstantize('')            # => \"\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "path",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/demodulize.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "demodulize",
+  "path": "packages/ree_string/package/ree_string/functions/demodulize.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Demodulize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Removes the module part from the expression in the string.\n\n  demodulize('ActiveSupport::Inflector::Inflections') # => \"Inflections\"\n  demodulize('Inflections')                           # => \"Inflections\"\n  demodulize('::Inflections')                         # => \"Inflections\"\n  demodulize('')                                      # => \"\"\n\nSee also #deconstantize.",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "path",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/indent.schema.json

@@ -0,0 +1,35 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "indent",
+  "path": "packages/ree_string/package/ree_string/functions/indent.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Indent",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Indents the lines in the receiver:\n\n  string = \n  def some_method\n    some_code\n  end\n  indent(string, 2)\n  # =>\n    def some_method\n      some_code\n    end\n\nThe second argument, +indent_string+, specifies which indent string to\nuse. The default is +nil+, which tells the method to make a guess by\npeeking at the first indented line, and fallback to a space if there is\nnone.\n\n  indent(\"  foo\", 2)              # => \"    foo\"\n  indent(\"foo\n\t\tbar\", 2, \"\t\") # => \"\t\tfoo\n\t\t\t\tbar\"\n  indent(\"foo\", 2, \"\t\")          # => \"\t\tfoo\"\n\nWhile +indent_string+ is typically one space or tab, it may be any string.\n\nThe third argument, +empty_lines+, is a flag that says whether\nempty lines should be indented. Default is false.\n\n  indent(\"foo\n\nbar\", 2)                    # => \"  foo\n\n  bar\"\n  indent(\"foo\n\nbar\", 2, empty_lines: true) # => \"  foo\n  \n  bar\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "string",
+          "type": "String"
+        },
+        {
+          "arg": "amount",
+          "type": "Integer"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:indent_string? => String, :empty_lines? => Bool]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/is_blank.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "0.1.0",
+  "name": "is_blank",
+  "path": "packages/ree_string/package/ree_string/functions/is_blank.rb",
+  "mount_as": "fn",
+  "class": "ReeString::IsBlank",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "Bool",
+      "args": [
+        {
+          "arg": "str",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/pluralize.schema.json

@@ -0,0 +1,35 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "pluralize",
+  "path": "packages/ree_string/package/ree_string/functions/pluralize.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Pluralize",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "count",
+          "type": "Integer"
+        },
+        {
+          "arg": "single",
+          "type": "String"
+        },
+        {
+          "arg": "plural",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/remove.schema.json

@@ -0,0 +1,31 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "remove",
+  "path": "packages/ree_string/package/ree_string/functions/remove.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Remove",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Alters the string by removing all occurrences of the patterns.\n  remove(\"foo bar test\", [\" test\", /bar/])         # => \"foo \"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "str",
+          "type": "String"
+        },
+        {
+          "arg": "patterns",
+          "type": "ArrayOf[Or[String, Regexp]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/squish.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "squish",
+  "path": "packages/ree_string/package/ree_string/functions/squish.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Squish",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Returns the string, first removing all whitespace on both ends of\nthe string, and then changing remaining consecutive whitespace\ngroups into one space each.\n\nNote that it handles both ASCII and Unicode whitespace.\n\n  squish(%{ Multi-line\n     string })                          # => \"Multi-line string\"\n  squish(\" foo   bar    \n   \t   boo\") # => \"foo bar boo\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "str",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/strip_heredoc.schema.json

@@ -0,0 +1,27 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "strip_heredoc",
+  "path": "packages/ree_string/package/ree_string/functions/strip_heredoc.rb",
+  "mount_as": "fn",
+  "class": "ReeString::StripHeredoc",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Strips indentation in heredocs.\n\nFor example:\n\n  puts strip_heredoc(<<-USAGE)\n    This command does such and such.\n\n    Supported options are:\n      -h         This message\n      ...\n  USAGE\n\nthe user would see the usage message aligned against the left margin.\n\nTechnically, it looks for the least indented non-empty line\nin the whole string, and removes that amount of leading whitespace.",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "string",
+          "type": "String"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}

data/lib/ree_lib/packages/ree_string/schemas/ree_string/functions/truncate.schema.json

@@ -0,0 +1,35 @@
+{
+  "schema_type": "object",
+  "ree_version": "1.0.1",
+  "name": "truncate",
+  "path": "packages/ree_string/package/ree_string/functions/truncate.rb",
+  "mount_as": "fn",
+  "class": "ReeString::Truncate",
+  "factory": null,
+  "methods": [
+    {
+      "doc": "Truncates a given +text+ after a given <tt>length</tt> if +text+ is longer than <tt>length</tt>:\n\n  truncate('Once upon a time in a world far far away', 27)\n  => \"Once upon a time in a wo...\"\n\nPass a string or regexp <tt>:separator</tt> to truncate +text+ at a natural break:\n\n  truncate('Once upon a time in a world far far away', 27, separator: ' ')\n  => \"Once upon a time in a...\"\n\n  truncate('Once upon a time in a world far far away', 27, separator: / /)\n  => \"Once upon a time in a...\"\n\nThe last characters will be replaced with the <tt>:omission</tt> string (defaults to \"...\")\nfor a total length not exceeding <tt>length</tt>:\n\n  truncate('And they found that many people were sleeping better.', 25, omission: '... (continued)')\n  => \"And they f... (continued)\"",
+      "throws": [
+
+      ],
+      "return": "String",
+      "args": [
+        {
+          "arg": "str",
+          "type": "String"
+        },
+        {
+          "arg": "truncate_at",
+          "type": "Integer"
+        },
+        {
+          "arg": "opts",
+          "type": "Ksplat[:omission? => String, :separator? => Or[String, Regexp]]"
+        }
+      ]
+    }
+  ],
+  "links": [
+
+  ]
+}