dsel 0.1.0

data/lib/dsel/api/node.rb

@@ -0,0 +1,241 @@
+module DSeL
+module API
+
+class Node < Node
+
+    def self.inherited( base )
+        base.extend ClassMethods
+    end
+
+    module ClassMethods
+        def run( *args, &block )
+            DSL::Nodes::API.new( new ).run( *args, &block )
+        end
+
+        def define( *types )
+            if types.size > 1
+                if has_options?
+                    fail ArgumentError,
+                         "Cannot set options for multiple types: #{types}"
+                end
+
+                if has_description?
+                    fail ArgumentError,
+                         "Cannot set description for multiple types: #{types}"
+                end
+            end
+
+            Generator.define_definers( self, *types )
+        end
+
+        def has_options?
+            !!@last_options
+        end
+
+        def has_description?
+            !!@last_description
+        end
+
+        def describe( description )
+            @last_description = description
+        end
+
+        def configure( options, &block )
+            @last_options = [options, block].compact
+        end
+
+        def definers
+            @definers ||= []
+        end
+
+        def has_call_handler?( type, *possible_object )
+            method_defined? Generator.call_handler_name( type, *possible_object )
+        end
+
+        def call_handlers
+            @call_handlers ||= []
+        end
+
+        def root?
+            !parent
+        end
+
+        def child?
+            !root?
+        end
+
+        def root
+            return self if root?
+
+            @root ||= begin
+                p = @parent
+                while p.parent
+                    p = p.parent
+                end
+                p
+            end
+        end
+
+        def parent
+            @parent
+        end
+
+        def push_children( c )
+            c.each do |name, (klass, *args)|
+                push_child( name, klass, *args )
+            end
+
+            nil
+        end
+
+        def push_child( name, node, s = nil )
+            if s && !s.is_a?( Symbol ) && !s.respond_to?( :call )
+                fail ArgumentError, 'Subject not Symbol nor responds to #call.'
+            end
+
+            node.set_parent( self )
+
+            child = {
+                name: name.to_sym,
+                node: node
+            }
+
+            if (options = self.flush_options)
+                child.merge!( options: options )
+            end
+
+            if (description = self.flush_description)
+                child.merge!( description: description )
+            end
+
+            children[name] = child
+
+            define_method name do
+                ivar = "@#{name}"
+
+                v = instance_variable_get( ivar )
+                return v if v
+
+                sub = @subject
+                if s.is_a?( Symbol )
+                    sub = sub.send( s )
+                end
+
+                if s.respond_to?( :call )
+                    sub = s.call( sub )
+                end
+
+                instance_variable_set( ivar, node.new( sub, parent: self ) )
+            end
+
+            child
+        end
+
+        def children
+            @children ||= {}
+        end
+
+        def tree
+            root.branch
+        end
+
+        def branch
+            t = {
+                definers:      self.definers,
+                call_handlers: self.call_handlers.map { |h| c = h.dup; c.delete( :method ); c },
+                children:      {}
+            }
+
+            self.children.each do |name, child|
+                t[:children][name] = child.merge( child[:node].branch )
+            end
+
+            t
+        end
+
+        # @private
+        def flush_description
+            d = @last_description
+            @last_description = nil
+            d
+        end
+
+        # @private
+        def flush_options
+            o = @last_options
+            @last_options = nil
+            o
+        end
+
+        # @private
+        def push_call_handler( type, method, *possible_object )
+            handler = {
+                type: type.to_sym
+            }
+
+            if !possible_object.empty?
+                handler.merge!( object: possible_object.first )
+            end
+
+            if (options = self.flush_options)
+                handler.merge!( options: options )
+            end
+
+            if (description = self.flush_description)
+                handler.merge!( description: description )
+            end
+
+            handler.merge!(
+                method: method.to_sym
+            )
+
+            call_handlers << handler
+            handler
+        end
+
+        # @private
+        def set_parent( node )
+            fail if @parent
+            @parent = node
+        end
+
+        # @private
+        def push_definer( type, method )
+            definer = {
+                type: type.to_sym
+            }
+
+            if (options = self.flush_options)
+                definer.merge!( options: options )
+            end
+
+            if (description = self.flush_description)
+                definer.merge!( description: description )
+            end
+
+            definer.merge!(
+                method: method.to_sym
+            )
+
+            definers << definer
+            definer
+        end
+
+        def method_missing( m, *args, &block )
+            ms = m.to_s
+            if ms.start_with? 'def_'
+                to_define = ms.split( 'def_', 2 ).last
+                define to_define
+
+                send m, *args, &block
+            else
+                super( m, *args, &block )
+            end
+        end
+
+    end
+
+end
+
+end
+end

