dsel 0.1.0

data/lib/dsel/dsl/nodes/direct.rb

@@ -0,0 +1,75 @@
+require_relative 'base'
+require_relative '../mixins/environment/ivar_explorer'
+
+module DSeL
+module DSL
+module Nodes
+
+class Direct < Base
+    require_relative 'direct/environment'
+
+    def extend_env
+        [
+            Environment,
+            Mixins::Environment::IvarExplorer
+        ]
+    end
+
+    def reset_methods
+        [
+            :instance_variables,
+            :method_missing
+        ]
+    end
+
+    private
+
+    def prepare_environment
+        capture_subject
+        decorate_subject
+
+        @environment = @subject
+    end
+
+    def cleanup_environment
+        restore_subject
+    end
+
+    def capture_subject
+        @original_methods = reset_methods.map do |m|
+            @subject.instance_eval do
+                method( m ) if respond_to? m
+            end
+        end.compact
+    end
+
+    def decorate_subject
+        # We could use @subject.extend but that only works the first time.
+        extend_env.each do |mod|
+            mod.instance_methods( true ).each do |m|
+                @subject.instance_eval do
+                    define_singleton_method m, mod.instance_method( m )
+                end
+            end
+        end
+    end
+
+    def restore_subject
+        cmethods = @subject.methods
+        extend_env.each do |mod|
+            mod.instance_methods( true ).each do |m|
+                next if !cmethods.include?( m )
+                @subject.instance_eval( "undef :'#{m}'" )
+            end
+        end
+
+        @original_methods.each do |m|
+            @subject.define_singleton_method m.name, &m
+        end
+    end
+
+end
+
+end
+end
+end

data/lib/dsel/dsl/nodes/proxy/environment.rb

@@ -0,0 +1,41 @@
+require_relative '../../mixins/environment/ivar_explorer'
+
+module DSeL
+module DSL
+module Nodes
+class Proxy
+
+class Environment
+    include Base::Environment
+    include Mixins::Environment::IvarExplorer
+
+    define_method "#{DSEL_NODE_ACCESSOR}=" do |node|
+        super( node )
+
+        if node
+            _dsel_node.subject.public_methods( false ).each do |m|
+                instance_eval( "undef :'#{m}'" ) rescue nil
+            end
+        end
+
+        node
+    end
+
+    def method_missing( name, *args, &block )
+        if _dsel_node && _dsel_self.respond_to?( name )
+            return _dsel_self.send( name, *args, &block )
+        end
+
+        super( name, *args, &block )
+    end
+
+    def respond_to?( *args )
+        super( *args ) || (_dsel_node && _dsel_self.respond_to?( *args ))
+    end
+
+end
+
+end
+end
+end
+end

data/lib/dsel/dsl/nodes/proxy.rb

@@ -0,0 +1,20 @@
+require_relative 'base'
+
+module DSeL
+module DSL
+module Nodes
+
+class Proxy < Base
+    require_relative 'proxy/environment'
+
+    private
+
+    def prepare_environment
+        @environment ||= Environment.new
+    end
+
+end
+
+end
+end
+end

data/lib/dsel/dsl.rb

@@ -0,0 +1,10 @@
+module DSeL
+module DSL
+
+    require_relative 'dsl/nodes/direct'
+    require_relative 'dsl/nodes/proxy'
+    require_relative 'dsl/nodes/api'
+    require_relative 'dsl/nodes/api_builder'
+
+end
+end

data/lib/dsel/node.rb

@@ -0,0 +1,42 @@
+module DSeL
+class Node
+
+    # @return   [Object]
+    attr_reader :subject
+
+    # @return   [Base, nil]
+    attr_reader :parent
+
+    # @return   [Base]
+    #   `self` if {#root?}.
+    attr_reader :root
+
+    # @param   [Object] subject
+    # @param   [Hash] options
+    # @option   options [Base, nil] :parent (nil)
+    def initialize( subject = nil, options = {} )
+        @subject = subject
+        @parent  = options[:parent]
+        @root    = (@parent ? @parent._dsel_node.root : self)
+    end
+
+    def root?
+        @root == self
+    end
+
+    # @private
+    def _dsel_node
+        self
+    end
+
+    def calc_node_hash( subject )
+        "#{self.class}:#{subject.object_id}".hash
+    end
+
+    def hash
+        calc_node_hash( @subject )
+    end
+
+end
+
+end

