rordash 0.1.0

data/spec/rordash/hash_util_spec.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/ModuleLength
+module Rordash
+  RSpec.describe HashUtil do
+    let(:hash) { { data: { nestedKey: { id: "some-identifier", items: [4, 9, 7] } } } }
+
+    describe 'dot notation' do
+      let(:dotted_hash) do
+        { "data.nestedKey.id" => "some-identifier",
+          "data.nestedKey.items[0]" => 4,
+          "data.nestedKey.items[1]" => 9,
+          "data.nestedKey.items[2]" => 7 }
+      end
+
+      describe ".dot" do
+        it "flattens deeply nested objects using dot notation" do
+          expect(described_class.dot(hash, keep_arrays: false)).to eql(dotted_hash)
+        end
+      end
+
+      describe ".dotted_keys" do
+        it "flattens deeply nested objects to keys in dot notation" do
+          expect(described_class.dotted_keys(hash, keep_arrays: false)).to eql(dotted_hash.keys)
+        end
+      end
+
+      describe ".undot" do
+        it "hydrates dotted hash to deeply nested object" do
+          expect(described_class.undot(dotted_hash)).to eql(hash)
+        end
+      end
+
+      describe '.pick' do
+        it 'picks keys from hash' do
+          paths = %w[data.nestedKey.id data.nestedKey.items[2] data.nestedKey.items[1]]
+          expect(described_class.pick(hash, paths,
+                                      keep_arrays: false)).to eql({ data: { nestedKey: { id: "some-identifier",
+                                                                                         items: [9, 7] } } })
+        end
+      end
+
+      describe '.get' do
+        it 'picks keys from hash' do
+          expect(described_class.get(hash, 'data.nestedKey.items[1]')).to be(9)
+        end
+      end
+
+      describe '.set' do
+        it 'sets key value pair at specified dotted path' do
+          expect(described_class.set({}, 'data.nestedKey.items[1]',
+                                     10)).to eql({ data: { nestedKey: { items: [nil, 10] } } })
+        end
+      end
+
+      describe 'reject_blank_values' do
+        let(:input) { { a: '', b: '  ', c: nil, d: '123', e: [], f: {} } }
+
+        it 'removes blank values' do
+          expect(described_class.reject_blank_values(input)).to eql({ d: "123", e: [], f: {} })
+        end
+
+        it 'does not deep remove blank values' do
+          expect(described_class.reject_blank_values(input.merge(f: { g: '' }))).to eql({ d: "123", e: [],
+                                                                                          f: { g: '' } })
+        end
+      end
+
+      describe 'deep_reject_blank_values' do
+        let(:input) { { a: '', b: '  ', c: nil, d: '123', e: [], f: { g: '' }, h: [1, nil, '', '    ', 3] } }
+
+        it 'removes deep blank values' do
+          expect(described_class.deep_reject_blank_values(input)).to eql({ d: "123", h: [1, 3] })
+        end
+      end
+    end
+
+    describe ".from_string" do
+      let(:input) { JSON.dump(a: 1) }
+
+      it "convert json string to hash" do
+        expect(described_class.from_string(input)).to eql({ a: 1 })
+      end
+
+      it "handles hashes" do
+        expect(described_class.from_string(a: 1)).to eql(a: 1)
+      end
+    end
+
+    describe ".group_by" do
+      let(:input) { [6.5, 4.12, 6.8, 5.4] }
+
+      context 'with hash input' do
+        let(:input) { [{ shared_key: 1, a: 1 }, { shared_key: 2, b: 2 }, { shared_key: 1, c: 3 }] }
+
+        it 'handles key only' do
+          expect(described_class.group_by(input,
+                                          :shared_key)).to eql({
+                                                                 1 => [{ shared_key: 1, a: 1 },
+                                                                       { shared_key: 1,
+                                                                         c: 3 }], 2 => [{ shared_key: 2, b: 2 }]
+                                                               })
+        end
+      end
+
+      it "groups elements" do
+        expect(described_class.group_by(input, lambda { |val|
+                                                 val.floor
+                                               })).to eql({ 4 => [4.12], 5 => [5.4], 6 => [6.5, 6.8] })
+      end
+    end
+
+    describe '.get_first_present' do
+      let(:google_address) { '2253-20800 Westminster Hwy, Richmond, BC V6V 2W3, Canada' }
+      let(:input) do
+        { 'google_address' => '',
+          'main_property' => { 'google_address' => '2253-20800 Westminster Hwy, Richmond, BC V6V 2W3, Canada' } }
+      end
+      let(:paths) { %w[google_address main_property.google_address] }
+
+      subject(:present_val) { described_class.get_first_present(input, paths) }
+
+      it 'returns first filled match' do
+        expect(present_val).to eql(google_address)
+      end
+    end
+
+    describe '.digest' do
+      let(:input) { { key: 'some-value' } }
+
+      subject(:digested_str) { described_class.digest(input) }
+      it 'returns encoded digest string of input' do
+        expect(digested_str).to eql('POWr8Qgq9OA+L8ejA4gkAG2kgNs=')
+      end
+    end
+
+    describe ".to_str" do
+      it "convert hash to json string" do
+        # rubocop:disable Layout/LineLength
+        expect(described_class.to_str(hash)).to eql("{\"data\":{\"nestedKey\":{\"id\":\"some-identifier\",\"items\":[4,9,7]}}}")
+        # rubocop:enable Layout/LineLength
+      end
+
+      it "handles strings" do
+        expect(described_class.to_str("{ a: 1 }")).to eql("{ a: 1 }")
+      end
+    end
+
+    describe ".pretty" do
+      it "returns correctly formatted string" do
+        expect(described_class.pretty(hash)).to eql(%({
+  "data": {
+    "nestedKey": {
+      "id": "some-identifier",
+      "items": [
+        4,
+        9,
+        7
+      ]
+    }
+  }
+}))
+      end
+
+      context 'with array' do
+        let(:input) { [{ a: 1 }, b: 2] }
+
+        it "returns correctly formatted string" do
+          expect(described_class.pretty(input)).to eql(%([
+  {
+    "a": 1
+  },
+  {
+    "b": 2
+  }
+]))
+        end
+      end
+    end
+  end
+end
+# rubocop:enable Metrics/ModuleLength

