templet_rails 0.1.0

data/lib/generators/templet/templates/core/helpers/app.rb

@@ -0,0 +1,4 @@
+
+module App
+end
+

data/lib/generators/templet/templates/core/helpers/templet_helper.rb

@@ -0,0 +1,10 @@
+
+#require 'templet/require_all'
+#require 'app'
+
+module TempletHelper
+  def icon(name)
+     "<span class='glyphicon glyphicon-#{name}'></span>".html_safe
+  end
+end
+

data/lib/generators/templet/templates/core/spec/support/apis/api_helper.rb

@@ -0,0 +1,13 @@
+
+module ApiHelper
+  include Rack::Test::Methods
+
+  def app
+    Rails.application
+  end
+end
+
+RSpec.configure do |config|
+  config.include ApiHelper, type: :api
+end
+

data/lib/generators/templet/templates/core/spec/support/apis/shared_examples_a_json_controller.rb

@@ -0,0 +1,196 @@
+
+require 'json'
+
+unless defined? UNPROCESSABLE_ENTITY
+  STATUS_SUCCESS, STATUS_CREATED, STATUS_NO_CONTENT = 200, 201, 204
+
+  UNPROCESSABLE_ENTITY = 422
+end
+
+shared_examples 'a json controller' do |actions|
+  # Naming the model and its belongs_to dependent
+  let(:model_name) { new_model.model_name }
+
+  let(:model_singular) { model_name.to_s }
+
+  #let(:model_plural) { model_name.plural }
+  let(:model_plural) { model_singular.to_s.pluralize.to_sym }
+
+  let(:model_class) { new_model.class }
+
+  let(:parent_name) { nil }
+
+  let(:parent) { parent_name and new_model.send(parent_name) }
+
+  #let(:foster_parent) { parent_name and create(parent_name) }
+
+  # Rest paths
+
+  #let :foster_parent_path do
+  #  foster_parent ? "/#{foster_parent.model_name.plural}/#{foster_parent.id}" : ''
+  #end
+
+  let(:scope) { nil }
+
+  let(:controller_name) { model_plural }
+
+  let(:scoped) { scope ? "#{scope}/" : '' }
+
+  let(:parent_elements) { parent ? "/#{parent.model_name.plural}/#{parent.id}" : '' }
+
+  let(:collection_path) { "#{scoped}#{parent_elements}/#{controller_name}" }
+
+  let(:member_path) { "#{collection_path}/#{model.id}" }
+
+  # Model sample field names and values
+
+  let(:field_name) { :name }
+
+  let(:field_value) { 'Previous' }
+
+  let(:new_field_value) { 'Latest' }
+
+  let(:invalid_field_value) { '' }
+
+  let(:invalid_text) { 'blank' }
+
+  let(:field_values) { %w(First Second Third) }
+
+  # Model instances
+
+  let(:new_model) { build model_singular, field_name => field_value }
+
+  let(:model) { create model_singular, field_name => field_value }
+
+  let(:models) do
+    field_values.map {|name| create model_singular, field_name => name }
+  end
+
+  # Request parameters
+
+  def model_params(**params)
+    { model_singular => params }
+  end
+
+  let(:format) { { format: :json } }
+
+  # Utilities
+
+  def json(response)
+    JSON.parse response.body
+  end
+
+  def extract(response, key=nil)
+    parsed = json response
+
+    if block_given?
+      yield parsed
+    else
+      parsed[key.to_s]
+    end
+  end
+
+  def find_model(value=new_field_value)
+    model_class.find_by(field_name => value)
+  end
+
+  if not actions or actions.include? :index
+    describe "GET #index" do
+      it "shows models" do
+        models
+
+        response = get(collection_path, format)
+
+        expect(response.status).to eq STATUS_SUCCESS
+
+        values = extract(response) do |atts_array|
+                   atts_array.map {|atts| atts[field_name.to_s] }
+                 end
+
+        expect(values).to eq field_values
+      end
+    end
+  end
+
+  if not actions or actions.include? :show
+    describe "GET #show" do
+      it "shows model" do
+        response = get(member_path, format)
+
+        expect(response.status).to eq STATUS_SUCCESS
+
+        expect(extract response, field_name).to eq field_value
+      end
+    end
+  end
+
+  if not actions or actions.include? :create
+    describe "POST #create" do
+      it "saves valid model" do
+        params = model_params(field_name => new_field_value).merge format
+
+        response = post(collection_path, params)
+
+        expect(response.status).to eq STATUS_CREATED
+
+        expect(extract response, field_name).to eq new_field_value
+
+        expect(find_model[field_name]).to eq new_field_value
+      end
+
+      it "handles invalid model" do
+        params = model_params(field_name => invalid_field_value).merge format
+
+        response = post(collection_path, params)
+
+        expect(response.status).to eq UNPROCESSABLE_ENTITY
+
+        expect(extract(response, field_name).first).to match /#{invalid_text}/
+      end
+    end
+  end
+
+  if not actions or actions.include? :update
+    describe "PUT #update" do
+      it "alters valid model" do
+        params = model_params(field_name => new_field_value).merge format
+
+        response = put(member_path, params)
+
+        expect(response.status).to eq STATUS_SUCCESS
+
+        expect(extract response, field_name).to eq new_field_value
+
+        expect(find_model[field_name]).to eq new_field_value
+      end
+
+      it "handles invalid model" do
+        params = model_params(field_name => invalid_field_value).merge format
+
+        response = put(member_path, params)
+
+        expect(response.status).to eq UNPROCESSABLE_ENTITY
+
+        expect(extract(response, field_name).first).to match /#{invalid_text}/
+      end
+    end
+  end
+
+  if not actions or actions.include?(:delete) or actions.include?(:destroy)
+    describe "DELETE #destroy" do
+      it "deletes model" do
+        model
+
+        expect { delete(member_path, format) }
+          .to change { model_class.count }
+          .by(-1)
+      end
+
+      it "returns no_content status" do
+        response = delete(member_path, format)
+
+        expect(response.status).to eq STATUS_NO_CONTENT
+      end
+    end
+  end
+end

