dsel 0.1.0

data/spec/dsel/api/node_spec.rb

@@ -0,0 +1,328 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::API::Node do
+    it_should_behave_like DSeL::Node
+
+    subject { Factory[:clean_api_spec] }
+    let(:other) { Factory[:clean_api_spec] }
+    let(:another) { Factory[:clean_api_spec] }
+    let(:api) { subject.new( Object.new ) }
+
+    describe '.define' do
+        it "delegates to #{DSeL::API::Generator}#define_definers" do
+            types = [:stuff, :stuff2]
+            expect(DSeL::API::Generator).to receive(:define_definers).with( subject, *types )
+
+            subject.define *types
+        end
+
+        context 'when a description has been set' do
+            context 'and more than 1 type is given' do
+                it 'raises ArgumentError' do
+                    subject.describe 'Stuff'
+
+                    expect do
+                        subject.define :stuff, :stuff2
+                    end.to raise_error ArgumentError
+                end
+            end
+        end
+
+        context 'when options have been set' do
+            context 'and more than 1 type is given' do
+                it 'raises ArgumentError' do
+                    subject.configure []
+
+                    expect do
+                        subject.define :stuff, :stuff2
+                    end.to raise_error ArgumentError
+                end
+            end
+        end
+    end
+
+    describe '.describe' do
+        let(:description) { 'Blah' }
+
+        it 'sets a description for the following definer' do
+            subject.describe description
+            subject.define :on
+
+            expect(subject.definers).to eq [{ type: :on, description: description, method: :def_on}]
+        end
+
+        it 'sets a description for the following call handler' do
+            subject.define :on
+
+            subject.describe description
+            subject.def_on( :stuff ) {}
+
+            ch = subject.call_handlers.first
+            ch.delete :method
+            expect(ch).to eq( type: :on, description: description, object: :stuff)
+        end
+
+        it 'sets a description for the following child' do
+            subject.describe description
+            subject.push_child :blah, other
+
+            expect(subject.children).to eq(
+                blah: {
+                    name: :blah,
+                    node: other,
+                    description: description
+                }
+            )
+        end
+    end
+
+    describe '.configure' do
+        let(:options) { { blah: :stuff } }
+
+        it 'sets a description for the following definer' do
+            subject.configure options
+            subject.define :on
+
+            expect(subject.definers).to eq [{ type: :on, options: [options], method: :def_on}]
+        end
+
+        it 'sets a description for the following call handler' do
+            subject.define :on
+
+            subject.configure options
+            subject.def_on( :stuff ) {}
+
+            ch = subject.call_handlers.first
+            ch.delete :method
+            expect(ch).to eq( type: :on, options: [options], object: :stuff)
+        end
+
+        it 'sets a description for the following child' do
+            subject.configure options
+            subject.push_child :blah, other
+
+            expect(subject.children).to eq(
+                blah: {
+                    name: :blah,
+                    node: other,
+                    options: [options]
+                }
+            )
+        end
+    end
+
+    describe '.has_options?' do
+        context 'when options are available in the buffer' do
+            it 'returns true' do
+                subject.configure []
+                expect(subject).to have_options
+            end
+        end
+
+        context 'when options are not available in the buffer' do
+            it 'returns false' do
+                expect(subject).to_not have_options
+            end
+        end
+    end
+
+    describe '.has_description?' do
+        context 'when a description is available in the buffer' do
+            it 'returns true' do
+                subject.describe ''
+                expect(subject).to have_description
+            end
+        end
+
+        context 'when no description is available in the buffer' do
+            it 'returns false' do
+                expect(subject).to_not have_description
+            end
+        end
+    end
+
+    describe '.root' do
+        it 'returns the root node' do
+            subject.push_child :blah, other
+            other.push_child :another, another
+
+            expect(another.root).to be subject
+        end
+
+        context 'when .root?' do
+            it 'returns self' do
+                expect(subject.root).to be subject
+            end
+        end
+    end
+
+    describe '.parent' do
+        it 'returns the parent node' do
+            subject.push_child :blah, other
+            expect(other.parent).to be subject
+
+            other.push_child :another, another
+            expect(another.parent).to be other
+        end
+
+        context 'when .root?' do
+            it 'returns nil' do
+                expect(subject.parent).to be_nil
+            end
+        end
+    end
+
+    describe '.has_call_handler?' do
+        context 'when there is a call handler' do
+            it 'returns true' do
+                subject.define :on
+
+                subject.def_on {}
+                expect( subject ).to have_call_handler :on
+
+                subject.def_on( :stuff ) {}
+                expect( subject ).to have_call_handler :on, :stuff
+            end
+        end
+
+        context 'when there is no such call handler' do
+            it 'returns false'  do
+                expect( subject ).to_not have_call_handler :blah
+
+                subject.define :on
+
+                expect( subject ).to_not have_call_handler :on
+                expect( subject ).to_not have_call_handler :on, :stuff
+            end
+        end
+    end
+
+    describe '.root?' do
+        context 'when there is no parent' do
+            it 'returns true' do
+                expect(subject).to be_root
+            end
+        end
+
+        context 'when there is a parent' do
+            it 'returns false' do
+                subject.push_child :blah, other
+                expect(other).to_not be_root
+            end
+        end
+    end
+
+    describe '.child?' do
+        context 'when there is no parent' do
+            it 'returns false' do
+                expect(subject).to_not be_child
+            end
+        end
+
+        context 'when there is a parent' do
+            it 'returns true' do
+                subject.push_child :blah, other
+                expect(other).to be_child
+            end
+        end
+    end
+
+    describe '.push_child' do
+        before do
+            subject.push_child :blah, other, s
+        end
+        let(:s) { nil }
+
+        it 'sets the given node as a child' do
+            expect(subject.children).to eq(
+                blah: {
+                    name: :blah,
+                    node: other
+                }
+            )
+        end
+
+        it 'creates an instance method for access' do
+            expect(api.blah).to be_kind_of other
+            expect(api.blah).to be api.blah
+        end
+
+        context 'when given a subject' do
+            context 'Symbol' do
+                let(:s) { :hash }
+
+                it 'sends it to the parent subject and uses the result as a subject' do
+                    expect(api.blah.subject).to be api.subject.hash
+                end
+            end
+
+            context '#call' do
+                let(:s) { proc { |o| o.hash } }
+
+                it 'uses the result as a subject' do
+                    expect(api.blah.subject).to be api.subject.hash
+                end
+            end
+
+            context 'other' do
+                it 'raises ArgumentError' do
+                    expect do
+                        subject.push_child :another, another, ''
+                    end.to raise_error ArgumentError
+                end
+            end
+        end
+    end
+
+    describe '.push_children' do
+        it 'delegates to .push_child' do
+            expect(subject).to receive(:push_child).with(:blah, other)
+            expect(subject).to receive(:push_child).with(:another, another)
+
+            subject.push_children(
+                blah:    other,
+                another: another
+            )
+        end
+    end
+
+    describe '.tree' do
+        it 'returns the API tree' do
+            subject.push_child :blah, other
+            other.push_child :another, another
+
+            tree = {
+                definers:      [],
+                call_handlers: [],
+                children:      {
+                    :blah => {
+                        :name          => :blah,
+                        :node          => other,
+                        :definers      => [],
+                        :call_handlers => [],
+                        :children      => {
+                            another: {
+                                :name          => :another,
+                                :node          => another,
+                                :definers      => [],
+                                :call_handlers => [],
+                                :children      => {}
+                            }
+                        }
+                    }
+                }
+            }
+
+            expect(another.tree). to eq tree
+        end
+    end
+
+    describe '.branch' do
+        it "returns the node's branch" do
+            subject.push_child :blah, other
+            other.push_child :another, another
+
+            expect(subject.branch). to eq other.tree
+        end
+    end
+end

