dsel 0.1.0

data/spec/dsel/dsl/nodes/api_builder_spec.rb

@@ -0,0 +1,148 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::APIBuilder do
+    include_examples DSeL::DSL::Nodes::Base
+
+    let(:name) { "MyAPI#{rand(999)}".to_sym }
+    let(:klass) { Object.const_get( name ) }
+
+    let(:child_name) { "MyAPIChild#{rand(999)}".to_sym }
+
+    let(:clean_api_spec) { Factory[:clean_api_spec] }
+    let(:context) { Factory[:clean_api_spec] }
+    let(:other_context) { Factory[:clean_api_spec] }
+
+    it 'uses the context as the environment' do
+        subject.run{}
+        expect(subject.environment).to be subject.subject
+    end
+
+    describe '.build' do
+        it 'runs the given block' do
+            described_class.build( name ){}
+            expect(klass).to be < DSeL::API::Node
+        end
+
+        it 'returns the API node' do
+            api = described_class.build( name ){}
+            expect(klass).to be api
+        end
+
+        context 'when no block has been given' do
+            it 'raises ArgumentError' do
+                expect do
+                    described_class.build( name )
+                end.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#initialize' do
+        describe 'node' do
+            context 'when given a' do
+                context 'Symbol' do
+                    let(:context){ name }
+
+                    it 'creates an API node by the same name' do
+                        subject
+                        expect(klass).to be < DSeL::API::Node
+                    end
+
+                    it 'uses it as a context' do
+                        subject
+                        expect(subject.subject).to be klass
+                    end
+
+                    context 'when the name has already been taken' do
+                        it 'raises ArgumentError' do
+                            subject
+
+                            expect do
+                                described_class.new( name )
+                            end.to raise_error ArgumentError
+                        end
+                    end
+                end
+
+                context 'DSeL::API::Node' do
+                    let(:context){ clean_api_spec }
+
+                    it 'uses it as a context' do
+                        expect(subject.subject).to be clean_api_spec
+                    end
+                end
+
+                context 'other' do
+                    let(:context){ '' }
+
+                    it 'raises ArgumentError' do
+                        expect do
+                            subject
+                        end.to raise_error ArgumentError
+                    end
+                end
+            end
+        end
+
+        describe 'options' do
+            describe 'when creating a new API node' do
+                let(:context) do
+                    name
+                end
+
+                describe ':namespace' do
+                    let(:namespace) { module MyNamespace;end; MyNamespace }
+                    let(:options) do
+                        { namespace: namespace }
+                    end
+
+                    it 'is placed under that namespace' do
+                        subject.subject
+                        expect(namespace.constants).to include name
+                    end
+                end
+
+                describe ':superclass' do
+                    let(:superclass) { other_context }
+                    let(:options) do
+                        { superclass: superclass }
+                    end
+
+                    it 'sets the API node superclass' do
+                        expect(subject.subject).to be < superclass
+                    end
+
+                    context "when not an #{DSeL::API::Node} subclass" do
+                        let(:superclass) { Object }
+
+                        it 'raises ArgumentError' do
+                            expect do
+                                subject
+                            end.to raise_error ArgumentError
+                        end
+                    end
+                end
+            end
+        end
+    end
+
+    describe '#node_for' do
+        let(:child_node) { subject.node_for( child_name ) }
+
+        it 'uses the current context as the namespace' do
+            expect(child_node.subject).to be subject.subject.const_get( child_name )
+        end
+
+        context 'when a superclass has been set' do
+            let(:superclass) { other_context }
+            let(:options) do
+                { superclass: superclass }
+            end
+
+            it 'uses it as the superclass' do
+                expect(child_node.subject).to be < superclass
+            end
+        end
+    end
+
+end

data/spec/dsel/dsl/nodes/api_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::API do
+    include_examples DSeL::DSL::Nodes::Base
+
+    let(:api_spec) { Factory[:clean_api_spec] }
+    let(:other_api_spec) { Factory[:clean_api_spec] }
+    let(:context) { api_spec.new }
+
+    it "uses #{described_class::Environment}" do
+        subject.run{}
+        expect(subject.environment).to be_kind_of described_class::Environment
+    end
+
+end

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

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::Direct::Environment do
+    include_examples DSeL::DSL::Nodes::Base::Environment
+
+    subject do
+        def node.cleanup_environment
+        end
+
+        node.run{}
+        node.environment
+    end
+
+end

