discerner 1.1.18

data/lib/discerner/parser.rb

@@ -0,0 +1,497 @@
+module Discerner
+  class Parser
+    attr_accessor :options, :errors, :updated_dictionaries, :updated_categories, :updated_parameters, :updated_parameter_value_categories, :updated_parameter_values, :blank_parameter_values
+
+    def initialize(options={})
+      self.options = options
+      self.errors = []
+      reset_counts
+    end
+
+    def reset_counts
+      self.updated_dictionaries = []
+      self.updated_categories = []
+      self.updated_parameters = []
+      self.updated_parameter_values = []
+      self.updated_parameter_value_categories = []
+      self.blank_parameter_values = []
+    end
+
+    def parse_dictionaries(str)
+      reset_counts
+      hash_from_file = YAML.load(str)
+
+      # find or initialize dictionaries
+      dictionaries_from_file = hash_from_file[:dictionaries]
+      error_message 'No dictionaries detected.' if dictionaries_from_file.blank?
+
+      Discerner::Dictionary.transaction do
+        dictionaries_from_file.each do |dictionary_from_file|
+          dictionary = parse_dictionary(dictionary_from_file)
+
+          ## find or initialize parameter categories
+          parameter_categories_from_file = dictionary_from_file[:parameter_categories]
+          error_message 'no parameter categories detected' if parameter_categories_from_file.blank?
+
+          parameter_categories_from_file.each do |parameter_category_from_file|
+            parameter_category = parse_parameter_category(dictionary, parameter_category_from_file)
+
+            ## find or initialize parameters
+            parameters_from_file = parameter_category_from_file[:parameters]
+            error_message 'no parameters detected' if parameters_from_file.blank?
+
+            parameters_from_file.each do |parameter_from_file|
+              parameter = parse_parameter(parameter_category, parameter_from_file)
+
+              search_identifiers = parameter_from_file[:search]
+              unless search_identifiers.blank?
+                ## find or initialize parameter value categories
+                unless search_identifiers[:parameter_value_categories].blank?
+                  search_identifiers[:parameter_value_categories].each do |parameter_value_category_from_file|
+                    parse_parameter_value_category(parameter, parameter_value_category_from_file)
+                  end
+                end
+
+                unless search_identifiers[:parameter_value_categories_source].blank?
+                  load_parameter_value_categories_from_source(parameter, search_identifiers[:parameter_value_categories_source])
+                end
+
+                ## find or initialize parameter values
+                unless search_identifiers[:parameter_values].blank?
+                  search_identifiers[:parameter_values].each do |parameter_value_from_file|
+                    parse_parameter_value(parameter, parameter_value_from_file)
+                  end
+                end
+
+                unless search_identifiers[:source].blank?
+                  load_parameter_value_from_source(parameter, search_identifiers[:source])
+                end
+
+                unless search_identifiers[:allow_empty_values] == false
+                  blank_parameter_values << find_or_create_parameter_value(parameter, '', 'None', nil, true)
+                end
+              end
+            end
+          end
+        end
+      end
+      notification_message "cleaing up ..."
+      cleanup unless errors.any?
+    end
+
+    def parse_dictionary(hash)
+      error_message 'dictionary definition was not provided' if hash.blank?
+
+      dictionary_name = hash[:name]
+      error_message 'dictionary name cannot be blank' if dictionary_name.blank?
+      notification_message "processing dictionary '#{dictionary_name}'"
+
+      dictionary = Discerner::Dictionary.find_or_initialize_by_name(dictionary_name)
+      dictionary.deleted_at = nil
+
+      if dictionary.new_record?
+        notification_message "creating dictionary ..."
+        dictionary.created_at = Time.now
+      else
+        notification_message "updating dictionary ..."
+        dictionary.updated_at = Time.now
+      end
+      error_message "dictionary could not be saved: #{dictionary.errors.full_messages}", dictionary_name unless dictionary.save
+      notification_message 'dictionary saved'
+      updated_dictionaries << dictionary
+      dictionary
+    end
+
+    def parse_parameter_category(dictionary, hash)
+      error_message 'parameter category definition was not provided' if hash.blank?
+
+      parameter_category_name = hash[:name]
+      error_message 'parameter category name cannot be blank' if parameter_category_name.blank?
+      notification_message "processing parameter category  '#{parameter_category_name}'"
+
+      parameter_category = Discerner::ParameterCategory.where(:name => parameter_category_name, :dictionary_id => dictionary.id).first_or_initialize
+      parameter_category.deleted_at = nil
+
+      if parameter_category.new_record?
+        notification_message "creating parameter category ..."
+        parameter_category.created_at = Time.now
+      else
+        notification_message "updating parameter category ..."
+        parameter_category.updated_at = Time.now
+      end
+      error_message "parameter category could not be saved: #{parameter_category.errors.full_messages}", parameter_category_name unless parameter_category.save
+      notification_message 'parameter category saved'
+      updated_categories << parameter_category
+      parameter_category
+    end
+
+    def parse_parameter(parameter_category, hash)
+      error_message 'parameter definition was not provided' if hash.blank?
+
+      parameter_name = hash[:name]
+      error_message 'parameter name cannot be blank' if parameter_name.blank?
+
+      notification_message "processing parameter '#{parameter_name}'"
+      unique_identifier = hash[:unique_identifier]
+      error_message "unique_identifier cannot be blank", parameter_name if unique_identifier.blank?
+
+      existing_parameter    = Discerner::Parameter.
+                              includes({:parameter_category => :dictionary}).
+                              where('discerner_parameters.unique_identifier = ? and discerner_dictionaries.id = ?', unique_identifier, parameter_category.dictionary.id).first
+      parameter             = existing_parameter || Discerner::Parameter.new(:unique_identifier => unique_identifier, :parameter_category => parameter_category)
+
+      parameter.name        = parameter_name
+      parameter.deleted_at  = nil
+      parameter.exclusive   = hash[:exclusive].nil? ? true : to_bool(hash[:exclusive])
+      parameter.parameter_category  = parameter_category
+
+      search_identifiers = hash[:search]
+      unless search_identifiers.blank?
+        error_message "Searchable parameter should search model, search method and parameter_type defined." if
+          search_identifiers[:model].blank? || search_identifiers[:method].blank? || search_identifiers[:parameter_type].blank?
+
+        parameter.search_model      = search_identifiers[:model].to_s
+        parameter.search_method     = search_identifiers[:method].to_s
+        parameter.parameter_type    = find_or_initialize_parameter_type(search_identifiers[:parameter_type])
+      end
+
+      export_identifiers = hash[:export]
+      unless export_identifiers.blank?
+        error_message "Exportable parameter should export model and export method defined." if
+          export_identifiers[:model].blank? || export_identifiers[:method].blank?
+
+        parameter.export_model      = export_identifiers[:model].to_s
+        parameter.export_method     = export_identifiers[:method].to_s
+      end
+
+      if parameter.new_record?
+        notification_message "creating parameter ..."
+        parameter.created_at = Time.now
+      else
+        notification_message "updating parameter ..."
+        parameter.updated_at = Time.now
+      end
+
+      error_message "parameter could not be saved: #{parameter.errors.full_messages}", parameter_name unless parameter.save
+      notification_message 'parameter saved'
+      updated_parameters << parameter
+      parameter
+    end
+
+    def parse_parameter_value(parameter, hash)
+      error_message 'parameter value definition was not provided' if hash.blank?
+      search_value = hash[:search_value]
+      error_message 'parameter value search_value cannot be blank' if search_value.nil?
+      find_or_create_parameter_value(parameter, search_value, hash[:name], hash[:parameter_value_category], false)
+    end
+
+    def parse_parameter_value_category(parameter, hash)
+      error_message 'parameter value category definition was not provided' if hash.blank?
+      unique_identifier = hash[:unique_identifier]
+      name = hash[:name]
+
+      error_message 'parameter value category unique_identifier cannot be blank' if unique_identifier.nil?
+      error_message 'parameter value category name cannot be blank' if name.nil?
+      find_or_create_parameter_value_category(parameter, unique_identifier, name, hash[:display_order], hash[:collapse])
+    end
+
+    def load_parameter_value_from_source(parameter, hash)
+      error_message 'parameter value definition was not provided' if hash.blank?
+
+      model_name  = hash[:model]
+      method_name = hash[:method]
+      error_message "model and method must be defined for parameter source" if model_name.blank? || method_name.blank?
+
+      source_model = model_name.safe_constantize
+      error_message "model '#{model_name}' could not be found" if source_model.blank?
+
+      if source_model.respond_to?(method_name)
+        notification_message "method '#{method_name}' recognized as a class method"
+
+        parameter_values = source_model.send(method_name)
+
+        error_message "method '#{method_name}' did not return an array of values" if parameter_values.blank? || !parameter_values.kind_of?(Array)
+
+        if parameter_values.select { |parameter_value| !parameter_value.has_key?(:name) || !parameter_value.has_key?(:search_value) }.any?
+          error_message "method '#{method_name}' does not adhere to the interface"
+        end
+
+        parameter_values.map{|parameter_value| find_or_create_parameter_value(parameter, parameter_value[:search_value], parameter_value[:name], parameter_value[:parameter_value_category]) }
+      else
+        notification_message "method '#{method_name}' is not recognized as a class method, will try it on instance.."
+        error_message "model '#{model_name}' does no respond to :all method" if !source_model.respond_to?(:all)
+
+        search_value_sources = source_model.send(:all)
+        error_message "model '#{method_name}' did not return an array of instances" if search_value_sources.blank?
+
+        search_value_sources.each do |row|
+          error_message "model '#{model_name}' instance does no respond to #{method_name} method" if !row.respond_to?(method_name)
+          find_or_create_parameter_value(parameter, row.send(method_name))
+        end
+      end
+    end
+
+    def load_parameter_value_categories_from_source(parameter, hash)
+      error_message 'parameter value category  definition was not provided' if hash.blank?
+
+      model_name  = hash[:model]
+      method_name = hash[:method]
+      error_message "model and method must be defined for parameter value category source" if model_name.blank? || method_name.blank?
+
+      source_model = model_name.safe_constantize
+      error_message "model '#{model_name}' could not be found" if source_model.blank?
+
+      if source_model.respond_to?(method_name)
+        notification_message "method '#{method_name}' recognized as a class method"
+
+        parameter_value_categories = source_model.send(method_name)
+
+        error_message "method '#{method_name}' did not return an array of values" if parameter_value_categories.blank? || !parameter_value_categories.kind_of?(Array)
+
+        if parameter_value_categories.select { |parameter_value_category| !parameter_value_category.has_key?(:name) || !parameter_value_category.has_key?(:unique_identifier)}.any?
+          error_message "method '#{method_name}' does not adhere to the interface"
+        end
+
+        parameter_value_categories.map{|parameter_value_category| find_or_create_parameter_value_category(parameter, parameter_value_category[:unique_identifier], parameter_value_category[:name], parameter_value_category[:display_order], parameter_value_category[:collapse])}
+      else
+        notification_message "method '#{method_name}' is not recognized as a class method, will try it on instance.."
+        error_message "model '#{model_name}' does no respond to :all method" if !source_model.respond_to?(:all)
+
+        parameter_value_category_sources = source_model.send(:all)
+        error_message "model '#{method_name}' did not return an array of instances" if parameter_value_category_sources.blank?
+
+        parameter_value_category_sources.each do |row|
+          error_message "model '#{model_name}' instance does no respond to #{method_name} method" if !row.respond_to?(method_name)
+          find_or_create_parameter_value_category(parameter, row.send(method_name))
+        end
+      end
+    end
+
+    def parse_operators(str)
+       hash_from_file = YAML.load(str)
+
+       operators_from_file = hash_from_file[:operators]
+       error_message 'No operators detected in the file.' if operators_from_file.blank?
+
+       Discerner::Operator.transaction do
+         operators_from_file.each do |operator_from_file|
+           error_message 'unique identifier has to be defined' if operator_from_file[:unique_identifier].blank?
+
+           operator = Discerner::Operator.find_or_initialize_by_unique_identifier(operator_from_file[:unique_identifier])
+           if operator.new_record?
+             notification_message "creating operator '#{operator_from_file[:unique_identifier]}'"
+             operator.created_at = Time.now
+           else
+             notification_message "operator '#{operator_from_file[:unique_identifier]}' already exists and will be updated"
+             operator.updated_at = Time.now
+           end
+           operator.deleted_at = operator_from_file[:deleted].blank? ? nil : Time.now
+
+           unless operator_from_file[:parameter_types].blank?
+             operator.parameter_types.destroy_all
+
+             operator_from_file[:parameter_types].each do |parameter_type_from_file|
+               parameter_type = find_or_initialize_parameter_type(parameter_type_from_file)
+               operator.parameter_types << parameter_type
+             end
+           end
+           operator.symbol        = operator_from_file[:symbol]
+           operator.text          = operator_from_file[:text]
+           operator.operator_type = operator_from_file[:type]
+           #operator.deleted_at    = operator_from_file[:deleted].blank? ? nil : Time.now
+           error_message "Operator could not be saved: #{operator.errors.full_messages}" unless operator.save
+         end
+      end
+    end
+
+    def find_or_initialize_parameter_type(name)
+      error_message "Parameter type name has to be provided" if name.blank?
+      error_message "'integer' parameter type has been replaced with 'numeric', please update your dictionary definition" if /integer/.match(name.downcase)
+
+      ## find or initialize parameter type
+      parameter_type = Discerner::ParameterType.find_or_initialize_by_name(name.downcase)
+      if parameter_type.new_record?
+        notification_message "Creating parameter type '#{name}'"
+        parameter_type.created_at = Time.now
+      else
+        notification_message "Parameter type '#{name}' already exists"
+      end
+      error_message "Parameter type #{name} could not be saved: #{parameter_type.errors.full_messages}" unless parameter_type.save
+      return parameter_type
+    end
+
+    def find_or_create_parameter_value(parameter, search_value, name=nil, parameter_value_category_identifier=nil, silent=nil)
+      error_message "search value was not provided" if search_value.nil?
+      search_value = search_value.to_s
+      notification_message "processing parameter value '#{search_value}'"
+
+      parameter_value = Discerner::ParameterValue.where(:search_value => search_value, :parameter_id => parameter.id).first_or_initialize
+      if parameter_value.new_record?
+        notification_message "creating parameter value ..."
+        parameter_value.created_at = Time.now
+      else
+        notification_message "updating parameter value ..."
+        parameter_value.updated_at = Time.now
+      end
+
+      unless parameter_value_category_identifier.blank?
+        parameter_value_category = Discerner::ParameterValueCategory.where(:unique_identifier => parameter_value_category_identifier, :parameter_id => parameter.id).first_or_initialize
+        if parameter_value_category.blank?
+          error_message "parameter value category with unique identifier #{parameter_value_category_identifier} is not found for parameter #{parameter.name}"
+        else
+          parameter_value.parameter_value_category = parameter_value_category
+        end
+      end
+
+      parameter_value.name = name || search_value
+      parameter_value.deleted_at = nil
+      error_message "parameter value #{search_value} could not be saved: #{parameter_value.errors.full_messages}" unless parameter_value.save
+      notification_message 'parameter value saved'
+      updated_parameter_values << parameter_value unless silent
+      parameter_value
+    end
+
+    def find_or_create_parameter_value_category(parameter, unique_identifier, name, display_order=0, collapse=nil)
+      error_message "unique_identifier was not provided" if unique_identifier.nil?
+      error_message "name was not provided" if name.nil?
+
+      unique_identifier = unique_identifier.to_s
+      notification_message "processing parameter value category '#{unique_identifier}'"
+
+      parameter_value_category = Discerner::ParameterValueCategory.where(:unique_identifier => unique_identifier, :parameter_id => parameter.id).first_or_initialize
+      if parameter_value_category.new_record?
+        notification_message "creating parameter value category..."
+        parameter_value_category.created_at = Time.now
+      else
+        notification_message "updating parameter value category ..."
+        parameter_value_category.updated_at = Time.now
+      end
+
+      parameter_value_category.name = name
+      parameter_value_category.display_order = display_order.to_i
+      parameter_value_category.collapse = collapse
+      parameter_value_category.deleted_at = nil
+      error_message "parameter value category #{unique_identifier} could not be saved: #{parameter_value_category.errors.full_messages}" unless parameter_value_category.save
+      notification_message 'parameter value category saved'
+      updated_parameter_value_categories << parameter_value_category
+      parameter_value_category
+    end
+
+    def error_message(str, target=nil)
+      errors << "#{target}: #{str}"
+      puts "ERROR: #{str}"
+      reset_counts
+      raise ActiveRecord::Rollback
+    end
+
+    def notification_message(str)
+      puts str unless self.options[:trace].blank?
+    end
+
+    def to_bool(s)
+      return true if s == true || s =~ (/^(true|t|yes|y|1)$/i)
+      return false if s == false || s.blank? || s =~ (/^(false|f|no|n|0)$/i)
+      error_message("invalid value for Boolean: \"#{s}\"")
+    end
+
+    def deleted?(param)
+      return false if param.blank?
+      to_bool(param)
+    end
+
+    private
+      def cleanup
+        cleanup_parameter_value_categories
+        cleanup_parameter_values
+        cleanup_parameters
+        cleanup_categories
+        cleanup_dictionaries
+      end
+
+      def cleanup_dictionaries
+        abandoned_dictionaries  = Discerner::Dictionary.order(:id).to_a - updated_dictionaries
+        used_dictionaries       = abandoned_dictionaries.reject{|d| d.searches.blank?}
+        not_used_dictionaries   = abandoned_dictionaries - used_dictionaries
+
+        used_dictionaries.each do |r|
+          notification_message("marking dictionary #{r.name} as deleted");
+          r.deleted_at = Time.now
+          error_message "dictionary could not be updated: #{r.errors.full_messages}", r.name unless r.save
+        end
+
+        unless not_used_dictionaries.blank?
+          notification_message("permanently deleting dictionaries #{not_used_dictionaries.map{|r| r.name}.join(', ')}");
+          not_used_dictionaries.each{|r| r.destroy}
+        end
+      end
+
+      def cleanup_categories
+        abandoned_categories = Discerner::ParameterCategory.order(:id).to_a - updated_categories
+        used_categories      = abandoned_categories.reject{|c| c.parameters.blank? || c.parameters.select{|p| p.used_in_search?}.blank?}
+        not_used_categories  = abandoned_categories - used_categories
+
+        used_categories.each do |r|
+          notification_message("marking parameter category #{r.name} as deleted");
+          r.deleted_at = Time.now
+          error_message "parameter category could not be deleted: #{r.errors.full_messages}", r.name unless r.save
+        end
+
+        unless not_used_categories.blank?
+          notification_message("permanently deleting parameter categories #{not_used_categories.map{|r| r.name}.join(', ')}");
+          not_used_categories.each{|r| r.destroy}
+        end
+      end
+
+      def cleanup_parameters
+        abandoned_parameters = Discerner::Parameter.order(:id).to_a - updated_parameters
+        used_parameters      = abandoned_parameters.select{|p| p.used_in_search?}
+        not_used_parameters  = abandoned_parameters - used_parameters
+
+        used_parameters.each do |r|
+          notification_message("marking parameter #{r.name} as deleted");
+          r.deleted_at = Time.now
+          error_message "parameter could not be deleted: #{r.errors.full_messages}", r.name unless r.save
+        end
+
+        unless not_used_parameters.blank?
+          notification_message("permanently deleting parameters #{not_used_parameters.map{|r| r.name}.join(', ')}");
+          not_used_parameters.each{|r| r.destroy}
+        end
+      end
+
+      def cleanup_parameter_value_categories
+        abandoned_categories = Discerner::ParameterValueCategory.order(:id).to_a - updated_parameter_value_categories
+        used_categories      = abandoned_categories.reject{|c| c.parameter_values.blank? || c.parameter_values.select{|v| v.used_in_search?}.blank?}
+        not_used_categories  = abandoned_categories - used_categories
+
+        used_categories.each do |r|
+          notification_message("marking parameter value category #{r.name} as deleted");
+          r.deleted_at = Time.now
+          error_message "parameter value category could not be deleted: #{r.errors.full_messages}", r.name unless r.save
+        end
+
+        unless not_used_categories.blank?
+          notification_message("permanently deleting parameter categories #{not_used_categories.map{|r| r.name}.join(', ')}");
+          not_used_categories.each{|r| r.destroy}
+        end
+      end
+      # this also marks search_parameter_values that reference this value and are chosen as deleted
+      # and destroys search_parameter_values that reference this value but are not chosen (list options)
+      def cleanup_parameter_values
+        abandoned_parameter_values = Discerner::ParameterValue.order(:id).to_a - updated_parameter_values - blank_parameter_values
+        used_parameter_values      = abandoned_parameter_values.select{|p| p.used_in_search?}
+        not_used_parameter_values  = abandoned_parameter_values - used_parameter_values
+
+        used_parameter_values.each do |r|
+          notification_message("marking parameter value #{r.name} as deleted");
+          r.deleted_at = Time.now
+          error_message "parameter value could not be marked as deleted: #{r.errors.full_messages}", r.name unless r.save
+        end
+
+        unless not_used_parameter_values.blank?
+          notification_message("permanently deleting parameter values #{not_used_parameter_values.map{|r| r.name}.join(', ')}");
+          not_used_parameter_values.each{|r| r.destroy}
+        end
+      end
+  end
+end

