363 lines
9.5 KiB
Ruby
363 lines
9.5 KiB
Ruby
require 'spec_helper'
|
|
require 'singleton'
|
|
|
|
describe Docile do
|
|
|
|
describe '.dsl_eval' do
|
|
|
|
context 'when DSL context object is an Array' do
|
|
let(:array) { [] }
|
|
let!(:result) { execute_dsl_against_array }
|
|
|
|
def execute_dsl_against_array
|
|
Docile.dsl_eval(array) do
|
|
push 1
|
|
push 2
|
|
pop
|
|
push 3
|
|
end
|
|
end
|
|
|
|
it 'executes the block against the DSL context object' do
|
|
expect(array).to eq([1, 3])
|
|
end
|
|
|
|
it 'returns the DSL object after executing block against it' do
|
|
expect(result).to eq(array)
|
|
end
|
|
|
|
it "doesn't proxy #__id__" do
|
|
Docile.dsl_eval(array) { expect(__id__).not_to eq(array.__id__) }
|
|
end
|
|
|
|
it "raises NoMethodError if the DSL object doesn't implement the method" do
|
|
expect { Docile.dsl_eval(array) { no_such_method } }.to raise_error(NoMethodError)
|
|
end
|
|
end
|
|
|
|
Pizza = Struct.new(:cheese, :pepperoni, :bacon, :sauce)
|
|
|
|
class PizzaBuilder
|
|
def cheese(v=true); @cheese = v; end
|
|
def pepperoni(v=true); @pepperoni = v; end
|
|
def bacon(v=true); @bacon = v; end
|
|
def sauce(v=nil); @sauce = v; end
|
|
def build
|
|
Pizza.new(!!@cheese, !!@pepperoni, !!@bacon, @sauce)
|
|
end
|
|
end
|
|
|
|
context 'when DSL context object is a Builder pattern' do
|
|
let(:builder) { PizzaBuilder.new }
|
|
let(:result) { execute_dsl_against_builder_and_call_build }
|
|
|
|
def execute_dsl_against_builder_and_call_build
|
|
@sauce = :extra
|
|
Docile.dsl_eval(builder) do
|
|
bacon
|
|
cheese
|
|
sauce @sauce
|
|
end.build
|
|
end
|
|
|
|
it 'returns correctly built object' do
|
|
expect(result).to eq(Pizza.new(true, false, true, :extra))
|
|
end
|
|
end
|
|
|
|
class InnerDSL
|
|
def initialize; @b = 'b'; end
|
|
attr_accessor :b
|
|
end
|
|
|
|
class OuterDSL
|
|
def initialize; @a = 'a'; end
|
|
attr_accessor :a
|
|
|
|
def inner(&block)
|
|
Docile.dsl_eval(InnerDSL.new, &block)
|
|
end
|
|
|
|
def inner_with_params(param, &block)
|
|
Docile.dsl_eval(InnerDSL.new, param, :foo, &block)
|
|
end
|
|
end
|
|
|
|
def outer(&block)
|
|
Docile.dsl_eval(OuterDSL.new, &block)
|
|
end
|
|
|
|
context 'when given parameters for the DSL block' do
|
|
def parameterized(*args, &block)
|
|
Docile.dsl_eval(OuterDSL.new, *args, &block)
|
|
end
|
|
|
|
it 'passes parameters to the block' do
|
|
parameterized(1,2,3) do |x,y,z|
|
|
expect(x).to eq(1)
|
|
expect(y).to eq(2)
|
|
expect(z).to eq(3)
|
|
end
|
|
end
|
|
|
|
it 'finds parameters before methods' do
|
|
parameterized(1) { |a| expect(a).to eq(1) }
|
|
end
|
|
|
|
it 'find outer dsl parameters in inner dsl scope' do
|
|
parameterized(1,2,3) do |a,b,c|
|
|
inner_with_params(c) do |d,e|
|
|
expect(a).to eq(1)
|
|
expect(b).to eq(2)
|
|
expect(c).to eq(3)
|
|
expect(d).to eq(c)
|
|
expect(e).to eq(:foo)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
class DSLWithNoMethod
|
|
def initialize(b); @b = b; end
|
|
attr_accessor :b
|
|
def push_element
|
|
@b.push 1
|
|
end
|
|
end
|
|
|
|
context 'when DSL have NoMethod error inside' do
|
|
it 'raise error from nil' do
|
|
Docile.dsl_eval(DSLWithNoMethod.new(nil)) do
|
|
expect { push_element }.to raise_error(NoMethodError, /undefined method `push' (for|on) nil:NilClass/)
|
|
end
|
|
end
|
|
end
|
|
|
|
context 'when DSL blocks are nested' do
|
|
|
|
context 'method lookup' do
|
|
it 'finds method of outer dsl in outer dsl scope' do
|
|
outer { expect(a).to eq('a') }
|
|
end
|
|
|
|
it 'finds method of inner dsl in inner dsl scope' do
|
|
outer { inner { expect(b).to eq('b') } }
|
|
end
|
|
|
|
it 'finds method of outer dsl in inner dsl scope' do
|
|
outer { inner { expect(a).to eq('a') } }
|
|
end
|
|
|
|
it "finds method of block's context in outer dsl scope" do
|
|
def c; 'c'; end
|
|
outer { expect(c).to eq('c') }
|
|
end
|
|
|
|
it "finds method of block's context in inner dsl scope" do
|
|
def c; 'c'; end
|
|
outer { inner { expect(c).to eq('c') } }
|
|
end
|
|
|
|
it 'finds method of outer dsl in preference to block context' do
|
|
def a; 'not a'; end
|
|
outer { expect(a).to eq('a') }
|
|
outer { inner { expect(a).to eq('a') } }
|
|
end
|
|
end
|
|
|
|
context 'local variable lookup' do
|
|
it 'finds local variable from block context in outer dsl scope' do
|
|
foo = 'foo'
|
|
outer { expect(foo).to eq('foo') }
|
|
end
|
|
|
|
it 'finds local variable from block definition in inner dsl scope' do
|
|
bar = 'bar'
|
|
outer { inner { expect(bar).to eq('bar') } }
|
|
end
|
|
end
|
|
|
|
context 'instance variable lookup' do
|
|
it 'finds instance variable from block definition in outer dsl scope' do
|
|
@iv1 = 'iv1'; outer { expect(@iv1).to eq('iv1') }
|
|
end
|
|
|
|
it "proxies instance variable assignments in block in outer dsl scope back into block's context" do
|
|
@iv1 = 'foo'; outer { @iv1 = 'bar' }; expect(@iv1).to eq('bar')
|
|
end
|
|
|
|
it 'finds instance variable from block definition in inner dsl scope' do
|
|
@iv2 = 'iv2'; outer { inner { expect(@iv2).to eq('iv2') } }
|
|
end
|
|
|
|
it "proxies instance variable assignments in block in inner dsl scope back into block's context" do
|
|
@iv2 = 'foo'; outer { inner { @iv2 = 'bar' } }; expect(@iv2).to eq('bar')
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
context 'when DSL context object is a Dispatch pattern' do
|
|
class DispatchScope
|
|
def params
|
|
{ :a => 1, :b => 2, :c => 3 }
|
|
end
|
|
end
|
|
|
|
class MessageDispatch
|
|
include Singleton
|
|
|
|
def initialize
|
|
@responders = {}
|
|
end
|
|
|
|
def add_responder path, &block
|
|
@responders[path] = block
|
|
end
|
|
|
|
def dispatch path, request
|
|
Docile.dsl_eval(DispatchScope.new, request, &@responders[path])
|
|
end
|
|
end
|
|
|
|
def respond(path, &block)
|
|
MessageDispatch.instance.add_responder(path, &block)
|
|
end
|
|
|
|
def send_request(path, request)
|
|
MessageDispatch.instance.dispatch(path, request)
|
|
end
|
|
|
|
it 'dispatches correctly' do
|
|
@first = @second = nil
|
|
|
|
respond '/path' do |request|
|
|
@first = request
|
|
end
|
|
|
|
respond '/new_bike' do |bike|
|
|
@second = "Got a new #{bike}"
|
|
end
|
|
|
|
def x(y) ; "Got a #{y}"; end
|
|
respond '/third' do |third|
|
|
expect(x(third)).to eq('Got a third thing')
|
|
end
|
|
|
|
fourth = nil
|
|
respond '/params' do |arg|
|
|
fourth = params[arg]
|
|
end
|
|
|
|
send_request '/path', 1
|
|
send_request '/new_bike', 'ten speed'
|
|
send_request '/third', 'third thing'
|
|
send_request '/params', :b
|
|
|
|
expect(@first).to eq(1)
|
|
expect(@second).to eq('Got a new ten speed')
|
|
expect(fourth).to eq(2)
|
|
end
|
|
|
|
end
|
|
|
|
end
|
|
|
|
describe '.dsl_eval_with_block_return' do
|
|
let(:array) { [] }
|
|
let!(:result) { execute_dsl_against_array }
|
|
|
|
def execute_dsl_against_array
|
|
Docile.dsl_eval_with_block_return(array) do
|
|
push 1
|
|
push 2
|
|
pop
|
|
push 3
|
|
'Return me!'
|
|
end
|
|
end
|
|
|
|
it 'executes the block against the DSL context object' do
|
|
expect(array).to eq([1, 3])
|
|
end
|
|
|
|
it "returns the block's return value" do
|
|
expect(result).to eq('Return me!')
|
|
end
|
|
end
|
|
|
|
describe '.dsl_eval_immutable' do
|
|
|
|
context 'when DSL context object is a frozen String' do
|
|
let(:original) { "I'm immutable!".freeze }
|
|
let!(:result) { execute_non_mutating_dsl_against_string }
|
|
|
|
def execute_non_mutating_dsl_against_string
|
|
Docile.dsl_eval_immutable(original) do
|
|
reverse
|
|
upcase
|
|
end
|
|
end
|
|
|
|
it "doesn't modify the original string" do
|
|
expect(original).to eq("I'm immutable!")
|
|
end
|
|
|
|
it 'chains the commands in the block against the DSL context object' do
|
|
expect(result).to eq("!ELBATUMMI M'I")
|
|
end
|
|
end
|
|
|
|
context 'when DSL context object is a number' do
|
|
let(:original) { 84.5 }
|
|
let!(:result) { execute_non_mutating_dsl_against_number }
|
|
|
|
def execute_non_mutating_dsl_against_number
|
|
Docile.dsl_eval_immutable(original) do
|
|
fdiv(2)
|
|
floor
|
|
end
|
|
end
|
|
|
|
it 'chains the commands in the block against the DSL context object' do
|
|
expect(result).to eq(42)
|
|
end
|
|
end
|
|
end
|
|
|
|
end
|
|
|
|
describe Docile::FallbackContextProxy do
|
|
|
|
describe '#instance_variables' do
|
|
subject { create_fcp_and_set_one_instance_variable.instance_variables }
|
|
let(:expected_type_of_names) { type_of_ivar_names_on_this_ruby }
|
|
let(:actual_type_of_names) { subject.first.class }
|
|
let(:excluded) { Docile::FallbackContextProxy::NON_PROXIED_INSTANCE_VARIABLES }
|
|
|
|
def create_fcp_and_set_one_instance_variable
|
|
fcp = Docile::FallbackContextProxy.new(nil, nil)
|
|
fcp.instance_variable_set(:@foo, 'foo')
|
|
fcp
|
|
end
|
|
|
|
def type_of_ivar_names_on_this_ruby
|
|
@a = 1
|
|
instance_variables.first.class
|
|
end
|
|
|
|
it 'returns proxied instance variables' do
|
|
expect(subject.map(&:to_sym)).to include(:@foo)
|
|
end
|
|
|
|
it "doesn't return non-proxied instance variables" do
|
|
expect(subject.map(&:to_sym)).not_to include(*excluded)
|
|
end
|
|
|
|
it 'preserves the type (String or Symbol) of names on this ruby version' do
|
|
expect(actual_type_of_names).to eq(expected_type_of_names)
|
|
end
|
|
end
|
|
|
|
end
|