templet_rails 0.1.0

data/lib/generators/templet/templates/core/spec/templet/forms/bs_form_errors_spec.rb

@@ -0,0 +1,18 @@
+
+require "rails_helper"
+
+require 'templet/forms/bs_form_errors'
+
+RSpec.describe Templet::Forms::BsFormErrors, type: :helper do
+  include PartialTestHelpers
+
+  let(:model) { build(:category, name: '').tap {|model| model.valid? } }
+
+  it "shows error message" do
+    selector = 'div[id=error_expl] ul li:first'
+
+    message = parse_html(selector, render_args: [model]).text
+
+    expect(message).to match %r(Name.+blank)
+  end
+end

data/lib/generators/templet/templates/core/spec/templet/forms/bs_form_spec.rb

@@ -0,0 +1,58 @@
+
+require "rails_helper"
+
+require 'templet/forms/bs_form'
+
+RSpec.describe Templet::Forms::BsForm, type: :helper do
+  include PartialTestHelpers
+
+  include ModelParentHelpers
+
+  def rest_path(model, parent=nil, **options)
+    Templet::Links::RestPath.new model, parent, **options.merge(scope: scope)
+  end
+
+  def parse_form_html(selector, model)
+    path = rest_path(model, parent)
+
+    html = render_partial(url: path) {}
+
+    parse_html(selector, html: html)
+  end
+
+  def expect_action(url_matcher, model=model())
+    selector = 'form[role=form]'
+
+    action = parse_form_html(selector, model)['action']
+
+    expect(action).to match url_matcher
+  end
+
+  def expect_method(http_method, model=model())
+    selector = 'input[name=_method]'
+
+    method_value = parse_form_html(selector, model)['value']
+
+    expect(method_value).to eq http_method
+  end
+
+  describe 'form action' do
+    it "has new model url" do
+      expect_action path_re, new_model
+    end
+
+    it "has persisted model url" do
+      expect_action path_re(suffix: '/\d+')
+    end
+  end
+
+  describe 'form method' do
+    it "is POST for new model" do
+      expect_method 'post', new_model
+    end
+
+    it "is PATCH for persisted model" do
+      expect_method 'patch'
+    end
+  end
+end

data/lib/generators/templet/templates/core/spec/templet/layout/html_rails_spec.rb

@@ -0,0 +1,64 @@
+
+require "rails_helper"
+
+require "nokogiri"
+
+require 'templet/layouts/html_rails'
+
+RSpec.describe Templet::Layouts::HtmlRails, type: :helper do
+  let(:layout) { Templet::Layouts::HtmlRails.new helper }
+
+  def render_layout(title: 'Mister', description: 'Nice', content: 'Guy')
+    layout.(title, description) { content }
+  end
+
+  def parse(html)
+    Nokogiri::HTML(html)
+  end
+
+  def parse_html(selector, single_return: true, html: render_layout)
+    method = single_return ? :at_css : :css
+
+    parse(html).send(method, selector)
+  end
+
+  it "includes viewport" do
+    content = parse_html('head meta[name=viewport]')['content']
+
+    expect(content).to match %r(width=.+initial-scale=)
+  end
+
+  describe 'Rails assets' do
+    it 'includes stylesheets' do
+      href = parse_html('head link[rel=stylesheet]')['href']
+
+      expect(href).to match %r(^/assets/application-.+\.css$)
+    end
+
+    it 'includes javascript' do
+      src = parse_html('head script')['src']
+
+      expect(src).to match %r(^/assets/application-.+\.js$)
+    end
+  end
+
+  describe "page params" do
+    it "includes title" do
+      title = parse_html('head title').text
+
+      expect(title).to eq("Mister")
+    end
+
+    it "includes description" do
+      description = parse_html('head meta[name=description]')['content']
+
+      expect(description).to eq("Nice")
+    end
+  end
+
+  it "includes body" do
+    body = parse_html('html body').text
+
+    expect(body).to eq("Guy")
+  end
+end

data/lib/generators/templet/templates/core/spec/templet/links/bs_link_set_collection_spec.rb

