alki-dsl 0.3.4 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 950660806cfbd74f9c85f33cb0aa9279d5337e07
-  data.tar.gz: 7cf697039eaad23ce522769d0e08c735e6d52d41
+  metadata.gz: 74a68f3b18db59488fcbe8c2037b3933f33aef5d
+  data.tar.gz: '070150789ebbd1bc8b2615395c3e803c0b259913'
 SHA512:
-  metadata.gz: 3c5ab25ef97f889ca268c34718ba26eade49cdb7d2f0f00b848d2212f82d1bc25b4873a78cc5028e21e717cbc1ce9c40f45d593da618c17a95fc9e84b7461433
-  data.tar.gz: 54e8939ddd2a280267d5ca38b21d587296eeb22d43fee1da5683dc48aa73aadea98ea5235ddc3536e4d62d94389a5e8007059520b0bf3dc558bbdd52b4c5b710
+  metadata.gz: 420aa794f86a9c2339e784cabd08260d304f500e4c6d6b9731e4b66c7d607153f89a6e1fb3f570a54040a475b7c16e0dbed658f237fd5bab1ee163cbc1e84742
+  data.tar.gz: 2a8a0cc25a0fe87a36fe278f5c3ee4768d4816650ead0354dda92e4861ff15e418e5b263ac04e78ef009db02303da87cacc6d996cf667e252dda54d5c2ec2eea

data/README.adoc