data/lib/dsel/api.rb

@@ -0,0 +1,8 @@
+module DSeL
+module API
+
+    require_relative 'api/generator'
+    require_relative 'api/node'
+
+end
+end

data/lib/dsel/dsl/mixins/environment/ivar_explorer.rb

@@ -0,0 +1,34 @@
+module DSeL
+module DSL
+module Mixins
+module Environment
+
+module IvarExplorer
+
+    def method_missing( name, *args, &block )
+        first_letter = name[0...1]
+
+        if block && first_letter == first_letter.capitalize
+            ivar = "@#{name}".to_sym
+            return _dsel_node_for_ivar( ivar, &block )
+        end
+
+        super( name, *args, &block )
+    end
+
+    # @private
+    def _dsel_node_for_ivar( ivar, &block )
+        ivar = ivar.downcase
+        if !_dsel_node.subject.instance_variable_defined?( ivar )
+            fail ArgumentError, "Instance variable not defined: #{ivar}"
+        end
+
+        _dsel_node.node_for( _dsel_node.subject.instance_variable_get( ivar ) ).run( &block )
+    end
+
+end
+
+end
+end
+end
+end

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

@@ -0,0 +1,49 @@
+require_relative '../proxy/environment'
+
+module DSeL
+module DSL
+module Nodes
+class API
+
+class Environment < Proxy::Environment
+
+    define_method "#{DSEL_NODE_ACCESSOR}=" do |node|
+        super( node )
+
+        if node
+            node.subject.class.children.keys.each do |name|
+                define_singleton_method name.capitalize do |&b|
+                    node.node_for( send( name ) ).run( &b )
+                end
+            end
+        end
+
+        node
+    end
+
+    def also( *args, &block )
+        # TODO: Store #last_call on Node at the instance level,
+        # this global state can be interfered with by other DSLs.
+        last_call = DSeL::API::Generator.last_call
+        type      = last_call[:type]
+
+        # Check to see if there is a handler that matches our possible object.
+        # If so, treat it as object.
+        # If not, use the last object and assume arguments.
+        if last_call.include?( :object ) &&
+            !_dsel_self.class.has_call_handler?( type, args.first )
+
+            args.unshift last_call[:object]
+        end
+
+        send( type, *args, &block )
+
+        self
+    end
+
+end
+
+end
+end
+end
+end

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

@@ -0,0 +1,18 @@
+module DSeL
+module DSL
+module Nodes
+
+class API < Proxy
+    require_relative 'api/environment'
+
+    private
+
+    def prepare_environment
+        @environment ||= Environment.new
+    end
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,56 @@
+module DSeL
+module DSL
+module Nodes
+class APIBuilder
+
+module Environment
+    include Base::Environment
+
+    def import( file )
+        f = file.dup
+        f << '.rb' if !file.end_with?( '.rb' )
+
+        _dsel_import f
+    end
+
+    def import_many( glob )
+        Dir["#{glob}.rb"].each { |file| _dsel_import( file ) }
+    end
+
+    def import_relative( file )
+        f = _dsel_caller_dir
+        f << file
+        f << '.rb' if !file.end_with?( '.rb' )
+
+        _dsel_import f
+    end
+
+    def import_relative_many( glob )
+        Dir["#{_dsel_caller_dir}#{glob}.rb"].each { |file| _dsel_import( file ) }
+    end
+
+    def child( method_name, class_name, *args, &block )
+        node = _dsel_node.node_for( class_name )
+        node.run( &block )
+
+        _dsel_node.subject.push_child(
+            method_name,
+            node.subject,
+            *args
+        )
+    end
+
+    def _dsel_import( file )
+        _dsel_node.subject.instance_eval( IO.read( file ) )
+    end
+
+    def _dsel_caller_dir( offset = 1 )
+        File.dirname( caller[offset].split( ':', 2 ).first ) << '/'
+    end
+
+end
+
+end
+end
+end
+end

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

