templet_rails 0.1.0 → 0.2.0

data/Rakefile

@@ -1,10 +1,24 @@
-require "bundler/gem_tasks"
-require "rake/testtask"
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
 
-Rake::TestTask.new(:test) do |t|
-  t.libs << "test"
-  t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'TempletRails'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-task :default => :test
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+#task default: :rspec

data/app/assets/config/templet_rails_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/templet_rails .js
+//= link_directory ../stylesheets/templet_rails .css

data/app/assets/javascripts/templet_rails/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require rails-ujs
+//= require activestorage
+//= require_tree .

data/app/assets/stylesheets/templet_rails/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/templet/json_rendering_helpers.rb

@@ -0,0 +1,12 @@
+
+# Produces output for all JSON requests
+module Templet::JsonRenderingHelpers
+  private
+
+  def json_for(model, status: :ok, in_error: false)
+    model, status = model.errors, :unprocessable_entity if in_error
+
+    { json: model, status: status, location: "#{controller_name}/#{action_name}" }
+  end
+end
+

data/app/controllers/templet/rendering_helpers.rb

@@ -0,0 +1,53 @@
+
+# Helper methods used in controller actions to render views
+module Templet::RenderingHelpers
+  include ActionView::Helpers::JavaScriptHelper
+
+  private
+
+  # Calls a Viewer class
+  def viewer(action, model_name=nil, **options)
+    options = viewer_options.merge(options)
+
+    model_name ||= options.delete(:model_name) || model_name()
+
+    Templet::ViewerCallString.new(action, model_name, **options)
+  end
+
+  # For JS requests
+  def viewer_to_s(*args, **options)
+    options.reverse_merge! wrapper: render_target
+
+    render_to_string inline viewer(*args, **options)
+  end
+  def js(html, target=nil)
+    target ||= "#panel-#{render_target}"
+
+    { js: "$('#{target}').html('#{escape_javascript html}')" }
+  end
+
+  # Invokes the Rails-supplied render option
+  def inline(ruby_code, has_layout=false)
+    { inline: "<%= (#{ruby_code}).html_safe %>", layout: has_layout }
+  end
+
+  # The following methods are defaults that can be overridden in the controller
+
+  # Used by the Viewer extensively, it points to the main instance variable,
+  # is shown in default headings, etc.
+  def model_name
+    controller_name.singularize
+  end
+
+  # Default options passed into the Viewer by each controller action
+  # You can specify the name of a controller's parent model here
+  def viewer_options
+    { controller: params[:controller] }
+  end
+
+  # The HTML id (within the panel) into which JS (remote) output is inserted
+  def render_target
+    :outer
+  end
+end
+

data/app/controllers/templet/viewer_call_string.rb

