strings-case 0.1.0

data/lib/strings/case/extensions.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module Strings
+  module Case
+    module Extensions
+      refine String do
+        def camelcase(*args)
+          Strings::Case.camelcase(self, *args)
+        end
+        alias lower_camelcase camelcase
+
+        def constcase(*args)
+          Strings::Case.constcase(self, *args)
+        end
+        alias constantcase constcase
+
+        def headercase(*args)
+          Strings::Case.headercase(self, *args)
+        end
+
+        def kebabcase(*args)
+          Strings::Case.kebabcase(self, *args)
+        end
+        alias dashcase kebabcase
+
+        def pascalcase(*args)
+          Strings::Case.pascalcase(self, *args)
+        end
+        alias upper_camelcase pascalcase
+
+        def pathcase(*args)
+          Strings::Case.pathcase(self, *args)
+        end
+
+        def sentencecase(*args)
+          Strings::Case.sentencecase(self, *args)
+        end
+
+        def snakecase(*args)
+          Strings::Case.snakecase(self, *args)
+        end
+        alias underscore snakecase
+
+        def titlecase(*args)
+          Strings::Case.titlecase(self, *args)
+        end
+      end
+    end # Extensions
+  end # Case
+end # Strings

data/lib/strings/case/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Strings
+  module Case
+    VERSION = "0.1.0"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+if ENV["COVERAGE"] || ENV["TRAVIS"]
+  require "simplecov"
+  require "coveralls"
+
+  SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new([
+    SimpleCov::Formatter::HTMLFormatter,
+    Coveralls::SimpleCov::Formatter
+  ])
+
+  SimpleCov.start do
+    command_name "spec"
+    add_filter "spec"
+  end
+end
+
+require "bundler/setup"
+require "strings/case"
+
+module Helpers
+  def modern_ruby?
+    Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("2.4")
+  end
+end
+
+RSpec.configure do |config|
+  config.extend Helpers
+
+  # Enable flags like --only-failures and --next-failure
+  config.example_status_persistence_file_path = ".rspec_status"
+
+  # Disable RSpec exposing methods globally on `Module` and `main`
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end

data/spec/unit/camelcase_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#camelcase" do
+  {
+    nil => nil,
+    "" => "",
+    "f" => "f",
+    "1234" => "1234",
+    "FOO" => "foo",
+    "FooBar" => "fooBar",
+    "fooBar" => "fooBar",
+    "foo bar" => "fooBar",
+    "Foo - Bar" => "fooBar",
+    "foo & bar" => "fooBar",
+    "FooFooBar" => "fooFooBar",
+    "Foo2Foo2Bar" => "foo2Foo2Bar",
+    "foo-bar-baz" => "fooBarBaz",
+    "foo_bar_1_2" => "fooBar12",
+    "_foo_bar_baz_" => "fooBarBaz",
+    "--foo-bar--" => "fooBar",
+    "FOO_BAR_baz" => "fooBarBaz",
+    "__FOO_BAR__" => "fooBar",
+    "Foo w1th apo's and punc]t" => "fooW1thAposAndPunct",
+    "getHTTPResponse" => "getHttpResponse",
+    "currencyISOCode" => "currencyIsoCode",
+    "get2HTTPResponse" => "get2HttpResponse",
+    "HTTPResponseCode" => "httpResponseCode",
+    "HTTPResponseCodeXY" => "httpResponseCodeXy",
+    "supports IPv6 on iOS?" =>  "supportsIpv6OnIos"
+  }.each do |actual, expected|
+    it "applies camelcase to #{actual.inspect} -> #{expected.inspect}" do
+      expect(Strings::Case.camelcase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.camelcase("ЗдравствуйтеПривет")).to eq("здравствуйтеПривет")
+  end
+
+  it "allows to preserve acronyms" do
+    camelized = Strings::Case.lower_camelcase("HTTP response code", acronyms: ["HTTP"])
+
+    expect(camelized).to eq("HTTPResponseCode")
+  end
+
+  it "changes a separator to :" do
+    camelized = Strings::Case.camelcase("HTTP response code", separator: ":")
+
+    expect(camelized).to eq("http:Response:Code")
+  end
+end

