ion_orders_engine_mockingjay 1.0.1.SNAPSHOT

data/app/controllers/reference/data_options_controller.rb

@@ -0,0 +1,147 @@
+class Reference::DataOptionsController < Reference::BaseController
+
+    before_filter :retrieve_data_list
+
+    # GET /reference/data_lists/:data_list_id/data_options
+    # GET /reference/data_lists/:data_list_id/data_options.json
+    def index
+      @data_options = @data_list.data_options
+      configure_breadcrumbs @data_list, :data_options
+
+      respond_to do |format|
+        format.html # index.html.erb
+        format.json { render json: @data_options }
+      end
+    end
+
+
+    # GET /reference/data_lists/:data_list_id/data_options/1
+    # GET /reference/data_lists/:data_list_id/data_options/1.json
+    def show
+      retrieve_data_option    
+
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @data_option }
+      end
+    end
+
+
+    # GET /reference/data_lists/:data_list_id/data_options/new
+    # GET /reference/data_lists/:data_list_id/data_options/new.json
+    def new
+      @data_option = DataOption.new
+      configure_breadcrumbs @data_list, :data_option
+
+      respond_to do |format|
+        format.html # new.html.erb
+        format.json { render json: @data_option }
+      end
+    end
+
+
+    # GET /reference/data_lists/:data_list_id/data_options/1/edit
+    def edit
+      retrieve_data_option
+    end
+
+
+    # POST /reference/data_lists/:data_list_id/data_options
+    # POST /reference/data_lists/:data_list_id/data_options.json
+    def create
+      unless @data_list
+        raise 'No data_list could be retrieved for whom to associate the newly created DataOption'
+      end
+
+      @data_option = DataOption.new(params[:data_option])
+      @data_list.data_options << @data_option
+
+      respond_to do |format|
+        if @data_option.save
+          Reference::DataTypes.reload # Update all of our reference data, given the new DataOption
+
+          format.html { redirect_to  [:reference, @data_list,  @data_option], 
+            notice: 'Data Option was successfully created.' }
+          format.json { render json: @data_option, status: :created, location: @data_option }
+        else
+          format.html do
+              # Set breadcrumbs again, otherwise they'd be lost on render of 'new' template:
+              configure_breadcrumbs @data_list, :data_option
+              render action: "new"
+            end
+          format.json { render json: @data_option.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+
+    # PUT /reference/data_lists/:data_list_id/data_options/:id
+    # PUT /reference/data_lists/:data_list_id/data_options/:id.json
+    def update
+      retrieve_data_option
+
+      respond_to do |format|
+        if @data_option.update_attributes(params[:data_option])
+          Reference::DataTypes.reload # Update all of our reference data, given the updated DataOption
+
+          format.html { redirect_to [:reference, @data_list,  @data_option], 
+            notice: 'Data Option was successfully updated.' }
+          format.json { head :no_content }
+        else
+          format.html { render action: "edit" }
+          format.json { render json: @data_option.errors, status: :unprocessable_entity }
+        end
+      end
+    end
+
+
+    # DELETE /reference/data_lists/:data_list_id/data_options/1
+    # DELETE /reference/data_lists/:data_list_id/data_options/1.json
+    def destroy
+      retrieve_data_option
+      root_resource = @data_option.root_resource
+      @data_option.destroy
+      root_resource.export_update # Allow root resource to save update to disk
+      Reference::DataTypes.reload # Update all of our reference data, given the removed DataOption
+
+      respond_to do |format|
+        format.html { redirect_to [:reference, @data_list, :data_options],
+                                  notice: 'Data Option was successfully destroyed.' }
+        format.json { head :no_content }
+      end
+    end
+
+
+
+    private
+
+    # We retrieve the data_list implied by the current set of params. 
+    def retrieve_data_list
+      return unless params[:data_list_id] # Nothing more to do if we don't have a data_list id.
+
+      @data_list = DataList.find(params[:data_list_id])    
+      
+      if @data_list
+        log_info "Found data_list with data_list_id: #{params[:data_list_id]}." 
+      else
+        log_warn "Could not retrieve data_list with id: #{params[:data_list_id]}. The params were: #{params}"
+      end
+    end
+
+
+    def retrieve_data_option
+      @data_option = DataOption.find(params[:id])
+
+      unless @data_list
+        params[:data_list_id] = @data_option.data_list_id
+        retrieve_data_list
+      end
+
+      unless @data_option
+        log_warn "\nCould not retrieve data_option from data_list model with data_option id: #{params[:id]}. The params were: #{params}\n"
+      end
+
+      configure_breadcrumbs @data_option
+    end
+  
+end

data/app/controllers/reference/data_sets_controller.rb

@@ -0,0 +1,160 @@
+class Reference::DataSetsController < Reference::BaseController
+    
+  layout 'reference/data_sets' # we don't want to use the general layout that has a data_set sidebar to it
+    
+  #before_filter :clear_data_set_sidebar
+
+  # Public: RESTful resource index operation. We additionally handle filtering the index based
+  # on any search parameters present.
+  # 
+  #   GET /reference/data_sets
+  #   GET /reference/data_sets.json
+  def index    
+    #params[:search] = nil if (params[:clear])
+    #search_string = params[:search]
+    #@data_sets = DataSet.search(search_string)
+    @data_sets = DataSet.all
+    configure_breadcrumbs :data_sets
+
+    respond_to do |format|
+      format.html # index.html.erb
+      format.json { render json: @data_sets }
+    end
+  end
+
+
+  # Public: RESTful resource show operation. 
+  #
+  #   GET /reference/data_sets/1
+  #   GET /reference/data_sets/1.json
+  def show
+    retrieve_data_set
+
+    if @data_set
+      respond_to do |format|
+        format.html # show.html.erb
+        format.json { render json: @data_set }
+      end
+    else
+      redirect_to [:reference, :data_sets], 
+        alert: "DataSet with id #{params[:id]} not found. You have been redirected to the DataSets listing."
+    end
+  end
+
+
+  # Public: RESTful resource new operation. We pre-fill the new DataSet with default options.
+  #
+  #   GET /reference/data_sets/new
+  #   GET /reference/data_sets/new.json
+  def new
+    @data_set = DataSet.new(DataSet.default_options)
+    configure_breadcrumbs :data_set
+
+    respond_to do |format|
+      format.html # new.html.erb
+      format.json { render json: @data_set }
+    end
+  end
+
+
+  # Public: RESTful resource edit operation. 
+  #
+  #   GET /reference/data_sets/1/edit
+  def edit
+    retrieve_data_set
+  end
+
+
+  # Public: RESTful resource create operation. 
+  #
+  #   POST /reference/data_sets
+  #   POST /reference/data_sets.json
+  def create
+    @data_set = DataSet.new(params[:data_set])
+
+    respond_to do |format|
+      if @data_set.save
+        # Note: we don't reload reference data yet, since a new DataSet has no content at first creation.
+        format.html { redirect_to [:reference, @data_set], notice: 'Data Set was successfully created.' }
+        format.json { render json: @data_set, status: :created, location: @data_set }
+      else
+        format.html do
+            # Set breadcrumbs again, otherwise they'd be lost on render of 'new' template:
+            configure_breadcrumbs :data_set
+            render action: "new"
+          end
+        format.json { render json: @data_set.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+
+  # Public: RESTful resource update operation.
+  #
+  #   PUT /reference/data_sets/1
+  #   PUT /reference/data_sets/1.json
+  def update
+    retrieve_data_set
+
+    respond_to do |format|
+      if @data_set.update_attributes(params[:data_set])
+        Reference::DataTypes.reload # Update all of our reference data, given the updated DataSet
+        format.html { redirect_to [:reference, @data_set], notice: 'Data Set was successfully updated.' }
+        format.json { head :no_content }
+      else
+        format.html { render action: "edit" }
+        format.json { render json: @data_set.errors, status: :unprocessable_entity }
+      end
+    end
+  end
+
+
+  # Public: RESTful resource destroy operation.
+  #
+  #   DELETE /reference/data_sets/1
+  #   DELETE /reference/data_sets/1.json
+  def destroy
+    retrieve_data_set
+    # Create the path to the reference file associated with this about to be deleted data set,
+    # so that we can delete it:
+    reference_filename = File.join(Rails.root, "data/reference/DataSets/#{@data_set.name}.js")   # TODO: DRY up these path references to somewhere central
+    @data_set.destroy
+    # Now that the DataSet has been removed from the database, go ahead and delete the
+    # reference file:
+    File.delete(reference_filename) if File.exists?(reference_filename)
+    Reference::DataTypes.reload # Update all of our reference data, given the destroyed DataSet
+
+    respond_to do |format|
+      format.html { redirect_to [:reference, :data_sets], notice: 'Data Set was successfully destroyed.' }
+      format.json { head :no_content }
+    end
+  end
+  
+  
+
+  private 
+  
+  # Internal: We don't want to show duplicate information in the sidebar about a data_set
+  # when a user is interacting with this data_set specific controller.
+  #def clear_data_set_sidebar
+  #  # Reset the sidebar to have no current data_set:
+  #  @data_set = nil
+  #  set_session_data_set
+  #  update_recent_data_sets
+  #end
+
+
+  # Internal: Retrieves the DataSet model instance from params. Also updates breadcrumb
+  # navigation, reflecting the retrieved data_set. We also update the recent data_sets
+  # list such that this data_set is at the top of a reverse chronological list.
+  def retrieve_data_set
+    begin
+      @data_set = DataSet.find(params[:id])
+      configure_breadcrumbs @data_set
+      #update_recent_data_sets
+    rescue Exception => e
+      log_error "Couldn't retrieve data_set requested. Exception: #{e}"
+    end
+  end
+
+end

data/app/helpers/application_helper.rb

@@ -0,0 +1,389 @@
+module ApplicationHelper
+
+  # ---------- Reformatting ----------
+
+  # Replace newlines with HTML break tags to achieve the equivalent
+  # intention, targeting this web UI.
+  def format_newlines(text_with_newlines)
+    text_with_newlines.gsub('\n', '<br/>') if text_with_newlines
+  end
+
+  # Shows the last four characters of the provided value.
+  # Typically used to truncate unsightly Mongo DB BSON IDs.
+  def truncated_id(full_id)
+  	"...#{full_id.to_s[-5..-1]}" if full_id
+  end
+  
+
+  # A wrapper for link_to that uses a truncated value of the provided
+  # full text, surfacing the full_text in a tooltip that shows on-hover.
+  def truncated_link_to(full_text, path, html_options={})
+  	tooltip_options = {rel: 'tooltip', title: full_text }
+  	html_options.merge! tooltip_options
+  	link_to truncated_id(full_text), path, html_options
+  end
+
+
+  # ---------- Headings: General ----------
+
+  # [model_class] An actual class, or a String title.
+  def show_resource_heading(model_class, resource_summary=nil)
+    default_heading =
+        if model_class.instance_of?(String)
+          model_class.titleize
+        else
+          model_class.model_name.human.titleize
+        end
+
+    optional_newline = default_heading.length > 15 ? '<br/>' : ''
+    default_heading.concat(" #{optional_newline}<small>#{resource_summary}</small>") if resource_summary
+    raw default_heading
+  end
+
+
+  def index_resource_heading(model_class, additional_text=nil)
+    default_heading = "#{model_class.model_name.human.pluralize.titleize}"
+    default_heading.concat(": #{additional_text}") if additional_text
+    t '.title', default: default_heading    
+  end
+
+
+  def new_resource_heading(model_class)
+    t '.title', default: t('helpers.titles.new', model: model_class.model_name.human,
+                                 default: "New #{model_class.model_name.human.titleize}")
+  end
+
+
+  def edit_resource_heading(model_class)
+    t '.title', default: t('helpers.titles.edit', model: model_class.model_name.human,
+                                   default: "Edit #{model_class.model_name.human.titleize}")
+  end
+
+
+  def actions_table_heading
+    t '.actions', default: t("helpers.actions")
+  end
+
+
+
+  # ---------- Show Resource ----------
+
+  # Call this with a block, to which we'll yield a helper object, much like
+  # you would form_for or simple_form_for. We instantiate a ResourceDisplayHelper
+  # and yield it into the block, so like you would in building a form for 
+  # editing an attribute, you have now have a convenient helper to show an attribute.
+  def display_for(model_object)
+    helper = ResourceDisplayHelper.new(model_object, self)
+    yield helper
+  end
+
+
+
+  # ---------- Button Links: General ----------
+
+  def export_button(model)
+    render partial: 'mock/common/export_button', locals: {model: model}
+  end
+
+
+  def search_submit_button_tag
+    submit_tag t('.search', default: t("helpers.links.search")), 
+      name: nil, class: 'btn btn-primary' 
+  end
+
+  
+  def clear_form_submit_button_tag
+    submit_tag 'Clear', name: 'clear', class: 'btn btn-primary' 
+  end
+
+
+  # Creates a submit button for the given form and model object passed in, handling the
+  # logic of 'Create' vs. 'Update' in the button title. We also handle titleizing the model name.
+  def submit_button(form, model_instance, singularize = true)
+    if singularize
+      resource_name = model_instance.class.model_name.underscore.singularize.humanize.titleize.split('/').last
+    else
+      resource_name = model_instance.class.model_name.underscore.humanize.titleize.split('/').last
+    end
+    operation_title = if model_instance.new_record? then 'Create' else 'Update' end
+    button_title = "#{operation_title} #{resource_name}"
+    form.button :submit, value: button_title, class: 'btn-primary'
+  end
+
+  # Generates a Back button, which is a back arrow followed by text inferred from the mandatory parameter
+  # provided, such as: [:mock, @commentable, :comments]
+  # We handle all the translate lookup and the CSS.
+  def back_button_link(path_as_array, options={})
+    last_element = path_as_array.last
+
+    # Are we dealing with a Ruby Symbol?
+    if last_element.is_a?(Symbol)
+      resource_name = last_element.to_s.humanize
+    else
+      resource_name = last_element.class.model_name.human
+      if last_element.is_singular_child_resource?
+        # YES. So we need to swap it out in the path array with
+        # a singular symbol of itself instead, so that when passed to url_for(),
+        # a correct URL path will be constructed.
+        # TODO: This has been used elsewhere; DRY it up by making this logic available somewhere common
+        path_as_array[-1] = path_as_array.last.class.to_s.tableize.singularize.to_sym
+      end
+    end
+
+    provided_resource_name = options[:resource_name] || resource_name
+
+    # Should we put an 'All' in front of the resource name?
+    if resource_name.plural?
+      button_text = "All #{provided_resource_name.pluralize}"
+    else 
+      button_text = provided_resource_name
+    end
+
+
+    # Are we dealing with a non-nested resource path that isn't going back
+    # to the root? We always prefer using a parent/child nesting route.
+    if path_as_array.length == 2 && !root_model_titles.include?(resource_name.singularize.titleize)
+      Rails.logger.debug "ROOT_MODEL_NAMES did not include: #{resource_name.singularize.titleize}" 
+      # We need to insert into the path as array, a parent object to the last element.
+      # e.g. if we received the array: 
+      #   [:mock, @phoneable]
+      # we would effectively convert it to:
+      #   [:mock, <parent of @phoneable>, @phoneable]
+      path_as_array.insert(1, last_element.parent_resource_model_object)
+    end
+
+    # Build the actual link that will look like a button, thanks to CSS:
+    link_to( raw("&larr; #{button_text.titleize}"), path_as_array, class: 'btn') 
+  end
+
+
+  # Generates the link_to for the Cancel button.
+  def cancel_button(path_as_array)
+    modifiable_object = resolved_last_object_from_path(path_as_array)
+
+    if modifiable_object && modifiable_object.new_record?
+      # YES: So turn the last element from a model object into a plural symbol.
+      last_element = path_as_array.last
+      cancel_path = path_as_array - [last_element]
+      cancel_path << last_element.class.model_name.tableize.gsub('/', '_').to_sym
+    else
+      cancel_path = path_as_array
+    end
+
+    link_to 'Cancel', cancel_path, class: 'btn'
+  end
+
+
+  # We display a button that says 'New <resource name>'. By definition, the array passed
+  # in will have the last element being a symbol representing the new thing to be created.
+  def new_button_link(path_as_array, options={})
+    resource_name = options[:resource_name] || path_as_array.last.to_s.humanize
+    operation_title = if options[:operation_title] then options[:operation_title] else 'New' end
+    button_text = "#{operation_title} #{resource_name.titleize}" 
+    
+    css_classes = 'btn btn-primary'
+    css_classes.concat(' btn-mini') if options[:as_mini]
+    css_classes.concat(' ').concat(options[:class]) if options[:class]
+
+    options = { class: css_classes }
+    parent_resource = path_as_array[-2] unless path_as_array.length < 2
+    
+    # Do we need to indicate with a confirmation that the parent resource we'd create under, is protected?
+    if parent_resource && !parent_resource.is_a?(Symbol) && parent_resource.marked_as_protected?
+      options[:data] = { confirm: "This would add a new #{resource_name.titleize} to a PROTECTED record. Are you sure?" } 
+    end
+
+    link_to button_text, path_as_array, options
+  end
+
+
+  # Variant of the new_button_link, but uses the title prefix 'Add Another' instead of 'New'
+  def add_another_button_link(path_as_array, options={})
+    options.merge!({ operation_title: 'Add Another' })
+    new_button_link(path_as_array, options)   
+  end
+
+
+  # We assume the last element in the provided array is a Symbol, since this is a variant of New.
+  # We'll use that last element to be part of the title of the button.
+  def add_button_link(path_as_array, options={})
+    css_classes = 'btn btn-primary'
+    css_classes.concat(' btn-mini') if options[:as_mini] 
+    resource_name = path_as_array.last.to_s.humanize.capitalize_words
+    button_text = "Add #{resource_name}"
+    link_to( button_text, path_as_array, class: css_classes)  
+  end
+
+
+  # In the options hash, pass in as_mini: true if you want the smaller version.
+  def show_button_link(path_as_array, options={})
+    css_classes = 'btn btn-success '
+    css_classes.concat options[:class] if options[:class]
+    css_classes.concat(' btn-mini') if options[:as_mini] 
+    button_text = options[:title] || t('.show', default: t("helpers.links.show"))
+    link_to button_text, path_as_array, class: css_classes
+  end
+
+
+  # In the options hash, pass in as_mini: true if you want the smaller version.
+  def go_button_link(path_as_array, options={})
+    css_classes = 'btn btn-success'
+    css_classes.concat(' btn-mini') if options[:as_mini] 
+    display_title = options[:title] || 'Go'
+    link_to display_title, path_as_array, class: css_classes
+  end
+
+
+  # In the options hash, pass in as_mini: true if you want the smaller version.
+  def edit_button_link(path_as_array, options={})
+    css_classes = 'btn'
+    css_classes.concat(' btn-mini') if options[:as_mini] 
+    display_title = t('.edit', default: t("helpers.links.edit"))
+    options = { class: css_classes }
+
+    # Determine whom the actual editable model object is, so we can determine if it
+    # claims to be marked as protected.
+    modifiable_object = resolved_last_object_from_path(path_as_array)
+    options[:data] = { confirm: 'This is a PROTECTED record. Are you sure?' } if modifiable_object.marked_as_protected?
+
+    link_to display_title, path_as_array, options
+  end
+
+
+  # In the options hash, pass in as_mini: true if you want the smaller version.
+  def destroy_button_link(path_as_array, options={})
+    css_classes = 'btn btn-danger'
+    css_classes.concat(' btn-mini') if options[:as_mini]
+
+    modifiable_object = resolved_last_object_from_path(path_as_array)
+    resource_name = modifiable_object.class.model_name.human.capitalize_words
+    default_confirmation_msg = "Are you sure you'd like to delete this #{resource_name}?"
+
+    if modifiable_object.marked_as_protected?
+      default_confirmation_msg.concat " This is a PROTECTED record."
+    end
+
+    link_to t('.destroy', default: t("helpers.links.destroy")),
+      path_as_array,
+      method: :delete,
+      data: { confirm: t('.confirm', default: t("helpers.links.confirm", default: default_confirmation_msg)) },
+      class: css_classes
+  end
+
+
+  # Public: In the options hash, you can provide a :class key to specify a string of additional
+  # CSS classes to use. For example, to have the button right aligned:
+  #
+  #   {class: 'pull-right'} 
+  #
+  # Returns String of HTML command to insert a link. 
+  def view_api_response_button_link(path, options={})
+    css_classes = 'btn btn-info '
+    css_classes.concat(options[:class]) if options[:class]
+    title = options[:title] || 'View API Response'
+    link_to title, path, target: 'API Window', rel: 'tooltip', title: path, class: css_classes 
+  end
+
+
+  def view_automation_data_button_link(path, options={})
+    css_classes = 'btn btn-info '
+    css_classes.concat(options[:class]) if options[:class]
+    title = options[:title] || 'View Automation Data'
+    link_to title, path, target: 'Data Window', rel: 'tooltip', title: path, class: css_classes 
+  end
+
+
+  def view_content_button_link(path, options={})
+    css_classes = 'btn btn-info '
+    css_classes.concat(options[:class]) if options[:class]
+    title = options[:title] || 'Show'
+    tooltip_title = options[:tooltip_title] || 'View content in new tab'
+    link_to title, path, target: 'Content Window', rel: 'tooltip', title: tooltip_title, class: css_classes
+  end
+
+
+  # Public: This inserts a mini button entitled 'Modify List' inside a nested div structure that mimics our
+  # layout into rows and columns, per Twitter Bootstrap. The button is actually a styled hyperlink.
+  # Since the Twitter Bootstrap layout we have already adopted is rather tight, we don't have a good way to include
+  # a button to the side of an input form control. By default, anything we add goes to the next line.
+  #
+  # In the case of our modify list button, being on the next line would look out of place. So, although
+  # we are technically on the next line, we employ some inline CSS (via the 'style') attribute, to float
+  # our button back into the ideal position (only ever obscured if the user makes the browser window really tiny).
+  #
+  #   reference_class - The Class object for the reference list we're making available for modification.
+  #                       An example would be Reference::LabGroup or Reference::AllergyReactionType.
+  #   options         - An optional Hash of values. Keys accepted:
+  #                       :class          - A String of additional CSS classes to include for the underlying link.
+  #                       :tooltip_title  - A String to override the tooltip shown when the user hovers over the
+  #                                           button we render.
+  def modify_reference_list(reference_class, options = {})
+    root_data_list = reference_class.root_data_list
+
+    unless root_data_list
+      Rails.logger.debug "#{self.class.name} modify_reference_list(): Could not retrieve root_data_list. Skipping insertion of option."
+      return nil
+    end
+
+    data_set = root_data_list.data_listable
+    css_classes = 'btn btn-info btn-mini'
+    css_classes.concat(options[:class]) if options[:class]
+    tooltip_title = options[:tooltip_title] || "Manage the reference #{root_data_list.display_name} list in a new tab"
+
+    # Build the hyperlink, styled as a button.
+    # TODO: Move the inline style to actual CSS and then just refer to it with a CSS class
+    value = link_to 'Modify List', [:reference, data_set, root_data_list],
+            target: 'Reference Window',
+            rel: 'tooltip',
+            title: tooltip_title,
+            class: css_classes,
+            style: 'float: top; margin-top: -90px; margin-left: 10px'
+
+    # Now render the partial that has some templated DIV structures into which we'll insert the 'Modify List' button:
+    render partial: 'mock/common/modify_reference_list', locals: {value: value}
+  end
+
+
+
+  # ---------- Button Links: Resource Specific ----------
+
+  def back_button_to_patient
+    back_button_link [:mock, @patient]
+  end
+
+
+  # ---------- General Utilities ----------
+
+  # Since some path arrays for resources can have a singular symbol at the end to indicate
+  # a singular resource, this method checks for that and backs up a level to invoke that
+  # resource symbol as a method on the preceding object (presumably the parent) to ultimately
+  # get a handle to the object in question.
+  def resolved_last_object_from_path(path_as_array)
+    if path_as_array.last.is_a?(Symbol) && path_as_array.size > 2
+      # YES: A symbol in the last position means we must be editing a singular resource.
+      # We'll retrieve that resource by asking the object preceding it for the relation
+      # given by that last element (the symbol). E.g. if we're given a path_as_array of
+      # [:edit, :mock, @chart_reviewable, :chart_review], then we'll call
+      # @chart_reviewable.send(:chart_review) to get at the ChartReview singular object.
+      path_as_array[-2].send(path_as_array.last)
+    else
+      path_as_array.last
+    end
+  end
+
+
+  # Determines which of our models are root resources. We then return an Array of humanized model
+  # class titles for these.
+  def root_model_titles
+    Rails.application.eager_load! # Needed to ensure all models are loaded for our asking them if they are root resources.
+
+    all_model_classes = ActiveRecord::Base.descendants
+    root_model_classes = all_model_classes.select { |model_class| model_class.included_modules.include? Mock::RootModelConcern }
+    names = root_model_classes.collect { |model_class| model_class.to_s.titleize }
+    Rails.logger.debug "ApplicationHelper root_model_titles(): Returning #{names}"
+    names
+  end
+
+
+
+end