alki-dsl 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 509cf74d2d757a7d980460a7bd63199e0cfabe39
+  data.tar.gz: 33c3f48bac58f19f73f7469ec42f4357cd2321b6
+SHA512:
+  metadata.gz: 2ad60f1b2f6c8f012e41c61ff18171ff1fafb65af694c04a96dc15c20ba664c88b60e25d9fc23cf430f7c41396509b7443169ef9f447af2af46e27114255894c
+  data.tar.gz: 1245f5d5471641f77603f23aac033fd273f9a622f327fb19ce2268616a9a1c6fb968d589e602f1294a28f69596d0a786242e035d8d5cdbe8bfdc9decca40ec40

data/.gitignore

@@ -0,0 +1,53 @@
+# Created by .ignore support plugin (hsz.mobi)
+### Ruby template
+*.gem
+*.rbc
+/.config
+/coverage/
+/InstalledFiles
+/pkg/
+/spec/reports/
+/spec/examples.txt
+/test/tmp/
+/test/version_tmp/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+# .env
+
+## Specific to RubyMotion:
+.dat*
+.repl_history
+build/
+*.bridgesupport
+build-iPhoneOS/
+build-iPhoneSimulator/
+
+## Specific to RubyMotion (use of CocoaPods):
+#
+# We recommend against adding the Pods directory to your .gitignore. However
+# you should judge for yourself, the pros and cons are mentioned at:
+# https://guides.cocoapods.org/using/using-cocoapods.html#should-i-check-the-pods-directory-into-source-control
+#
+# vendor/Pods/
+
+## Documentation cache and generated files:
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+## Environment normalization:
+/.bundle/
+/vendor/bundle
+/lib/bundler/man/
+
+# for a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in:
+Gemfile.lock
+# .ruby-version
+# .ruby-gemset
+
+# unless supporting rvm < 1.11.0 or doing something fancy, ignore this:
+.rvmrc
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/alki-dsl.gemspec

@@ -0,0 +1,22 @@
+# coding: utf-8
+require_relative 'lib/alki/dsl/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "alki-dsl"
+  spec.version       = Alki::Dsl::VERSION
+  spec.authors       = ["Matt Edlefsen"]
+  spec.email         = ["matt.edlefsen@gmail.com"]
+  spec.summary       = %q{Alki dsl library}
+  spec.description   = %q{Library for defining and using DSLs}
+  spec.homepage      = "https://github.com/medlefsen/alki-dsl"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.bindir        = 'exe'
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency 'alki-support', '~> 0.3'
+  spec.add_development_dependency 'minitest', '~> 5.9', '>= 5.9.1'
+end

data/lib/alki/class_builder.rb

