collapsium 0.4.1 → 0.5.0

data/spec/environment_override_spec.rb

@@ -18,22 +18,29 @@ describe ::Collapsium::EnvironmentOverride do
 
   context "environment variable name" do
     it "upcases keys" do
-      expect(@tester.key_to_env("foo")).to eql "FOO"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo")).to eql "FOO"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("f0o")).to eql "F0O"
     end
 
     it "replaces non-alphanumeric characters with underscores" do
-      expect(@tester.key_to_env("foo!bar")).to eql "FOO_BAR"
-      expect(@tester.key_to_env("foo.bar")).to eql "FOO_BAR"
-      expect(@tester.key_to_env("foo@bar")).to eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo!bar")).to \
+        eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo.bar")).to \
+        eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo@bar")).to \
+        eql "FOO_BAR"
     end
 
     it "collapses multiple underscores into one" do
-      expect(@tester.key_to_env("foo!_@bar")).to eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo!_@bar")).to \
+        eql "FOO_BAR"
     end
 
     it "strips leading and trailing underscores" do
-      expect(@tester.key_to_env(".foo@bar")).to eql "FOO_BAR"
-      expect(@tester.key_to_env("foo@bar_")).to eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env(".foo@bar")).to \
+        eql "FOO_BAR"
+      expect(::Collapsium::EnvironmentOverride.key_to_env("foo@bar_")).to \
+        eql "FOO_BAR"
     end
   end
 
@@ -46,9 +53,9 @@ describe ::Collapsium::EnvironmentOverride do
     end
 
     it "inherits environment override" do
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo"]["bar"].is_a?(Integer)).to be_truthy
       ENV["BAR"] = "test"
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo"]["bar"].is_a?(Integer)).to be_falsy
       expect(@tester["foo"]["bar"]).to eql "test"
     end
 
@@ -74,12 +81,18 @@ describe ::Collapsium::EnvironmentOverride do
 
   context "with PathedAccess" do
     before :each do
-      @tester = { "foo" => { "bar" => 42 } }
+      @tester = {
+        "foo" => {
+          "bar" => 42
+        },
+        "baz" => [{ "quux" => 123 }]
+      }
       @tester.extend(::Collapsium::PathedAccess)
       @tester.extend(::Collapsium::EnvironmentOverride)
       ENV.delete("FOO")
       ENV.delete("BAR")
       ENV.delete("FOO_BAR")
+      ENV.delete("BAZ_0_QUUX")
     end
 
     it "overrides first-order keys" do
@@ -90,9 +103,9 @@ describe ::Collapsium::EnvironmentOverride do
     end
 
     it "inherits environment override" do
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_truthy
       ENV["BAR"] = "test"
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_falsy
       expect(@tester["foo.bar"]).to eql "test"
     end
 
@@ -116,27 +129,39 @@ describe ::Collapsium::EnvironmentOverride do
     end
 
     it "overrides from pathed key" do
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_truthy
       ENV["FOO_BAR"] = "test"
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_falsy
       expect(@tester["foo.bar"]).to eql "test"
     end
 
     it "prefers pathed key over non-pathed key" do
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_truthy
       ENV["FOO_BAR"] = "pathed"
       ENV["BAR"] = "simple"
-      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo.bar"].is_a?(Integer)).to be_falsy
       expect(@tester["foo.bar"]).to eql "pathed"
     end
 
     it "prefers pathed key over non-pathed key when using nested values" do
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_truthy
+      expect(@tester["foo"]["bar"].is_a?(Integer)).to be_truthy
       ENV["FOO_BAR"] = "pathed"
       ENV["BAR"] = "simple"
-      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo"]["bar"].is_a?(Integer)).to be_falsy
       expect(@tester["foo"]["bar"]).to eql "pathed"
     end
+
+    it "can deal with componentized keys" do
+      expect(@tester["foo"]["foo.bar"]).to be_nil
+      ENV["FOO_BAR"] = "pathed"
+      expect(@tester["foo"]["foo.bar"]).to be_nil
+    end
+
+    it "works with arrays" do
+      expect(@tester["baz"][0]["quux"]).to eql 123
+      ENV["BAZ_0_QUUX"] = "override"
+      expect(@tester["baz"][0]["quux"]).to eql "override"
+    end
   end
 
   context "respects the behaviour of wrapped methods" do