data/lib/discerner/version.rb

@@ -0,0 +1,3 @@
+module Discerner
+  VERSION = "1.1.18"
+end

data/lib/discerner.rb

@@ -0,0 +1,4 @@
+require "discerner/engine"
+
+module Discerner
+end

data/lib/generators/discerner/dictionary/dictionary_generator.rb

@@ -0,0 +1,38 @@
+module Discerner
+  class DictionaryGenerator < Rails::Generators::Base
+    class_option "no-load",   :type => :boolean
+    class_option "no-models", :type => :boolean
+    class_option "no-views",  :type => :boolean
+
+    source_root File.expand_path('../templates', __FILE__)
+    argument :dictionary_file_path, :type => :string
+
+    def parse_dictionary_file
+      rake("discerner:setup:dictionaries FILE=#{dictionary_file_path}") unless options["no-load"]
+    end
+
+    def create_stub_dictionary_files
+      Discerner::Dictionary.not_deleted.each do |dictionary|
+        create_dictionary_class(dictionary) unless options["no-models"]
+        create_dictionary_view(dictionary)  unless options["no-views"]
+      end
+    end
+
+    def add_excel_mime_type
+      inject_into_file("#{Rails.root}/config/initializers/mime_types.rb", 'Mime::Type.register "application/xls", :xls', :after => "# Be sure to restart your server when you modify this file.\n")
+    end
+
+    private
+      def create_dictionary_class(dictionary)
+        @class_name = dictionary.parameterized_name.camelize
+        template "model.rb", "#{Rails.root}/app/models/#{dictionary.parameterized_name}.rb"
+      end
+
+      def create_dictionary_view(dictionary)
+        @dictionary_name = dictionary.name
+        empty_directory "#{Rails.root}/app/views/discerner/dictionaries/#{dictionary.parameterized_name}"
+        template "view.html.haml", "#{Rails.root}/app/views/discerner/dictionaries/#{dictionary.parameterized_name}/_results.html.haml"
+        template "show.xls.erb", "#{Rails.root}/app/views/discerner/dictionaries/#{dictionary.parameterized_name}/show.xls.erb"
+      end
+  end
+end