data/lib/dsel/ruby/object.rb

@@ -0,0 +1,53 @@
+class Object
+
+    def as_dsel( parent = nil, &block )
+        _dsel_determine_node( DSeL::DSL::Nodes::Proxy, parent ).run( &block )
+    end
+
+    def dsel_script( script, parent = nil )
+        _dsel_determine_node( DSeL::DSL::Nodes::Proxy, parent ).run( script )
+    end
+
+    def as_direct_dsel( parent = nil, &block )
+        _dsel_determine_node( DSeL::DSL::Nodes::Direct, parent ).run( &block )
+    end
+
+    def direct_dsel_script( script, parent = nil )
+        _dsel_determine_node( DSeL::DSL::Nodes::Direct, parent ).run( script )
+    end
+
+    def DSeL( object = self, &block )
+        object.as_dsel( _dsel_self_if_node, &block )
+    end
+
+    def DSeLScript( script, object = self )
+        object.dsel_script( script, _dsel_self_if_node )
+    end
+
+    def DirectDSeL( object = self, &block )
+        object.as_direct_dsel( _dsel_self_if_node, &block )
+    end
+
+    def DirectDSeLScript( script, object = self )
+        object.direct_dsel_script( script, _dsel_self_if_node )
+    end
+
+    private
+
+    def _dsel_self_if_node
+        respond_to?( DSeL::DSL::Nodes::Base::Environment::DSEL_NODE_ACCESSOR ) ? self : nil
+    end
+
+    def _dsel_determine_node( klass, parent = nil )
+        return klass.new( self ) if !parent
+
+        if parent._dsel_node.is_a?( klass )
+            parent._dsel_node.node_for( self )
+        else
+            node = klass.new( self, parent: parent )
+            parent._dsel_node.cache_node node
+            node
+        end
+    end
+
+end

data/lib/dsel/version.rb

@@ -0,0 +1,3 @@
+module DSeL
+    VERSION = '0.1.0'
+end

data/lib/dsel.rb

@@ -0,0 +1,10 @@
+require 'ap'
+
+module DSeL
+
+    require 'dsel/version'
+    require 'dsel/node'
+    require 'dsel/api'
+    require 'dsel/dsl'
+
+end

data/spec/dsel/api/generator_spec.rb