data/spec/unit/constcase_spec.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#constcase" do
+  {
+    nil => nil,
+    "" => "",
+    "1234" => "1234",
+    "FOO" => "FOO",
+    "FooBar" => "FOO_BAR",
+    "fooBar" => "FOO_BAR",
+    "foo bar" => "FOO_BAR",
+    "Foo - Bar" => "FOO_BAR",
+    "foo & bar" => "FOO_BAR",
+    "FooFooBar" => "FOO_FOO_BAR",
+    "Foo2Foo2Bar" => "FOO2_FOO2_BAR",
+    "foo-bar-baz" => "FOO_BAR_BAZ",
+    "foo_bar_1_2" => "FOO_BAR_1_2",
+    "_foo_bar_baz_" => "_FOO_BAR_BAZ_",
+    "--foo-bar--" => "FOO_BAR",
+    "FOO_BAR_baz" => "FOO_BAR_BAZ",
+    "__FOO_BAR__" => "_FOO_BAR_",
+    "Foo w1th apo's and punc]t" => "FOO_W1TH_APOS_AND_PUNCT",
+    "getHTTPResponse" => "GET_HTTP_RESPONSE",
+    "currencyISOCode" => "CURRENCY_ISO_CODE",
+    "get2HTTPResponse" => "GET2_HTTP_RESPONSE",
+    "HTTPResponseCode" => "HTTP_RESPONSE_CODE",
+    "HTTPResponseCodeXY" => "HTTP_RESPONSE_CODE_XY",
+    "supports IPv6 on iOS?" =>  "SUPPORTS_IPV6_ON_IOS",
+  }.each do |actual, expected|
+    it "applies constcase to #{actual.inspect} -> #{expected.inspect}" do
+      expect(Strings::Case.constcase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.constantcase("ЗдравствуйтеПривет")).to eq("ЗДРАВСТВУЙТЕ_ПРИВЕТ")
+  end
+
+  it "changes a separator to :" do
+    constant = Strings::Case.constcase("HTTP response code", separator: ":")
+
+    expect(constant).to eq("HTTP:RESPONSE:CODE")
+  end
+end

data/spec/unit/extensions_spec.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+require "strings/case/extensions"
+
+using Strings::Case::Extensions
+
+RSpec.describe Strings::Case::Extensions do
+  it "camelcase a string" do
+    expect("foo bar baz".camelcase).to eq("fooBarBaz")
+  end
+
+  it "camelcase a string with acronyms" do
+    expect("HTTP Response Code".lower_camelcase(acronyms: ["HTTP"])).to eq("HTTPResponseCode")
+  end
+
+  it "constcase a string" do
+    expect("foo bar baz".constcase).to eq("FOO_BAR_BAZ")
+  end
+
+  it "headercases a string" do
+    expect("foo bar baz".headercase).to eq("Foo-Bar-Baz")
+  end
+
+  it "headercases a string with acronyms" do
+    expect("HTTP Response Code".headercase(acronyms: ["HTTP"])).to eq("HTTP-Response-Code")
+  end
+
+  it "kebabcases a string" do
+    expect("foo bar baz".kebabcase).to eq("foo-bar-baz")
+  end
+
+  it "kebabcases a string with acronyms" do
+    expect("HTTP Response Code".dashcase(acronyms: ["HTTP"])).to eq("HTTP-response-code")
+  end
+
+  it "pascalcases a string" do
+    expect("foo bar baz".pascalcase).to eq("FooBarBaz")
+  end
+
+  it "pascalcases a string with acronyms" do
+    expect("HTTP Response Code".pascalcase(acronyms: ["HTTP"])).to eq("HTTPResponseCode")
+  end
+
+  it "pathcases a string" do
+    expect("foo bar baz".pathcase).to eq("foo/bar/baz")
+  end
+
+  it "pathcases a string with acronyms" do
+    expect("HTTP Response Code".pathcase(acronyms: ["HTTP"])).to eq("HTTP/response/code")
+  end
+
+  it "sentencecases a string" do
+    expect("foo bar baz".sentencecase).to eq("Foo bar baz")
+  end
+
+  it "sentencecases a string with acronyms" do
+    expect("HTTP Response Code".sentencecase(acronyms: ["HTTP"])).to eq("HTTP response code")
+  end
+
+  it "snakecases a string" do
+    expect("foo bar baz".snakecase).to eq("foo_bar_baz")
+  end
+
+  it "snakecases a string with acronyms" do
+    expect("HTTP Response Code".underscore(acronyms: ["HTTP"])).to eq("HTTP_response_code")
+  end
+
+  it "titlecases a string" do
+    expect("foo bar baz".titlecase).to eq("Foo Bar Baz")
+  end
+
+  it "titlecase a string with acronyms" do
+    expect("HTTP Response Code".titlecase(acronyms: ["HTTP"])).to eq("HTTP Response Code")
+  end
+end