@@ -0,0 +1,71 @@
+require_relative 'direct'
+
+module DSeL
+module DSL
+module Nodes
+
+class APIBuilder < Nodes::Direct
+    require_relative 'api_builder/environment'
+
+    def self.build( *args, &block )
+        fail ArgumentError, 'Missing block.' if !block
+
+        node = new( *args )
+        node.run( &block )
+        node.subject
+    end
+
+    API_NODE = DSeL::API::Node
+
+    def initialize( node, options = {} )
+        @superclass = options[:superclass] || API_NODE
+        if !(@superclass <= API_NODE)
+            fail ArgumentError, "Superclass not subclass of #{API_NODE}."
+        end
+
+        if node.is_a?( Symbol )
+            namespace = options[:namespace]  || Object
+
+            if namespace.constants.include?( node )
+                fail ArgumentError, "Node name taken: #{c.inspect}"
+            end
+
+            subject = namespace.const_set( node, Class.new( @superclass ) )
+
+        elsif node.is_a?( Class ) && node < DSeL::API::Node
+            subject = node
+
+        else
+            fail ArgumentError,
+                 "Expected #{Symbol} or #{DSeL::API::Node}, got: #{node.inspect}"
+        end
+
+        super( subject, options )
+    end
+
+    # @private
+    def node_for( subject, options = {} )
+        super( subject, options.merge(
+            namespace:  @subject,
+            superclass: @superclass
+        ))
+    end
+
+    def reset_methods
+        [
+            :instance_variables,
+            :method_missing
+        ]
+    end
+
+    def extend_env
+        [
+            Environment
+        ]
+    end
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,50 @@
+module DSeL
+module DSL
+module Nodes
+class Base
+
+module Environment
+
+    DSEL_NODE_ACCESSOR = :_dsel_node
+    DSEL_NODE_IVAR     = "@#{DSEL_NODE_ACCESSOR}".to_sym
+
+    # @private
+    attr_accessor DSEL_NODE_ACCESSOR
+
+    def instance_variables
+        super.tap { |ivars| ivars.delete DSEL_NODE_IVAR }
+    end
+
+    def _dsel_shared_variables
+        _dsel_node.shared_variables
+    end
+
+    def _dsel_self
+        _dsel_node.subject
+    end
+
+    def _dsel_variables
+        s = {}
+        instance_variables.each do |ivar|
+            s[ivar.to_s.sub( '@', '' ).to_sym] = instance_variable_get( ivar )
+        end
+        s.freeze
+    end
+
+    def Parent( &block )
+        fail 'Already root.' if _dsel_node.root?
+
+        _dsel_node.parent.run( &block )
+    end
+
+    def Root( &block )
+        fail 'Already root.' if _dsel_node.root?
+        _dsel_node.root.run( &block )
+    end
+
+end
+
+end
+end
+end
+end

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

@@ -0,0 +1,110 @@
+module DSeL
+module DSL
+module Nodes
+
+class Base < Node
+    require_relative 'base/environment'
+
+    # @return   [Environment]
+    attr_reader :environment
+
+    def initialize(*)
+        super
+
+        @shared_variables = {}
+        @nodes            = {}
+
+        cache_node( self )
+    end
+
+    # @private
+    def nodes
+        root? ? @nodes : @root.nodes
+    end
+
+    def shared_variables
+        root? ? @shared_variables : @root.shared_variables
+    end
+
+    # @private
+    def cache_node( node )
+        nodes[node.hash] ||= node
+    end
+
+    # @private
+    def node_for( subject, options = {} )
+        nodes[calc_node_hash( subject )] ||=
+            self.class.new( subject, options.merge( parent: self ) )
+    end
+
+    def run( script = nil, &block )
+        if script && block
+            fail ArgumentError, 'Cannot use both script and &block.'
+        end
+
+        begin
+            prepare
+
+            calling do
+                if block
+                    return @environment.instance_eval( &block )
+                end
+
+                if script
+                    @environment.instance_eval do
+                        return eval( IO.read( script ) )
+                    end
+                end
+            end
+        ensure
+            # Re-entry, don't touch anything.
+            return if calling?
+
+            # May not have been prepared yet.
+            return if !@environment.respond_to?( Environment::DSEL_NODE_ACCESSOR )
+
+            cleanup
+        end
+    end
+
+    private
+
+    def prepare
+        prepare_environment
+        @environment._dsel_node = self
+    end
+
+    def cleanup
+        @environment._dsel_node = nil
+        cleanup_environment
+    end
+
+    # @abstract
+    def cleanup_environment
+    end
+
+    # @abstract
+    def prepare_environment
+        fail 'Not implemented.'
+    end
+
+    def calling( &block )
+        return block.call if @calling
+
+        @calling = true
+        begin
+            block.call
+        ensure
+            @calling = false
+        end
+    end
+
+    def calling?
+        @calling
+    end
+
+end
+
+end
+end
+end

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

@@ -0,0 +1,14 @@
+module DSeL
+module DSL
+module Nodes
+class Direct
+
+module Environment
+    include Base::Environment
+
+end
+
+end
+end
+end
+end