strings-case 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 5985a29d7cd211560f31949ea90cacd559ec100cc993c12cd2d5c2a6c0fdb683
+  data.tar.gz: 9e542cd6473627f1f5bad0b05ec47a0e8b667bcbf00377cac5a918da13524fad
+SHA512:
+  metadata.gz: 9e73e4189c6af4a9458022af07b20a8863e9fb344dadd223a1e86ba16c44a2a798c7d8fd5f663b556e89f7c8577d060791eb05c59bc967c9d9e07faa39d07ac6
+  data.tar.gz: 7052e5e1fffd616a6c00fb92cb2869586a21232d062f1625c09503c79b396a21e645e432d63a648f479465ac99b25f25dfc83b1284009bff79a230d662ee7711

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+# Change log
+
+## [v0.1.0] - 2019-11-11
+
+* Initial implementation and release
+
+[v0.1.0]: https://github.com/piotrmurach/strings-case/compare/v0.1.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Piotr Murach
+
+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.

data/README.md

@@ -0,0 +1,317 @@
+<div align="center">
+  <img width="225" src="https://github.com/piotrmurach/strings/blob/master/assets/strings_logo.png" alt="strings logo" />
+</div>
+
+# Strings::Case
+
+[![Gem Version](https://badge.fury.io/rb/strings-case.svg)][gem]
+[![Build Status](https://secure.travis-ci.org/piotrmurach/strings-case.svg?branch=master)][travis]
+[![Build status](https://ci.appveyor.com/api/projects/status/yr87c96wxp1cw2ep?svg=true)][appveyor]
+[![Maintainability](https://api.codeclimate.com/v1/badges/7938258c4af196a19843/maintainability)][codeclimate]
+[![Coverage Status](https://coveralls.io/repos/github/piotrmurach/strings-case/badge.svg?branch=master)][coverage]
+[![Inline docs](http://inch-ci.org/github/piotrmurach/strings-case.svg?branch=master)][inchpages]
+
+[gem]: http://badge.fury.io/rb/strings-case
+[travis]: http://travis-ci.org/piotrmurach/strings-case
+[appveyor]: https://ci.appveyor.com/project/piotrmurach/strings-case
+[codeclimate]: https://codeclimate.com/github/piotrmurach/strings-case/maintainability
+[coverage]: https://coveralls.io/github/piotrmurach/strings-case?branch=master
+[inchpages]: http://inch-ci.org/github/piotrmurach/strings-case
+
+> Convert strings to different cases.
+
+**Strings::Case** provides string case conversions for [Strings](https://github.com/piotrmurach/strings) utilities.
+
+## Motivation
+
+Popular solutions that deal with transforming string cases work well in simple cases.(Sorry ;-) With more complex strings you may get unexpected results:
+
+```ruby
+ActiveSupport::Inflector.underscore("supports IPv6 on iOS?")
+# => "supports i_pv6 on i_os?"
+```
+
+In contrast, `Strings::Case` aims to be able to transform any string to expected case:
+
+```ruby
+Strings::Case.underscore("supports IPv6 on iOS?")
+# => "supports_ipv6_on_ios"
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'strings-case'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install strings-case
+
+
+## Features
+
+* No monkey-patching String class
+* Converts any string to specified case
+* Supports Unicode characters
+* Provides many common case transformations
+* Allows to preserve casing of acronyms
+
+## Contents
+
+* [1. Usage](#1-usage)
+* [2. API](#2-api)
+  * [2.1 camelcase](#21-camelcase)
+  * [2.2 constcase](#22-constcase)
+  * [2.3 headercase](#23-headercase)
+  * [2.4 kebabcase | dashcase](#24-kebabcase--dashcase)
+  * [2.5 pascalcase](#25-pascalcase)
+  * [2.6 pathcase](#26-pathcase)
+  * [2.7 sentencecase](#27-sentencecase)
+  * [2.8 snakecase | underscore](#28-snakecase--underscore)
+  * [2.9 titlecase](#29-titlecase)
+* [3. Extending String class](#3-extending-string-class)
+
+## 1. Usage
+
+The `Strings::Case` is a module with functions for transforming between string cases:
+
+```ruby
+Strings::Case.snakecase("foo bar baz")
+# => "foo_bar_baz"
+````
+
+It will transform any string into expected case:
+
+```ruby
+Strings::Case.snake_case("supports IPv6 on iOS?")
+# => "supports_ipv6_on_ios"
+```
+
+You can apply case transformations to Unicode characters:
+
+```ruby
+Strings::Case.snake_case("ЗдравствуйтеПривет")
+# => "здравствуйте_привет"
+```
+
+Here is a quick summary of available transformations:
+
+| Case Type | Result |
+| --------- | ------- |
+| ```Strings::Case.camelcase("foo bar baz")``` | `"fooBarBaz"` |
+| ```Strings::Case.constcase("foo bar baz")``` | `"FOO_BAR_BAZ"` |
+| ```Strings::Case.headercase("foo bar baz")``` | `"Foo-Bar-Baz"` |
+| ```Strings::Case.kebabcase("foo bar baz")``` | `"foo-bar-baz"` |
+| ```Strings::Case.pascalcase("foo bar baz")``` | `"FooBarBaz"` |
+| ```Strings::Case.pathcase("foo bar baz")``` | `"foo/bar/baz"` |
+| ```Strings::Case.sentencecase("foo bar baz")``` | `"Foo bar baz"` |
+| ```Strings::Case.snakecase("foo bar baz")``` | `"foo_bar_baz"` |
+| ```Strings::Case.titlecase("foo bar baz")``` | `"Foo Bar Baz"` |
+
+## 2. API
+
+### 2.1 camelcase
+
+To convert a string into a camel case, that is, a case with all the words capitilized apart from the first one and compouned together without any space use `camelase` method. For example:
+
+```ruby
+Strings::Case.camelcase("HTTP Response Code")
+# => "httpResponseCode"
+```
+
+To preserve the acronyms use the `:acronyms` option:
+
+```ruby
+Strings::Case.camelcase("HTTP Response Code", acronyms: ["HTTP"])
+# => "HTTPResponseCode"
+```
+
+### 2.2 constcase
+
+To convert a string into a constant case, that is, a case with all the words uppercased and separated by underscore character use `constcase`. For example:
+
+```ruby
+Strings::Case.constcase("HTTP Response Code")
+# => "HTTP_RESPONSE_CODE"
+```
+
+### 2.3 headercase
+
+To covert a string into a header case, that is, a case with all the words capitalized and separated by a hypen use `headercase`. For example:
+
+```ruby
+Strings::Case.headercase("HTTP Response Code")
+# => "Http-Response-Code"
+```
+
+To preserve the acronyms use the `:acronyms` option:
+
+```ruby
+Strings::Case.headercase("HTTP Response Code", acronyms: ["HTTP"])
+# => "HTTP-Response-Code"
+```
+### 2.4 kebabcase | dashcase
+
+To convert a string into a kebab case, that is, a case with all the words lowercased and separted by a dash, like a words kebabab on a skewer, use `kebabcase` or `dashcase` methods. For example:
+
+```ruby
+Strings::Case.kebabcase("HTTP Response Code")
+# => "http-response-code"
+```
+
+To preserve the acronyms use the `:acronyms` option:
+
+```ruby
+Strings::Case.dashcase("HTTP Response Code", acronyms: ["HTTP"])
+
+expect(dashed).to eq("HTTP-response-code")
+```
+
+### 2.5 pascalcase
+
+To convert a string into a pascal case, that is, a case with all the words capitilized and compounded together without a space, use `pascalcase` method. For example:
+
+```ruby
+Strings::Case.pascalcase("HTTP Response Code")
+# => "HttpResponseCode"
+```
+
+To preserve the acronyms use the `:acronyms` option:
+
+```ruby
+Strings::Case.pascalcase("HTTP Response Code")
+# => "HTTPResponseCode"
+```
+
+### 2.6 pathcase
+
+To convert a string into a file path use `pathcase`:
+
+```ruby
+Strings::Case.pathcase("HTTP Response Code")
+# => "http/response/code"
+````
+
+To preserve the acronyms use the `:acronyms` option:
+
+```ruby
+Strings::Case.pathcase("HTTP Response Code", acronyms: ["HTTP"])
+# => "HTTP/response/code"
+```
+
+By default the `/` is used as a path separator. To change this use a `:sep` option. For example, on Windows the file path separator is `\`:
+
+```ruby
+Strings::Case.pathcase("HTTP Response Code", separator: "\\")
+# => "http\response\code"
+```
+
+### 2.7 `sentencecase`
+
+To turn a string into a sentence use `sentencecase`:
+
+```ruby
+Strings::Case.sentencecase("HTTP Response Code")
+# => "Http response code"
+```
+
+To preserve the `HTTP` acronym use the `:acronyms` option:
+
+```ruby
+Strings::Case.sentencecase("HTTP Response Code", acronyms: ["HTTP"])
+# => "HTTP response code"
+```
+
+### 2.8 `snakecase` | `underscore`
+
+To convert a string into a snake case by lowercasing all the characters and separating them with an `_` use `snakecase` or `underscore` methods. For example:
+
+```ruby
+Strings::Case.snakecase("HTTP Response Code")
+# => "http_response_code"
+```
+
+To preserve acronyms in your string use the `:acronyms` option. For example:
+
+```ruby
+Strings::Case.snakecase("HTTP Response Code", acronyms: ["HTTP"])
+# => "HTTP_response_code"
+```
+
+### 2.9 `titlecase`
+
+To convert a string into a space delimited words that have their first letter capitalized use `titlecase`. For example:
+
+```ruby
+Strings::Case.titlecase("HTTPResponseCode")
+# => "Http Response Code"
+```
+
+To preserve the `HTTP` acronym use the `:acronyms` option:
+
+```ruby
+Strings::Case.titlecase("HTTP response code", acronyms: ["HTTP"])
+# => "HTTP Response Code"
+```
+
+## 3. Extending String class
+
+Though it is highly discouraged to pollute core Ruby classes, you can add the required methods to `String` class by using refinements.
+
+For example, if you wish to only extend strings with `wrap` method do:
+
+```ruby
+module MyStringExt
+  refine String do
+    def snakecase(*args)
+      Strings::Case.snakecase(self, *args)
+    end
+  end
+end
+```
+
+Then `snakecase` method will be available for any strings where refinement is applied:
+
+```ruby
+using MyStringExt
+
+"foo bar baz".snakecase
+# => "foo_bar_baz"
+```
+
+However, if you want to include all the **Strings::Case** methods, you can use provided extensions file:
+
+```ruby
+require "strings/case/extensions"
+
+using Strings::Case::Extensions
+```
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/piotrmurach/strings-case. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Strings::Case project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/piotrmurach/strings-case/blob/master/CODE_OF_CONDUCT.md).
+
+## Copyright
+
+Copyright (c) 2019 Piotr Murach. See LICENSE for further details.

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/gem_tasks"
+
+FileList["tasks/**/*.rake"].each(&method(:import))
+
+desc "Run all specs"
+task ci: %w[ spec ]
+
+task default: :spec

data/lib/strings-case.rb

@@ -0,0 +1 @@
+require_relative "strings/case"

data/lib/strings/case.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require_relative "case/version"
+
+module Strings
+  module Case
+    DIGITS = ("0".."9").freeze
+    UP_LETTERS = ("A".."Z").freeze
+    DOWN_LETTERS = ("a".."z").freeze
+    DELIMITERS = [" ", "\n", "\t", "_", ".", "-", "#", "?", "!"].freeze
+    NONALPHANUMERIC = (32..127).map(&:chr) -
+      (DIGITS.to_a + DOWN_LETTERS.to_a + UP_LETTERS.to_a + DELIMITERS)
+    UPCASE = /(?<!\p{Lu})\p{Lu}$/.freeze
+    LOWERCASE = /\p{Lu}(?=\p{Ll})/.freeze
+
+    class Error < StandardError; end
+
+    # Prevent changing case
+    module NullCase
+      def downcase
+        self
+      end
+      alias upcase downcase
+      alias capitalize downcase
+    end
+
+    # Convert string to camel case:
+    # * start with a lowercase character
+    # * every subsequent word has its first character uppercased
+    # * all words are compounded together
+    #
+    # @example
+    #   camelcase("foo bar baz") # => "fooBarBaz"
+    #
+    # @param [String] string
+    #   the string to camelcase
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default none
+    #
+    # @api public
+    def camelcase(string, acronyms: [], separator: "")
+      res = parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+
+      return res if res.to_s.empty?
+
+      acronyms_regex = /^(#{acronyms.join("|")})/
+      if !acronyms.empty? && (res =~ acronyms_regex)
+        res
+      else
+        res[0].downcase + res[1..-1]
+      end
+    end
+    module_function :camelcase
+
+    alias lower_camelcase camelcase
+    module_function :lower_camelcase
+
+    # Converts string to a constant
+    #
+    # @example
+    #   constantcase("foo bar baz") # => "FOO_BAR_BAZ"
+    #
+    # @param [String] string
+    #   the string to turn into constant
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the words separator, by default "_"
+    #
+    # @api public
+    def constcase(string, separator: "_")
+      parsecase(string, sep: separator, casing: :upcase)
+    end
+    module_function :constcase
+
+    alias constantcase constcase
+    module_function :constantcase
+
+    # Convert string to a HTTP Header
+    #
+    # @example
+    #   headercase("foo bar baz") # = "Foo-Bar-Baz"
+    #
+    # @param [String] string
+    #   the string to turn into header
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the words separator, by default "-"
+    #
+    # @api public
+    def headercase(string, acronyms: [], separator: "-")
+      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    end
+    module_function :headercase
+
+    # Converts string to lower case words linked by hyphenes
+    #
+    # @example
+    #   kebabcase("fooBarBaz") # => "foo-bar-baz"
+    #
+    #   kebabcase("__FOO_BAR__") # => "foo-bar"
+    #
+    # @param [String] string
+    #   the string to convert to dashed string
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default hyphen
+    #
+    # @return [String]
+    #
+    # @api public
+    def kebabcase(string, acronyms: [], separator: "-")
+      parsecase(string, acronyms: acronyms, sep: separator)
+    end
+    module_function :kebabcase
+
+    alias dashcase kebabcase
+    module_function :dashcase
+
+    # Convert string to pascal case:
+    # * every word has its first character uppercased
+    # * all words are compounded together
+    #
+    # @example
+    #   pascalcase("foo bar baz") # => "FooBarBaz"
+    #
+    # @param [String] string
+    #   the string to convert to camel case with capital letter
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default none
+    #
+    # @api public
+    def pascalcase(string, acronyms: [], separator: "")
+      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    end
+    module_function :pascalcase
+
+    alias upper_camelcase pascalcase
+    module_function :upper_camelcase
+
+    # Convert string into a file path.
+    #
+    # By default uses `/` as a path separator.
+    #
+    # @example
+    #   pathcase("foo bar baz") # => "foo/bar/baz"
+    #
+    #   pathcase("FooBarBaz") # => "foo/bar/baz"
+    #
+    # @param [String] string
+    #   the string to convert to file path
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default `/`
+    #
+    # @api public
+    def pathcase(string, acronyms: [], separator: "/")
+      parsecase(string, acronyms: acronyms, sep: separator)
+    end
+    module_function :pathcase
+
+    # Convert string int a sentence
+    #
+    # @example
+    #   sentencecase("foo bar baz") # => "Foo bar baz"
+    #
+    # @param [String] string
+    #   the string to convert to sentence
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default a space
+    #
+    # @api public
+    def sentencecase(string, acronyms: [], separator: " ")
+      res = parsecase(string, acronyms: acronyms, sep: separator, casing: :downcase)
+
+      return res if res.to_s.empty?
+
+      res[0].upcase + res[1..-1]
+    end
+    module_function :sentencecase
+
+    # Convert string into a snake_case
+    #
+    # @example
+    #   snakecase("foo bar baz") # => "foo_bar_baz"
+    #
+    #   snakecase("ЗдравствуйтеПривет") # => "здравствуйте_привет"
+    #
+    #   snakecase("HTTPResponse") # => "http_response"
+    #
+    # @param [String] string
+    #   the string to convert to snake case
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default `_`
+    #
+    # @api public
+    def snakecase(string, acronyms: [], separator: "_")
+      parsecase(string, acronyms: acronyms, sep: separator)
+    end
+    module_function :snakecase
+
+    alias underscore snakecase
+    module_function :underscore
+
+    # Convert string into a title case
+    #
+    # @example
+    #   titlecase("foo bar baz") # => "Foo Bar Baz"
+    #
+    # @param [String] string
+    #   the string to convert to title case
+    # @param [Array[String]] acronyms
+    #   the acronyms to use to prevent modifications
+    # @param [String] separator
+    #   the separator for linking words, by default a space
+    #
+    # @api public
+    def titlecase(string, acronyms: [], separator: " ")
+      parsecase(string, acronyms: acronyms, sep: separator, casing: :capitalize)
+    end
+    module_function :titlecase
+
+    # Parse string and transform to desired case
+    #
+    # @api private
+    def parsecase(string, acronyms: [], sep: "_", casing: :downcase)
+      return if string.nil?
+
+      words = split_into_words(string, sep: sep)
+
+      no_case = ->(w) { acronyms.include?(w) ? w.extend(NullCase) : w }
+
+      words
+        .map(&no_case)
+        .map(&casing)
+        .join(sep)
+    end
+    module_function :parsecase
+    private_class_method :parsecase
+
+    # Split string into words
+    #
+    # @return [Array[String]]
+    #   the split words
+    #
+    # @api private
+    def split_into_words(string, sep: nil)
+      words = []
+      word = []
+      last = string.length - 1
+
+      string.each_char.with_index do |char, i|
+        combine = word[-1].to_s + char
+
+        if combine =~ UPCASE
+          if word.size <= 1 # don't allow single letter words
+            word << char
+          else
+            words << word.join
+            word = [char]
+          end
+        elsif combine =~ LOWERCASE
+          letter = word.pop
+          if word.size <= 1 # don't allow single letter words
+            word << letter << char
+          else
+            words << word.join
+            word = [letter, char]
+          end
+        elsif DELIMITERS.include?(char)
+          words << word.join unless word.empty?
+          if i.zero? && char == sep
+            words << ""
+          else
+            word = []
+          end
+        elsif NONALPHANUMERIC.include?(char)
+          # noop
+        else
+          word << char
+        end
+
+        if last == i
+          word = [""] if char == sep
+          words << word.join unless word.empty?
+        end
+      end
+
+      words
+    end
+    module_function :split_into_words
+  end # Case
+end # Strings