data/spec/dsel/dsel_spec.rb

@@ -0,0 +1,63 @@
+require 'spec_helper'
+
+RSpec.describe DSeL do
+
+    it 'has a version number' do
+        expect(DSeL::VERSION).not_to be nil
+    end
+
+    describe 'examples/' do
+        let(:examples_dir) { examples_path }
+
+        describe 'api/' do
+            let(:api_dir) { "#{examples_dir}/api/" }
+
+            describe 'my_api' do
+                before do
+                    require "#{api_dir}/my_api"
+                end
+
+                describe 'my_api_dsl' do
+                    it 'works' do
+                        expect do
+                            MyAPI.run "#{api_dir}/my_api_dsl.rb"
+                        end.to_not raise_error
+                    end
+                end
+
+                describe 'my_api_ruby' do
+                    it 'works' do
+                        expect do
+                            require "#{api_dir}/my_api_ruby"
+                        end.to_not raise_error
+                    end
+                end
+            end
+        end
+
+        describe 'dsl/' do
+            let(:dsl_dir) { "#{examples_dir}/dsl/" }
+
+            before do
+                require "#{dsl_dir}/object"
+            end
+
+            describe 'proxy' do
+                it 'works' do
+                    expect do
+                        require "#{dsl_dir}/proxy"
+                    end.to_not raise_error
+                end
+            end
+
+            describe 'direct' do
+                it 'works' do
+                    expect do
+                        require "#{dsl_dir}/direct"
+                    end.to_not raise_error
+                end
+            end
+        end
+    end
+
+end