data/spec/dsel/dsl/nodes/direct_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::Direct do
+    include_examples DSeL::DSL::Nodes::Base
+
+    it 'uses the context as the environment' do
+        subject.run{}
+        expect(subject.environment).to be subject.subject
+    end
+
+    describe '#run' do
+        let(:environment) do
+            subject.run{}
+            subject.environment
+        end
+
+        it 'removes environment methods from the object' do
+            called = true
+
+            subject.extend_env.each do |mod|
+                mod.instance_methods( true ).each do |m|
+                    next if subject.reset_methods.include? m
+
+                    expect(environment).to_not respond_to m
+                end
+            end
+
+            expect(called).to be_truthy
+        end
+
+        it 'resets overridden object methods' do
+            called = true
+
+            subject.reset_methods.each do |m|
+                next if !environment.respond_to? m
+
+                expect(environment.method(m).source_location).to be_nil
+            end
+
+            expect(called).to be_truthy
+        end
+    end
+end

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

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::Proxy::Environment do
+    include_examples DSeL::DSL::Nodes::Base::Environment
+    # include_examples DSeL::DSL::Mixins::Environment::IvarExplorer
+
+    subject { described_class.new }
+    let(:node_context) do
+        Class.new do
+            def test
+                __method__
+            end
+
+            def hash
+                1
+            end
+        end.new
+    end
+
+    it 'forwards methods to the context' do
+        expect(subject.test).to be :test
+    end
+
+    describe "##{described_class::DSEL_NODE_ACCESSOR}=" do
+        context 'when a node is given' do
+            it 'undefines methods with the same name as the context' do
+                expect(subject.hash).to eq node.subject.hash
+            end
+        end
+
+        context 'when nil is given' do
+            it 'does nothing' do
+                subject._dsel_node = nil
+                expect(subject._dsel_node).to be_nil
+            end
+        end
+    end
+
+    describe '#respond_to?' do
+        it 'returns false' do
+            expect(subject).to_not respond_to :stuff
+        end
+
+        context 'when self responds' do
+            it 'returns true' do
+                expect(subject).to respond_to :_dsel_variables
+            end
+        end
+
+        context 'when the context responds' do
+            it 'returns true' do
+                expect(subject).to respond_to :test
+            end
+        end
+    end
+end

data/spec/dsel/dsl/nodes/proxy_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::DSL::Nodes::Proxy do
+    include_examples DSeL::DSL::Nodes::Base
+
+    it "uses #{described_class::Environment}" do
+        subject.run{}
+        expect(subject.environment).to be_kind_of described_class::Environment
+    end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'bundler/setup'
+require 'dsel'
+
+require_relative 'support/helpers/paths'
+
+Dir.glob( "#{support_path}/{lib,fixtures,factories,shared}/**/*.rb" ).each { |f| require f }
+
+RSpec.configure do |config|
+    # Enable flags like --only-failures and --next-failure
+    config.example_status_persistence_file_path = '.rspec_status'
+
+    # Disable RSpec exposing methods globally on `Module` and `main`
+    config.disable_monkey_patching!
+
+    config.expect_with :rspec do |c|
+        c.syntax = :expect
+    end
+
+    config.before :each do
+        DSeL::API::Generator.reset
+    end
+end

data/spec/support/factories/clean_api_spec.rb

@@ -0,0 +1,6 @@
+Factory.define :clean_api_spec do
+    Object.const_set(
+        "MockNode#{rand(9999)}".to_sym,
+        Class.new( DSeL::API::Node )
+    )
+end

data/spec/support/fixtures/mock_api.rb

@@ -0,0 +1,4 @@
+class MockAPI < DSeL::API::Node
+    define :on
+    def_on { |*args| }
+end

data/spec/support/helpers/paths.rb

@@ -0,0 +1,19 @@
+def name_from_filename
+    File.basename( caller.first.split( ':' ).first, '_spec.rb' )
+end
+
+def spec_path
+    File.expand_path( File.dirname( File.absolute_path( __FILE__ )  ) + '/../../' ) << '/'
+end
+
+def examples_path
+    File.expand_path( "#{spec_path}/../examples" ) << '/'
+end
+
+def support_path
+    "#{spec_path}support/"
+end
+
+def fixtures_path
+    "#{support_path}fixtures/"
+end

data/spec/support/lib/factory.rb

