octiron 0.1.0

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# Always start SimpleCov
+require 'simplecov'
+SimpleCov.start do
+  add_filter 'spec'
+end

data/spec/support_camel_case_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require_relative '../lib/octiron/support/camel_case'
+
+class Tester
+  include ::Octiron::Support::CamelCase
+end
+
+describe ::Octiron::Support::CamelCase do
+  before do
+    @tester = Tester.new
+  end
+
+  it "capitalizes a single word" do
+    expect(@tester.camel_case('foo')).to eql 'Foo'
+  end
+
+  it "capitalizes letters in underscore separated words" do
+    expect(@tester.camel_case('foo_bar')).to eql 'FooBar'
+  end
+
+  it "handles symbols" do
+    expect(@tester.camel_case(:foo_bar)).to eql 'FooBar'
+  end
+end

data/spec/support_constantize_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require_relative '../lib/octiron/support/constantize'
+
+class Tester
+  include ::Octiron::Support::Constantize
+end
+
+class Test
+end
+
+module TestModule
+  class InnerTest
+  end
+end
+
+class A
+  class A
+  end
+end
+
+class B < A
+  class B
+  end
+end
+
+describe ::Octiron::Support::Constantize do
+  before do
+    @tester = Tester.new
+  end
+
+  it "throws with an empty path (i.e. '::')" do
+    expect do
+      @tester.constantize('::')
+    end.to raise_error(NameError)
+  end
+
+  it "resolves a constant in the global namespace" do
+    expect(@tester.constantize('Test')).to eql Test
+  end
+
+  it "accepts absolute paths (i.e. starting with '::')" do
+    expect(@tester.constantize('::Test')).to eql Test
+  end
+
+  it "accepts nested names" do
+    expect(@tester.constantize('TestModule::InnerTest')).to \
+      eql TestModule::InnerTest
+  end
+
+  it "performs lookup in ancestors" do
+    expect(@tester.constantize('A::A')).to eql A::A
+
+    expect do
+      @tester.constantize('A::does_not_exist')
+    end.to raise_error(NameError)
+
+    expect(@tester.constantize('B::B')).to eql B::B
+    expect(@tester.constantize('B::A')).to eql A::A
+
+    expect do
+      @tester.constantize('B::does_not_exist')
+    end.to raise_error(NameError)
+  end
+end

data/spec/support_identifiers_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require_relative '../lib/octiron/support/identifiers'
+
+class Tester
+  include ::Octiron::Support::Identifiers
+
+  def initialize(*_)
+    @default_namespace = 'Octiron::Support'
+  end
+end
+
+class Test
+end
+
+module TestModule
+  class InnerTest
+  end
+end
+
+class A
+  class A
+  end
+end
+
+class B < A
+  class B
+  end
+end
+
+describe ::Octiron::Support::Identifiers do
+  before do
+    @tester = Tester.new
+  end
+
+  it "throws with an empty path (i.e. '::')" do
+    expect do
+      @tester.identify('::')
+    end.to raise_error(NameError)
+
+    expect do
+      @tester.identify('')
+    end.to raise_error(NameError)
+
+    expect do
+      @tester.identify(nil)
+    end.to raise_error(NameError)
+  end
+
+  it "returns the name of a Class" do
+    expect(@tester.identify(Test)).to eql 'Test'
+    expect(@tester.identify(A)).to eql 'A'
+    expect(@tester.identify(B)).to eql 'B'
+  end
+
+  it "returns Hashes untouched" do
+    test_hash = {}
+    expect(@tester.identify(test_hash)).to eql test_hash
+    expect(@tester.identify(test_hash).object_id).to eql test_hash.object_id
+  end
+
+  it "resolves strings to constant names" do
+    expect(@tester.identify('Octiron::Support::Identifiers')).to eql \
+      'Octiron::Support::Identifiers'
+  end
+
+  it "attempts to resolve anything else as constants in the default namespace" do
+    expect(@tester.identify(:identifiers)).to eql \
+      'Octiron::Support::Identifiers'
+  end
+end

