string_foundation 1.0.0 → 1.1.0

data/spec/string_foundation/convert_spec.rb

@@ -1,30 +1,30 @@
 # ==============================================================================
-# SPEC - STRING FOUNDATION - CONVERT
-# ==============================================================================
+# SPEC - STRING FOUNDATION - CONVERT SPEC
 # frozen_string_literal: true
-describe '[ Convert Methods ]' do
+# ==============================================================================
+describe "[ Convert Methods ]" do
 
   # ----------------------------------------------------------------------------
   # Convert To TrueClass Or FalseClass
   # ----------------------------------------------------------------------------
-  describe 'CONVERT TO TRUECLASS OR FALSE CLASS' do
+  describe "CONVERT TO TRUECLASS OR FALSE CLASS" do
     let(:string) { nil }
     subject { string.to_bool }
 
-    context 'when a string is "true",' do
-      let(:string) { 'true' }
+    context "when a string is \"true\"," do
+      let(:string) { "true" }
 
-      it { is_expected.to eq true }
+      it { is_expected.to be true }
     end
 
-    context 'when a string is "false",' do
-      let(:string) { 'false' }
+    context "when a string is \"false\"," do
+      let(:string) { "false" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is invalid,' do
-      let(:string) { 'dummy' }
+    context "when a string is invalid," do
+      let(:string) { "dummy" }
 
       it { is_expected_as_block.to raise_error(TypeError) }
     end
@@ -34,68 +34,68 @@ describe '[ Convert Methods ]' do
   # ----------------------------------------------------------------------------
   # Convert A BOOLY STRING To TrueClass Or FalseClass
   # ----------------------------------------------------------------------------
-  describe 'CONVERT A BOOLY STRING TO TRUECLASS OR FALSE CLASS' do
+  describe "CONVERT A BOOLY STRING TO TRUECLASS OR FALSE CLASS" do
     let(:string) { nil }
     subject { string.to_booly }
 
-    context 'when a string is "true",' do
-      let(:string) { 'true' }
+    context "when a string is \"true\"," do
+      let(:string) { "true" }
 
-      it { is_expected.to eq true }
+      it { is_expected.to be true }
     end
 
-    context 'when a string is "false",' do
-      let(:string) { 'false' }
+    context "when a string is \"false\"," do
+      let(:string) { "false" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is invalid,' do
-      let(:string) { 'dummy' }
+    context "when a string is invalid," do
+      let(:string) { "dummy" }
 
       it { is_expected_as_block.to raise_error(TypeError) }
     end
 
-    context 'when a string is a positive integral number,' do
-      let(:string) { '1' }
+    context "when a string is a positive integral number," do
+      let(:string) { "1" }
 
-      it { is_expected.to eq true }
+      it { is_expected.to be true }
     end
 
-    context 'when a string is a negative integral number,' do
-      let(:string) { '-1' }
+    context "when a string is a negative integral number," do
+      let(:string) { "-1" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is a positive floating point number,' do
-      let(:string) { '0.1' }
+    context "when a string is a positive floating point number," do
+      let(:string) { "0.1" }
 
-      it { is_expected.to eq true }
+      it { is_expected.to be true }
     end
 
-    context 'when a string is a negative floating point number,' do
-      let(:string) { '-0.1' }
+    context "when a string is a negative floating point number," do
+      let(:string) { "-0.1" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is 0,' do
-      let(:string) { '0' }
+    context "when a string is 0," do
+      let(:string) { "0" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is 0.0,' do
-      let(:string) { '0.0' }
+    context "when a string is 0.0," do
+      let(:string) { "0.0" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is an empty string,' do
-      let(:string) { '' }
+    context "when a string is an empty string," do
+      let(:string) { "" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
   end
 
@@ -103,62 +103,62 @@ describe '[ Convert Methods ]' do
   # ----------------------------------------------------------------------------
   # Convert To Proper Class From String
   # ----------------------------------------------------------------------------
-  describe 'CONVER TO PROPER CLASS FROM STRING' do
+  describe "CONVER TO PROPER CLASS FROM STRING" do
     let(:string) { nil }
     subject { string.to_pretty }
 
-    context 'when a string is "0",' do
-      let(:string) { '0' }
+    context "when a string is \"0\"," do
+      let(:string) { "0" }
 
-      it { is_expected.to eq 0 }
+      it { is_expected.to eq(0) }
     end
 
-    context 'when a string is "1",' do
-      let(:string) { '1' }
+    context "when a string is \"1\"," do
+      let(:string) { "1" }
 
-      it { is_expected.to eq 1 }
+      it { is_expected.to eq(1) }
     end
 
-    context 'when a string is "000123",' do
-      let(:string) { '000123' }
+    context "when a string is \"000123\"," do
+      let(:string) { "000123" }
 
-      it { is_expected.to eq 123 }
+      it { is_expected.to eq(123) }
     end
 
-    context 'when a string is "0.0",' do
-      let(:string) { '0.0' }
+    context "when a string is \"0.0\"," do
+      let(:string) { "0.0" }
 
-      it { is_expected.to eq 0.0 }
+      it { is_expected.to eq(0.0) }
     end
 
-    context 'when a string is "000.00123",' do
-      let(:string) { '000.00123' }
+    context "when a string is \"000.00123\"," do
+      let(:string) { "000.00123" }
 
-      it { is_expected.to eq 0.00123 }
+      it { is_expected.to eq(0.00123) }
     end
 
-    context 'when a string is "true",' do
-      let(:string) { 'true' }
+    context "when a string is \"true\"," do
+      let(:string) { "true" }
 
-      it { is_expected.to eq true }
+      it { is_expected.to be true }
     end
 
-    context 'when a string is "false",' do
-      let(:string) { 'false' }
+    context "when a string is \"false\"," do
+      let(:string) { "false" }
 
-      it { is_expected.to eq false }
+      it { is_expected.to be false }
     end
 
-    context 'when a string is "dummy",' do
-      let(:string) { 'dummy' }
+    context "when a string is \"dummy\"," do
+      let(:string) { "dummy" }
 
-      it { is_expected.to eq string }
+      it { is_expected.to eq(string) }
     end
 
-    context 'when a string is an empty string,' do
-      let(:string) { '' }
+    context "when a string is an empty string," do
+      let(:string) { "" }
 
-      it { is_expected.to eq nil }
+      it { is_expected.to be_nil }
     end
   end
 
@@ -166,43 +166,43 @@ describe '[ Convert Methods ]' do
   # ----------------------------------------------------------------------------
   # Convert From Newline To Characters
   # ----------------------------------------------------------------------------
-  describe 'CONVERT FROM NEWLINE TO CHARACTERS' do
-    let(:string) { "We are Brushdown.\nWe are Brushdown." }
-    let(:char) { '<br>' }
+  describe "CONVERT FROM NEWLINE TO CHARACTERS" do
+    let(:string) { "I am Jaga Apple.\nI am Jaga Apple." }
+    let(:char) { "<br>" }
     subject { string.nl_to(char) }
 
-    context 'when a string has newlines "\n",' do
-      it { is_expected.to eq 'We are Brushdown.<br>We are Brushdown.' }
+    context "when a string has newlines \"\\n\"," do
+      it { is_expected.to eq("I am Jaga Apple.<br>I am Jaga Apple.") }
     end
 
-    context 'when a string has newlines "\r\n",' do
-      let(:string) { "We are Brushdown.\r\nWe are Brushdown." }
+    context "when a string has newlines \"\\r\\n\"," do
+      let(:string) { "I am Jaga Apple.\r\nI am Jaga Apple." }
 
-      it { is_expected.to eq 'We are Brushdown.<br>We are Brushdown.' }
+      it { is_expected.to eq("I am Jaga Apple.<br>I am Jaga Apple.") }
     end
 
-    context 'when a string does not have newlines,' do
-      let(:string) { "We are Brushdown. We are Brushdown." }
+    context "when a string does not have newlines," do
+      let(:string) { "I am Jaga Apple. I am Jaga Apple." }
 
-      it { is_expected.to eq string }
+      it { is_expected.to eq(string) }
     end
 
-    context 'when an argument is not set,' do
-      subject { string.nl_to() }
+    context "when an argument is not set," do
+      subject { string.nl_to }
 
       it { is_expected_as_block.to raise_error(ArgumentError) }
     end
 
-    context 'when an argument is nil,' do
+    context "when an argument is nil," do
       let(:char) { nil }
 
-      it { is_expected.to eq 'We are Brushdown.We are Brushdown.' }
+      it { is_expected.to eq("I am Jaga Apple.I am Jaga Apple.") }
     end
 
-    context 'when an argument is an empty string,' do
-      let(:char) { '' }
+    context "when an argument is an empty string," do
+      let(:char) { "" }
 
-      it { is_expected.to eq 'We are Brushdown.We are Brushdown.' }
+      it { is_expected.to eq("I am Jaga Apple.I am Jaga Apple.") }
     end
   end
 
@@ -210,24 +210,24 @@ describe '[ Convert Methods ]' do
   # ----------------------------------------------------------------------------
   # Convert From Newline To <br>
   # ----------------------------------------------------------------------------
-  describe 'CONVERT FROM NEWLINE TO `<br>`' do
-    let(:string) { "We are Brushdown.\nWe are Brushdown." }
+  describe "CONVERT FROM NEWLINE TO `<br>`" do
+    let(:string) { "I am Jaga Apple.\nI am Jaga Apple." }
     subject { string.nl_to_br }
 
-    context 'when a string has newlines "\n",' do
-      it { is_expected.to eq 'We are Brushdown.<br>We are Brushdown.' }
+    context "when a string has newlines \"\n\"," do
+      it { is_expected.to eq("I am Jaga Apple.<br>I am Jaga Apple.") }
     end
 
-    context 'when a string has newlines "\r\n",' do
-      let(:string) { "We are Brushdown.\r\nWe are Brushdown." }
+    context "when a string has newlines \"\\r\\n\"," do
+      let(:string) { "I am Jaga Apple.\r\nI am Jaga Apple." }
 
-      it { is_expected.to eq 'We are Brushdown.<br>We are Brushdown.' }
+      it { is_expected.to eq("I am Jaga Apple.<br>I am Jaga Apple.") }
     end
 
-    context 'when a string does not have newlines,' do
-      let(:string) { "We are Brushdown. We are Brushdown." }
+    context "when a string does not have newlines," do
+      let(:string) { "I am Jaga Apple. I am Jaga Apple." }
 
-      it { is_expected.to eq string }
+      it { is_expected.to eq(string) }
     end
   end
 

data/spec/string_foundation/convertible_spec.rb

@@ -0,0 +1,286 @@
+# ==============================================================================
+# SPEC - STRING FOUNDATION - CONVERTIBLE SPEC
+# frozen_string_literal: true
+# ==============================================================================
+describe "[ Convertible Methods ]" do
+
+  # ----------------------------------------------------------------------------
+  # Check Convertible To Integer
+  # ----------------------------------------------------------------------------
+  describe "CHECK CONVERTIBLE TO INTEGER" do
+    let(:string) { nil }
+    subject { string.to_i? }
+
+    context "when a string is an integral number," do
+      context "it is a positive number," do
+        let(:string) { "123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-5" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is a floating point number," do
+      context "it is a positive number," do
+        let(:string) { "0.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+0.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-5.123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is a floating point number without an integer," do
+      context "it is a positive number," do
+        let(:string) { ".123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-.123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string a number has leading zeros," do
+      context "it is a positive number," do
+        let(:string) { "00000123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+00000123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-00000123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is not a number," do
+      let(:string) { "abc" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+
+  # ----------------------------------------------------------------------------
+  # Check Convertible To Float
+  # ----------------------------------------------------------------------------
+  describe "CHECK CONVERTIBLE TO FLOAT" do
+    let(:string) { nil }
+    subject { string.to_f? }
+
+    context "when a string is an integral number," do
+      context "it is a positive number," do
+        let(:string) { "123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-5" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is a floating point number," do
+      context "it is a positive number," do
+        let(:string) { "0.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+0.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-5.123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is a floating point number without an integer," do
+      context "it is a positive number," do
+        let(:string) { ".123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+.123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-.123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string a number has leading zeros," do
+      context "it is a positive number," do
+        let(:string) { "00000123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a positive number with a sign," do
+        let(:string) { "+00000123" }
+
+        it { is_expected.to be true }
+      end
+
+      context "it is a negative number," do
+        let(:string) { "-00000123" }
+
+        it { is_expected.to be true }
+      end
+    end
+
+    context "when a string is not a number," do
+      let(:string) { "abc" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+
+  # ----------------------------------------------------------------------------
+  # Check Convertible To Boolean
+  # ----------------------------------------------------------------------------
+  describe "CHECK CONVERTIBLE TO BOOLEAN" do
+    let(:string) { nil }
+    subject { string.to_bool? }
+
+    context "when a string is \"true\"," do
+      let(:string) { "true" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is \"false\"," do
+      let(:string) { "false" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is empty," do
+      let(:string) { "" }
+
+      it { is_expected.to be false }
+    end
+
+    context "when a string is a positive number," do
+      let(:string) { "1" }
+
+      it { is_expected.to be false }
+    end
+
+    context "when a string is a negative number," do
+      let(:string) { "-1" }
+
+      it { is_expected.to be false }
+    end
+
+    context "when a string is not a number," do
+      let(:string) { "abc" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+
+  # ----------------------------------------------------------------------------
+  # Check Convertaile To Booly
+  # ----------------------------------------------------------------------------
+  describe "CHECK CONVERTIBLE TO BOOLYs" do
+    let(:string) { nil }
+    subject { string.to_booly? }
+
+    context "when a string is \"true\"," do
+      let(:string) { "true" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is \"false\"," do
+      let(:string) { "false" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is empty," do
+      let(:string) { "" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is a positive number," do
+      let(:string) { "1" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is a negative number," do
+      let(:string) { "-1" }
+
+      it { is_expected.to be true }
+    end
+
+    context "when a string is not a number," do
+      let(:string) { "abc" }
+
+      it { is_expected.to be false }
+    end
+  end
+
+end