data/spec/pathed_access_spec.rb

@@ -5,42 +5,16 @@ class PathedHash < Hash
   prepend ::Collapsium::PathedAccess
 end
 
+class IncludedPathedHash < Hash
+  include ::Collapsium::PathedAccess
+end
+
 describe ::Collapsium::PathedAccess do
   before :each do
     @tester = {}
     @tester.extend(::Collapsium::PathedAccess)
   end
 
-  describe "Path components" do
-    it "splits a path into components" do
-      expect(@tester.path_components("foo.bar")).to eql %w(foo bar)
-    end
-
-    it "strips empty components at the beginning" do
-      expect(@tester.path_components("..foo.bar")).to eql %w(foo bar)
-    end
-
-    it "strips empty components at the end" do
-      expect(@tester.path_components("foo.bar..")).to eql %w(foo bar)
-    end
-
-    it "strips empty components in the middle" do
-      expect(@tester.path_components("foo...bar")).to eql %w(foo bar)
-    end
-
-    it "joins path components" do
-      expect(@tester.join_path(%w(foo bar))).to eql "foo.bar"
-    end
-
-    it "joins empty components to an empty string" do
-      expect(@tester.join_path([])).to eql ""
-    end
-
-    it "normalizes a path" do
-      expect(@tester.normalize_path("foo..bar..baz.")).to eql ".foo.bar.baz"
-    end
-  end
-
   describe "Hash-like" do
     it "responds to Hash functions" do
       [:invert, :delete, :fetch].each do |meth|
@@ -67,8 +41,8 @@ describe ::Collapsium::PathedAccess do
       end
 
       it "defaults to empty String" do
-        expect(@tester.path_prefix).to be_empty
         expect(@tester.path_prefix.class).to eql String
+        expect(@tester.path_prefix).to eql '.' # separator
       end
 
       it "can be set" do
@@ -79,6 +53,31 @@ describe ::Collapsium::PathedAccess do
         @tester.path_prefix = "foo..bar..baz.."
         expect(@tester.path_prefix).to eql ".foo.bar.baz"
       end
+
+      it "has the correct path for each value" do
+        @tester.merge!(
+            foo: {
+              first: 1, second: 2,
+              inner: { x: 1 },
+            },
+            bar: {
+              baz: 42, quux: 123,
+              inner: { x: 1 },
+            },
+            baz: [{ inner: { x: 1 } }],
+            "foo.bar" => 123,
+            "pathed.key" => 321
+        )
+
+        expect(@tester.path_prefix).to eql "."
+        expect(@tester[:foo].path_prefix).to eql ".foo"
+        expect(@tester[:foo][:inner].path_prefix).to eql ".foo.inner"
+        expect(@tester[:bar].path_prefix).to eql ".bar"
+        expect(@tester[:bar][:inner].path_prefix).to eql ".bar.inner"
+        expect(@tester[:baz].path_prefix).to eql ".baz"
+        expect(@tester[:baz][0].path_prefix).to eql ".baz.0"
+        expect(@tester[:baz][0][:inner].path_prefix).to eql ".baz.0.inner"
+      end
     end
 
     it "can recursively read entries via a path" do
@@ -136,6 +135,16 @@ describe ::Collapsium::PathedAccess do
       expect(@tester[".does.not.exist"]).to be_nil
       expect(@tester.fetch(".does.not.exist", 42)).to eql 42
     end
+
+    it "ignores keys containing the path separator" do
+      # Exists at the top level, no "pathed" item exists at the top level,
+      # though.
+      expect(@tester["pathed.key"]).to be_nil
+
+      # "foo" exists at the top level, but it does not contain "bar".
+      # "foo.bar" also exists at the top level.
+      expect(@tester["foo.bar"]).to be_nil
+    end
   end
 
   describe "nested inherit capabilities" do
@@ -177,6 +186,20 @@ describe ::Collapsium::PathedAccess do
       expect(@tester['foo.bar']).to eql 123
       expect(@tester['foo.baz']).to eql 'quux'
     end