data/spec/dsel/dsl/nodes/api/environment.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::API::Environment do
+    include_examples DSeL::DSL::Nodes::Base::Environment
+
+    let(:api_spec) { Factory[:clean_api_spec] }
+    let(:other_api_spec) { Factory[:clean_api_spec] }
+    let(:node_context) { api_spec.new }
+
+    let(:other_node_context) { api_spec.new }
+    let(:another_node_context) { api_spec.new }
+
+    context 'when the API node has children' do
+        before do
+            api_spec.push_child :other_api_spec, other_api_spec
+        end
+
+        it 'creates DSL helpers for them' do
+            child = node.run { Other_api_spec { real_self } }
+            expect(child).to be node_context.other_api_spec
+        end
+    end
+
+    describe '#also' do
+        let(:calls) { [] }
+
+        context 'when repeating a catch-all' do
+            before do
+                api_spec.define :on
+
+                c = calls
+                api_spec.def_on do |*args|
+                    c << [:on, args]
+                end
+            end
+
+            context 'that had no arguments' do
+                it 'does not send any arguments' do
+                    node.run do
+                        on
+                        also
+                    end
+
+                    expect(calls).to eq [[:on, []], [:on, []]]
+                end
+
+                context 'with new arguments' do
+                    it 'sends the new arguments' do
+                        node.run do
+                            on
+                            also :stuff
+                        end
+
+                        expect(calls).to eq [[:on, []], [:on, [:stuff]]]
+                    end
+                end
+            end
+
+            context 'that had arguments' do
+                it 'does not send any arguments' do
+                    node.run do
+                        on :stuff
+                        also
+                    end
+
+                    expect(calls).to eq [[:on, [:stuff]], [:on, []]]
+                end
+
+                context 'with new arguments' do
+                    it 'sends the new arguments' do
+                        node.run do
+                            on :stuff
+                            also :stuff2
+                        end
+
+                        expect(calls).to eq [[:on, [:stuff]], [:on, [:stuff2]]]
+                    end
+                end
+            end
+        end
+
+        context 'when repeating an object call' do
+            before do
+                api_spec.define :on
+
+                c = calls
+
+                api_spec.def_on :stuff do |*args|
+                    c << [:stuff, args]
+                end
+
+                api_spec.def_on :other_stuff do |*args|
+                    c << [:other_stuff, args]
+                end
+            end
+
+            context 'with a specified object' do
+                it 'changes the call handler' do
+                    node.run do
+                        on :stuff
+                        also :other_stuff
+                    end
+
+                    expect(calls).to eq [[:stuff, []], [:other_stuff, []]]
+                end
+
+                context 'that had no arguments' do
+                    it 'does not send any arguments' do
+                        node.run do
+                            on :stuff
+                            also :other_stuff
+                        end
+
+                        expect(calls).to eq [[:stuff, []], [:other_stuff, []]]
+                    end
+
+                    context 'with new arguments' do
+                        it 'sends the new arguments' do
+                            node.run do
+                                on :stuff
+                                also :other_stuff, :arg
+                            end
+
+                            expect(calls).to eq [[:stuff, []], [:other_stuff, [:arg]]]
+                        end
+                    end
+                end
+
+                context 'that had arguments' do
+                    it 'does not send any arguments' do
+                        node.run do
+                            on :stuff, :arg
+                            also :other_stuff
+                        end
+
+                        expect(calls).to eq [[:stuff, [:arg]], [:other_stuff, []]]
+                    end
+
+                    context 'with new arguments' do
+                        it 'sends the new arguments' do
+                            node.run do
+                                on :stuff
+                                also :other_stuff, :arg
+                            end
+
+                            expect(calls).to eq [[:stuff, []], [:other_stuff, [:arg]]]
+                        end
+                    end
+                end
+            end
+
+            context 'without an object' do
+                it 'uses the previous call handler' do
+                    node.run do
+                        on :stuff
+                        also :stuff2
+                    end
+
+                    expect(calls).to eq [[:stuff, []], [:stuff, [:stuff2]]]
+                end
+
+                context 'that had no arguments' do
+                    it 'does not send any arguments' do
+                        node.run do
+                            on :stuff
+                            also
+                        end
+
+                        expect(calls).to eq [[:stuff, []], [:stuff, []]]
+                    end
+
+                    context 'with new arguments' do
+                        it 'sends the new arguments' do
+                            node.run do
+                                on :stuff
+                                also :arg
+                            end
+
+                            expect(calls).to eq [[:stuff, []], [:stuff, [:arg]]]
+                        end
+                    end
+                end
+
+                context 'that had arguments' do
+                    it 'does not send any arguments' do
+                        node.run do
+                            on :stuff, :arg
+                            also
+                        end
+
+                        expect(calls).to eq [[:stuff, [:arg]], [:stuff, []]]
+                    end
+
+                    context 'with new arguments' do
+                        it 'sends the new arguments' do
+                            node.run do
+                                on :stuff
+                                also :arg
+                            end
+
+                            expect(calls).to eq [[:stuff, []], [:stuff, [:arg]]]
+                        end
+                    end
+                end
+            end
+        end
+    end
+end