@@ -0,0 +1,144 @@
+
+module Templet
+  # Constructs a string of Ruby that, when executed, returns a string of HTML.
+  #
+  # It calls a method, named by the given +action+ parameter, on an instance
+  # of the type: Templet::ViewerRest.
+  #
+  # The resultant code statement is executed within the view context
+  # i.e. as if it's called from the inside of an ERb partial.
+  #
+  # It takes this circuitous route to pass various items from the controller
+  # to the view e.g. instance variables, model names, link set controls.
+  class ViewerCallString
+    attr_accessor :action, :controller, :model_name, :parent,
+                  :models, :use_model_name,
+                  :grand_parent, :variables, :wrapper
+
+    attr_accessor :viewer_class
+    #
+    # +action+:: The REST action, i.e. the controller method name
+    #
+    # +controller+:: The name without the suffix 'Controller', but may be prefixed with a scope/namespace
+    #
+    # +model_name+:: The model name, mirroring the model's instance variable
+    #
+    # +parent+:: An actual instance of a model's dependent, i.e. the belongs_to
+    #
+    # +models+:: A list of models, used in the index action, it names the instance variable
+    #
+    # +use_model_name+:: If true, no instance variable of the model is defined, e.g. in index and new
+    #
+    # +use_base+:: If true, it will render the view using the superclass, Templet::ApplicationRestViewer
+    #
+    # +class_name+:: The name of the Viewer class
+    #
+    # +module_name+:: The name of the Viewer module
+    #
+    # +grand_parent+:: The name of the parent's parent, for 'Back' buttons
+    #
+    # +variables+:: A list of instance variables to be passed into the view (no @ prefix)
+    #
+    # +wrapper+:: For specifying an HTML id, i.e. the target of a JS request
+    #
+    def initialize(action, model_name, controller: nil,
+                                       parent: nil,
+                                       models: nil,
+                                       use_model_name: nil,
+                                       use_base: false,
+                                       class_name: nil,
+                                       module_name: nil,
+                                       grand_parent: nil,
+                                       variables: [],
+                                       wrapper: nil)
+      self.action = action
+
+      self.controller = controller
+
+      self.model_name = model_name
+
+      self.parent = parent
+
+      self.models = models
+
+      # Specify a model name as opposed to an instance in an instance variable
+      # It's because there is no model in the actions 'index' and 'new'
+      self.use_model_name = if use_model_name.nil?
+                              models ? true : false 
+                            else
+                              use_model_name
+                            end
+
+      self.grand_parent = grand_parent
+
+      self.variables = variables
+
+      self.wrapper = wrapper
+
+      self.viewer_class = ViewerCallStringClass.new(controller, model_name,
+                                                    use_base,
+                                                    class_name, module_name)
+    end
+
+    def call(action=action())
+      "#{viewer_class}.new(#{args}#{opts}).#{action}"
+    end
+
+    alias to_s call
+
+    private
+
+    # Arguments
+
+    def args
+      "self" << model_arg << parent_arg
+    end
+
+    def model_arg
+      prefix = use_model_name ? ':' : '@'
+
+      to_arg(model_name, prefix)
+    end
+
+    def parent_arg
+      to_arg(parent, '@')
+    end
+
+    def to_arg(value_name, value_prefix='')
+      value_name ? ", #{value_prefix}#{value_name}" : ''
+    end
+
+    # Options
+
+    def opts
+      opts = controller_opt << models_opt << grand_parent_opt << wrapper_opt
+
+      variables.reduce(opts) {|acca, variable| acca << to_opt(variable) }
+    end
+
+    def controller_opt
+      controller ? to_opt("'#{controller}'", :controller, '') : ''
+    end
+
+    def models_opt
+      to_opt(models, :models, models.to_s.start_with?('@') ? '' : '@')
+    end
+
+    def grand_parent_opt
+      to_opt(grand_parent, :grand_parent)
+    end
+
+    def wrapper_opt
+      to_opt((wrapper == false ? :none : wrapper), :wrapper)
+    end
+
+    def to_opt(value_name, key_name=nil, value_prefix=nil)
+      value_prefix ||= key_name ? ':' : '@'
+
+      key_name ||= value_name
+
+      value_name ? ", #{key_name}: #{value_prefix}#{value_name}" : ''
+    end
+  end
+end
+

data/app/controllers/templet/viewer_call_string_class.rb

@@ -0,0 +1,65 @@
+
+module Templet
+  # Returns the name (as a string) of the Viewer class
+  # It's used internally by ViewerCallString
+  class ViewerCallStringClass < Struct.new(:controller, :model_name,
+                                           :use_base, :class_name,
+                                           :module_name)
+    APP_MODULE = 'App' # Base namespace of the application subclasses
+
+    VIEWER_CLASS_SUFFIX = "Viewer"
+
+    VIEWER_BASE_CLASS = APP_MODULE + '::Base' + VIEWER_CLASS_SUFFIX
+
+    def call
+      if use_base
+        VIEWER_BASE_CLASS
+      elsif String === class_name
+        class_name
+      else
+        subclass_name
+      end
+    end
+
+    alias to_s call
+
+    private
+
+    # Reverts to the base class if there is no Viewer class that is either
+    # explicitly given or is implicitly derived, e.g. from the controller's name
+    def subclass_name
+      subclass_name = application_subclass
+
+      if (subclass_name.constantize rescue false)
+        subclass_name
+      else
+        VIEWER_BASE_CLASS
+      end
+    end
+
+    def application_subclass
+      APP_MODULE + controller_module +
+        (class_name || controller_name || model_name).to_s.classify +
+        VIEWER_CLASS_SUFFIX
+    end
+
+    def controller_name
+      if controller
+        controller.to_s.split('/').last
+      end
+    end
+
+    def controller_module
+      if module_name
+        "#{module_name.to_s.classify}::"
+      elsif controller
+        controller.to_s.split('/')[0..-2].reduce('') do |acca, name|
+          acca << '::' << name.classify
+        end << '::'
+      else
+        '::'
+      end
+    end
+  end
+end
+