data/spec/unit/headercase_spec.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#headercase" do
+  {
+    nil => nil,
+    "" => "",
+    "1234" => "1234",
+    "FOO" => "Foo",
+    "FooBar" => "Foo-Bar",
+    "fooBar" => "Foo-Bar",
+    "foo bar" => "Foo-Bar",
+    "Foo - Bar" => "Foo-Bar",
+    "foo & bar" => "Foo-Bar",
+    "FooFooBar" => "Foo-Foo-Bar",
+    "Foo2Foo2Bar" => "Foo2-Foo2-Bar",
+    "foo-bar-baz" => "Foo-Bar-Baz",
+    "foo_bar_1_2" => "Foo-Bar-1-2",
+    "_foo_bar_baz_" => "Foo-Bar-Baz",
+    "--foo-bar--" => "-Foo-Bar-",
+    "FOO_BAR_baz" => "Foo-Bar-Baz",
+    "__FOO_BAR__" => "Foo-Bar",
+    "Foo w1th apo's and punc]t" => "Foo-W1th-Apos-And-Punct",
+    "getHTTPResponse" => "Get-Http-Response",
+    "currencyISOCode" => "Currency-Iso-Code",
+    "get2HTTPResponse" => "Get2-Http-Response",
+    "HTTPResponseCode" => "Http-Response-Code",
+    "HTTPResponseCodeXY" => "Http-Response-Code-Xy",
+    "supports IPv6 on iOS?" =>  "Supports-Ipv6-On-Ios",
+  }.each do |actual, expected|
+    it "applies headercase to #{actual.inspect} -> #{expected.inspect}" do
+      expect(Strings::Case.headercase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.headercase("ЗдравствуйтеПривет")).to eq("Здравствуйте-Привет")
+  end
+
+  it "allows to preserve acronyms" do
+    headered = Strings::Case.headercase("HTTP response code", acronyms: ["HTTP"])
+
+    expect(headered).to eq("HTTP-Response-Code")
+  end
+
+  it "changes a separator to :" do
+    headered = Strings::Case.headercase("HTTP response code", separator: ":")
+
+    expect(headered).to eq("Http:Response:Code")
+  end
+end

data/spec/unit/kebabcase_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#kebabcase" do
+  {
+    "" => "",
+    "1234" => "1234",
+    "FOO" => "foo",
+    "FooBar" => "foo-bar",
+    "fooBar" => "foo-bar",
+    "foo bar" => "foo-bar",
+    "Foo - Bar" => "foo-bar",
+    "foo & bar" => "foo-bar",
+    "FooFooBar" => "foo-foo-bar",
+    "Foo2Foo2Bar" => "foo2-foo2-bar",
+    "foo-bar-baz" => "foo-bar-baz",
+    "_foo_bar_baz_" => "foo-bar-baz",
+    "--foo-bar--" => "-foo-bar-",
+    "FOO_BAR_baz" => "foo-bar-baz",
+    "__FOO_BAR__" => "foo-bar",
+    "Foo w1th apo's and punc]t" => "foo-w1th-apos-and-punct",
+    "getHTTPResponse" => "get-http-response",
+    "currencyISOCode" => "currency-iso-code",
+    "get2HTTPResponse" => "get2-http-response",
+    "HTTPResponseCode" => "http-response-code",
+    "HTTPResponseCodeXY" => "http-response-code-xy",
+    "supports IPv6 on iOS?" =>  "supports-ipv6-on-ios"
+  }.each do |actual, expected|
+    it "applies kebabcase from #{actual.inspect} to #{expected.inspect}" do
+      expect(Strings::Case.kebabcase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.kebabcase("ЗдравствуйтеПривет")).to eq("здравствуйте-привет")
+  end
+
+  it "allows to preserve acronyms" do
+    dashed = Strings::Case.dashcase("HTTP response code", acronyms: ["HTTP"])
+
+    expect(dashed).to eq("HTTP-response-code")
+  end
+
+  it "changes a separator to :" do
+    dashed = Strings::Case.kebabcase("HTTP response code", separator: ":")
+
+    expect(dashed).to eq("http:response:code")
+  end
+end

