agrippa 0.0.1

data/lib/agrippa/state.rb

@@ -0,0 +1,12 @@
+require "agrippa/proxy"
+
+module Agrippa
+    class State < Proxy
+        def method_missing(method, *args, &block)
+            output = @value.send(method, *args, &block)
+            return(output) unless proxied_method?(method)
+            @value = output
+            self
+        end
+    end
+end

data/lib/agrippa/utilities.rb

@@ -0,0 +1,12 @@
+module Agrippa
+    module Utilities
+        def self.try_require(file, fail_message = nil)
+            begin
+                require(file)
+            rescue LoadError => error
+                return(false) if fail_message.nil?
+                raise(LoadError, fail_message)
+            end
+        end
+    end
+end

data/lib/agrippa/version.rb

@@ -0,0 +1,3 @@
+module Agrippa
+  VERSION = "0.0.1"
+end

data/spec/delegation_spec.rb

@@ -0,0 +1,146 @@
+require "spec_helper"
+require "agrippa/delegation"
+require "agrippa/mutable"
+require "agrippa/immutable"
+
+RSpec.describe Agrippa::Delegation do
+    let(:klass) { Class.new.send(:include, Agrippa::Delegation) }
+
+    let(:instance) { klass.new }
+
+    describe ".delegate" do
+        describe "to a method" do
+            let(:receiver) { double(ping: "pong", bing: "bong") }
+
+            before(:each) { klass.send(:attr_accessor, :target) }
+
+            it "without a prefix" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(:ping, to: :target)
+                instance.target = receiver
+                expect(instance.ping).to eq("pong")
+            end
+
+            it "with default prefix" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(:ping, to: :target, prefix: true)
+                instance.target = receiver
+                expect(instance.target_ping).to eq("pong")
+            end
+
+            it "with custom prefix" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(:ping, to: :target, prefix: "mister")
+                instance.target = receiver
+                expect(instance.mister_ping).to eq("pong")
+            end
+
+            it "with default suffix" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(:ping, to: :target, suffix: true)
+                instance.target = receiver
+                expect(instance.ping_target).to eq("pong")
+            end
+
+            it "with custom suffix" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(:ping, to: :target, suffix: "mister")
+                instance.target = receiver
+                expect(instance.ping_mister).to eq("pong")
+            end
+
+            it "accepts strings" do
+                expect(receiver).to receive(:ping)
+                klass.delegate("ping", to: :target)
+                instance.target = receiver
+                expect(instance.ping).to eq("pong")
+            end
+
+            it "multiple methods" do
+                expect(receiver).to receive(:ping)
+                klass.delegate(*%w(ping bing), to: :target)
+                instance.target = receiver
+                expect(instance.ping).to eq("pong")
+                expect(instance.bing).to eq("bong")
+            end
+
+        end
+
+        it "to the class" do
+            klass.delegate(:ping, to: :class)
+            receiver = Module.new
+            receiver.send(:define_method, :ping) { "class pong" }
+            klass.send(:extend, receiver)
+            expect(instance.ping).to eq("class pong")
+        end
+    end
+
+    describe ".class_delegate" do
+        let(:receiver) { double(ping: "pong") }
+
+        before(:each) do
+            klass.class_eval("class << self; attr_accessor :target; end")
+            klass.target = receiver
+        end
+
+        it "without a prefix" do
+            expect(receiver).to receive(:ping)
+            klass.class_delegate(:ping, to: :target)
+            expect(klass.ping).to eq("pong")
+        end
+
+        it "with default prefix" do
+            expect(receiver).to receive(:ping)
+            klass.class_delegate(:ping, to: :target, prefix: true)
+            expect(klass.target_ping).to eq("pong")
+        end
+
+        it "with custom prefix" do
+            expect(receiver).to receive(:ping)
+            klass.class_delegate(:ping, to: :target, prefix: "mister")
+            expect(klass.mister_ping).to eq("pong")
+        end
+
+        it "with default suffix" do
+            expect(receiver).to receive(:ping)
+            klass.class_delegate(:ping, to: :target, suffix: true)
+            expect(klass.ping_target).to eq("pong")
+        end
+
+        it "with custom suffix" do
+            expect(receiver).to receive(:ping)
+            klass.class_delegate(:ping, to: :target, suffix: "mister")
+            expect(klass.ping_mister).to eq("pong")
+        end
+    end
+
+    describe ".delegate_command" do
+        let(:klass) do
+            result = Class.new.send(:include, Agrippa::Delegation)
+                .send(:include, Agrippa::Mutable)
+                .state_accessor(:target)
+        end
+
+        let(:instance) { klass.new }
+
+        let(:receiver_class) do
+            Class.new.send(:include, Agrippa::Immutable)
+                .state_accessor(:value)
+        end
+
+        let(:receiver) { receiver_class.new }
+
+        let(:random_value) { Object.new }
+
+        it "delegates" do
+            klass.delegate_command(:set_value, to: :target)
+            instance.set_target(receiver)
+            expect(instance.target).to be(receiver)
+            result = instance.set_value(random_value)
+            expect(result).to be(instance)
+            expect(instance.target).to be_a(receiver_class)
+            expect(instance.target).to_not be(receiver)
+            expect(instance.target.value).to be(random_value)
+        end
+    end
+end