data/app/controllers/templet/viewer_responders.rb

@@ -0,0 +1,121 @@
+
+# Used in controller actions to dispatch the HTML, JS & JSON formats
+module Templet::ViewerResponders
+  include Templet::RenderingHelpers
+
+  include Templet::JsonRenderingHelpers
+
+  private
+
+  def respond_to_index(models_name=nil, models=nil, **options)
+    models_name ||= model_name.to_s.pluralize
+
+    respond_to do |format|
+      format.html do
+        render inline viewer(:index, **merge_models(options, models_name))
+      end
+
+      format.js do
+        render js viewer_to_s(:index, **merge_models(options, models_name))
+      end
+
+      format.json do
+        render json_for(models || instance_var(models_name))
+      end
+    end
+  end
+
+  def respond_to_action(action, model=nil, **options)
+    respond_to do |format|
+      format.html { render inline viewer(action, **options) }
+
+      format.js { render js viewer_to_s(action, **options) }
+
+      format.json { render json_for(model || instance_var(model_name)) }
+    end
+  end
+
+  def respond_to_show(*args)
+    respond_to_action :show, *args
+  end
+  def respond_to_new(*args)
+    respond_to_action :new, *args
+  end
+  def respond_to_edit(*args)
+    respond_to_action :edit, *args
+  end
+
+  def respond_to_save_success(model, redirect=model, status=nil,
+                              notice=nil, **options)
+    status ||= model.id_previously_changed? ? :created : :ok
+
+    notice ||= default_notice(model)
+
+    respond_to do |format|
+      format.html do
+        redirect_to redirect, notice: notice
+      end
+
+      format.js do
+        set_message(notice)
+
+        render js viewer_to_s(:show, **options)
+      end
+
+      format.json { render json_for(model, status: status) }
+    end
+  end
+
+  def respond_to_save_failure(action, model, **options)
+    respond_to do |format|
+      format.html { render inline viewer(action, **options) }
+
+      format.js { render js viewer_to_s(action, **options) }
+
+      format.json { render json_for(model, in_error: true) }
+    end
+  end
+
+  def respond_to_destroy(model, redirect=model, notice=nil)
+    notice ||= default_notice(model, "deleted")
+
+    respond_to do |format|
+      format.html { redirect_to redirect, notice: notice }
+
+      format.js do
+        set_message(notice)
+
+        index
+      end
+
+      format.json { head :no_content }
+    end
+  end
+
+  def merge_models(options, models_name)
+    options.merge models: to_iv(models_name)
+  end
+
+  def instance_var(name)
+    instance_variable_get to_iv(name)
+  end
+
+  def to_iv(name)
+    name.to_s.start_with?('@') ? name : "@#{name}".to_sym
+  end
+
+  def default_notice(model, suffix=nil, prefix=nil)
+    "#{prefix || notice_prefix} #{model} #{suffix || notice_suffix}."
+  end
+  def notice_prefix
+    model_name.to_s.capitalize
+  end
+  def notice_suffix
+    action_name + 'd'
+  end
+
+  def set_message(text, key=:notice)
+    flash.now[key] = text
+  end
+end
+