collapsium 0.3.0 → 0.4.0

data/spec/environment_override_spec.rb

@@ -0,0 +1,154 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/environment_override'
+require_relative '../lib/collapsium/pathed_access'
+
+class EnvironmentHash < Hash
+  # We need only one of these; this is for coverage mostly
+  prepend ::Collapsium::EnvironmentOverride
+  include ::Collapsium::EnvironmentOverride
+end
+
+describe ::Collapsium::EnvironmentOverride do
+  before :each do
+    @tester = { "foo" => { "bar" => 42 } }
+    @tester.extend(::Collapsium::EnvironmentOverride)
+    ENV.delete("FOO")
+    ENV.delete("BAR")
+  end
+
+  context "environment variable name" do
+    it "upcases keys" do
+      expect(@tester.key_to_env("foo")).to eql "FOO"
+    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"
+    end
+
+    it "collapses multiple underscores into one" do
+      expect(@tester.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"
+    end
+  end
+
+  context "without pathed access" do
+    it "overrides first-order keys" do
+      expect(@tester["foo"].is_a?(Hash)).to be_truthy
+      ENV["FOO"] = "test"
+      expect(@tester["foo"].is_a?(Hash)).to be_falsy
+      expect(@tester["foo"]).to eql "test"
+    end
+
+    it "inherits environment override" do
+      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_truthy
+      ENV["BAR"] = "test"
+      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo"]["bar"]).to eql "test"
+    end
+
+    it "write still works" do
+      @tester.store("foo", 42)
+      expect(@tester["foo"]).to eql 42
+    end
+  end
+
+  context "with pathed access" do
+    before :each do
+      @tester = { "foo" => { "bar" => 42 } }
+      @tester.extend(::Collapsium::EnvironmentOverride)
+      @tester.extend(::Collapsium::PathedAccess)
+      ENV["FOO"] = nil
+      ENV["BAR"] = nil
+      ENV["FOO_BAR"] = nil
+    end
+
+    it "overrides first-order keys" do
+      expect(@tester["foo"].is_a?(Hash)).to be_truthy
+      ENV["FOO"] = "test"
+      expect(@tester["foo"].is_a?(Hash)).to be_falsy
+      expect(@tester["foo"]).to eql "test"
+    end
+
+    it "inherits environment override" do
+      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_truthy
+      ENV["BAR"] = "test"
+      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo"]["bar"]).to eql "test"
+    end
+
+    it "write still works" do
+      @tester.store("foo", 42)
+      expect(@tester["foo"]).to eql 42
+    end
+
+    it "overrides from pathed key" do
+      expect(@tester["foo.bar"].is_a?(Fixnum)).to be_truthy
+      ENV["FOO_BAR"] = "test"
+      expect(@tester["foo.bar"].is_a?(Fixnum)).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
+      ENV["FOO_BAR"] = "pathed"
+      ENV["BAR"] = "simple"
+      expect(@tester["foo.bar"].is_a?(Fixnum)).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
+      ENV["FOO_BAR"] = "pathed"
+      ENV["BAR"] = "simple"
+      expect(@tester["foo"]["bar"].is_a?(Fixnum)).to be_falsy
+      expect(@tester["foo"]["bar"]).to eql "pathed"
+    end
+  end
+
+  context "respects the behaviour of wrapped methods" do
+    it "works with :[]" do
+      ENV["FOO"] = "test"
+      expect(@tester["foo"]).to eql "test"
+    end
+
+    it "works with :fetch" do
+      ENV["FOO"] = "test"
+      expect(@tester.fetch("foo", 1234)).to eql "test"
+    end
+
+    it "works with :key?" do
+      ENV["FOO"] = "test"
+      expect(@tester.key?("foo")).to eql true   # not be_truthy
+      expect(@tester.key?("bar")).to eql false  # not be_falsey
+    end
+  end
+
+  context EnvironmentHash do
+    let(:test_hash) { EnvironmentHash.new }
+
+    it "works when prepended" do
+      ENV["FOO"] = "test"
+      expect(test_hash["foo"]).to eql "test"
+    end
+  end
+
+  context "JSON" do
+    it "interprets JSON content in environment variables" do
+      ENV["FOO"] = '{ "json_key": "json_value" }'
+      expect(@tester["foo"].is_a?(Hash)).to be_truthy
+      expect(@tester["foo"]["json_key"]).to eql "json_value"
+    end
+  end
+
+  context "coverage" do
+    it "raises when not passing arguments" do
+      expect { @tester.fetch }.to raise_error
+    end
+  end
+end

data/spec/pathed_access_spec.rb

@@ -1,12 +1,46 @@
 require 'spec_helper'
 require_relative '../lib/collapsium/pathed_access'
 
+class PathedHash < Hash
+  prepend ::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|
@@ -27,6 +61,26 @@ describe ::Collapsium::PathedAccess do
   end
 
   describe "pathed access" do
+    context ":path_prefix" do
+      it "can be read" do
+        expect { @tester.path_prefix }.not_to raise_error
+      end
+
+      it "defaults to empty String" do
+        expect(@tester.path_prefix).to be_empty
+        expect(@tester.path_prefix.class).to eql String
+      end
+
+      it "can be set" do
+        expect { @tester.path_prefix = "foo.bar" }.not_to raise_error
+      end
+
+      it "normalizes when set" do
+        @tester.path_prefix = "foo..bar..baz.."
+        expect(@tester.path_prefix).to eql ".foo.bar.baz"
+      end
+    end
+
     it "can recursively read entries via a path" do
       @tester["foo"] = 42
       @tester["bar"] = {
@@ -84,6 +138,26 @@ describe ::Collapsium::PathedAccess do
     end
   end
 
+  describe "nested inherit capabilities" do
+    before do
+      @tester['foo'] = {
+        'bar' => {
+          'baz' => 42,
+        },
+      }
+    end
+
+    it "can still perform pathed access" do
+      foo = @tester['foo']
+      expect(foo['bar.baz']).to eql 42
+    end
+
+    it "knows its path prefix" do
+      bar = @tester['foo.bar']
+      expect(bar.path_prefix).to eql '.foo.bar'
+    end
+  end
+
   describe "with indifferent access" do
     before do
       require_relative '../lib/collapsium/indifferent_access'
@@ -104,4 +178,13 @@ describe ::Collapsium::PathedAccess do
       expect(@tester['foo.baz']).to eql 'quux'
     end
   end
+
+  context PathedHash do
+    let(:test_hash) { PathedHash.new }
+
+    it "can write recursively" do
+      test_hash["foo.bar"] = 42
+      expect(test_hash["foo.bar"]).to eql 42
+    end
+  end
 end

data/spec/recursive_merge_spec.rb

@@ -67,4 +67,21 @@ describe ::Collapsium::RecursiveMerge do
 
     expect(x[:bar].length).to eql 2
   end
+
+  it "makes nested hashes able to merge recursively" do
+    @tester[:foo] = {
+      bar: true,
+    }
+    expect(@tester[:foo].respond_to?(:recursive_merge)).to be_truthy
+
+    to_merge = {
+      foo: {
+        bar: false,
+      },
+    }
+    x = @tester.recursive_merge(to_merge)
+
+    expect(@tester[:foo].respond_to?(:recursive_merge)).to be_truthy
+    expect(x[:foo].respond_to?(:recursive_merge)).to be_truthy
+  end
 end

data/spec/support_methods_spec.rb

@@ -0,0 +1,231 @@
+require 'spec_helper'
+require_relative '../lib/collapsium/support/methods'
+
+module First
+  class << self
+    include ::Collapsium::Support::Methods
+
+    def prepended(base)
+      wrap_method(base, :calling_test) do |super_method, *args, &block|
+        result = super_method.call(*args, &block)
+        next "first: #{result}"
+      end
+
+      wrap_method(base, :test) do
+        next "first"
+      end
+    end
+  end # class << self
+end # module First
+
+module Second
+  class << self
+    include ::Collapsium::Support::Methods
+
+    def prepended(base)
+      wrap_method(base, :calling_test) do |super_method, *args, &block|
+        result = super_method.call(*args, &block)
+        next "second: #{result}"
+      end
+
+      wrap_method(base, :test) do
+        next "second"
+      end
+    end
+  end # class << self
+end # module First
+
+class FirstThenSecond
+  def calling_test
+    return "first_then_second"
+  end
+
+  def test
+    return "first_then_second"
+  end
+
+  prepend First
+  prepend Second
+end
+
+class SecondThenFirst
+  def calling_test
+    return "second_then_first"
+  end
+
+  def test
+    return "second_then_first"
+  end
+
+  prepend Second
+  prepend First
+end
+
+module IncludeModule
+  class << self
+    include ::Collapsium::Support::Methods
+
+    def included(base)
+      wrap_method(base, :calling_test) do |super_method, *args, &block|
+        result = super_method.call(*args, &block)
+        next "include_module: #{result}"
+      end
+
+      wrap_method(base, :test) do
+        next "include_module"
+      end
+    end
+  end
+end
+
+class Included
+  def calling_test
+    return "included"
+  end
+
+  def test
+    return "included"
+  end
+
+  include IncludeModule
+end
+
+module NestModule
+  def calling_test
+    return "nest_module"
+  end
+
+  def test
+    return "nest_module"
+  end
+
+  include IncludeModule
+end
+
+class PrependNested
+  prepend NestModule
+end
+
+class IncludeNested
+  include NestModule
+end
+
+class IncludeNestedWithOwn
+  def calling_test
+    return "include_nested_with_own"
+  end
+
+  def test
+    return "include_nested_with_own"
+  end
+
+  include NestModule
+end
+
+class PrependNestedWithOwn
+  def calling_test
+    return "prepend_nested_with_own"
+  end
+
+  def test
+    return "prepend_nested_with_own"
+  end
+
+  prepend NestModule
+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
+        end
+      end.to raise_error(NameError)
+    end
+
+    context FirstThenSecond do
+      let(:tester) { FirstThenSecond.new }
+
+      it "uses only the second module's return value for non-calling methods" do
+        expect(tester.test).to eql 'second'
+      end
+
+      it "wraps results appropriately for calling methods" do
+        expect(tester.calling_test).to eql 'second: first: first_then_second'
+      end
+    end
+
+    context SecondThenFirst do
+      let(:tester) { SecondThenFirst.new }
+
+      it "uses only the second module's return value for non-calling methods" do
+        expect(tester.test).to eql 'first'
+      end
+
+      it "wraps results appropriately for calling methods" do
+        expect(tester.calling_test).to eql 'first: second: second_then_first'
+      end
+    end
+
+    context Included do
+      let(:tester) { Included.new }
+
+      it "uses only the included module's return value for non-calling methods" do
+        expect(tester.test).to eql 'include_module'
+      end
+
+      it "wraps results appropriately for calling methods" do
+        expect(tester.calling_test).to eql 'include_module: included'
+      end
+    end
+
+    context PrependNested do
+      let(:tester) { PrependNested.new }
+
+      it "uses only the included module's return value for non-calling methods" do
+        expect(tester.test).to eql 'include_module'
+      end
+
+      it "wraps results appropriately for calling methods" do
+        expect(tester.calling_test).to eql 'include_module: nest_module'
+      end
+    end
+
+    context IncludeNested do
+      let(:tester) { IncludeNested.new }
+
+      it "uses only the included module's return value for non-calling methods" do
+        expect(tester.test).to eql 'include_module'
+      end
+
+      it "wraps results appropriately for calling methods" do
+        expect(tester.calling_test).to eql 'include_module: nest_module'
+      end
+    end
+
+    context IncludeNestedWithOwn do
+      let(:tester) { IncludeNestedWithOwn.new }
+
+      it "uses only the own class result for non-calling methods" do
+        expect(tester.test).to eql 'include_nested_with_own'
+      end
+
+      it "uses only the own class result for calling methods" do
+        expect(tester.calling_test).to eql 'include_nested_with_own'
+      end
+    end
+
+    context PrependNestedWithOwn do
+      let(:tester) { PrependNestedWithOwn.new }
+
+      it "ignores class methods for non-calling methods" do
+        expect(tester.test).to eql 'include_module'
+      end
+
+      it "ignores class methods for calling methods" do
+        expect(tester.calling_test).to eql 'include_module: nest_module'
+      end
+    end
+  end
+end