strings-case 0.2.0 → 0.4.0

data/spec/spec_helper.rb

@@ -1,39 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,44 +0,0 @@
-# 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

@@ -1,75 +0,0 @@
-# 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

@@ -1,50 +0,0 @@
-# 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

@@ -1,48 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

@@ -1,51 +0,0 @@
-# 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

data/spec/unit/sentencecase_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Strings::Case, "#sentencecase" 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 sentencecase to #{actual.inspect} -> #{expected.inspect}" do
-      expect(Strings::Case.sentencecase(actual)).to eq(expected)
-    end
-  end
-
-  it "supports unicode", if: modern_ruby? do
-    expect(Strings::Case.sentencecase("ЗдравствуйтеПривет")).to eq("Здравствуйте привет")
-  end
-
-  it "allows to preserve acronyms" do
-    sentence = Strings::Case.sentencecase("HTTP response code", acronyms: ["HTTP"])
-
-    expect(sentence).to eq("HTTP response code")
-  end
-
-  it "changes a separator to :" do
-    sentence = Strings::Case.sentencecase("HTTP response code", separator: ":")
-
-    expect(sentence).to eq("Http:response:code")
-  end
-end

data/spec/unit/snakecase_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Strings::Case, "#snakecase" 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 snakecase to #{actual.inspect} -> #{expected.inspect}" do
-      expect(Strings::Case.snakecase(actual)).to eq(expected)
-    end
-  end
-
-  it "supports unicode", if: modern_ruby? do
-    expect(Strings::Case.snakecase("ЗдравствуйтеПривет")).to eq("здравствуйте_привет")
-  end
-
-  it "allows to preserve acronyms" do
-    snaked = Strings::Case.underscore("HTTP response code", acronyms: ["HTTP"])
-
-    expect(snaked).to eq("HTTP_response_code")
-  end
-
-  it "changes a separator to :" do
-    snaked = Strings::Case.snakecase("HTTP response code", separator: ":")
-
-    expect(snaked).to eq("http:response:code")
-  end
-end

data/spec/unit/titlecase_spec.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-RSpec.describe Strings::Case, "#titlecase" 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 titlecase to #{actual.inspect} -> #{expected.inspect}" do
-      expect(Strings::Case.titlecase(actual)).to eq(expected)
-    end
-  end
-
-  it "supports unicode", if: modern_ruby? do
-    expect(Strings::Case.titlecase("ЗдравствуйтеПривет")).to eq("Здравствуйте Привет")
-  end
-
-  it "allows to preserve acronyms" do
-    titilized = Strings::Case.titlecase("HTTP response code", acronyms: ["HTTP"])
-
-    expect(titilized).to eq("HTTP Response Code")
-  end
-
-  it "changes a separator to :" do
-    titilized = Strings::Case.titlecase("HTTP response code", separator: ":")
-
-    expect(titilized).to eq("Http:Response:Code")
-  end
-end

data/strings-case.gemspec

@@ -1,32 +0,0 @@
-lib = File.expand_path("lib", __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "strings/case/version"
-
-Gem::Specification.new do |spec|
-  spec.name          = "strings-case"
-  spec.version       = Strings::Case::VERSION
-  spec.authors       = ["Piotr Murach"]
-  spec.email         = ["me@piotrmurach.com"]
-  spec.summary       = %q{Convert strings to different cases}
-  spec.description   = %q{Convert strings to different cases}
-  spec.homepage      = "https://github.com/piotrmurach/strings-case"
-  spec.license       = "MIT"
-
-  spec.metadata["allowed_push_host"] = "https://rubygems.org"
-  spec.metadata["changelog_uri"] = "https://github.com/piotrmurach/strings-case/blob/master/CHANGELOG.md"
-  spec.metadata["documentation_uri"] = "https://www.rubydoc.info/gems/strings-case"
-  spec.metadata["homepage_uri"] = spec.homepage
-  spec.metadata["source_code_uri"] = "https://github.com/piotrmurach/strings-case"
-
-  spec.files         = Dir["{lib,spec}/**/*.rb"]
-  spec.files        += Dir["tasks/*", "strings-case.gemspec"]
-  spec.files        += Dir["README.md", "CHANGELOG.md", "LICENSE.txt", "Rakefile"]
-  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.required_ruby_version = ">= 2.0.0"
-
-  spec.add_development_dependency "bundler", ">= 1.5"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end

data/tasks/console.rake

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-desc "Load gem inside irb console"
-task :console do
-  require "irb"
-  require "irb/completion"
-  require File.join(__FILE__, "../../lib/strings-case")
-  ARGV.clear
-  IRB.start
-end
-task c: %w[ console ]

data/tasks/coverage.rake

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-
-desc "Measure code coverage"
-task :coverage do
-  begin
-    original, ENV["COVERAGE"] = ENV["COVERAGE"], "true"
-    Rake::Task["spec"].invoke
-  ensure
-    ENV["COVERAGE"] = original
-  end
-end

data/tasks/spec.rake

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "rspec/core/rake_task"
-
-  desc "Run all specs"
-  RSpec::Core::RakeTask.new(:spec) do |task|
-    task.pattern = "spec/{unit,integration}{,/*/**}/*_spec.rb"
-  end
-
-  namespace :spec do
-    desc "Run unit specs"
-    RSpec::Core::RakeTask.new(:unit) do |task|
-      task.pattern = "spec/unit{,/*/**}/*_spec.rb"
-    end
-
-    desc "Run integration specs"
-    RSpec::Core::RakeTask.new(:integration) do |task|
-      task.pattern = "spec/integration{,/*/**}/*_spec.rb"
-    end
-  end
-
-rescue LoadError
-  %w[spec spec:unit spec:integration].each do |name|
-    task name do
-      $stderr.puts "In order to run #{name}, do `gem install rspec`"
-    end
-  end
-end