@@ -0,0 +1,277 @@
+# Alki::Dsl
+
+Alki::Dsl is a library for building DSLs. The resulting DSL buliders can be used standalone or as builders for
+https://github.com/alki-project/alki-loader[Alki::Loader].
+
+Alki::Dsl also allows composing and extending DSLs and comes with built in DSLs for building classes and
+new DSLs.
+
+## Synopsis
+
+```ruby
+require 'alki/dsl'
+
+strings_dsl = Alki::Dsl.build 'alki/dsls/dsl' do
+  init do
+    @strings = []
+  end
+
+  dsl_method :add do |val|
+    @strings << val
+  end
+
+  finish do
+    ctx[:result] = @strings.join("\n")
+  end
+end
+
+val = strings_dsl.build do
+  add "hello"
+  add "world"
+end
+
+puts val
+
+# output:
+# hello
+# world
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'alki-dsl'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install alki-dsl
+
+## Usage
+
+All DSLs created with Alki::Dsl are Class objects with `::build` methods. These build methods take an optional
+hash of parameters, along with a ruby block to be evaluated. DSLs created with Alki::Dsl cannot directly
+strings.
+
+While DSLs can be created with Alki::Dsl manually, the easiest way is to use the provided "dsl" DSL. Each
+DSL defines any number of "dsl methods", which are methods that will be exposed to the user of the DSL.
+The DSL can also define "init" and "finish" blocks which will be run before and after the DSL is evaluated.
+
+DSLs can "require" other DSLs, causing both of their methods to be available to the user.
+
+DSLs are always evaluated within a new instance, so instance variables can be used to store state, however
+these will not be accessible to other DSLs being evaluated at the same time (via requires).
+
+Data is passed into and out of a DSL via the `ctx` hash. It is initially set using the hash provided to the
+DSLs build method, but can be updated by code in the DSL. Unlike instance variables, all DSLs being run share
+a single ctx hash, so it can be used to pass data between them.
+
+The result of the build method will either be the full ctx hash, or just the value of `ctx[:result]` if it
+exists (including if it's set to false or nil).
+
+```ruby
+require 'alki/dsl'
+
+strings_dsl = Alki::Dsl.build 'alki/dsls/dsl' do
+  init do # Init block, runs before any dsl methods are called
+    ctx[:strings] = [] # Store strings in ctx so other DSLs can access them
+  end
+
+  dsl_method :add do |val| # Simple dsl method called "add"
+    ctx[:strings] << val
+  end
+
+  finish do # Finish block, runs after any dsls methods are called
+    sep = ctx[:separator] || "\n" # Allow caller of dsl to set the separator
+    ctx[:result] = ctx[:strings].join(sep) # Set ctx[:result] so we only return this value
+  end
+end
+
+my_dsl = Alki::Dsl.build 'alki/dsls/dsl' do
+  require_dsl strings_dsl # Require other DSL. Value can also be a "load" string (see Alki::Loader section)
+
+  init do # This init block will be run *after* the strings_dsl one
+    @transform = nil
+  end
+
+  dsl_method :transform do |&blk|
+    @transform = blk # Don't need to share this, so just use instance variable
+  end
+
+  finish do # This finish block will be run *before* the strings_dsl one.
+    if @transform
+      ctx[:strings].map! &@transform
+    end
+  end
+end
+
+result = my_dsl.build(separator: ', ') do # Pass in a separator via data hash
+  transform(&:capitalize)
+
+  add "hello"
+  add "world"
+end
+
+puts result
+
+# output: Hello, World
+
+```
+
+### Using with Alki::Loader
+
+https://github.com/alki-project/alki-loader[Alki::Loader] is library that provides extra functionality
+over base Ruby around loading source files. One of its features is to associate "builder" objects with files
+or directories so that the code within them is processed by the builder object when they are loaded. More
+documentation can be found at the Alki::Loader https://github.com/alki-project/alki-loader[github page].
+
+The DSLs created by Alki::Dsl can be used as Alki::Loader builder objects, allowing DSLs to be used to define
+classes and modules. In addition, because the provided "dsl" DSL creates classes, it can also be used with
+Alki::Loader to allow defining your DSLs in standalone source files.
+
+To get started, in your project create a dsls directory at something like `lib/my_project/dsls`. This will
+be where we put our DSL source files.
+
+To register it create a `lib/alki_loader.rb` file:
+
+.lib/alki_loader.rb
+```ruby
+Alki::Loader.register 'my_project/dsls', builder: 'alki/dsls/dsl'
+```
+
+****
+*Note*: This registers the builder using a string. This is a "load" string and is used frequently in Alki
+projects. When used, the string will be `require`-d and then transformed into a constant name
+(so "alki/dsls/dsl" becomes Alki::Dsls::Dsl) and the resulting class will be used. In addition to less
+typing, this also allows lazy loading behavior, where the file and class are only loaded if needed.
+
+The DSL class can be passed directly instead of the load string.
+****
+
+Now a DSL definition file can be created in `lib/my_project/dsls`. Revisiting the previous example, a "strings"
+can be created.
+
+.lib/my_project/dsls/strings.rb
+```ruby
+Alki do
+  init do
+    ctx[:strings] = []
+  end
+
+  dsl_method :add do |val|
+    ctx[:strings] << val
+  end
+
+  finish do
+    sep = ctx[:separator] || "\n"
+    ctx[:result] = ctx[:strings].join(sep)
+  end
+end
+```
+
+The `Alki do ... end` block is part of Alki::Loader and is required. The rest of the DSL is the same
+as before. When this file is loaded by Ruby, it will create a DSL class called MyProject::Dsls::Strings.
+
+To use we can require the file normally (making sure to add `lib` to the load path and requiring 'alki/dsl'
+first).
+
+```
+$ irb -Ilib
+> require 'alki/dsl'
+> require 'my_project/dsls/strings'
+> MyProject::Dsls::Strings.build do
+>   add "hello"
+>   add "world"
+> end
+ => "hello\nworld"
+>
+```
+
+The second DSL can now be setup the same way. Note that the `require_dsl` value has been replaced with a load
+string.
+
+.lib/my_project/dsls/transformable_strings.rb
+```ruby
+Alki do
+  require_dsl 'my_project/dsls/strings'
+
+  init do
+    @transform = nil
+  end
+
+  dsl_method :transform do |&blk|
+    @transform = blk
+  end
+
+  finish do
+    if @transform
+      ctx[:strings].map! &@transform
+    end
+  end
+end
+```
+
+So what if we want to use our DSL with Alki::Loader as well? First, Alki::Loader requires builders to
+define a constant with the correct name, so we need code to do that. Alki::Dsl comes with a "class" DSL
+that makes this easy. First lets create a new DSL that adapts our transformable_strings DSL into a module
+builder.
+
+.lib/my_project/dsls/strings_class.rb
+```ruby
+Alki do
+  require_dsl 'alki/dsls/class'
+  require_dsl 'my_project/dsls/transformable_strings', :after # This makes it's finish runs before ours
+
+  finish do
+    # Helpers provided by alki/dsls/class
+    create_as_module # Don't need a class, just a module
+    value = ctx[:result]
+    add_class_method(:value) { value }
+  end
+end
+```
+
+Now we can create a new directory, register it with Alki::Loader, and add a file that uses the DSL. Note
+that we can set separator in the Alki::Loader register call. Any data values set here are passed in
+as `ctx` in the DSL.
+
+.lib/alki_loader.rb
+```ruby
+Alki::Loader.register 'my_project/dsls', builder: 'alki/dsls/dsl'
+Alki::Loader.register 'my_project/strings', builder: 'my_project/dsls/strings_class', separator: ', '
+```
+
+.lib/my_project/strings/hello_world.rb
+```ruby
+Alki do
+  transform &:capitalize
+
+  add "hello"
+  add "world"
+end
+```
+
+```
+$ irb -Ilib
+> require 'alki/dsl'
+> require 'my_project/strings/hello_world'
+> MyProject::Strings::HelloWorld.value
+ => "Hello, World"
+>
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/alki-project/alki-dsl. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the http://contributor-covenant.org[Contributor Covenant] code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the http://opensource.org/licenses/MIT[MIT License].
+