@@ -0,0 +1,402 @@
+require 'spec_helper'
+
+RSpec.describe DSeL::API::Generator do
+    let(:api_spec) { MockAPI }
+    let(:api) { api_spec.new }
+    let(:clean_api_spec) { Factory[:clean_api_spec] }
+    let(:clean_api) { clean_api_spec.new }
+    subject { described_class }
+
+    describe '#last_call' do
+        let(:last_call) { subject.last_call }
+
+        before do
+            api.on
+            api.on 2
+        end
+
+        it 'returns the last call' do
+            expect(last_call[:node]).to be api_spec
+            expect(last_call[:type]).to be :on
+            expect(last_call[:args]).to eq [2]
+        end
+
+        context '#last_call_with_caller?' do
+            context 'true' do
+                before do
+                    subject.last_call_with_caller!
+                    api.on 3
+                end
+
+                it 'includes caller information' do
+                    expect(last_call[:caller]).to be_kind_of Array
+                end
+            end
+
+            context 'false' do
+                before do
+                    subject.last_call_without_caller!
+                    api.on 3
+                end
+
+                it 'does not include caller information' do
+                    expect(last_call).to_not include :caller
+                end
+            end
+
+            context 'default' do
+                before do
+                    api.on 3
+                end
+
+                it 'does not include caller information' do
+                    expect(last_call).to_not include :caller
+                end
+            end
+        end
+    end
+
+    describe '#last_call_with_caller?' do
+        it 'returns false' do
+            expect(subject).to_not be_last_call_with_caller
+        end
+
+        context 'when #last_call_with_caller! has been called' do
+            before do
+                subject.last_call_with_caller!
+            end
+
+            it 'returns true' do
+                expect(subject).to be_last_call_with_caller
+            end
+        end
+    end
+
+    describe '#last_call_without_caller!' do
+        it 'disables tracking of last call callers' do
+            subject.last_call_with_caller!
+            expect(subject).to be_last_call_with_caller
+
+            subject.last_call_without_caller!
+            expect(subject).to_not be_last_call_with_caller
+        end
+    end
+
+    describe '#last_call_witt_caller!' do
+        it 'enables tracking of last call callers' do
+            subject.last_call_with_caller!
+            expect(subject).to be_last_call_with_caller
+        end
+    end
+
+    describe '#on_call' do
+        it 'sets callbacks for each call' do
+            calls = Hash.new
+
+            subject.on_call do |call|
+                (calls[:first] ||= []) << call
+            end
+
+            subject.on_call do |call|
+                (calls[:second] ||= []) << call
+            end
+
+            api.on 4
+
+            expect(calls[:first]).to eq calls[:second]
+            {
+                node: api_spec,
+                type: :on,
+                args: [4]
+            }.each do |k, v|
+                calls[:first].each do |call|
+                    expect(call[k]).to eq v
+                end
+            end
+        end
+
+        it 'returns self' do
+            expect(subject.on_call{}).to be subject.instance
+        end
+
+        context 'when no block is given' do
+            it 'raises ArgumentError' do
+                expect do
+                    subject.on_call
+                end.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#call_object_hasher=' do
+        before do
+            subject.define_definers( clean_api_spec, :on )
+        end
+
+        context 'nil' do
+            before do
+                subject.call_object_hasher = nil
+            end
+
+            it 'uses #hash' do
+                o = Object.new
+                expect(o).to receive(:hash).and_return(1)
+
+                called = false
+                subject.define_call_handler clean_api_spec, :on, o do |*a, &block|
+                    called = true
+                end
+
+                o2 = Object.new
+                expect(o2).to receive(:hash).and_return(1)
+
+                clean_api.on o2
+                expect(called).to be_truthy
+            end
+
+            it 'treats strings as case-insensitive' do
+                o = 'StFuFf'
+
+                called = false
+                subject.define_call_handler clean_api_spec, :on, o do |*a, &block|
+                    called = true
+                end
+
+                clean_api.on o.downcase
+                expect(called).to be_truthy
+            end
+        end
+
+        context 'Symbol' do
+            before do
+                subject.call_object_hasher = :object_id
+            end
+
+            it 'uses it as a method on the object' do
+                o = Object.new
+
+                called = false
+                subject.define_call_handler clean_api_spec, :on, o do |*a, &block|
+                    called = true
+                end
+
+                expect do
+                    clean_api.on Object.new
+                end.to raise_error NoMethodError
+
+                clean_api.on o
+                expect(called).to be_truthy
+            end
+        end
+
+        context '#call' do
+            before do
+                subject.call_object_hasher = proc do |o|
+                    o.hash
+                end
+            end
+
+            it 'passes the object to it' do
+                o = Object.new
+                expect(o).to receive(:hash).and_return(1)
+
+                called = false
+                subject.define_call_handler clean_api_spec, :on, o do |*a, &block|
+                    called = true
+                end
+
+                o2 = Object.new
+                expect(o2).to receive(:hash).and_return(1)
+
+                clean_api.on o2
+                expect(called).to be_truthy
+            end
+        end
+
+        context 'other' do
+            it 'raises ArgumentError' do
+                expect do
+                    subject.call_object_hasher = 'stuff'
+                end.to raise_error ArgumentError
+            end
+        end
+
+        context 'when the return value is not an Integer' do
+            before do
+                subject.call_object_hasher = :to_s
+            end
+
+            it 'raises ArgumentError' do
+                o = Object.new
+
+                expect do
+                    subject.define_call_handler( clean_api_spec, :on, o ){}
+                end.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#define_definers' do
+        it 'defines the given definers on the given node' do
+            subject.define_definers( clean_api_spec, :on, :after )
+
+            expect(clean_api_spec.definers).to eq [
+                { type: :on,    method: :def_on },
+                { type: :after, method: :def_after }
+            ]
+
+            expect(clean_api_spec).to respond_to :def_on
+            expect(clean_api_spec).to respond_to :def_after
+        end
+
+        context 'when a definer already exists' do
+            it 'raises NameError' do
+                subject.define_definers( clean_api_spec, :on )
+
+                expect do
+                    subject.define_definers( clean_api_spec, :on )
+                end.to raise_error NameError
+            end
+        end
+
+        context 'when a definer is given more than 2 objects' do
+            it 'raises ArgumentError' do
+                subject.define_definers( clean_api_spec, :on )
+
+                expect do
+                    clean_api_spec.def_on :stuff, :stuff2 do
+
+                    end
+                end.to raise_error ArgumentError
+            end
+        end
+    end
+
+    describe '#define_call_handler' do
+        before do
+            subject.define_definers( clean_api_spec, :on, :after )
+        end
+
+        it 'defines a handler for the given type and object' do
+            on_args = []
+            subject.define_call_handler clean_api_spec, :on, :stuff do |*a, &block|
+                on_args << [a, block]
+            end
+
+            after_args = []
+            subject.define_call_handler clean_api_spec, :after, :stuff do |*a, &block|
+                after_args << [a, block]
+            end
+
+            b1 = proc{}
+            clean_api.on :stuff, 1, &b1
+
+            b2 = proc{}
+            clean_api.after :stuff, 2, &b2
+
+            expect(on_args).to eq [[[1], b1]]
+            expect(after_args).to eq [[[2], b2]]
+        end
+
+        it 'enforces argument arity' do
+            subject.define_call_handler clean_api_spec, :on, :none do
+            end
+
+            expect do
+                clean_api.on :none
+            end.to_not raise_error
+
+            expect do
+                clean_api.on :none, 1
+            end.to raise_error ArgumentError
+
+
+            subject.define_call_handler clean_api_spec, :on, :one do |x|
+            end
+
+            expect do
+                clean_api.on :one, 1
+            end.to_not raise_error
+
+            expect do
+                clean_api.on :one
+            end.to raise_error ArgumentError
+
+            expect do
+                clean_api.on :one, 1, 2
+            end.to raise_error ArgumentError
+
+
+            subject.define_call_handler clean_api_spec, :on, :two do |x, y|
+            end
+
+            expect do
+                clean_api.on :two, 1, 2
+            end.to_not raise_error
+
+            expect do
+                clean_api.on :two
+            end.to raise_error ArgumentError
+
+            expect do
+                clean_api.on :two, 1
+            end.to raise_error ArgumentError
+
+            expect do
+                clean_api.on :two, 1, 2, 3
+            end.to raise_error ArgumentError
+
+
+            subject.define_call_handler clean_api_spec, :on, :var do |*args|
+            end
+
+            expect do
+                clean_api.on :var
+            end.to_not raise_error
+
+            expect do
+                clean_api.on :var, 1
+            end.to_not raise_error
+        end
+
+        context 'when object is' do
+            context 'nil' do
+                it 'is treated as an object' do
+                    args = []
+                    subject.define_call_handler clean_api_spec, :on, nil do |*a|
+                        args << a
+                    end
+
+                    expect do
+                        clean_api.on
+                    end.to raise_error NoMethodError
+
+                    clean_api.on nil, :stuff
+
+                    expect(args).to eq [[:stuff]]
+                end
+            end
+        end
+
+        context 'when no object is given' do
+            it 'is treated as a catch-call' do
+                args = []
+                subject.define_call_handler clean_api_spec, :on do |*a|
+                    args << a
+                end
+
+                subject.define_call_handler clean_api_spec, :on, :something do |*a|
+                end
+
+                clean_api.on
+                clean_api.on nil
+                clean_api.on [:stuff]
+                clean_api.on :stuff2, { mode: :stuff }
+
+                clean_api.on :something
+
+                expect(args).to eq [[], [nil], [[:stuff]], [:stuff2, { mode: :stuff }]]
+            end
+        end
+    end
+end