@@ -0,0 +1,132 @@
+require 'forwardable'
+require 'alki/support'
+
+module Alki
+  class ClassBuilder
+    def self.create_constant(name,value = Class.new, parent=nil)
+      parent ||= Object
+      *ans, ln = name.to_s.split('::')
+      ans.each do |a|
+        unless parent.const_defined? a
+          parent.const_set a, Module.new
+        end
+        parent = parent.const_get a
+      end
+
+      parent.const_set ln, value
+    end
+
+    def self.build(data)
+      class_name = data[:class_name]
+      if !class_name && data[:name] && data[:prefix]
+        class_name = Alki::Support.classify(
+          data[:prefix].empty? ? data[:name] : "#{data[:prefix]}/#{data[:name]}"
+        )
+      end
+
+      if data[:type] == :module
+        klass = Module.new
+      else
+        super_class = if data[:super_class]
+          Alki::Support.load_class data[:super_class]
+        else
+          Object
+        end
+        klass = Class.new super_class
+      end
+      build_class data, klass
+      if class_name
+        create_constant class_name, klass, data[:parent_class]
+      end
+      if data[:secondary_classes]
+        data[:secondary_classes].each do |data|
+          if data[:subclass]
+            data = data.merge(parent_class: klass,class_name: data[:subclass])
+          elsif !data[:class_name] && !data[:name]
+            raise ArgumentError.new("Secondary classes must have names")
+          end
+          build data
+        end
+      end
+      klass
+    end
+
+    def self.module_not_empty?(mod)
+      not mod.instance_methods.empty? &&
+        mod.private_instance_methods.empty?
+    end
+
+    def self.build_class(data,klass)
+      if data[:module]
+        if module_not_empty? data[:module]
+          klass.include data[:module]
+        end
+        if data[:module].const_defined?(:ClassMethods) &&
+          module_not_empty?(data[:module]::ClassMethods)
+          klass.extend data[:module]::ClassMethods
+        end
+      end
+
+      if data[:modules]
+        data[:modules].each do |mod|
+          klass.include mod
+        end
+      end
+      if data[:class_modules]
+        data[:class_modules].each do |mod|
+          klass.extend mod
+        end
+      end
+
+      add_methods klass, data
+      add_initialize klass, data[:initialize_params] if data[:initialize_params]
+    end
+
+    def self.add_methods(klass, data)
+      if data[:class_methods]
+        data[:class_methods].each do |name, method|
+          klass.define_singleton_method name, &method[:body]
+          klass.singleton_class.send :private, name if method[:private]
+        end
+      end
+
+      if data[:instance_methods]
+        data[:instance_methods].each do |name, method|
+          klass.send :define_method, name, &method[:body]
+          klass.send :private, name if method[:private]
+        end
+      end
+
+      if data[:delegators]
+        klass.extend Forwardable
+        data[:delegators].each do |name,delegator|
+          klass.def_delegator delegator[:accessor], delegator[:method], name
+        end
+      end
+
+      klass.send :attr_reader, *data[:attr_readers] if data[:attr_readers]
+      klass.send :attr_writer, *data[:attr_writers] if data[:attr_writers]
+      klass.send :attr_accessor, *data[:attr_accessors] if data[:attr_accessors]
+    end
+
+    def self.add_initialize(klass,params)
+      at_setters = ''
+      params.each do |(p,default)|
+        if default
+          default_method = "_default_#{p}".to_sym
+          klass.send :define_method, default_method do
+            default
+          end
+          klass.send :private, default_method
+          at_setters << "@#{p} = #{p} || #{default_method}\n"
+        else
+          at_setters << "@#{p} = #{p}\n"
+        end
+      end
+
+      klass.class_eval "
+        def initialize(#{params.map{|p| p[1] ? "#{p[0]}=nil" : p[0]}.join(', ')})
+        #{at_setters}end"
+    end
+  end
+end

data/lib/alki/dsl/base.rb

@@ -0,0 +1,45 @@
+require 'alki/support'
+require 'alki/dsl/evaluator'
+
+module Alki
+  module Dsl
+    class Base
+      def self.build(data={},&blk)
+        Alki::Dsl::Evaluator.evaluate self, data, &blk
+      end
+
+      def self.generate(ctx)
+        obj = new(ctx)
+        result = {methods: {}}
+        info = self.dsl_info
+
+        result[:init] = obj.method(info[:init]) if info[:init]
+        result[:finish] = obj.method(info[:finish]) if info[:finish]
+        result[:requires] = info[:requires] if info[:requires]
+        result[:helpers] = info[:helpers] if info[:helpers]
+
+        if info[:methods]
+          info[:methods].each do |method|
+            if method.is_a?(Array)
+              name, method = method
+            else
+              name = method
+            end
+            result[:methods][name] = obj.method method
+          end
+        end
+        result
+      end
+
+      def self.dsl_info
+        {}
+      end
+
+      def initialize(ctx)
+        @ctx = ctx
+      end
+
+      attr_reader :ctx
+    end
+  end
+end

data/lib/alki/dsl/builder.rb

@@ -0,0 +1,42 @@
+require 'alki/support'
+require 'alki/dsl/evaluator'
+
+module Alki
+  module Dsl
+    class Builder
+      def self.build(data,&blk)
+        result = Alki::Dsl::Evaluator.evaluate _dsls,data,&blk
+        if _processor
+          _processor.build result
+        else
+          result
+        end
+      end
+
+      private
+
+      def self.dsl(name)
+        klass = Alki::Support.load_class name
+        unless klass
+          raise "Unable to load class #{name.inspect}"
+        end
+        dsls = _dsls
+        dsls += [klass]
+        define_singleton_method(:_dsls) { dsls }
+      end
+
+      def self.processor(name)
+        klass = Alki::Support.load_class name
+        define_singleton_method(:_processor) { klass }
+      end
+
+      def self._dsls
+        []
+      end
+
+      def self._processor
+        nil
+      end
+    end
+  end
+end

data/lib/alki/dsl/class_helpers.rb

@@ -0,0 +1,86 @@
+module Alki
+  module Dsl
+    module ClassHelpers
+      def class_builder(subclass = nil)
+        unless @ctx[:class_builder]
+          @ctx[:class_builder] = {}
+          %i(module name prefix).each do |attr|
+            @ctx[:class_builder][attr] = @ctx[attr] if @ctx[attr]
+          end
+        end
+        if subclass
+          scs = @ctx[:class_builder][:secondary_classes] ||= []
+          cb = scs.find { |sc| sc[:subclass] == subclass }
+          unless cb
+            cb = { subclass: subclass }
+            scs << cb
+          end
+          cb
+        else
+          @ctx[:class_builder]
+        end
+      end
+
+      def create_as_module(subclass: nil)
+        class_builder(subclass)[:type] = :module
+      end
+
+      def set_super_class(klass,subclass: nil)
+        class_builder(subclass)[:super_class] = klass
+      end
+
+      def add_method(name,context:nil,private: false,subclass: nil, &blk)
+        class_builder(subclass)[:instance_methods] ||= {}
+        class_builder(subclass)[:instance_methods][name.to_sym] = {
+          body: blk,
+          context: context,
+          private: private
+        }
+      end
+
+      def add_class_method (name,context: nil,private: false,subclass: nil,&blk)
+        class_builder(subclass)[:class_methods] ||= {}
+        class_builder(subclass)[:class_methods][name.to_sym] = {
+          body: blk,
+          context: context,
+          private: private
+        }
+      end
+
+      def add_helper(name,&blk)
+        class_builder('Helpers')[:type] = :module
+        add_method name, &blk
+        add_method name, subclass: 'Helpers', &blk
+      end
+
+      def add_helper_module(mod)
+        class_builder('Helpers')[:type] = :module
+        add_module mod
+        add_module mod, subclass: 'Helpers'
+      end
+
+      def add_initialize_param(name,default=nil,subclass: nil)
+        (class_builder(subclass)[:initialize_params]||=[]) << [name.to_sym,default]
+      end
+
+      def add_instance_class_proxy(type, name,subclass: nil)
+        (class_builder(subclass)[:instance_class]||={})[name.to_sym] = {type: type}
+      end
+
+      def add_module(mod,subclass: nil)
+        (class_builder(subclass)[:modules]||=[]) << mod
+      end
+
+      def add_accessor(name,type: :accessor,subclass: nil)
+        (class_builder(subclass)["attr_#{type}s".to_sym]||=[]) << name
+      end
+
+      def add_delegator(name,accessor,method=name,subclass: nil)
+        (class_builder(subclass)[:delegators]||={})[name] = {
+          accessor: accessor,
+          method: method
+        }
+      end
+    end
+  end
+end

data/lib/alki/dsl/evaluator.rb

@@ -0,0 +1,67 @@
+require 'set'
+require 'alki/support'
+
+module Alki
+  module Dsl
+    class Evaluator
+      def initialize
+        @inits = []
+        @finishers = []
+        @processors = []
+        @dsls_seen = Set.new
+      end
+
+      def evaluate(dsl,data={},&blk)
+        mod = (data[:module] ||= Module.new)
+        process_dsl dsl, data
+
+        @inits.each(&:call)
+        dsl_exec mod, &blk
+        @finishers.reverse_each(&:call)
+        clear_dsl_methods mod
+
+        @processors.each do |processor|
+          processor.build data
+        end
+
+        data
+      end
+
+      def process_dsl(dsl,data)
+        return unless @dsls_seen.add? dsl
+        cbs = dsl.generate(data)
+        if cbs[:requires]
+          cbs[:requires].each do |required_dsl|
+            process_dsl Alki::Support.load_class(required_dsl), data
+          end
+        end
+        @inits << cbs[:init] if cbs[:init]
+        @finishers << cbs[:finish] if cbs[:finish]
+        @processors << cbs[:processors] if cbs[:processors]
+        if cbs[:methods]
+          cbs[:methods].each do |name, proc|
+            define_dsl_method data[:module], name, &proc
+          end
+        end
+      end
+
+      def define_dsl_method(mod,name,&blk)
+        mod.define_singleton_method name, &blk
+      end
+
+      def clear_dsl_methods(mod)
+        mod.singleton_methods do |m|
+          mod.singleton_class.send :remove_method, m
+        end
+      end
+
+      def dsl_exec(mod,&blk)
+        mod.class_exec &blk
+      end
+
+      def self.evaluate(dsl, data={}, &blk)
+        new.evaluate dsl, data, &blk
+      end
+    end
+  end
+end

data/lib/alki/dsl/loader.rb

@@ -0,0 +1,28 @@
+require 'alki/support'
+require 'alki/dsl'
+
+module Alki
+  module Dsl
+    class Loader
+      def initialize(root_dir)
+        @root_dir = root_dir
+      end
+
+      def all_paths
+        Dir[File.join(@root_dir,'**','*.rb')].map do |path|
+          path.gsub(File.join(@root_dir,''),'').gsub(/\.rb$/,'')
+        end
+      end
+
+      def load_all
+        all_paths.inject({}) do |h,path|
+          h.merge!(path => Alki::Dsl.load(path))
+        end
+      end
+
+      def load(file)
+        Alki::Dsl.load File.expand_path("#{file}.rb",@root_dir)
+      end
+    end
+  end
+end

data/lib/alki/dsl/registry.rb

@@ -0,0 +1,66 @@
+require 'alki/dsl/loader'
+require 'alki/support'
+
+module Alki
+  module Dsl
+    module Registry
+      @registered_paths = {}
+      @registered_dirs = {}
+
+      def self.register(path,builder,**data)
+        @registered_paths[File.absolute_path(path)] = Entry.new(builder,data)
+      end
+
+      def self.register_dir(dir_path,builder,**data)
+        @registered_dirs[File.join(File.absolute_path(dir_path),'')] = [builder,data]
+      end
+
+      def self.lookup(path, load_configs: true)
+        path = File.absolute_path path
+        entry = @registered_paths[path]
+        return entry if entry
+
+        @registered_dirs.each do |dir,(builder,data)|
+          if path.start_with? dir
+            data = {name: Alki::Support.path_name(path, dir)}.merge data
+            return Entry.new(builder,data)
+          end
+        end
+
+        if load_configs
+          root = Alki::Support.find_root(path) do |dir|
+            File.exists?(File.join(dir,'config','dsls.rb'))
+          end
+          if root
+            config_file = File.join(root,'config','dsls.rb')
+            register config_file, 'alki/dsls/dsl_config', root: root
+            require config_file
+            return lookup path, load_configs: false
+          end
+        end
+
+        nil
+      end
+
+      def self.build(path,&blk)
+        entry = lookup path
+        if entry
+          entry.build blk
+        else
+          nil
+        end
+      end
+
+      class Entry
+        def initialize(builder,data)
+          @builder = builder
+          @data = data
+        end
+
+        def build(blk)
+          Alki::Support.load_class(@builder).build @data, &blk
+        end
+      end
+    end
+  end
+end

data/lib/alki/dsl/version.rb

@@ -0,0 +1,5 @@
+module Alki
+  module Dsl
+    VERSION = '0.3.0'
+  end
+end

data/lib/alki/dsl.rb

@@ -0,0 +1,48 @@
+require 'alki/dsl/evaluator'
+require 'alki/dsl/registry'
+
+module Alki
+  module Dsl
+    @loaded = {}
+    def self.[]=(path,value)
+      @loaded[path] =value
+    end
+
+    def self.[](path)
+      @loaded[path]
+    end
+
+    def self.register(*args)
+      Alki::Dsl::Registry.register *args
+    end
+
+    def self.register_dir(*args)
+      Alki::Dsl::Registry.register_dir *args
+    end
+
+    def self.load(path)
+      path = File.absolute_path(path)
+      require path
+      self[path]
+    end
+
+    def self.build(name,data={},&blk)
+      Alki::Support.load_class(name).build data, &blk
+    end
+  end
+end
+
+module Kernel
+  def Alki(builder=nil,&blk)
+    if blk
+      path = caller_locations(1,1)[0].absolute_path
+      result = if builder
+        builder.build({}, &blk)
+      else
+        Alki::Dsl::Registry.build path, &blk
+      end
+      Alki::Dsl[path] = result
+    end
+    ::Alki
+  end
+end

data/lib/alki/dsls/class.rb

@@ -0,0 +1,31 @@
+require 'alki/dsl/base'
+require 'alki/dsl/class_helpers'
+require 'alki/class_builder'
+
+module Alki
+  module Dsls
+    class Class < Alki::Dsl::Base
+      include Alki::Dsl::ClassHelpers
+
+      self::Helpers = Alki::Dsl::ClassHelpers
+
+      def self.dsl_info
+        {
+          methods: %i(class_methods),
+          finish: :finish
+        }
+      end
+
+      def class_methods(&blk)
+        unless ctx[:module].const_defined? :ClassMethods
+          ctx[:module].const_set :ClassMethods, Module.new
+        end
+        ctx[:module]::ClassMethods.class_exec &blk
+      end
+
+      def finish
+        ctx[:class] = Alki::ClassBuilder.build class_builder
+      end
+    end
+  end
+end

data/lib/alki/dsls/dsl.rb

@@ -0,0 +1,78 @@
+require 'alki/dsl/base'
+require 'alki/support'
+require 'alki/dsl/class_helpers'
+
+module Alki
+  module Dsls
+    class Dsl < Alki::Dsl::Base
+      include Alki::Dsl::ClassHelpers
+      Helpers = Alki::Dsl::ClassHelpers
+
+      def self.dsl_info
+        {
+          requires: ['alki/dsls/class'],
+          methods: [
+            :dsl_method,
+            [:init,:dsl_init],
+            [:finish,:dsl_finish],
+            :require_dsl,
+            :helper,
+            :helper_module
+          ],
+          init: :init,
+          finish: :finish
+        }
+      end
+
+      def init
+        @info = {
+          methods: [],
+          requires: []
+        }
+        @helper_modules = []
+        @helpers = {}
+      end
+
+      def dsl_method(name, &blk)
+        method_name = name.to_sym
+        add_method method_name, private: true, &blk
+        @info[:methods] << [name.to_sym,method_name]
+      end
+
+      def dsl_init(&blk)
+        add_method :_dsl_init, private: true, &blk
+        @info[:init] = :_dsl_init
+      end
+
+      def dsl_finish(&blk)
+        add_method :_dsl_finish, private: true, &blk
+        @info[:finish] = :_dsl_finish
+      end
+
+      def require_dsl(dsl)
+        dsl_class = Alki::Support.load_class(dsl)
+        @info[:requires] << dsl_class
+        if defined? dsl_class::Helpers
+          add_module dsl_class::Helpers
+          add_helper_module dsl_class::Helpers
+        end
+      end
+
+      def helper(name,&blk)
+        add_helper name, &blk
+      end
+
+      def helper_module(mod)
+        add_helper_module mod
+      end
+
+      def finish
+        set_super_class 'alki/dsl/base'
+        info = @info.freeze
+        add_class_method :dsl_info do
+          info
+        end
+      end
+    end
+  end
+end

data/lib/alki/dsls/dsl_config.rb

@@ -0,0 +1,28 @@
+require 'alki/dsl/base'
+
+module Alki
+  module Dsls
+    class DslConfig < Alki::Dsl::Base
+      def self.dsl_info
+        {
+          methods: %i(register register_dir register_lib_dir)
+        }
+      end
+
+      def register(path,*args)
+        path = File.expand_path(path,@ctx[:root])
+        Alki::Dsl::Registry.register path, *args
+      end
+
+      def register_dir(path,*args)
+        path = File.expand_path(path,@ctx[:root])
+        Alki::Dsl::Registry.register_dir path, *args
+      end
+
+      def register_lib_dir(prefix,dsl,**data)
+        path = File.join(@ctx[:root],'lib', prefix)
+        Alki::Dsl::Registry.register_dir path, dsl, data.merge(prefix: prefix)
+      end
+    end
+  end
+end

data/test/feature/config_test.rb

@@ -0,0 +1,19 @@
+require_relative '../test_helper'
+require 'alki/dsl'
+
+describe 'dsl configuration' do
+  before do
+    $LOAD_PATH.unshift fixture_path('example','lib')
+  end
+
+  it 'should be automatically loaded when requiring a dsl' do
+    require 'alki_test/dsls/number'
+    AlkiTest::Dsls::Number.must_be_instance_of Class
+    AlkiTest::Dsls::Number.singleton_methods.must_include :generate
+  end
+
+  it 'should allow using dsls specified in same dsl config' do
+    Kernel.load(fixture_path('example','numbers','three.rb'))
+    AlkiTest::Numbers::Three.new.must_equal 3
+  end
+end

data/test/fixtures/example/config/dsls.rb

@@ -0,0 +1,4 @@
+Alki do
+  register_dir 'numbers', 'alki_test/dsls/number', prefix: 'alki_test/numbers'
+  register_lib_dir 'alki_test/dsls', 'alki/dsls/dsl'
+end

data/test/fixtures/example/lib/alki_test/dsls/number.rb

@@ -0,0 +1,11 @@
+Alki do
+  require_dsl 'alki_test/dsls/value'
+
+  init do
+    self.value = 0
+  end
+
+  dsl_method :succ do
+    self.value += 1
+  end
+end

data/test/fixtures/example/lib/alki_test/dsls/value.rb

@@ -0,0 +1,19 @@
+Alki do
+  require_dsl 'alki/dsls/class'
+
+  helper :value= do |v|
+    ctx[:value] = v
+  end
+
+  helper :value do
+    ctx[:value]
+  end
+
+  finish do
+    create_as_module
+    value = ctx[:value]
+    add_class_method :new do
+      value
+    end
+  end
+end

data/test/fixtures/example/numbers/three.rb

@@ -0,0 +1,5 @@
+Alki do
+  succ
+  succ
+  succ
+end

data/test/integration/class_builder_test.rb

@@ -0,0 +1,148 @@
+require_relative '../test_helper'
+require 'alki/class_builder'
+
+describe Alki::ClassBuilder do
+  describe :build do
+    def build(data={})
+      Alki::ClassBuilder.build data
+    end
+
+    it 'should create and return a new class' do
+      build.must_be_instance_of Class
+    end
+
+    it 'should allow creation of modules' do
+      build(type: :module).must_be_instance_of Module
+    end
+
+    it 'should allow setting instance methods' do
+      obj = build(
+        instance_methods: {
+          test1: {
+            body: -> { :test1 }
+          },
+          test2: {
+            body: -> { :test2 },
+            private: true
+          }
+        }
+      ).new
+      obj.test1.must_equal :test1
+      assert_raises NoMethodError do
+        obj.test2
+      end
+      obj.send(:test2).must_equal :test2
+    end
+
+    it 'should allow setting class methods' do
+      klass = build(
+        class_methods: {
+          test1: {
+            body: -> { :test1 }
+          },
+          test2: {
+            body: -> { :test2 },
+            private: true
+          }
+        }
+      )
+      klass.test1.must_equal :test1
+      assert_raises NoMethodError do
+        klass.test2
+      end
+      klass.send(:test2).must_equal :test2
+    end
+
+    it 'should allow setting super class' do
+      super_class = Class.new
+      build(super_class: super_class).superclass.must_equal super_class
+    end
+
+    it 'should allow setting super class by name' do
+      class AlkiTestClass; end
+      build(super_class: 'alki_test_class').superclass.must_equal AlkiTestClass
+      Object.send :remove_const, :AlkiTestClass
+    end
+
+    it 'should include module and extend module::ClassMethods if provided' do
+      m = Module.new do
+        module self::ClassMethods
+          def test1
+            :test1
+          end
+        end
+        def test2
+          :test2
+        end
+      end
+      klass = build(module: m)
+      klass.included_modules.must_include m
+      klass.test1.must_equal :test1
+      klass.new.test2.must_equal :test2
+    end
+
+    it 'should include modules' do
+      ms = [Module.new,Module.new]
+      klass = build(modules: ms)
+      ms.each do |m|
+        klass.included_modules.must_include m
+      end
+    end
+
+    it 'should extend class_modules' do
+      ms = [
+        Module.new { def test1; :test1; end },
+        Module.new { def test2; :test2; end },
+      ]
+      klass = build(class_modules: ms)
+      klass.test1.must_equal :test1
+      klass.test2.must_equal :test2
+    end
+
+    it 'should create basic #initialize using initialize_params' do
+      obj = build(initialize_params: [:a,:b]).new 1, 2
+      obj.instance_variable_get(:@a).must_equal 1
+      obj.instance_variable_get(:@b).must_equal 2
+    end
+
+    it 'should allow providing a class name' do
+      if defined?(AlkiTestClass)
+        Object.send :remove_const, :AlkiTestClass
+      end
+      build(class_name: "AlkiTestClass")
+      assert(defined?(AlkiTestClass),'Expected AlkiTestClass to be defined')
+      Object.send :remove_const, :AlkiTestClass
+      assert(!defined?(AlkiTestClass))
+    end
+
+    it 'should use name to create class name' do
+      if defined?(AlkiTest::TestClass)
+        Object.send :remove_const, :AlkiTest
+      end
+      build(prefix: '', name: "alki_test/test_class")
+      assert(defined?(AlkiTest::TestClass),'Expected AlkiTest::TestClass to be defined')
+      Object.send :remove_const, :AlkiTest
+    end
+
+    it 'should use prefix and name to create class name' do
+      if defined?(AlkiTest::TestClass)
+        Object.send :remove_const, :AlkiTest
+      end
+      build(prefix: 'alki_test', name: "test_class")
+      assert(defined?(AlkiTest::TestClass),'Expected AlkiTest::TestClass to be defined')
+      Object.send :remove_const, :AlkiTest
+    end
+
+    it 'should allow creating secondary classes' do
+      build(
+        secondary_classes: [
+          {
+            class_name: 'AlkiTestClass'
+          }
+        ]
+      )
+      assert(defined?(AlkiTestClass),'Expected AlkiTestClass to be defined')
+      Object.send :remove_const, :AlkiTestClass
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,13 @@
+$LOAD_PATH.unshift File.expand_path('../../lib',__FILE__)
+
+require 'minitest/autorun'
+
+class Minitest::Spec
+  def root
+    File.expand_path('../..',__FILE__)
+  end
+
+  def fixture_path(*path)
+    File.join(root,'test','fixtures',*path)
+  end
+end

data/test/unit/evaluator_test.rb

@@ -0,0 +1,6 @@
+require_relative '../test_helper'
+require 'alki/dsl/evaluator'
+
+describe Alki::Dsl::Evaluator do
+
+end

metadata

@@ -0,0 +1,109 @@
+--- !ruby/object:Gem::Specification
+name: alki-dsl
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Matt Edlefsen
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-12-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: alki-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.3'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.9.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 5.9.1
+description: Library for defining and using DSLs
+email:
+- matt.edlefsen@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- alki-dsl.gemspec
+- lib/alki/class_builder.rb
+- lib/alki/dsl.rb
+- lib/alki/dsl/base.rb
+- lib/alki/dsl/builder.rb
+- lib/alki/dsl/class_helpers.rb
+- lib/alki/dsl/evaluator.rb
+- lib/alki/dsl/loader.rb
+- lib/alki/dsl/registry.rb
+- lib/alki/dsl/version.rb
+- lib/alki/dsls/class.rb
+- lib/alki/dsls/dsl.rb
+- lib/alki/dsls/dsl_config.rb
+- test/feature/config_test.rb
+- test/fixtures/example/config/dsls.rb
+- test/fixtures/example/lib/alki_test/dsls/number.rb
+- test/fixtures/example/lib/alki_test/dsls/value.rb
+- test/fixtures/example/numbers/three.rb
+- test/integration/class_builder_test.rb
+- test/test_helper.rb
+- test/unit/evaluator_test.rb
+homepage: https://github.com/medlefsen/alki-dsl
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Alki dsl library
+test_files:
+- test/feature/config_test.rb
+- test/fixtures/example/config/dsls.rb
+- test/fixtures/example/lib/alki_test/dsls/number.rb
+- test/fixtures/example/lib/alki_test/dsls/value.rb
+- test/fixtures/example/numbers/three.rb
+- test/integration/class_builder_test.rb
+- test/test_helper.rb
+- test/unit/evaluator_test.rb