data/spec/rordash/numeric_util_spec.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe NumericUtil do
+    describe '.numeric?' do
+      let(:value) { '12345' }
+
+      subject(:is_numeric) { described_class.numeric?(value) }
+
+      it 'returns true' do
+        expect(is_numeric).to be_truthy
+      end
+
+      context 'with value with non numeric values' do
+        let(:value) { '12A345' }
+
+        it 'returns false' do
+          expect(is_numeric).to be_falsey
+        end
+      end
+
+      context 'with blank value' do
+        let(:value) { '' }
+
+        it 'returns false' do
+          expect(is_numeric).to be_falsey
+        end
+      end
+
+      context 'with whitespace' do
+        let(:value) { '  1' }
+
+        it 'returns false' do
+          expect(is_numeric).to be_truthy
+        end
+      end
+    end
+
+    describe '.convert_unit' do
+      let(:from_unit) { :m }
+      let(:to_unit) { :ft }
+      let(:value) { 10 }
+
+      subject(:converted_unit) { described_class.convert_unit(value, from_unit: from_unit, to_unit: to_unit) }
+
+      it 'calculates amount correctly' do
+        expect(converted_unit.round(4)).to be(32.8084)
+      end
+    end
+
+    describe '.convert_unit_sq' do
+      let(:from_unit) { :m }
+      let(:to_unit) { :ft }
+      let(:value) { 25 }
+
+      subject(:sq_unit) { described_class.convert_unit_sq(value, from_unit: from_unit, to_unit: to_unit) }
+
+      it 'calculates amount correctly' do
+        expect(sq_unit.round(3)).to be(269.098)
+      end
+    end
+  end
+end

data/spec/rordash/object_util_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe ObjectUtil do
+    describe '.to_classname' do
+      context 'when given a class object that is not defined' do
+        it 'returns nil' do
+          expect(described_class.to_classname("Foo")).to be_nil
+        end
+      end
+    end
+  end
+end
+

data/spec/rordash/path_util_spec.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe PathUtil do
+    describe '#fixtures_path' do
+      context 'without arg' do
+        it 'returns full fixture path' do
+          fixtures_path = Rails.root.join('spec', 'fixtures')
+
+          expect(described_class.fixtures_path).to eql(Pathname.new(fixtures_path))
+        end
+      end
+
+      context 'with filename' do
+        let(:filename) { 'some-file-name.png ' }
+
+        it 'returns full fixture path' do
+          fixtures_path = Rails.root.join('spec', 'fixtures')
+          expect(described_class.fixtures_path(filename)).to eql(Pathname.new("#{fixtures_path}/#{filename}"))
+        end
+      end
+    end
+  end
+end