data/spec/unit/pascalcase_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#pascalcase" do
+  {
+    nil => nil,
+    "" => "",
+    "f" => "F",
+    "1234" => "1234",
+    "FOO" => "Foo",
+    "FooBar" => "FooBar",
+    "fooBar" => "FooBar",
+    "foo bar" => "FooBar",
+    "Foo - Bar" => "FooBar",
+    "foo & bar" => "FooBar",
+    "FooFooBar" => "FooFooBar",
+    "Foo2Foo2Bar" => "Foo2Foo2Bar",
+    "foo-bar-baz" => "FooBarBaz",
+    "foo_bar_1_2" => "FooBar12",
+    "_foo_bar_baz_" => "FooBarBaz",
+    "--foo-bar--" => "FooBar",
+    "FOO_BAR_baz" => "FooBarBaz",
+    "__FOO_BAR__" => "FooBar",
+    "Foo w1th apo's and punc]t" => "FooW1thAposAndPunct",
+    "getHTTPResponse" => "GetHttpResponse",
+    "currencyISOCode" => "CurrencyIsoCode",
+    "get2HTTPResponse" => "Get2HttpResponse",
+    "HTTPResponseCode" => "HttpResponseCode",
+    "HTTPResponseCodeXY" => "HttpResponseCodeXy",
+    "supports IPv6 on iOS?" =>  "SupportsIpv6OnIos"
+  }.each do |actual, expected|
+    it "applies pascalcase to #{actual.inspect} -> #{expected.inspect}" do
+      expect(Strings::Case.pascalcase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.pascalcase("ЗдравствуйтеПривет")).to eq("ЗдравствуйтеПривет")
+  end
+
+  it "allows to preserve acronyms" do
+    camelized = Strings::Case.upper_camelcase("HTTP response code", acronyms: ["HTTP"])
+
+    expect(camelized).to eq("HTTPResponseCode")
+  end
+
+  it "changes a separator to :" do
+    camelized = Strings::Case.pascalcase("HTTP response code", separator: ":")
+
+    expect(camelized).to eq("Http:Response:Code")
+  end
+end

data/spec/unit/pathcase_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+RSpec.describe Strings::Case, "#pathcase" do
+  {
+    nil => nil,
+    "" => "",
+    "f" => "f",
+    "1234" => "1234",
+    "FOO" => "foo",
+    "FooBar" => "foo/bar",
+    "fooBar" => "foo/bar",
+    "foo bar" => "foo/bar",
+    "Foo - Bar" => "foo/bar",
+    "foo & bar" => "foo/bar",
+    "FooFooBar" => "foo/foo/bar",
+    "Foo2Foo2Bar" => "foo2/foo2/bar",
+    "foo-bar-baz" => "foo/bar/baz",
+    "foo_bar_1_2" => "foo/bar/1/2",
+    "_foo_bar_baz_" => "foo/bar/baz",
+    "--foo-bar--" => "foo/bar",
+    "FOO_BAR_baz" => "foo/bar/baz",
+    "__FOO_BAR__" => "foo/bar",
+    "Foo w1th apo's and punc]t" => "foo/w1th/apos/and/punct",
+    "getHTTPResponse" => "get/http/response",
+    "currencyISOCode" => "currency/iso/code",
+    "get2HTTPResponse" => "get2/http/response",
+    "HTTPResponseCode" => "http/response/code",
+    "HTTPResponseCodeXY" => "http/response/code/xy",
+    "supports IPv6 on iOS?" =>  "supports/ipv6/on/ios"
+  }.each do |actual, expected|
+    it "applies pathcase to #{actual.inspect} -> #{expected.inspect}" do
+      expect(Strings::Case.pathcase(actual)).to eq(expected)
+    end
+  end
+
+  it "supports unicode", if: modern_ruby? do
+    expect(Strings::Case.pathcase("ЗдравствуйтеПривет")).to eq("здравствуйте/привет")
+  end
+
+  it "allows to preserve acronyms" do
+    pathed = Strings::Case.pathcase("HTTP response code", acronyms: ["HTTP"])
+
+    expect(pathed).to eq("HTTP/response/code")
+  end
+
+  it "changes file path separator" do
+    pathed = Strings::Case.pathcase("HTTP response code", separator: "\\")
+
+    expect(pathed).to eq("http\\response\\code")
+  end
+end