data/spec/transmogrifiers_registry_spec.rb

@@ -0,0 +1,311 @@
+require 'spec_helper'
+require_relative '../lib/octiron/transmogrifiers/registry'
+
+class Test1
+end
+
+class Test2
+end
+
+class Test3
+end
+
+class Transmogrifier
+  attr_reader :invoked
+  def initialize
+    @invoked = 0
+  end
+
+  def call(_)
+    @invoked += 1
+  end
+end
+
+class HashTransmogrifier < Transmogrifier
+  def initialize(bad = false)
+    super()
+    @bad = bad
+  end
+
+  def call(from)
+    super
+
+    if @bad
+      return {}
+    end
+
+    return {
+      a: from[:a],
+      b_c: from[:b][:c],
+    }
+  end
+end
+
+class Test1To2Transmogrifier < Transmogrifier
+  def call(from)
+    super
+    return Test2.new
+  end
+end
+
+class Test2To3Transmogrifier < Transmogrifier
+  def call(from)
+    super
+    return Test3.new
+  end
+end
+
+class Test1To3Transmogrifier < Transmogrifier
+  def call(from)
+    super
+    return Test3.new
+  end
+end
+
+describe Octiron::Transmogrifiers::Registry do
+  describe "construction" do
+    it "can be constructed without a default namespace" do
+      reg = nil
+      expect do
+        reg = ::Octiron::Transmogrifiers::Registry.new
+      end.not_to raise_error
+
+      expect(reg.default_namespace).to eql 'Octiron::Transmogrifiers'
+    end
+
+    it "can be constructed with a namespace" do
+      reg = nil
+      expect do
+        reg = ::Octiron::Transmogrifiers::Registry.new(::Octiron::Transmogrifiers)
+      end.not_to raise_error
+
+      expect(reg.default_namespace).to eql 'Octiron::Transmogrifiers'
+    end
+  end
+
+  describe "registration" do
+    before :each do
+      @reg = ::Octiron::Transmogrifiers::Registry.new
+    end
+
+    it "can register a transmogrifier object" do
+      expect do
+        @reg.register(Test1, Test2, false, Transmogrifier.new)
+      end.not_to raise_error
+    end
+
+    it "throws when registering a transmogrifier for the same pair twice" do
+      expect do
+        @reg.register(Test1, Test2, false, Transmogrifier.new)
+      end.not_to raise_error
+
+      expect do
+        @reg.register(Test1, Test2, false, Transmogrifier.new)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "can overwrite transmogrifiers" do
+      expect do
+        @reg.register(Test1, Test2, false, Transmogrifier.new)
+      end.not_to raise_error
+
+      expect do
+        @reg.register(Test1, Test2, true, Transmogrifier.new)
+      end.not_to raise_error
+    end
+
+    it "can register transmogrifier procs" do
+      expect do
+        @reg.register(Test1, Test2) do |_|
+        end
+      end.not_to raise_error
+    end
+
+    it "raises if no transmogrifier is given" do
+      expect do
+        @reg.register(Test1, Test2)
+      end.to raise_error(ArgumentError)
+
+      expect do
+        @reg.register(Test1, Test2, false)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "can deregister a transmogrifier" do
+      expect do
+        @reg.register(Test1, Test2) do |_|
+        end
+      end.not_to raise_error
+
+      # First time, there is a transmogrifier
+      expect do
+        @reg.deregister(Test1, Test2)
+      end.not_to raise_error
+
+      # Second time, there is none - it still shouldn't fail
+      expect do
+        @reg.deregister(Test1, Test2)
+      end.not_to raise_error
+    end
+  end
+
+  describe "register argument validation" do
+    before :each do
+      @reg = ::Octiron::Transmogrifiers::Registry.new
+    end
+
+    it "accepts string names" do
+      expect do
+        @reg.register('Test1', 'Test2', false, Transmogrifier.new)
+      end.not_to raise_error
+    end
+
+    it "accepts symbol names" do
+      expect do
+        @reg.register(:test1, :test2, false, Transmogrifier.new)
+      end.not_to raise_error
+    end
+
+    it "accepts hash prototypes" do
+      proto1 = {
+        a: nil,
+        b: {
+          c: 42,
+        },
+      }
+      proto2 = {
+        a: nil,
+        b_c: nil,
+      }
+
+      expect do
+        @reg.register(proto1, proto2, false, Transmogrifier.new)
+      end.not_to raise_error
+    end
+  end
+
+  describe "transmogrification" do
+    before :each do
+      @reg = ::Octiron::Transmogrifiers::Registry.new
+      @trans1to2 = Test1To2Transmogrifier.new
+      @trans2to3 = Test2To3Transmogrifier.new
+      @reg.register(Test1, Test2, false, @trans1to2)
+      @reg.register(Test2, Test3, false, @trans2to3)
+    end
+
+    it "can transmogrify with a directly registered transmogrifier" do
+      result = nil
+
+      expect do
+        result = @reg.transmogrify(Test1.new, Test2)
+      end.not_to raise_error
+
+      expect(result.class).to eql Test2
+
+      expect(@trans1to2.invoked).to eql 1
+      expect(@trans2to3.invoked).to eql 0
+    end
+
+    it "can transmogrify with indirectly registered transmogrifiers" do
+      result = nil
+
+      expect do
+        result = @reg.transmogrify(Test1.new, Test3)
+      end.not_to raise_error
+
+      expect(result.class).to eql Test3
+
+      expect(@trans1to2.invoked).to eql 1
+      expect(@trans2to3.invoked).to eql 1
+    end
+
+    it "chooses the shortest transmogrification path" do
+      result = nil
+
+      direct = Test1To3Transmogrifier.new
+      @reg.register(Test1, Test3, false, direct)
+
+      expect do
+        result = @reg.transmogrify(Test1.new, Test3)
+      end.not_to raise_error
+
+      expect(result.class).to eql Test3
+
+      expect(@trans1to2.invoked).to eql 0
+      expect(@trans2to3.invoked).to eql 0
+      expect(direct.invoked).to eql 1
+    end
+
+    it "fails if no transmogrifier is found" do
+      expect do
+        @reg.transmogrify(Test1.new, Hash)
+      end.to raise_error(ArgumentError)
+    end
+
+    it "fails if a transmogrifier misbehaves" do
+      # Register the wrong 'direct' transmogrifier that will then be chosen
+      direct = Test1To2Transmogrifier.new
+      @reg.register(Test1, Test3, false, direct)
+
+      expect do
+        @reg.transmogrify(Test1.new, Test3)
+      end.to raise_error(RuntimeError)
+    end
+
+    it "transmogrifies hashes" do
+      proto1 = {
+        a: nil,
+        b: {
+          c: 42,
+        },
+      }
+      proto2 = {
+        a: nil,
+        b_c: nil,
+      }
+
+      @reg.register(proto1, proto2, false, HashTransmogrifier.new)
+
+      from = {
+        a: 'foo',
+        b: {
+          c: 42,
+        },
+      }
+
+      result = nil
+      expect do
+        result = @reg.transmogrify(from, proto2)
+      end.not_to raise_error
+
+      expect(result[:a]).to eql 'foo'
+      expect(result[:b_c]).to eql 42
+    end
+
+    it "throws if a hash transmogrifier produces bad results" do
+      proto1 = {
+        a: nil,
+        b: {
+          c: 42,
+        },
+      }
+      proto2 = {
+        a: nil,
+        b_c: nil,
+      }
+
+      @reg.register(proto1, proto2, false, HashTransmogrifier.new(true))
+
+      from = {
+        a: 'foo',
+        b: {
+          c: 42,
+        },
+      }
+
+      expect do
+        @reg.transmogrify(from, proto2)
+      end.to raise_error(RuntimeError)
+    end
+  end
+end