+
+    it "doesn't break #path_prefix" do
+      @tester[:foo] = {
+        bar: {
+          baz: 123,
+        }
+      }
+      @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
+
+      expect(@tester[:foo].path_prefix).to eql ".foo"
+      expect(@tester["foo"].path_prefix).to eql ".foo"
+      expect(@tester[:foo][:bar].path_prefix).to eql ".foo.bar"
+      expect(@tester["foo.bar"].path_prefix).to eql ".foo.bar"
+    end
   end
 
   context PathedHash do
@@ -187,4 +210,46 @@ describe ::Collapsium::PathedAccess do
       expect(test_hash["foo.bar"]).to eql 42
     end
   end
+
+  context IncludedPathedHash do
+    let(:test_hash) { IncludedPathedHash.new }
+
+    it "can write recursively" do
+      test_hash["foo.bar"] = 42
+      expect(test_hash["foo.bar"]).to eql 42
+    end
+  end
+
+  context "array entries" do
+    before do
+      @tester['foo'] = {
+        'bar' => [
+          { 'baz1' => 'quux1' },
+          { 'baz2' => 'quux2' },
+        ]
+      }
+    end
+
+    it "resolved with pathed access" do
+      expect(@tester['foo.bar.0.baz1']).to eql 'quux1'
+      expect(@tester['foo.bar.1.baz2']).to eql 'quux2'
+    end
+  end
+
+  context "nested symbol keys" do
+    before do
+      @tester['foo'] = {
+        bar: { 'baz' => 'quux' },
+      }
+    end
+
+    it "resolve with pathed access & indifferent access" do
+      # This should be nil - we don't use indifferent access yet.
+      expect(@tester['foo.bar.baz']).to be_nil
+
+      # With indifferent access, pathed access must work
+      @tester.default_proc = ::Collapsium::IndifferentAccess::DEFAULT_PROC
+      expect(@tester['foo.bar.baz']).to eql 'quux'
+    end
+  end
 end

data/spec/support_methods_spec.rb

@@ -5,6 +5,10 @@ module First
   class << self
     include ::Collapsium::Support::Methods
 
+    def extended(base)
+      prepended(base)
+    end
+
     def prepended(base)
       wrap_method(base, :calling_test) do |super_method, *args, &block|
         result = super_method.call(*args, &block)
@@ -35,6 +39,48 @@ module Second
   end # class << self
 end # module First
 
+module NonRaising
+  class << self
+    include ::Collapsium::Support::Methods
+
+    def extended(base)
+      prepended(base)
+    end
+
+    def prepended(base)
+      opts = { raise_on_missing: false }
+
+      wrap_method(base, :calling_test, opts) do |super_method, *args, &block|
+        result = super_method.call(*args, &block)
+        next "nonraising: #{result}"
+      end
+
+      wrap_method(base, :test, opts) do
+        next "nonraising"
+      end
+    end
+  end # class << self
+end # module NonRaising
+
+module Looping
+  class << self
+    include ::Collapsium::Support::Methods
+
+    def extended(base)
+      prepended(base)
+    end
+
+    def prepended(base)
+      wrap_method(base, :loop, raise_on_missing: false) do |super_method, *_, &_|
+        super_method.receiver.loop
+      end
+    end
+  end # class << self
+end # module NonRaising
+
+class EmptyClass
+end
+
 class FirstThenSecond
   def calling_test
     return "first_then_second"
@@ -136,12 +182,18 @@ end
 
 describe ::Collapsium::Support::Methods do
   context "#wrap_method" do
-    it "fails if there is no method to wrap" do
-      expect do
-        class NoMethodToWrap
-          prepend First
+    it "can wrap objects" do
+      class TestClass
+        def calling_test
+          return "object wrapping"
         end
-      end.to raise_error(NameError)
+      end
+
+      tester = nil
+      expect { tester = TestClass.new }.not_to raise_error
+      expect { tester.extend(First) }.not_to raise_error
+
+      expect(tester.calling_test).to eql "first: object wrapping"
     end
 
     context FirstThenSecond do
@@ -154,6 +206,18 @@ describe ::Collapsium::Support::Methods do
       it "wraps results appropriately for calling methods" do
         expect(tester.calling_test).to eql 'second: first: first_then_second'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 2
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 2
+      end
     end
 
     context SecondThenFirst do