data/spec/rordash/regex_util_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe RegexUtil do
+    describe '.match?' do
+      subject(:matched) { described_class.match?(type, value) }
+
+      let(:value) { nil }
+      let(:type) { nil }
+
+      describe ':email' do
+        let(:type) { :email }
+
+        context 'with valid email' do
+          let(:value) { 'email@domain.com' }
+
+          it 'returns true' do
+            expect(matched).to be_truthy
+          end
+        end
+
+        context 'with invalid email' do
+          let(:value) { 'emaild.g' }
+
+          it 'returns false' do
+            expect(matched).to be_falsey
+          end
+        end
+      end
+
+      context 'with a URI' do
+        it 'returns true for a valid URI' do
+          expect(described_class.match?(:uri, 'https://www.example.com')).to be_truthy
+        end
+
+        it 'returns false for an invalid URI' do
+          expect(described_class.match?(:uri, 'not a uri')).to be_falsey
+        end
+      end
+
+      context 'with a postal code' do
+        it 'returns true for a valid postal code' do
+          expect(described_class.match?(:postal_code, 'V5K 0A1')).to be_truthy
+        end
+
+        it 'returns false for an invalid postal code' do
+          expect(described_class.match?(:postal_code, 'not a postal code')).to be_falsey
+        end
+      end
+
+      context 'with a dotted index' do
+        it 'returns true for a valid dotted index' do
+          expect(described_class.match?(:dotted_index, 'person.address[0]')).to be_truthy
+        end
+
+        it 'returns false for an invalid dotted index' do
+          expect(described_class.match?(:dotted_index, 'not a dotted index')).to be_falsey
+        end
+      end
+    end
+
+    describe '#match' do
+      it 'returns the matched value for a successful match' do
+        expect(described_class.match(:uri, 'https://www.example.com').to_s).to eq('https://www.example.com')
+      end
+
+      it 'returns nil for an unsuccessful match' do
+        expect(described_class.match(:uri, 'not a uri')).to be_nil
+      end
+    end
+
+    describe '#replace' do
+      it 'replaces the matched value with the replacement string' do
+        expect(described_class.replace(:postal_code, 'V5K 0A1', 'REDACTED')).to eq('REDACTED')
+      end
+
+      it 'returns the original value if the regular expression does not match' do
+        expect(described_class.replace(:postal_code, 'not a postal code', 'REDACTED')).to eq('not a postal code')
+      end
+
+      it 'returns the original value if the value is not a string' do
+        expect(described_class.replace(:postal_code, 123, 'REDACTED')).to eq(123)
+      end
+    end
+  end
+end

data/spec/rordash/url_util_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Rordash
+  RSpec.describe UrlUtil do
+    let(:url) { "http://html.joe.com/Jobs/123/249 Subert Place Feb29'27.pdf" }
+
+    describe '.safe_escape' do
+      it 'encodes url' do
+        expect(described_class.safe_escape(url)).to eql("http://html.joe.com/Jobs/123/249%20Subert%20Place%20Feb29'27.pdf")
+      end
+    end
+
+    describe '.error_from_http_status' do
+      it 'returns appropriate http status message' do
+        expect(described_class.error_from_http_status(400)).to eql("Bad Request")
+      end
+
+      context 'with invalid http status code' do
+        it 'unknown http code message' do
+          expect(described_class.error_from_http_status(-1)).to eql("Invalid HTTP Status Code")
+        end
+      end
+    end
+  end
+end

data/spec/rordash_spec.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+RSpec.describe Rordash do
+  it "has a version number" do
+    expect(Rordash::VERSION).not_to be_nil
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require File.join(__dir__, "..", 'dev', 'setup')
+require Pathname.new(__dir__).realpath.join('coverage_helper').to_s
+
+unless defined? Rails
+  module Rails
+    class << self
+      def root
+        Pathname.new(__dir__).join('..')
+      end
+    end
+  end
+end
+
+RSpec.configure do |config|
+  # 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