data/alki-dsl.gemspec

@@ -17,6 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency 'alki-support', '~> 0.6'
+  spec.add_dependency 'alki-support', '~> 0.7'
+  spec.add_dependency 'alki-loader', '~> 0.1'
   spec.add_development_dependency 'minitest', '~> 5.9', '>= 5.9.1'
 end

data/lib/alki/class_builder.rb

@@ -17,11 +17,9 @@ module Alki
     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]}"
-        )
+      class_name = data[:constant_name]
+      if !class_name && data[:name]
+        class_name = Alki::Support.classify(data[:name])
       end
 
       klass = Alki::Support.constantize class_name, data[:parent_class] if class_name
@@ -40,7 +38,7 @@ module Alki
           raise "#{class_name} already exists as is a #{klass.class}"
         end
         super_class = if data[:super_class]
-          Alki::Support.load_class data[:super_class]
+          Alki.load data[:super_class]
         else
           Object
         end
@@ -59,8 +57,8 @@ module Alki
       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]
+            data = data.merge(parent_class: klass,constant_name: data[:subclass])
+          elsif !data[:constant_name] && !data[:name]
             raise ArgumentError.new("Secondary classes must have names")
           end
           build data

data/lib/alki/dsl.rb

@@ -1,48 +1,10 @@
-require 'alki/dsl/evaluator'
-require 'alki/dsl/registry'
+require 'alki/loader'
 
 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
