ncase 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16a2690323ff720a8937d24dd52c62d8d3e66811f8d9cc9ce97dedb55caee3f3
-  data.tar.gz: b0b4e213140f6140c953484e37ffa020b394b5ca0bbda1ace27ff71c15c9c1ee
+  metadata.gz: f63a81646702a0bf54bb8987867f86144a6fc4bf816893bad066ef84ef46d4ae
+  data.tar.gz: e1a824fd7c86e5245f39c8d30f5391aed2672247598b0255ada6728e18b79e96
 SHA512:
-  metadata.gz: 9b60a5f4275a83b679caa3cc8c479a1a8ec74535be18fb5c5880351be1db47848c25ea446614caa0930b06562748f1c544a48fd2f2e258ee4c491d8c3a3fa134
-  data.tar.gz: 5ace2c70da311791b66f53e65e08b83aa031a663469094d6e96d155c69f7baaa21f285c9aa6d5aa5f83d503cb3f20037ac6c9ac0521780d89ed5e6289b11f143
+  metadata.gz: 0bb39994226927772dc6a1cb7037d4bdb56cf27573436fbebbcbfc8e1a6bd45cf49ac9ee8ebf39b94c23f0a2d6d68713d09a51eebaf134516b313e733c3beef0
+  data.tar.gz: 2a391f0aa7a8de40ee82b8e51788ac57111c9bd4bf089866a5ddb8fdb0a68c76cb46e7ceac76d48d285869ddb03e07aaf5eeb49f11694d66c30bcd865a6bf50d

data/bin/ncase

@@ -1,33 +1,34 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift("#{__dir__}/../lib") if __dir__ =~ /proj|src/i
+$LOAD_PATH.unshift("#{__dir__}/../lib") if /proj|src/i.match?(__dir__)
 
 require "ncase"
 require "optparse"
 
 separator = nil
-to_case = :random_case
+to_case = :random
+
 OptionParser.new do |opts|
   opts.banner = "Usage: ncase [OPTIONS] [TEXT]"
   opts.version = Ncase::VERSION
 
-  opts.on("-F", "--separator REGEXP", "Use REGEXP as the separator") {|v| separator = v}
-
-  opts.on("-c", "--camel-case",       "Enforce camelCase")     {to_case = :camel_case}
-  opts.on("-P", "--pascal-case",      "Enforce PascalCase")    {to_case = :pascal_case}
-  opts.on("-k", "--kebab-case",       "Enforce kebab-case")    {to_case = :kebab_case}
-  opts.on("-K", "--upper-kebab-case", "Enforce KEBAB-CASE")    {to_case = :upper_kebab_case}
-  opts.on("-l", "--lower-case",       "Enforce `lower case`")  {to_case = :lower_case}
-  opts.on("-U", "--upper-case",       "Enforce `UPPER CASE`")  {to_case = :upper_case}
-  opts.on("-s", "--snake-case",       "Enforce snake_case")    {to_case = :snake_case}
-  opts.on("-S", "--upper-snake-case", "Enforce SNAKE_CASE")    {to_case = :upper_snake_case}
-  opts.on("-t", "--title-case",       "Enforce `Title Case`")  {to_case = :title_case}
-  opts.on("-T", "--inver-title-case", "Enforce `tITLE cASE`")  {to_case = :inver_title_case}
-  opts.on("-r", "--random-case",      "Enforce `rAnDOm CaSe`") {to_case = :random_case}
+  opts.on("-F", "--separator REGEXP", "Use REGEXP as the separator") { |v| separator = v }
+
+  opts.on("-c", "--camel-case",       "Enforce camelCase")     { to_case = :camel }
+  opts.on("-P", "--pascal-case",      "Enforce PascalCase")    { to_case = :pascal }
+  opts.on("-s", "--snake-case",       "Enforce snake_case")    { to_case = :snake }
+  opts.on("-S", "--upper-snake-case", "Enforce SNAKE_CASE")    { to_case = :upper_snake }
+  opts.on("-k", "--kebab-case",       "Enforce kebab-case")    { to_case = :kebab }
+  opts.on("-K", "--upper-kebab-case", "Enforce KEBAB-CASE")    { to_case = :upper_kebab }
+  opts.on("-l", "--lower-case",       "Enforce `lower case`")  { to_case = :lower }
+  opts.on("-U", "--upper-case",       "Enforce `UPPER CASE`")  { to_case = :upper }
+  opts.on("-t", "--title-case",       "Enforce `Title Case`")  { to_case = :title }
+  opts.on("-T", "--inver-title-case", "Enforce `tITLE cASE`")  { to_case = :inver_title }
+  opts.on("-r", "--random-case",      "Enforce `rAnDOm CaSe`") { to_case = :random }
 end.parse!
 
 separator &&= Regexp.new(separator)