data/spec/dsel/dsl/nodes/api_builder/environment_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::APIBuilder::Environment do
+    include_examples DSeL::DSL::Nodes::Base::Environment
+
+    let(:node_context) { Factory[:clean_api_spec] }
+    let(:other_node_context) { Factory[:clean_api_spec] }
+    let(:another_node_context) { Factory[:clean_api_spec] }
+
+    subject do
+        def node.cleanup_environment
+        end
+
+        node.run{}
+        node.environment
+    end
+
+    let(:script) do
+        <<RUBY
+        define :on
+RUBY
+    end
+    let(:filename) do
+        'script.rb'
+    end
+    let(:file) do
+        File.open "#{Dir.tmpdir}/#{filename}", 'w' do |f|
+            f.write script
+            f.flush
+            f.path
+        end
+    end
+
+    describe '#import' do
+        it 'imports a file' do
+            expect(subject.definers).to be_empty
+            subject.import file
+            expect(subject.definers).to eq [{ type: :on, method: :def_on}]
+        end
+
+        context 'without extension' do
+            let(:filename) do
+                'script'
+            end
+
+            it 'assumes .rb' do
+                expect(subject.definers).to be_empty
+                subject.import file
+                expect(subject.definers).to eq [{ type: :on, method: :def_on}]
+            end
+        end
+    end
+
+    describe '#import_many' do
+        it 'imports globs' do
+            expect(subject.definers).to be_empty
+            subject.import_many "#{Dir.tmpdir}/scr*pt"
+            expect(subject.definers).to eq [{ type: :on, method: :def_on}]
+        end
+    end
+
+    describe '#import_relative' do
+        it 'imports a file'
+
+        context 'without extension' do
+            let(:filename) do
+                'script'
+            end
+
+            it 'assumes .rb'
+        end
+    end
+
+    describe '#import_relative_many' do
+        it 'imports relative globs'
+    end
+
+    describe '#child' do
+        it 'adds a child node' do
+            subject.child :child, :Child do
+            end
+
+            expect(subject.children).to eq(
+                child: {
+                    name: :child,
+                    node: subject.const_get( :Child )
+                }
+            )
+        end
+    end
+end