data/lib/generators/discerner/dictionary/templates/model.rb

@@ -0,0 +1,15 @@
+class <%= @class_name %>
+  attr_accessor :search
+
+  def initialize(search)
+    @search = search
+  end
+
+  def search(params = {}, options = {})
+
+  end
+
+  def export(params = {}, options = {})
+
+  end
+end

data/lib/generators/discerner/dictionary/templates/show.xls.erb

@@ -0,0 +1,37 @@
+<?xml version="1.0"?>
+<Workbook xmlns="urn:schemas-microsoft-com:office:spreadsheet"
+  xmlns:o="urn:schemas-microsoft-com:office:office"
+  xmlns:x="urn:schemas-microsoft-com:office:excel"
+  xmlns:ss="urn:schemas-microsoft-com:office:spreadsheet"
+  xmlns:html="http://www.w3.org/TR/REC-html40">
+  <Worksheet ss:Name="Sheet1">
+    <Table>
+      <Row>
+        <Cell><Data ss:Type="String">ID</Data></Cell>
+        <Cell><Data ss:Type="String">Name</Data></Cell>
+        <Cell><Data ss:Type="String">Release Date</Data></Cell>
+        <Cell><Data ss:Type="String">Price</Data></Cell>
+      </Row>
+    </Table>
+  </Worksheet>
+  <Worksheet ss:Name="Sheet2">
+    <Table>
+      <Row>
+        <Cell><Data ss:Type="String">ID</Data></Cell>
+        <Cell><Data ss:Type="String">Name</Data></Cell>
+        <Cell><Data ss:Type="String">Release Date</Data></Cell>
+        <Cell><Data ss:Type="String">Price</Data></Cell>
+      </Row>
+    </Table>
+  </Worksheet>
+  <Worksheet ss:Name="Sheet3">
+    <Table>
+      <Row>
+        <Cell><Data ss:Type="String">ID</Data></Cell>
+        <Cell><Data ss:Type="String">Name</Data></Cell>
+        <Cell><Data ss:Type="String">Release Date</Data></Cell>
+        <Cell><Data ss:Type="String">Price</Data></Cell>
+      </Row>
+    </Table>
+  </Worksheet>
+</Workbook>

data/lib/generators/discerner/dictionary/templates/view.html.haml

@@ -0,0 +1,2 @@
+%p
+  Results for search on the `<%=@dictionary_name %>` dictionary can be added here