-in_lines = if ARGV.empty? then readlines else [ARGV.join(" ")] end
-out_lines = in_lines.map {|l| Ncase::Words.new(l, separator: separator).__send__ to_case}
-puts out_lines
+
+input = ARGV.empty? ? readlines : [ARGV.join(" ")]
+input.each { |line| puts Ncase.public_send(to_case, line, separator: separator) }

data/lib/ncase/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Ncase
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/ncase/words.rb

@@ -1,9 +1,7 @@
 # frozen_string_literal: true
 
-# Support library for +bin/ncase+.
 module Ncase
-  # Implements efficient conversion of a string into a multitude of case
-  # styles.
+  # Implements efficient conversion of a string into multiple case styles.
   #
   # By default will guess the separator in the string:
   #
@@ -13,115 +11,107 @@ module Ncase
   #    more frequent is a separator.
   # 3. A case-switch is a separator.
   #
-  # @example Convert a string into +PascalCase+
+  # @example Convert a string into +PascalCase+ and +snake_case+
   #   require "ncase"
   #
   #   w = Ncase::Words.new("this is a test string")
   #   p w.pascal_case  # => "ThisIsATestString"
+  #   p w.snake_case   # => "this_is_a_test_string"
   class Words
-    # @param s [String] the string to convert
+    # @param str [String] the string to work with
     # @param separator [Regexp] the pattern to split the string into words.
     #   If +nil+, it will guess the separator as described in {Words}.
     # @see String#split
-    def initialize(s, separator: nil)
-      ss = s.strip
-      separator ||= guess_separator(ss)
-      @words = ss.split(separator)
+    def initialize(str, separator: nil)
+      sstr = str.strip
+      separator ||= guess_separator(sstr)
+      @words = sstr.split(separator)
     end
 
     # @return [String] the +camelCase+ representation of the string
     def camel_case
-      first_word = @words.first
-      if first_word
-        @words.drop(1)
-          .map {|s| s.capitalize}
-          .unshift(first_word.downcase)
-          .join
-      else
-        ""
-      end
+      return "" if @words.empty?
+
+      @words.each(&:capitalize!)
+      @words.first.downcase!
+      @words.join
     end
 
     # @return [String] the +PascalCase+ representation of the string
     def pascal_case
-      @words.map {|s| s.capitalize}.join
+      @words.each(&:capitalize!).join
     end
 
     # @return [String] the +kebab-case+ representation of the string
     def kebab_case
-      @words.map {|s| s.downcase}.join("-")
+      @words.each(&:downcase!).join("-")
     end
 
     # @return [String] the +KEBAB-CASE+ representation of the string
     def upper_kebab_case
-      @words.map {|s| s.upcase}.join("-")
+      @words.each(&:upcase!).join("-")
     end
 
     # @return [String] the +lower case+ representation of the string
     def lower_case
-      @words.map {|s| s.downcase}.join(" ")
+      @words.each(&:downcase!).join(" ")
     end
 
     # @return [String] the +UPPER CASE+ representation of the string
     def upper_case
-      @words.map {|s| s.upcase}.join(" ")
+      @words.each(&:upcase!).join(" ")
     end
 
     # @return [String] the +snake_case+ representation of the string
     def snake_case