@@ -0,0 +1,79 @@
+
+require "rails_helper"
+
+require 'templet/links'
+
+RSpec.describe Templet::Links::BsLinkSetCollection, type: :helper do
+  include PartialTestHelpers
+
+  include ModelParentHelpers
+
+  def scoped_partial(*args, **options)
+    partial(*args, **options.merge(scope: scope)).call
+  end
+
+  describe 'link count' do
+    it "has two without parent" do
+      links = scoped_partial(grand_parent, nil)
+
+      expect(links.size).to eq 2
+    end
+
+    it "has three with parent" do
+      links = scoped_partial(model, parent, grand_parent_singular)
+
+      expect(links.size).to eq 3
+    end
+  end
+
+  describe 'parent link' do
+    it "has href to grand_parent index" do
+      links = scoped_partial(parent, grand_parent)
+
+      re = %r(href="#{scope and '/' + scope}/#{grand_parent_plural}")
+
+      expect(links.first).to match re
+    end
+
+    it "has href to parent index" do
+      links = scoped_partial(model, parent, grand_parent_plural.singularize)
+
+      re = path_re prefix: '.+href="', suffix: '".+',
+                   parent: grand_parent_plural, model: parent_plural
+
+      expect(links.first).to match re
+    end
+  end
+
+  describe 'index link' do
+    it "has href" do
+      links = scoped_partial(model, parent, grand_parent_singular)
+
+      re = path_re prefix: '.+href="', suffix: '".+'
+
+      expect(links.second).to match re
+    end
+  end
+
+  describe 'new link' do
+    it "has href" do
+      links = scoped_partial(model, parent, grand_parent_singular)
+
+      re = path_re prefix: '.+href="', suffix: '/new".+'
+
+      expect(links.last).to match re
+    end
+  end
+
+  describe 'param passing' do
+    it "has default param" do
+      param = { token: 'book' }
+
+      options = { default_params: param }
+
+      links = scoped_partial(model, parent, grand_parent_singular, **options)
+
+      expect(links.first).to match %r(\?token=book)
+    end
+  end
+end

data/lib/generators/templet/templates/core/spec/templet/links/rest_link_procs_params_spec.rb

@@ -0,0 +1,68 @@
+
+require "rails_helper"
+
+require 'templet/links'
+
+RSpec.describe Templet::Links::RestLinkProcs, type: :helper do
+  include PartialTestHelpers
+
+  include RestLinkProcsHelpers
+  include RestLinkProcsAssignments
+
+  def link_method(action)
+    "#{action}_link"
+  end
+
+  def orphaned(with_parent)
+    with_parent ? parent : nil
+  end
+
+  describe 'Parameter passing' do
+    %w(index show delete).each do |action|
+      [ false, true ].each do |with_parent|
+        desc = "#{action} parameters with#{with_parent ? '' : :out} parent"
+
+        describe desc do
+          it 'passes direct params' do
+            link_proc = link_procs.send(link_method(action), params: param)
+
+            _, path = execute(link_proc, model, orphaned(with_parent))
+
+            expect(path.last).to eq param
+          end
+
+          it 'uses default params' do
+            link_proc = link_procs(param_options).send(link_method(action))
+
+            _, path = execute(link_proc, model, orphaned(with_parent))
+
+            expect(path.last).to eq default_param
+          end
+
+          it 'passes direct params and uses default params' do
+            link_procs = link_procs(param_options)
+
+            link_proc = link_procs.send(link_method(action), params: param)
+
+            _, path = execute(link_proc, model, orphaned(with_parent))
+
+            expect(path.last).to eq default_param.merge(param)
+          end
+        end
+      end
+    end
+  end
+
+=begin
+  describe 'param passing' do
+    it "has param" do
+
+      link = link_proc.index_link(params: param).(renderer, question, category)
+
+      expect(link).to match %r(\?.*q=jumper)
+
+      expect(link).to match %r(\?.*token=book)
+    end
+  end
+=end
+end

data/lib/generators/templet/templates/core/spec/templet/links/rest_link_procs_parents_spec.rb

@@ -0,0 +1,78 @@
+
+require "rails_helper"
+
+require 'templet/links'
+
+RSpec.describe Templet::Links::RestLinkProcs, type: :helper do
+  include PartialTestHelpers
+
+  include RestLinkProcsHelpers
+  include RestLinkProcsAssignments
+
+  describe 'parent link' do
+    let (:gp_opts) { { grand_parent: parent_singular } }
+
+    describe '#index' do
+      it 'has path of parent' do
+        _, path = execute(link_procs.index_parent_link, model, parent)
+
+        expect(path).to eq [parent_plural]
+      end
+
+      it 'has path of grand parent' do
+       link_proc = link_procs.index_parent_link(**gp_opts)
+
+        _, path = execute(link_proc, child, model)
+
+        expect(path).to eq [parent, model_plural]
+      end
+    end
+
+    describe '#show' do
+      it 'has path of parent' do
+        _, path = execute(link_procs.show_parent_link, model, parent)
+
+        expect(path).to eq [parent]
+      end
+
+      it 'has path of grand parent' do
+        link_proc = link_procs.show_parent_link(**gp_opts)
+        _, path = execute(link_proc, child, model)
+
+        expect(path).to eq [parent, model]
+      end
+    end
+
+    describe '#new' do
+      it 'has path of parent' do
+        _, path = execute(link_procs.new_parent_link, model, parent)
+
+        expect(path).to eq [:new, parent_singular]
+      end
+
+      it 'has path of grand parent' do
+       link_proc = link_procs.new_parent_link(**gp_opts)
+
+        _, path = execute(link_proc, child, model)
+
+        expect(path).to eq  [:new, parent, model_singular]
+      end
+    end
+
+    describe '#edit' do
+      it 'has path of parent' do
+        _, path = execute(link_procs.edit_parent_link, model, parent)
+
+        expect(path).to eq [:edit, parent]
+      end
+
+      it 'has path of grand parent' do
+       link_proc = link_procs.edit_parent_link(**gp_opts)
+
+        _, path = execute(link_proc, child, model)
+
+        expect(path).to eq  [:edit, parent, model]
+      end
+    end
+  end
+end