data/lib/generators/templet/templates/core/spec/support/core/model_parent_helpers.rb

@@ -0,0 +1,36 @@
+
+module ModelParentHelpers
+  def self.included(base)
+    base.class_eval do
+      # TODO: change!
+      let(:scope) { nil }
+
+      # TODO: change!
+      let(:new_model) { build :answer }
+
+      # TODO: change!
+      let(:model) { create :answer }
+
+      # TODO: change!
+      let(:parent) { model.question }
+
+      # TODO: change!
+      let(:grand_parent) { parent.category }
+
+      # The following can be left alone
+
+      let(:model_plural) { model.model_name.plural }
+
+      let(:parent_plural) { parent.model_name.plural }
+
+      let(:grand_parent_singular) { grand_parent.model_name.singular }
+
+      let(:grand_parent_plural) { grand_parent.model_name.plural }
+    end
+  end
+
+  def path_re(prefix: '', suffix: '', parent: parent_plural, model: model_plural)
+    %r(^#{prefix}#{scope and '/' + scope}/#{parent}/\d+/#{model}#{suffix}$)
+  end
+end
+

data/lib/generators/templet/templates/core/spec/support/core/rest_link_procs_assignments.rb

@@ -0,0 +1,43 @@
+
+require 'active_support/concern'
+
+module RestLinkProcsAssignments
+  extend ActiveSupport::Concern
+
+  included do
+    #let(:renderer) { Templet::Renderer.new(self) }
+    let :renderer do
+      Class.new do
+        def call(&block)
+          instance_eval &block
+        end
+
+        def link_to(*args)
+          args
+        end
+      end.new
+    end
+
+    let(:child) { build :answer }
+    let(:model) { child.question }
+    let(:parent) { model.category }
+
+    let(:model_singular) { model.model_name.singular.to_sym }
+    let(:model_plural) { model.model_name.plural.to_sym }
+
+    let(:parent_plural) { parent.model_name.plural.to_sym }
+    let(:parent_singular) { parent.model_name.singular.to_sym }
+
+    let (:single_path) { [ model ] }
+    let (:dual_path) { [ parent, model ] }
+
+    let(:param) { { q: 'jumper' } }
+
+    let(:default_param) { { token: 'book' } }
+
+    let(:param_options) { { default_params: default_param } }
+
+    let(:remote_options) { { remote: true } }
+  end
+end
+

data/lib/generators/templet/templates/core/spec/support/core/rest_link_procs_helpers.rb

@@ -0,0 +1,15 @@
+
+module RestLinkProcsHelpers
+  def link_procs(**options)
+    options.reverse_merge! verify_path: false
+
+    Templet::Links::RestLinkProcs.new(nil, **options)
+  end
+
+  def execute(link_proc, model, parent, **opts)
+    link = link_proc.(renderer, model, parent)
+
+    return link, link[1]
+  end
+end
+

data/lib/generators/templet/templates/core/spec/support/viewer/partial_test_helpers.rb

@@ -0,0 +1,32 @@
+
+require "nokogiri"
+
+module PartialTestHelpers
+  def renderer
+    Templet::Renderer.new helper
+  end
+
+  def partial_for(klass, *args)
+    klass.new(renderer, *args)
+  end
+  def partial(*args, **options)
+    partial_for(described_class, *args, **options)
+  end
+
+  def render_partial(*args, &block)
+    partial.(*args, &block)
+  end
+
+  def parse(html)
+    Nokogiri::HTML(html)
+  end
+
+  def parse_html(selector, single_return: true,
+                           render_args: [],
+                           html: render_partial(*render_args))
+    method = single_return ? :at_css : :css
+
+    parse(html).send(method, selector)
+  end
+end
+

data/lib/generators/templet/templates/core/spec/support/viewer/shared_examples_a_viewer.rb

@@ -0,0 +1,105 @@
+
+#require_relative "partial_test_helpers"
+
+  shared_examples 'a viewer' do |actions|
+    include PartialTestHelpers
+
+    let(:scope) { nil }
+
+    let(:controller_name) { nil }
+
+    let(:model) { create model_name, field_name => field_value }
+
+    let(:parent) { model.send parent_name if model.respond_to?(parent_name || '') }
+
+    let(:new_model) { build model_name, field_name => field_value }
+
+    let(:field_values) { %w(First Second Third) }
+
+    let :models do
+      field_values.map {|value| create model_name, field_name => value }
+    end
+
+    let(:parent_name) { }
+
+    let(:grand_parent_name) { }
+
+    let(:field_name) { :name }
+
+    let(:field_value) { "#{model_name} #{field_name}" }
+
+    let(:input_field_tag) { "input" }
+
+    let(:index_selector) { 'tbody tr td:first' }
+
+    let(:field_selector) { "#{input_field_tag}[id=#{model_name}_#{field_name}]" }
+
+    let(:list_selector) { 'dl dd:first' }
+
+    def viewer(model, parent=nil, **opts)
+      if scope or controller_name
+        opts[:controller] = (scope ? "#{scope}/" : '') +
+                            (controller_name&.to_s || model_name.to_s.pluralize)
+      end
+
+      opts[:grand_parent] = grand_parent_name if grand_parent_name
+
+      described_class.new helper, model, parent, **opts
+    end
+
+    if not actions or actions.include? :index
+      describe '#index' do
+        it "shows model queries" do
+          html = viewer(model_name, parent, models: models).index
+
+          queries = parse_html(index_selector, html: html, single_return: false)
+
+          expect(queries.map(&:text)).to eq field_values
+        end
+      end
+    end
+
+    if not actions or actions.include? :show
+      describe '#show' do
+        it 'displays field value' do
+          html = viewer(model, parent).show
+
+          value = parse_html(list_selector, html: html).text
+
+          expect(value).to eq field_value
+        end
+      end
+    end
+
+    if not actions or actions.include? :new
+      describe '#new' do
+        it 'prompts for field value' do
+          helper.instance_variable_set("@#{model_name}", new_model)
+
+          html = viewer(new_model, parent).new
+
+          selected = parse_html(field_selector, html: html)
+
+          value = selected['value'] || selected.text
+
+          expect(value.strip).to eq field_value
+       end
+      end
+    end
+
+    if not actions or actions.include? :edit
+      describe '#edit' do
+        it 'prompts for field value' do
+          helper.instance_variable_set("@#{model_name}", model)
+
+          html = viewer(model, parent).edit
+
+          selected = parse_html(field_selector, html: html)
+
+          value = selected['value'] || selected.text
+
+          expect(value.strip).to eq field_value
+        end
+      end
+    end
+  end