nm 0.5.4 → 0.6.0

data/test/unit/render_tests.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "assert"
+require "nm/render"
+
+class Nm::Render
+  class UnitTests < Assert::Context
+    desc "Nm::Render"
+    subject{ unit_class }
+
+    let(:unit_class){ Nm::Render }
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    subject{ unit_class.new(dstack: dstack, locals: locals) }
+
+    let(:dstack){ [] }
+    let(:locals){ {} }
+
+    should have_readers :dstack, :locals
+
+    should "know its attributes" do
+      assert_that(subject.dstack).equals(dstack)
+      assert_that(subject.locals).equals(locals)
+    end
+  end
+end

data/test/unit/source_tests.rb

@@ -1,155 +1,138 @@
-require 'assert'
-require 'nm/source'
+# frozen_string_literal: true
 
-require 'nm/template'
+require "assert"
+require "nm/source"
 
-class Nm::Source
+require "nm/context"
 
+class Nm::Source
   class UnitTests < Assert::Context
     desc "Nm::Source"
-    setup do
-      @source_class = Nm::Source
-    end
-    subject{ @source_class }
+    subject{ unit_class }
 
+    let(:unit_class){ Nm::Source }
   end
 
   class InitTests < UnitTests
     desc "when init"
-    setup do
-      @root = Factory.template_root
-      @source = @source_class.new(@root)
-    end
-    subject{ @source }
+    subject{ source }
 
-    should have_readers :root, :ext, :cache, :template_class
-    should have_imeths :data, :render, :partial
+    let(:root){ Factory.template_root }
+    let(:source){ unit_class.new(root) }
 
-    should "know its root" do
-      assert_equal @root, subject.root.to_s
-    end
-
-    should "know its extension for looking up source files" do
-      assert_nil subject.ext
+    should have_readers :root, :extension, :cache, :locals
+    should have_imeths :data, :render, :file_path!
 
-      ext = Factory.string
-      source = @source_class.new(@root, :ext => ext)
-      assert_equal ".#{ext}", source.ext
-    end
+    should "know its attributes" do
+      assert_that(subject.root.to_s).equals(root)
+      assert_that(subject.extension).is_nil
+      assert_that(subject.cache).is_a(unit_class::NullCache)
+      assert_that(subject.locals).equals({})
 
-    should "not cache templates by default" do
-      assert_kind_of NullCache, subject.cache
+      extension = Factory.string
+      locals = { key: "value" }
+      source =
+        unit_class.new(root, extension: extension, cache: true, locals: locals)
+      assert_that(source.extension).equals(".#{extension}")
+      assert_that(source.cache).is_a(Hash)
+      assert_that(source.locals).equals(locals)
     end
-
-    should "cache templates if the :cache opt is `true`" do
-      source = @source_class.new(@root, :cache => true)
-      assert_kind_of Hash, source.cache
-    end
-
-    should "know its template class" do
-      assert_true subject.template_class < Nm::Template
-    end
-
-    should "optionally take and apply default locals to its template class" do
-      local_name, local_val = [Factory.string, Factory.string]
-      source = @source_class.new(@root, :locals => {
-        local_name => local_val
-      })
-      template = source.template_class.new
-
-      assert_responds_to local_name, template
-      assert_equal local_val, template.send(local_name)
-    end
-
   end
 
   class DataTests < InitTests
     desc "`data` method"
-    setup do
-      @file_path = Factory.template_file('obj.nm')
-    end
+
+    let(:file_path){ Factory.template_file("obj.nm") }
 
     should "read the contents of a given file path" do
-      exp = File.read(@file_path)
-      assert_equal exp, subject.data(@file_path)
+      assert_that(subject.data(file_path)).equals(File.read(file_path))
     end
 
     should "not cache template source by default" do
-      assert_equal [], subject.cache.keys
+      assert_that(subject.cache.keys).equals([])
     end
 
     should "cache template source by file path if enabled" do
-      source = @source_class.new(@root, :cache => true)
+      source = unit_class.new(root, cache: true)
 
-      exp = File.read(@file_path)
-      assert_equal exp, source.data(@file_path)
-      assert_equal [@file_path], source.cache.keys
-      assert_equal exp, source.cache[@file_path]
+      file_data = File.read(file_path)
+      assert_that(source.data(file_path)).equals(file_data)
+      assert_that(source.cache.keys).equals([file_path])
+      assert_that(source.cache[file_path]).equals(file_data)
     end