data/lib/generators/templet/templates/core/spec/templet/links/rest_link_procs_spec.rb

@@ -0,0 +1,140 @@
+
+require "rails_helper"
+
+require 'templet/links'
+
+RSpec.describe Templet::Links::RestLinkProcs, type: :helper do
+  include PartialTestHelpers
+
+  include RestLinkProcsHelpers
+  include RestLinkProcsAssignments
+
+  describe 'link path' do
+    describe '#index' do
+      describe 'unnamed' do
+        it 'has path with model' do
+          _, path = execute(link_procs.index_link, model, nil)
+
+          expect([model_plural]).to eq path
+          expect(path).to eq [model_plural]
+        end
+
+        it 'has path with model and parent' do
+          _, path = execute(link_procs.index_link, model, parent)
+
+          expect(path).to eq [parent, model_plural]
+        end
+      end
+
+      describe 'named' do
+        it 'has path with no model' do
+          _, path = execute(link_procs.index_link(name: :dropper), nil, nil)
+
+          expect(path).to eq %i(droppers)
+        end
+
+        it 'has path with model' do
+          _, path = execute(link_procs.index_link(name: :dropper), model, nil)
+
+          expect(path).to eq [model, :droppers]
+        end
+
+        it 'has path with model and parent' do
+          _, path = execute(link_procs.index_link(name: :dropper), model, parent)
+
+          expect(path).to eq [model, :droppers]
+        end
+      end
+    end
+
+    describe '#show' do
+      it 'has path with model' do
+        _, path = execute(link_procs.show_link, model, nil)
+
+        expect(path).to eq single_path
+      end
+
+      it 'has path with model and parent' do
+        _, path = execute(link_procs.show_link, model, parent)
+
+        expect(path).to eq dual_path
+      end
+    end
+
+    describe '#new' do
+      describe 'unnamed' do
+        it 'has path with model' do
+          _, path = execute(link_procs.new_link, model, nil)
+
+          expect(path).to eq [:new, model_singular]
+        end
+
+        it 'has path with model and parent' do
+          _, path = execute(link_procs.new_link, model, parent)
+
+          expect(path).to eq [:new, parent, model_singular]
+        end
+      end
+
+      describe 'named' do
+        it 'has path with no model' do
+          _, path = execute(link_procs.new_link(name: :dropper), nil, nil)
+
+          expect(path).to eq %i(new dropper)
+        end
+
+        it 'has path with model' do
+          _, path = execute(link_procs.new_link(name: :dropper), model, nil)
+
+          expect(path).to eq [:new, model, :dropper]
+        end
+
+        it 'has path with model and parent' do
+          _, path = execute(link_procs.new_link(name: :dropper), model, parent)
+
+          expect(path).to eq [:new, model, :dropper]
+        end
+      end
+    end
+
+    describe '#edit' do
+      it 'has path with model' do
+        _, path = execute(link_procs.edit_link, model, nil)
+
+        expect(path).to eq %i(edit) + single_path
+      end
+
+      it 'has path with model and parent' do
+        _, path = execute(link_procs.edit_link, model, parent)
+
+        expect(path).to eq %i(edit) + dual_path
+      end
+    end
+
+    describe '#delete' do
+      it 'has path with model' do
+        _, path = execute(link_procs.delete_link, model, nil)
+
+        expect(path).to eq single_path
+      end
+
+      it 'has path with model and parent' do
+        _, path = execute(link_procs.delete_link, model, parent)
+
+        expect(path).to eq dual_path
+      end
+
+      it 'uses delete method' do
+        link, _ = execute(link_procs.delete_link, model, parent)
+
+        expect(link[2][:method]).to eq :delete
+      end
+
+      it 'has confirm data' do
+        link, _ = execute(link_procs.delete_link, model, parent)
+
+        expect(link[2][:data][:confirm]).to match /Delete/
+      end
+    end
+  end
+end