data/spec/immutable_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+require "shared/state_container_examples"
+require "agrippa/immutable"
+
+RSpec.describe Agrippa::Immutable do
+    let(:klass) { Class.new.send(:include, Agrippa::Immutable) }
+
+    it_behaves_like "a state container"
+
+    it "#store does not mutate" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to_not be(instance)
+    end
+
+    describe "#new" do
+        it "directly uses Hamster::Hash" do
+            initial_state = Hamster::Hash.new(a: 1)
+            instance = klass.new(initial_state)
+            final_state = instance.instance_variable_get(:@state)
+            expect(final_state).to be(initial_state)
+        end
+    end
+end

data/spec/maybe_spec.rb

@@ -0,0 +1,32 @@
+require "spec_helper"
+require "agrippa/maybe"
+
+RSpec.describe Agrippa::Maybe do
+    it "handles nils" do
+        instance = double(call: nil)
+        expect(instance).to receive(:call)
+        proxy = Agrippa::Maybe.new(instance)
+        expect { proxy.call }.to_not raise_error
+        expect { proxy.call }.to_not raise_error
+        expect(proxy._value).to be_nil
+    end
+
+    it "handles unknown methods" do
+        instance = Object.new
+        proxy = Agrippa::Maybe.new(instance)
+        expect { proxy.call }.to_not raise_error
+        expect(proxy._value).to be_nil
+    end
+
+    it "chains" do
+        finish = double(call: 42)
+        start = double(call: finish)
+        expect(start).to receive(:call)
+        expect(finish).to receive(:call)
+        proxy = Agrippa::Maybe.new(start)
+        expect { proxy.call }.to_not raise_error
+        expect(proxy._value).to eq(finish)
+        expect { proxy.call }.to_not raise_error
+        expect(proxy._value).to eq(42)
+    end
+end

data/spec/methods_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "agrippa/methods"
+
+RSpec.describe Agrippa::Methods do
+    let(:klass) { Class.new.send(:include, Agrippa::Methods) }
+
+    describe ".command_methods" do
+        def methods
+            klass.command_methods
+        end
+
+        it "empty by default" do
+            expect(methods).to be_empty
+        end
+
+        describe "adds methods" do
+            it "single string" do
+                klass.mark_as_commands "foo"
+                expect(methods).to eq(foo: true)
+            end
+
+            it "single symbol" do
+                klass.mark_as_commands :foo
+                expect(methods).to eq(foo: true)
+            end
+            
+            it "list of symbols" do
+                klass.mark_as_commands :foo, :bar
+                expect(methods).to eq(foo: true, bar: true)
+            end
+
+            it "array of strings" do
+                klass.mark_as_commands %w(foo bar)
+                expect(methods).to eq(foo: true, bar: true)
+            end
+        end
+    end
+end

data/spec/mutable_hash_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "shared/state_container_examples"
+require "agrippa/mutable_hash"
+
+RSpec.describe Agrippa::MutableHash do
+    let(:klass) { Class.new.send(:include, Agrippa::MutableHash) }
+
+    it_behaves_like "a state container"
+
+    it "#store mutates" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to be(instance)
+    end
+end

data/spec/mutable_spec.rb

@@ -0,0 +1,14 @@
+require "spec_helper"
+require "shared/state_container_examples"
+require "agrippa/mutable"
+
+RSpec.describe Agrippa::Mutable do
+    let(:klass) { Class.new.send(:include, Agrippa::Mutable) }
+
+    it_behaves_like "a state container"
+
+    it "#store mutates" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to be(instance)
+    end
+end