-
   end
 
   class RenderTests < InitTests
     desc "`render` method"
-    setup do
-      @template_name = ['locals', 'locals_alt'].sample
-      @file_locals = { 'key' => 'a-value' }
-      @file_path = Dir.glob("#{Factory.template_file(@template_name)}*").first
-    end
-
-    should "render a template for the given template name and return its data" do
-      exp = Nm::Template.new(subject, @file_path, @file_locals).__data__
-      assert_equal exp, subject.render(@template_name, @file_locals)
-    end
-
-    should "alias `render` as `partial`" do
-      exp = subject.render(@template_name, @file_locals)
-      assert_equal exp, subject.partial(@template_name, @file_locals)
-    end
-
-    should "only render templates with the matching ext if one is specified" do
-      source = @source_class.new(@root, :ext => 'nm')
-      file_path = Factory.template_file('locals.nm')
-      exp = Nm::Template.new(source, file_path, @file_locals).__data__
-      ['locals', 'locals.nm'].each do |name|
-        assert_equal exp, source.render(name, @file_locals)
-      end
 
-      source = @source_class.new(@root, :ext => 'inem')
-      file_path = Factory.template_file('locals_alt.data.inem')
-      exp = Nm::Template.new(source, file_path, @file_locals).__data__
-      ['locals', 'locals_alt', 'locals_alt.data', 'locals_alt.data.inem'].each do |name|
-        assert_equal exp, source.render(name, @file_locals)
+    let(:custom_context){ Class.new.new }
+    let(:template_name){ ["locals", "locals_alt"].sample }
+    let(:file_path) do
+      Dir.glob("#{Factory.template_file(template_name)}*").first
+    end
+    let(:file_locals){ { "key" => "a-value" } }
+
+    should "render a template for the given name and return its data" do
+      assert_that(subject.render(template_name, locals: file_locals))
+        .equals(
+          Nm::Context
+            .new(Nm.default_context, source: subject, locals: subject.locals)
+            .render(template_name, file_locals),
+        )
+    end
+
+    should "only render templates with the matching extension if specified" do
+      source = unit_class.new(root, extension: "nm")
+      ["locals", "locals.nm"].each do |name|
+        assert_that(subject.render(name, locals: file_locals))
+          .equals(
+            Nm::Context
+              .new(Nm.default_context, source: subject, locals: subject.locals)
+              .render(name, file_locals),
+          )
       end
 
-      source = @source_class.new(@root, :ext => 'nm')
-      ['locals_alt', 'locals_alt.data', 'locals_alt.data.inem'].each do |name|
-        assert_raises(ArgumentError){ source.render(name, @file_locals) }
+      source = unit_class.new(root, extension: "inem")
+      ["locals", "locals_alt", "locals_alt.data", "locals_alt.data.inem"]
+        .each do |name|
+          assert_that(subject.render(name, locals: file_locals))
+            .equals(
+              Nm::Context
+                .new(
+                  Nm.default_context,
+                  source: subject,
+                  locals: subject.locals,
+                )
+                .render(name, file_locals),
+            )
+        end
+
+      source = unit_class.new(root, extension: "nm")
+      ["locals_alt", "locals_alt.data", "locals_alt.data.inem"].each do |name|
+        assert_that{ source.render(name, file_locals) }.raises(ArgumentError)
       end
 
-      source = @source_class.new(@root, :ext => 'data')
-      ['locals_alt', 'locals_alt.data', 'locals_alt.data.inem'].each do |name|
-        assert_raises(ArgumentError){ source.render(name, @file_locals) }
+      source = unit_class.new(root, extension: "data")
+      ["locals_alt", "locals_alt.data", "locals_alt.data.inem"].each do |name|
+        assert_that{ source.render(name, file_locals) }.raises(ArgumentError)
       end
     end
-
   end
 
-  class DefaultSource < UnitTests
-    desc "DefaultSource"
-    setup do
-      @source = Nm::DefaultSource.new
-    end
-    subject{ @source }
+  class FilePathBangTests < InitTests
+    desc "`file_path!` method"
 
-    should "be a Source" do
-      assert_kind_of @source_class, subject
+    let(:template_name){ ["locals", "locals_alt"].sample }
+    let(:file_path) do
+      Dir.glob("#{Factory.template_file(template_name)}*").first
     end
 