-      @words.map {|s| s.downcase}.join("_")
+      @words.each(&:downcase!).join("_")
     end
 
     # @return [String] the +SNAKE_CASE+ representation of the string
     def upper_snake_case
-      @words.map {|s| s.upcase}.join("_")
+      @words.each(&:upcase!).join("_")
     end
 
     # @return [String] the +Title Case+ representation of the string
     def title_case
-      @words.map {|s| s.capitalize}.join(" ")
+      @words.each(&:capitalize!).join(" ")
     end
 
     # @return [String] the +tITLE cASE+ representation of the string
     def inver_title_case
-      title_case.swapcase
+      @words.each(&:capitalize!).each(&:swapcase!).join(" ")
     end
 
     # @return [String] a +rAnDOm CaSe+ representation of the string
     def random_case
       @words.join(" ")
-        .chars
-        .map {|c| if rand(2) == 0 then c.downcase else c.upcase end}
-        .join
+            .chars
+            .each { |c| rand(2).zero? ? c.downcase! : c.upcase! }
+            .join
     end
 
-    SPACE_SEP_REGEXP      = /\s+/
-    HYPHEN_SEP_REGEXP     = /-/
-    UNDERSCORE_SEP_REGEXP = /_/
+    SPACE_SEP_REGEXP      = /\s+/.freeze
+    HYPHEN_SEP_REGEXP     = /-/.freeze
+    UNDERSCORE_SEP_REGEXP = /_/.freeze
     CASE_SEP_REGEXP       = / (?<=[[:lower:]]) (?=[[:upper:]])              # z|A
                             | (?<=[[:upper:]]) (?=[[:upper:]] [[:lower:]])  # A|Bc
-                            /x
+                            /x.freeze
     private_constant :SPACE_SEP_REGEXP, :HYPHEN_SEP_REGEXP, :UNDERSCORE_SEP_REGEXP, :CASE_SEP_REGEXP
 
     private
 
+    # @param str [String] the string to guess the separator
     # @return [Regexp] the most likely separator for the string
-    def guess_separator(s)
-      if s.include?(" ")
-        SPACE_SEP_REGEXP
-      else
-        num_both = s.count("-_")
-        if num_both > 0
-          num_hyphens = s.count("-")
-          if num_hyphens * 2 >= num_both
-            HYPHEN_SEP_REGEXP
-          else
-            UNDERSCORE_SEP_REGEXP
-          end
-        else
-          CASE_SEP_REGEXP
-        end
+    def guess_separator(str)
+      return SPACE_SEP_REGEXP if str.include?(" ")
+
+      num_both = str.count("-_")
+      if num_both.positive?
+        return HYPHEN_SEP_REGEXP if str.count("-") * 2 >= num_both
+
+        return UNDERSCORE_SEP_REGEXP
       end
+      CASE_SEP_REGEXP
     end
   end
 end

data/lib/ncase.rb

@@ -2,3 +2,21 @@
 
 require_relative "ncase/version"
 require_relative "ncase/words"
+
+# Contains convenience methods for one-off use.
+module Ncase
+  module_function
+
+  # Delegate +<name>+ to +Words#<name>_case+ if it's defined.
+  def method_missing(name, *args)
+    if (method = Words.public_instance_method("#{name}_case"))
+      method.bind(Words.new(*args)).call
+    else
+      super
+    end
+  end
+
+  def respond_to_missing?(name, *)
+    Words.public_instance_method("#{name}_case") || super
+  end
+end

metadata

@@ -1,58 +1,114 @@
 --- !ruby/object:Gem::Specification
 name: ncase
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Stas Miasnikoŭ
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-03-02 00:00:00.000000000 Z
+date: 2021-10-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '5.11'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '12.3'
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0.9'
-description: 
+        version: '0'
+description:
 email:
 - miasnikou@yandex.by
 executables:
@@ -69,7 +125,7 @@ licenses:
 - ISC
 metadata:
   source_code_uri: https://github.com/xmyst/ncase
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -77,7 +133,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.6'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -85,7 +141,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.0.3
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Enforce a case style.
 test_files: []