+      Alki.load(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/dsl/evaluator.rb

@@ -20,29 +20,37 @@ module Alki
         @finishers.reverse_each(&:call)
         clear_dsl_methods mod
 
-        @processors.each do |processor|
-          processor.build data
+        if data.key? :result
+          data[:result]
+        else
+          data
         end
-
-        data
       end
 
       def process_dsl(dsl,data)
         return unless @dsls_seen.add? dsl
         cbs = dsl.generate(data)
+        after_requires = []
         if cbs[:requires]
-          cbs[:requires].each do |required_dsl|
-            process_dsl Alki::Support.load_class(required_dsl), data
+          cbs[:requires].each do |(required_dsl,order)|
+            case order
+              when :before
+                process_dsl Alki.load(required_dsl), data
+              when :after
+                after_requires << [Alki.load(required_dsl), data]
+            end
           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
+        after_requires.each do |process_args|
+          process_dsl *process_args
+        end
       end
 
       def define_dsl_method(mod,name,&blk)
@@ -64,4 +72,4 @@ module Alki
       end
     end
   end
-end
+end

data/lib/alki/dsl/version.rb

@@ -1,5 +1,5 @@
 module Alki
   module Dsl
-    VERSION = '0.3.4'
+    VERSION = '0.4.0'
   end
 end

data/lib/alki/dsls/class.rb

@@ -24,7 +24,7 @@ module Alki
       end
 
       def finish
-        ctx[:class] = Alki::ClassBuilder.build class_builder
+        ctx[:result] = Alki::ClassBuilder.build class_builder
         ctx.delete :class_builder
       end
     end

data/lib/alki/dsls/dsl.rb

@@ -10,7 +10,7 @@ module Alki
 
       def self.dsl_info
         {
-          requires: ['alki/dsls/class'],
+          requires: [['alki/dsls/class',:before]],
           methods: [
             :dsl_method,
             [:init,:dsl_init],
@@ -49,9 +49,9 @@ module Alki
         @info[:finish] = :_dsl_finish
       end
 
-      def require_dsl(dsl)
-        dsl_class = Alki::Support.load_class(dsl)
-        @info[:requires] << dsl_class
+      def require_dsl(dsl, order=:before)
+        dsl_class = Alki.load(dsl)
+        @info[:requires] << [dsl_class,order]
         if defined? dsl_class::Helpers
           add_module dsl_class::Helpers
           add_helper_module dsl_class::Helpers

data/test/feature/config_test.rb

@@ -13,7 +13,7 @@ describe 'dsl configuration' do
   end
 
   it 'should allow using dsls specified in same dsl config' do
-    Kernel.load(fixture_path('example','numbers','three.rb'))
+    require 'alki_test/numbers/three'
     AlkiTest::Numbers::Three.new.must_equal 3
   end
-end
+end

data/test/fixtures/example/lib/alki_loader.rb

@@ -0,0 +1,2 @@
+Alki::Loader.register '../numbers', builder: 'alki_test/dsls/number', name: 'alki_test/numbers'
+Alki::Loader.register 'alki_test/dsls', builder: 'alki/dsls/dsl'

data/test/integration/class_builder_test.rb

@@ -105,11 +105,11 @@ describe Alki::ClassBuilder do
       obj.instance_variable_get(:@b).must_equal 2
     end
 
-    it 'should allow providing a class name' do
+    it 'should allow providing a constant name' do
       if defined?(AlkiTestClass)
         Object.send :remove_const, :AlkiTestClass
       end
-      build(class_name: "AlkiTestClass")
+      build(constant_name: "AlkiTestClass")
       assert(defined?(AlkiTestClass),'Expected AlkiTestClass to be defined')
       Object.send :remove_const, :AlkiTestClass
       assert(!defined?(AlkiTestClass))
@@ -119,16 +119,7 @@ describe Alki::ClassBuilder 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")
+      build(name: "alki_test/test_class")
       assert(defined?(AlkiTest::TestClass),'Expected AlkiTest::TestClass to be defined')
       Object.send :remove_const, :AlkiTest
     end
@@ -137,12 +128,25 @@ describe Alki::ClassBuilder do
       build(
         secondary_classes: [
           {
-            class_name: 'AlkiTestClass'
+            constant_name: 'AlkiTestClass'
           }
         ]
       )
       assert(defined?(AlkiTestClass),'Expected AlkiTestClass to be defined')
       Object.send :remove_const, :AlkiTestClass
     end
+
+    it 'should allow creating subclasses' do
+      build(
+        constant_name: 'AlkiTestClass',
+        secondary_classes: [
+          {
+            subclass: 'Subclass'
+          }
+        ]
+      )
+      assert(defined?(AlkiTestClass::Subclass),'Expected AlkiTestClass::Subclass to be defined')
+      Object.send :remove_const, :AlkiTestClass
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: alki-dsl
 version: !ruby/object:Gem::Version
-  version: 0.3.4
+  version: 0.4.0
 platform: ruby
 authors:
 - Matt Edlefsen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-20 00:00:00.000000000 Z
+date: 2016-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: alki-support
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.6'
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: alki-loader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: minitest
   requirement: !ruby/object:Gem::Requirement
@@ -53,21 +67,18 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - Gemfile
+- README.adoc
 - 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_loader.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
@@ -100,7 +111,7 @@ 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_loader.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

data/lib/alki/dsl/builder.rb

@@ -1,42 +0,0 @@
-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/loader.rb

@@ -1,28 +0,0 @@
-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

@@ -1,76 +0,0 @@
-require 'alki/dsl/loader'
-require 'alki/support'
-
-module Alki
-  module Dsl
-    module Registry
-      @registered_paths = {}
-      @registered_dirs = {}
-
-      def self.registered_paths
-        @registered_paths.keys
-      end
-
-      def self.registered_dirs
-        @registered_dirs.keys
-      end
-
-      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
-        attr_reader :data
-
-        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/dsls/dsl_config.rb

@@ -1,28 +0,0 @@
-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/fixtures/example/config/dsls.rb

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