-    should "use `/` as its root" do
-      assert_equal '/', subject.root.to_s
+    should "return the file path for the given template name if it exists" do
+      assert_that(subject.file_path!(template_name)).equals(file_path)
     end
 
+    should "complain if the given template name does not exist" do
+      assert_that{ subject.file_path!(Factory.path) }.raises(ArgumentError)
+    end
   end
-
 end

data/test/unit/template_behaviors_tests.rb

@@ -0,0 +1,259 @@
+# frozen_string_literal: true
+
+require "assert"
+require "nm/template_behaviors"
+
+require "nm/context"
+require "nm/ext"
+require "nm/source"
+
+module Nm::TemplateBehaviors
+  class UnitTests < Assert::Context
+    desc "Nm::TemplateBehaviors"
+    subject{ unit_class }
+
+    let(:unit_module){ Nm::TemplateBehaviors }
+  end
+
+  class InitTests < UnitTests
+    desc "when mixed in on an context instance"
+    subject{ context }
+
+    setup do
+      nm_context
+      context.__nm_push_render__({})
+    end
+
+    let(:nm_context) do
+      Nm::Context.new(context, source: source, locals: context_locals)
+    end
+    let(:context){ Class.new.new }
+    let(:template_root){ Factory.template_root }
+    let(:source){ Nm::Source.new(template_root) }
+    let(:context_locals){ {} }
+
+    should have_accessors :__nm_context__
+    should have_imeths :__nm_data__, :__node__, :__map__, :__partial__
+    should have_imeths :node, :_node, :n
+    should have_imeths :map,  :_map,  :m
+    should have_imeths :partial, :_partial, :p
+
+    should "have empty data if no markup meths called or no source given" do
+      assert_that(subject.__nm_data__).equals({})
+    end
+  end
+
+  class NodeMethodTests < InitTests
+    desc "the `__node__` method"
+
+    should "return itself when called" do
+      assert_that(subject.__node__("key", "value")).equals(subject)
+    end
+
+    should "add key-value pairs at the root level" do
+      subject.__node__("a", "Aye")
+      assert_that(subject.__nm_data__).equals({ "a" => "Aye" })
+    end
+
+    should "add key-value pairs at nested levels" do
+      subject.__node__("nested"){ __node__("a", "Aye") }
+      assert_that(subject.__nm_data__)
+        .equals({
+          "nested" => { "a" => "Aye" },
+        })
+    end
+
+    should "be aliased as `node`, `_node` and `n`" do
+      exp = { "a" => "Aye" }
+      assert_that(subject.__node__("a", "Aye").__nm_data__).equals(exp)
+      assert_that(subject.node("a", "Aye").__nm_data__).equals(exp)
+      assert_that(subject._node("a", "Aye").__nm_data__).equals(exp)
+      assert_that(subject.n("a", "Aye").__nm_data__).equals(exp)
+    end
+
+    should "complain if called after a `__map__` call" do
+      subject.__map__([1, 2, 3])
+      assert_that{ subject.__node__("a", "Aye") }.raises(Nm::InvalidError)
+    end
+  end
+
+  class MapMethodTests < InitTests
+    desc "the `map` method"
+
+    let(:list){ [1, 2, 3] }
+
+    should "return itself when called" do
+      assert_that(subject.__map__([], &Proc.new{})).equals(subject)
+    end
+
+    should "map a given list to the data" do
+      assert_that(subject.__map__(list).__nm_data__).equals(list)
+    end
+
+    should "map a given list to node data" do
+      subject.__map__(list){ |item| __node__(item.to_s, item) }
+      assert_that(subject.__nm_data__)
+        .equals(
+          [
+            { "1" => 1 },
+            { "2" => 2 },
+            { "3" => 3 },
+          ],
+        )
+    end
+
+    should "map a given list to node data at a nested level" do
+      list_value = list
+      subject.__node__("list") do
+        __map__(list_value){ |item| __node__(item.to_s, item) }
+      end
+      assert_that(subject.__nm_data__)
+        .equals(
+          {
+            "list" => [
+              { "1" => 1 },
+              { "2" => 2 },
+              { "3" => 3 },
+            ],
+          },
+        )
+    end
+
+    should "be aliased as `map`, `_map` and `m`" do
+      assert_that(subject.__map__(list).__nm_data__).equals(list)
+      assert_that(subject.map(list).__nm_data__).equals(list + list)
+      assert_that(subject._map(list).__nm_data__).equals(list + list + list)
+      assert_that(subject.m(list).__nm_data__).equals(list + list + list + list)
+    end
+
+    should "complain if given a list that doesn't respond to `.map`" do
+      val = 123
+      assert_that(val).does_not_respond_to(:map)
+      assert_that{ subject.__map__(val) }.raises(ArgumentError)
+    end
+
+    should "complain if called after a `__node__` call" do
+      subject.__node__("a", "Aye")
+      assert_that{ subject.__map__([1, 2, 3]) }.raises(Nm::InvalidError)
+    end
+  end
+
+  class PartialMethodTests < InitTests
+    desc "the `partial` method"
+
+    let(:obj_template_name){ "obj" }
+    let(:obj) do
+      {
+        "obj" => {
+          "a" => "Aye",
+          "b" => "Bee",
+          "c" => "See",
+        },
+      }
+    end
+    let(:list_template_name){ "list" }
+    let(:list) do
+      [
+        { "1" => 1 },
+        { "2" => 2 },
+        { "3" => 3 },
+      ]
+    end
+    let(:partial_obj_template_name){ "_obj" }
+    let(:partial_obj) do
+      {
+        "a" => "Aye",
+        "b" => "Bee",
+        "c" => "See",
+      }
+    end
+    let(:partial_list_template_name){ "_list" }
+    let(:partial_list){ list }
+
+    should "return itself when called" do
+      assert_that(subject.__partial__(Factory.template_file("obj")))
+        .equals(subject)
+    end
+
+    should "render a template for the given partial name and add its data" do
+      assert_that(subject.__partial__(partial_obj_template_name).__nm_data__)
+        .equals(partial_obj)
+    end
+
+    should "be aliased as `render`, `_render` and `r`" do
+      assert_that(subject.__partial__(partial_obj_template_name).__nm_data__)
+        .equals(partial_obj)
+      assert_that(subject.partial(partial_obj_template_name).__nm_data__)
+        .equals(partial_obj)
+      assert_that(subject._partial(partial_obj_template_name).__nm_data__)
+        .equals(partial_obj)
+      assert_that(subject.p(partial_obj_template_name).__nm_data__)
+        .equals(partial_obj)
+    end
+
+    should "merge if call returns an obj and called after `__node__`" do
+      subject.__node__("1", "One")
+
+      exp = { "1" => "One" }.merge(partial_obj)
+      assert_that(subject.__partial__(partial_obj_template_name).__nm_data__)
+        .equals(exp)
+    end
+
+    should "complain if call returns an obj and called after `__map__`" do
+      subject.__map__([1, 2, 3])
+      assert_that{ subject.__partial__(partial_obj_template_name).__nm_data__ }
+        .raises(Nm::InvalidError)
+    end
+
+    should "merge if call returns a list and called after `__map__`" do
+      subject.__map__([1, 2, 3])
+
+      exp = [1, 2, 3].concat(partial_list)
+      assert_that(subject.__partial__(partial_list_template_name).__nm_data__)
+        .equals(exp)
+    end
+
+    should "complain if call returns a list and called after `__node__`" do
+      subject.__node__("1", "One")
+
+      assert_that{ subject.__partial__(partial_list_template_name).__nm_data__ }
+        .raises(Nm::InvalidError)
+    end
+  end
+
+  class RenderTests < InitTests
+    desc "and used to render a template"
+
+    let(:context) do
+      Class
+        .new{
+          def helper_method1
+            "helper method value 1"
+          end
+        }
+        .new
+    end
+    let(:context_locals) do
+      {
+        "key1" => "value1",
+        "node" => "A Node",
+        "map" => "A Map",
+      }
+    end
+    let(:render_locals) do
+      { "key2" => "value2" }
+    end
+
+    should "render exposing locals and context methods as expected" do
+      d = nm_context.render("aliases.nm", render_locals)
+      assert_that(d).is_a(::Array)
+      assert_that(d.size).equals(1)
+      assert_that(d.first["node local value"]).equals("A Node")
+      assert_that(d.first["map local value"]).equals("A Map")
+      assert_that(d.first["context method value"])
+        .equals("helper method value 1")
+      assert_that(d.first["context local value"]).equals("value1")
+      assert_that(d.first["render local value"]).equals("value2")
+    end
+  end
+end