@@ -166,6 +230,18 @@ describe ::Collapsium::Support::Methods do
       it "wraps results appropriately for calling methods" do
         expect(tester.calling_test).to eql 'first: second: second_then_first'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 2
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 2
+      end
     end
 
     context Included do
@@ -178,6 +254,18 @@ describe ::Collapsium::Support::Methods do
       it "wraps results appropriately for calling methods" do
         expect(tester.calling_test).to eql 'include_module: included'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 1
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 1
+      end
     end
 
     context PrependNested do
@@ -190,6 +278,18 @@ describe ::Collapsium::Support::Methods do
       it "wraps results appropriately for calling methods" do
         expect(tester.calling_test).to eql 'include_module: nest_module'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 1
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 1
+      end
     end
 
     context IncludeNested do
@@ -202,6 +302,18 @@ describe ::Collapsium::Support::Methods do
       it "wraps results appropriately for calling methods" do
         expect(tester.calling_test).to eql 'include_module: nest_module'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 1
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 1
+      end
     end
 
     context IncludeNestedWithOwn do
@@ -214,6 +326,18 @@ describe ::Collapsium::Support::Methods do
       it "uses only the own class result for calling methods" do
         expect(tester.calling_test).to eql 'include_nested_with_own'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 1
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 1
+      end
     end
 
     context PrependNestedWithOwn do
@@ -226,6 +350,124 @@ describe ::Collapsium::Support::Methods do
       it "ignores class methods for calling methods" do
         expect(tester.calling_test).to eql 'include_module: nest_module'
       end
+
+      it "defines two wrappers for #test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :test).size
+        ).to eql 1
+      end
+
+      it "defines two wrappers for #calling_test" do
+        expect(
+          ::Collapsium::Support::Methods.wrappers(tester, :calling_test).size
+        ).to eql 1
+      end
+    end
+
+    context "failing" do
+      context "classes" do
+        it "fails if there is no method to wrap" do
+          expect do
+            class NoMethodToWrap1
+              prepend First
+            end
+          end.to raise_error(NameError)
+        end
+
+        it "fails silently if asked not to raise" do
+          expect do
+            class NoMethodToWrap2
+              prepend NonRaising
+            end
+          end.not_to raise_error
+        end
+      end
+
+      context "objects" do
+        it "fails if there is no method to wrap" do
+          expect do
+            tester = EmptyClass.new
+            tester.extend(First)
+          end.to raise_error(NameError)
+        end
+
+        it "fails silently if asked not to raise" do
+          expect do
+            tester = EmptyClass.new
+            tester.extend(NonRaising)
+          end.not_to raise_error
+        end
+      end
+    end
+  end
+
+  context "#wrappers" do
+    it "finds wrappers in FirstThenSecond" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(FirstThenSecond, :test).size
+      ).to eql 2
+    end
+
+    it "finds wrappers in SecondThenFirst" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(SecondThenFirst, :test).size
+      ).to eql 2
+    end
+
+    it "finds wrappers in Included" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(Included, :test).size
+      ).to eql 1
+    end
+
+    it "finds wrappers in NestModule" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(NestModule, :test).size
+      ).to eql 1
+    end
+
+    it "finds wrappers in PrependNested" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(PrependNested, :test).size
+      ).to eql 1
+    end
+
+    it "finds wrappers in IncludeNested" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(IncludeNested, :test).size
+      ).to eql 1
+    end
+
+    it "finds wrappers in PrependNestedWithOwn" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(PrependNestedWithOwn, :test).size
+      ).to eql 1
+    end
+
+    it "finds wrappers in IncludeNestedWithOwn" do
+      expect(
+        ::Collapsium::Support::Methods.wrappers(IncludeNestedWithOwn, :test).size
+      ).to eql 1
+    end
+
+    it "does not find wrappers on undecorated Hashes" do
+      expect(::Collapsium::Support::Methods.wrappers({}, :test)).to be_empty
+    end
+  end
+
+  context "loop detection" do
+    class LoopClass
+      def loop
+        return "loop"
+      end
+    end
+
+    it "prevents loops" do
+      tester = LoopClass.new
+      tester.extend(Looping)
+
+      expect { tester.loop }.not_to raise_error
+      expect(tester.loop).to eql "loop"
     end
   end
 end