@@ -0,0 +1,107 @@
+class Factory
+class <<self
+
+    # Clears all instructions and aliases.
+    def reset
+        @instructions = {}
+        @aliases      = {}
+    end
+
+    # Defines instruction on how to create a given object.
+    #
+    # There are 2 ways to define a factory instruction:
+    #
+    #   * Using a `generator` block to return an object.
+    #   * Using the `options` to generate an object.
+    #
+    # @param    [Symbol]    object_name     Name of the object.
+    # @param    [Hash]    options   Generation options.
+    # @option   options [Class] :class
+    #   Class to instantiate.
+    # @option   options [Hash] :options
+    #   Options to use to instantiate the `:class`.
+    def define( object_name, options = {}, &generator )
+        @instructions[object_name] = {
+            options:   options.dup,
+            generator: generator
+        }
+    end
+
+    # @param    [Symbol]    object_name     Name of the object.
+    # @param    []  args
+    #   If a `generator` block has been provided via {#define}, those arguments
+    #   will be passed to it.
+    #
+    #   If `:options` have been passed to {#define}, the `args` will be merged
+    #   with them before instantiating the object.
+    def create( object_name, *args )
+        ensure_defined( object_name )
+
+        instructions = instructions_for( object_name )
+
+        if instructions[:generator]
+            instructions[:generator].call( *args )
+        elsif (options = instructions[:options]).include? :class
+            options[:class].new( options[:options].merge( args.first || {} ) )
+        end
+    end
+
+    # @param    [Symbol]    object_name     Name of the object.
+    # @return   [Hash]  Instantiation options passed to {#define}.
+    def options_for( object_name )
+        instructions_for( object_name )[:options][:options].freeze
+    end
+
+    # @note {#create} helper.
+    #
+    # @param    [Symbol]    object_name     Name of the object.
+    # @return   [Object]    Instantiated object.
+    def []( object_name )
+        create object_name
+    end
+
+    # @param    [Symbol]    object_name
+    #   Name of the new object.
+    # @param    [Symbol]    existing_object_name
+    #   Name of the existing object.
+    def alias( object_name, existing_object_name )
+        ensure_defined( existing_object_name )
+        @aliases[object_name] = existing_object_name
+    end
+
+    # @param    [Symbol]    object_name Object to delete.
+    def delete( object_name )
+        @instructions.delete object_name
+    end
+
+    # @param    [Symbol]    object_name Alias to delete.
+    def unalias( object_name )
+        @aliases.delete object_name
+        nil
+    end
+
+    # @param    [Symbol]    object_name
+    #   Name of the new object.
+    # @return   [Bool]
+    #   `true` if instructions have been {#defined} for the `object_name`,
+    #   `false` otherwise.
+    def defined?( object_name )
+        !!instructions_for( object_name ) rescue false
+    end
+
+    private
+
+    def instructions_for( object_name )
+        instructions = @instructions[object_name] || @instructions[@aliases[object_name]]
+        return instructions if instructions
+
+        fail ArgumentError, "Factory '#{object_name}' not defined."
+    end
+
+    def ensure_defined( object_name )
+        !!instructions_for( object_name )
+    end
+end
+reset
+
+end

data/spec/support/shared/dsl/nodes/base/environment.rb

@@ -0,0 +1,104 @@
+require 'tempfile'
+
+shared_examples_for DSeL::DSL::Nodes::Base::Environment do
+    if !defined? :subject
+        subject do
+            Class.new( described_class ).new
+        end
+    end
+
+    let(:node_class) do
+        sep = '::'
+        splits = described_class.to_s.split( sep )
+        splits.pop
+
+        Object.const_get( splits.join( sep ) )
+    end
+    let(:node) { node_class.new( node_context, node_options ) }
+    let(:node_options) { {} }
+    let(:node_context) { '2' }
+
+    let(:other_node) { node_class.new( other_node_context, other_node_options ) }
+    let(:other_node_options) { {} }
+    let(:other_node_context) { '1' }
+
+    let(:another_node) { node_class.new( another_node_context, another_node_options ) }
+    let(:another_node_options) { {} }
+    let(:another_node_context) { '3' }
+
+    before do
+        subject.send( "#{described_class::DSEL_NODE_ACCESSOR}=", node )
+    end
+
+    describe '#instance_variables' do
+        it "excludes #{described_class::DSEL_NODE_IVAR}" do
+            expect(subject.instance_variables).to_not include described_class::DSEL_NODE_IVAR
+        end
+    end
+
+    describe '#_dsel_shared_variables' do
+        it 'delegates to node' do
+            expect(subject._dsel_shared_variables).to be node.shared_variables
+        end
+    end
+
+    describe '#_dsel_self' do
+        it 'returns the context' do
+            expect(subject._dsel_self).to be node.subject
+        end
+    end
+
+    describe '#_dsel_variables' do
+        it 'returns instance variables' do
+            subject.instance_variable_set( :@tmp, 1 )
+            expect(subject._dsel_variables).to eq( tmp: 1 )
+        end
+    end
+
+    describe '#Parent' do
+        context 'when #root?' do
+            it 'raises error' do
+                expect do
+                    subject.Parent{}
+                end.to raise_error RuntimeError
+            end
+        end
+
+        context 'when not #root?' do
+            let(:node_options) { { parent: other_node } }
+
+            it 'runs the block in the parent' do
+                node = nil
+                p = proc { node = send( DSeL::DSL::Nodes::Base::Environment::DSEL_NODE_ACCESSOR ) }
+
+                subject.Parent( &p )
+
+                expect(node).to be other_node
+            end
+        end
+    end
+
+    describe '#Root' do
+        context 'when #root?' do
+            it 'raises error' do
+                expect do
+                    subject.Root{}
+                end.to raise_error RuntimeError
+            end
+        end
+
+        context 'when not #root?' do
+            let(:node_options) { { parent: other_node } }
+            let(:other_node_options) { { parent: another_node } }
+
+            it 'runs the block in the root' do
+                n = nil
+                p = proc { n = send( DSeL::DSL::Nodes::Base::Environment::DSEL_NODE_ACCESSOR ) }
+
+                subject.Root( &p )
+
+                expect(n).to be another_node
+            end
+        end
+    end
+end