data/spec/object_state_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+require "agrippa/mutable"
+require "agrippa/mutable_hash"
+require "agrippa/immutable"
+require "shared/state_container_examples"
+
+RSpec.describe Agrippa::Mutable do
+    let(:klass) { Class.new.send(:include, Agrippa::Mutable) }
+
+    it_behaves_like "a state container"
+
+    it "#store mutates" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to be(instance)
+    end
+end
+
+RSpec.describe Agrippa::MutableHash do
+    let(:klass) { Class.new.send(:include, Agrippa::MutableHash) }
+
+    it_behaves_like "a state container"
+
+    it "#store mutates" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to be(instance)
+    end
+end
+
+RSpec.describe Agrippa::Immutable do
+    let(:klass) { Class.new.send(:include, Agrippa::Immutable) }
+
+    it_behaves_like "a state container"
+
+    it "#store does not mutate" do
+        instance = klass.new(a: 1)
+        expect(instance.store(:b, 2)).to_not be(instance)
+    end
+end

data/spec/proxy_spec.rb

@@ -0,0 +1,107 @@
+require "spec_helper"
+require "agrippa/proxy"
+require "agrippa/methods"
+
+RSpec.describe Agrippa::Proxy do
+    let(:klass) { Class.new }
+
+    let(:instance) { klass.new }
+    
+    it "requires subclasses to implement method_missing" do
+        proxy = Agrippa::Proxy.new(instance)
+        expect { proxy.foo }.to raise_error(NoMethodError)
+    end
+
+    describe "proxied methods" do
+        it "everything by default" do
+            proxy = Agrippa::Proxy.new(instance)
+            expect(proxy.proxied_method?(:foo)).to be(true)
+        end
+
+        it "specified only" do
+            proxy = Agrippa::Proxy.new(instance, :a, "b")
+            expect(proxy.proxied_methods).to eq(a: true, b: true)
+            expect(proxy.proxied_method?(:c)).to be(false)
+        end
+
+        it "command" do
+            klass.send(:include, Agrippa::Methods)
+            klass.mark_as_command(:a)
+            proxy = Agrippa::Proxy.new(instance)
+            expect(proxy.proxied_methods).to eq(a: true)
+        end
+
+        it "both specified and command" do
+            klass.send(:include, Agrippa::Methods)
+            klass.mark_as_command(:a)
+            proxy = Agrippa::Proxy.new(instance, :b)
+            expect(proxy.proxied_methods).to eq(a: true, b: true)
+        end
+    end
+
+    it "#is_a? wrapped class" do
+        proxy = Agrippa::Proxy.new(instance)
+        expect(proxy.is_a?(klass)).to be(true)
+    end
+
+    it "#is_a? proxy" do
+        proxy = Agrippa::Proxy.new(instance)
+        expect(proxy.is_a?(Agrippa::Proxy)).to be(true)
+    end
+
+    it "#respond_to? proxy" do
+        proxy = Agrippa::Proxy.new(instance)
+        expect(proxy.respond_to?(:proxied_methods)).to be(true)
+        expect(proxy.respond_to?(:total_bullshit)).to be(false)
+    end
+
+    it "#respond_to? wrapped" do
+        instance = double(ping: "pong")
+        proxy = Agrippa::Proxy.new(instance)
+        expect(proxy.respond_to?(:ping)).to be(true)
+        expect(proxy.respond_to?(:pong)).to be(false)
+    end
+
+    it "#_value" do
+        inner_class = Class.new(Agrippa::Proxy)
+        outer_class = Class.new(Agrippa::Proxy)
+        instance = double()
+        inner = inner_class.new(instance)
+        outer = outer_class.new(inner)
+        expect(outer._value.__id__).to eq(inner.__id__)
+    end
+
+    it "#_ returns #_value" do
+        inner_class = Class.new(Agrippa::Proxy)
+        outer_class = Class.new(Agrippa::Proxy)
+        instance = double()
+        inner = inner_class.new(instance)
+        outer = outer_class.new(inner)
+        expect(outer._.__id__).to eq(outer._value.__id__)
+    end
+
+    it "#_deep_value" do
+        inner_class = Class.new(Agrippa::Proxy)
+        outer_class = Class.new(Agrippa::Proxy)
+        instance = double()
+        inner = inner_class.new(instance)
+        outer = outer_class.new(inner)
+        expect(outer._deep_value).to be(instance)
+    end
+
+    it "proxies" do
+        passthrough = Module.new do
+            def method_missing(name, *args, &block)
+                @value.send(name, *args, &block)
+            end
+        end
+        inner_class = Class.new(Agrippa::Proxy)
+            .send(:include, passthrough)
+        outer_class = Class.new(Agrippa::Proxy)
+            .send(:include, passthrough)
+        instance = double(ping: "pong")
+        inner = inner_class.new(instance)
+        outer = outer_class.new(inner)
+        expect(outer.ping).to eq("pong")
+    end
+end