dbviewer 0.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 8d10de35b5f14855ae9b48f687d54ebc97d5fef12049575ca0c3d2ff05803407
+  data.tar.gz: bf2ced6c5eb2ac2e6c643d3bee0fb0e37e552c9e96f3fbc6a401e760130337bc
+SHA512:
+  metadata.gz: 15fe890300e21acdddcd3d5452bd4ac2ff6d1bb65e889cff892e9c1dca0d16929f2af33bf2b848278353c82c9d0fecfb8a540f40ffc8c58801f953566d3416d0
+  data.tar.gz: 12c1bee1aee7989157c7faf79c69fa101a81412503c762917d91e65d0624444eb4bc86a45cce37ee9a7efb13573542e65a92529be95f333c6522babb192cfb41

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright Wailan Tirajoh
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,250 @@
+# 👁️ DBViewer
+
+DBViewer is a powerful Rails engine that provides a comprehensive interface to view and explore database tables, records, and schema.
+It's designed for development, debugging, and database analysis, offering a clean and intuitive way to interact with your application's database.
+
+<img width="1470" alt="image" src="https://github.com/user-attachments/assets/c946a286-e80a-4cca-afa0-654052e4ef2c" />
+
+## ✨ Features
+
+- **Dashboard**: View a comprehensive dashboard with database analytics, largest tables, most complex tables, and recent SQL queries
+- **Table Overview**: View a list of all tables with record count, column count, and quick access links
+- **Detailed Schema Information**:
+  - View columns with their types, nullability, defaults, and primary key indicators
+  - Examine table indexes and their uniqueness constraints
+  - Explore foreign key relationships between tables
+- **Entity Relationship Diagram (ERD)**:
+  - Interactive visualization of database schema and table relationships
+  - Zoomable and pannable diagram to explore complex database structures
+  - Full table details including all columns and their data types
+  - Visual representation of foreign key relationships between tables
+- **Data Browsing**:
+  - Browse table records with customizable pagination (10, 20, 50, or 100 records per page)
+  - Sort data by any column in ascending or descending order
+  - Navigate through large datasets with an intuitive pagination interface
+  - Scrollable table with fixed headers for improved navigation
+  - Single-line cell display with ellipsis for wide content (tooltips on hover)
+- **SQL Queries**:
+  - Run custom SELECT queries against your database in a secure, read-only environment
+  - View table structure reference while writing queries
+  - Protection against potentially harmful SQL operations
+  - Query execution statistics and timing
+- **Enhanced UI Features**:
+  - Responsive, Bootstrap-based interface that works on desktop and mobile
+  - Fixed header navigation with quick access to all features
+  - Modern sidebar layout with improved filtering and scrollable table list
+  - Clean tabbed interface for exploring different aspects of table structure
+  - Advanced table filtering with keyboard navigation support
+  - Proper formatting for various data types (dates, JSON, arrays, etc.)
+  - Enhanced data presentation with appropriate styling
+
+## 📸 Screenshots
+
+<details>
+  <summary>Click to see more screenshots</summary>
+  
+  #### Dashboard Overview
+  <img width="1470" alt="image" src="https://github.com/user-attachments/assets/4e803d51-9a5b-4c80-bb4c-a761dba15a40" />
+
+#### Table Details
+
+  <img width="1470" alt="image" src="https://github.com/user-attachments/assets/fe425ab4-5b22-4839-87bc-050b80ad4cf0" />
+
+#### Query Editor
+
+  <img width="1470" alt="image" src="https://github.com/user-attachments/assets/392c73c7-0724-4a39-8ffa-8ff5115c5d5f" />
+
+#### Query Logs
+
+  <img width="1470" alt="image" src="https://github.com/user-attachments/assets/7fcf3355-be3c-4d6a-9ab0-811333be5bbc" />
+
+#### ERD
+
+  <img width="1470" alt="image" src="https://github.com/user-attachments/assets/0a2f838f-4ca6-4592-b939-7c7f8ac40f48" />
+  
+</details>
+
+## 📥 Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "dbviewer", group: :development
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+## 🔧 Usage
+
+Mount the engine in your application's `config/routes.rb` file:
+
+```ruby
+Rails.application.routes.draw do
+  # Your application routes...
+
+  # Mount the DBViewer engine
+  if Rails.env.development?
+    mount Dbviewer::Engine, at: "/dbviewer"
+  end
+end
+```
+
+Then, visit `/dbviewer` in your browser to access the database viewer.
+
+### Rails API-only Applications
+
+If you're using a Rails API-only application (created with `--api` flag), you'll need to enable the Flash middleware for DBViewer to work properly. Add the following to your `config/application.rb`:
+
+```ruby
+module YourApp
+  class Application < Rails::Application
+    # ... existing configuration
+
+    # Required for DBViewer flash messages
+    config.middleware.use ActionDispatch::Flash
+  end
+end
+```
+
+This is necessary because API-only Rails applications don't include the Flash middleware by default, which DBViewer uses for displaying notifications.
+
+### Available Pages
+
+- **Dashboard** (`/dbviewer`): Comprehensive overview with database statistics and analytics
+- **Tables Index** (`/dbviewer/tables`): Shows all tables in your database with column counts and quick access
+- **Table Details** (`/dbviewer/tables/:table_name`): Shows table structure and records with pagination
+- **SQL Query** (`/dbviewer/tables/:table_name/query`): Allows running custom SQL queries
+- **ERD View** (`/dbviewer/entity_relationship_diagrams`): Interactive Entity Relationship Diagram of your database
+- **SQL Query Logs** (`/dbviewer/logs`): View and analyze logged SQL queries with performance metrics
+
+## 🤝🏻 Extending DBViewer
+
+### Adding Custom Functionality
+
+You can extend the database manager with custom methods:
+
+```ruby
+# config/initializers/dbviewer_extensions.rb
+Rails.application.config.to_prepare do
+  Dbviewer::DatabaseManager.class_eval do
+    def table_statistics(table_name)
+      # Your custom code to generate table statistics
+      {
+        avg_row_size: calculate_avg_row_size(table_name),
+        last_updated: last_updated_timestamp(table_name)
+      }
+    end
+
+    private
+
+    def calculate_avg_row_size(table_name)
+      # Implementation...
+    end
+
+    def last_updated_timestamp(table_name)
+      # Implementation...
+    end
+  end
+end
+```
+
+## ⚙️ Configuration Options
+
+You can configure DBViewer by creating an initializer in your application:
+
+```ruby
+# config/initializers/dbviewer.rb
+Dbviewer.configure do |config|
+  config.per_page_options = [10, 20, 50, 100, 250]  # Default pagination options
+  config.default_per_page = 20                       # Default records per page
+  config.max_query_length = 10000                    # Maximum SQL query length
+  config.cache_expiry = 300                          # Cache expiration in seconds
+  config.max_records = 10000                         # Maximum records to return in any query
+  config.enable_data_export = false                  # Whether to allow data exporting
+  config.query_timeout = 30                          # SQL query timeout in seconds
+
+  # Query logging options
+  config.query_logging_mode = :memory                # Storage mode for SQL queries (:memory or :file)
+  config.query_log_path = "log/dbviewer.log"         # Path for query log file when in :file mode
+  config.max_memory_queries = 1000                   # Maximum number of queries to store in memory
+end
+```
+
+The configuration is accessed through `Dbviewer.configuration` throughout the codebase. You can also access it via `Dbviewer.config` which is an alias for backward compatibility.
+
+## 🪵 Query Logging
+
+DBViewer includes a powerful SQL query logging system that captures and analyzes database queries. You can access this log through the `/dbviewer/logs` endpoint. The logging system offers two storage backends:
+
+### In-Memory Storage (Default)
+
+By default, queries are stored in memory. This provides fast access but queries are lost when the application restarts:
+
+```ruby
+config.query_logging_mode = :memory       # Store queries in memory (default)
+config.max_memory_queries = 1000          # Maximum number of queries stored
+```
+
+### File-Based Storage
+
+For persistent logging across application restarts, you can use file-based storage:
+
+```ruby
+config.query_logging_mode = :file         # Store queries in a log file
+config.query_log_path = "log/dbviewer.log" # Path where query log file will be stored
+```
+
+The file format uses one JSON entry per line, making it easy to analyze with standard tools.
+
+## 🔒 Security Features
+
+DBViewer includes several security features to protect your database:
+
+- **Read-only Mode**: Only SELECT queries are allowed; all data modification operations are blocked
+- **SQL Validation**: Prevents potentially harmful operations with comprehensive validation
+- **Query Limits**: Automatic LIMIT clause added to prevent excessive data retrieval
+- **Pattern Detection**: Detection of SQL injection patterns and suspicious constructs
+- **Error Handling**: Informative error messages without exposing sensitive information
+
+## 🌱 Production Access (Not Recommended)
+
+By default, DBViewer only runs in development or test environments for security reasons. If you need to access it in production (not recommended):
+
+1. Set an environment variable with a secure random key:
+
+   ```
+   DBVIEWER_PRODUCTION_ACCESS_KEY=your_secure_random_key
+   ```
+
+2. Add an additional constraint in your routes:
+
+   ```ruby
+   if Rails.env.production?
+     constraints ->(req) { req.params[:access_key] == ENV["DBVIEWER_PRODUCTION_ACCESS_KEY"] } do
+       mount Dbviewer::Engine, at: "/dbviewer"
+     end
+   else
+     mount Dbviewer::Engine, at: "/dbviewer"
+   end
+   ```
+
+3. Access the tool with the override parameter:
+   ```
+   https://yourdomain.com/dbviewer?override_env_check=your_secure_random_key
+   ```
+
+## 📝 Security Note
+
+⚠️ **Warning**: This engine is designed for development purposes. It's not recommended to use it in production as it provides direct access to your database contents. If you must use it in production, ensure it's protected behind authentication and use the production access key mechanism with a strong random key.
+
+## 🤌🏻 Contributing
+
+Bug reports and pull requests are welcome.
+
+## 📄 License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,8 @@
+require "bundler/setup"
+
+APP_RAKEFILE = File.expand_path("test/dummy/Rakefile", __dir__)
+load "rails/tasks/engine.rake"
+
+load "rails/tasks/statistics.rake"
+
+require "bundler/gem_tasks"

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

@@ -0,0 +1,21 @@
+/*
+ * 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_self
+ *= require dbviewer/enhanced
+ *= require dbviewer/dbviewer
+ */
+
+/* 
+ * Note: Critical styles are also included inline in the application layout
+ * to ensure the UI is functional even if asset compilation fails
+ */

data/app/controllers/concerns/dbviewer/database_operations.rb

@@ -0,0 +1,354 @@
+module Dbviewer
+  module DatabaseOperations
+    extend ActiveSupport::Concern
+
+    included do
+      helper_method :current_table?, :get_database_name if respond_to?(:helper_method)
+    end
+
+    # Initialize the database manager
+    def database_manager
+      @database_manager ||= ::Dbviewer::DatabaseManager.new
+    end
+
+    # Get the name of the current database
+    def get_database_name
+      adapter = database_manager.connection.adapter_name.downcase
+
+      case adapter
+      when /mysql/
+        query = "SELECT DATABASE() as db_name"
+        result = database_manager.execute_query(query).first
+        result ? result["db_name"] : "Database"
+      when /postgres/
+        query = "SELECT current_database() as db_name"
+        result = database_manager.execute_query(query).first
+        result ? result["db_name"] : "Database"
+      when /sqlite/
+        # For SQLite, extract the database name from the connection_config
+        database_path = ActiveRecord::Base.connection.pool.spec.config[:database] || ""
+        File.basename(database_path, ".*") || "SQLite Database"
+      else
+        "Database" # Default fallback
+      end
+    rescue => e
+      Rails.logger.error("Error retrieving database name: #{e.message}")
+      "Database"
+    end
+
+    # Fetch all tables with their stats
+    # By default, don't include record counts for better performance on sidebar
+    def fetch_tables_with_stats(include_record_counts = false)
+      database_manager.tables.map do |table_name|
+        table_stats = {
+          name: table_name,
+          columns_count: database_manager.column_count(table_name)
+        }
+
+        # Only fetch record counts if explicitly requested
+        table_stats[:record_count] = database_manager.record_count(table_name) if include_record_counts
+
+        table_stats
+      end
+    end
+
+    # Gather database analytics information
+    def fetch_database_analytics
+      # For analytics, we do need record counts
+      tables = fetch_tables_with_stats(include_record_counts: true)
+
+      # Calculate overall statistics
+      analytics = {
+        total_tables: tables.size,
+        total_records: tables.sum { |t| t[:record_count] },
+        total_columns: tables.sum { |t| t[:columns_count] },
+        largest_tables: tables.sort_by { |t| -t[:record_count] }.first(5),
+        widest_tables: tables.sort_by { |t| -t[:columns_count] }.first(5),
+        empty_tables: tables.select { |t| t[:record_count] == 0 }
+      }
+
+      # Calculate schema size if possible
+      begin
+        analytics[:schema_size] = calculate_schema_size
+      rescue => e
+        Rails.logger.error("Error calculating schema size: #{e.message}")
+        analytics[:schema_size] = nil
+      end
+
+      # Calculate average rows per table
+      if tables.any?
+        analytics[:avg_records_per_table] = (analytics[:total_records].to_f / tables.size).round(1)
+        analytics[:avg_columns_per_table] = (analytics[:total_columns].to_f / tables.size).round(1)
+      else
+        analytics[:avg_records_per_table] = 0
+        analytics[:avg_columns_per_table] = 0
+      end
+
+      analytics
+    end
+
+    # Calculate approximate schema size
+    def calculate_schema_size
+      adapter = database_manager.connection.adapter_name.downcase
+
+      case adapter
+      when /mysql/
+        query = <<-SQL
+          SELECT
+            SUM(data_length + index_length) AS size
+          FROM
+            information_schema.TABLES
+          WHERE
+            table_schema = DATABASE()
+        SQL
+        result = database_manager.execute_query(query).first
+        result ? result["size"].to_i : nil
+      when /postgres/
+        query = <<-SQL
+          SELECT pg_database_size(current_database()) AS size
+        SQL
+        result = database_manager.execute_query(query).first
+        result ? result["size"].to_i : nil
+      when /sqlite/
+        # For SQLite, we need to use the special PRAGMA method without LIMIT
+        # Get page count
+        page_count_result = database_manager.execute_sqlite_pragma("page_count")
+        page_count = page_count_result.first.values.first.to_i
+
+        # Get page size
+        page_size_result = database_manager.execute_sqlite_pragma("page_size")
+        page_size = page_size_result.first.values.first.to_i
+
+        # Calculate total size
+        page_count * page_size
+      else
+        nil # Unsupported database type for size calculation
+      end
+    rescue => e
+      Rails.logger.error("Error calculating database size: #{e.message}")
+      nil
+    end
+
+    # Get column information for a specific table
+    def fetch_table_columns(table_name)
+      database_manager.table_columns(table_name)
+    end
+
+    # Get the total number of records in a table
+    def fetch_table_record_count(table_name)
+      database_manager.table_count(table_name)
+    end
+
+    # Fetch records for a table with pagination and sorting
+    def fetch_table_records(table_name)
+      database_manager.table_records(
+        table_name,
+        @current_page,
+        @order_by,
+        @order_direction,
+        @per_page
+      )
+    end
+
+    # Safely quote a table name, with fallback
+    def safe_quote_table_name(table_name)
+      database_manager.connection.quote_table_name(table_name)
+    rescue => e
+      Rails.logger.warn("Failed to quote table name: #{e.message}")
+      table_name
+    end
+
+    # Get table metadata for display (e.g., primary key, foreign keys, indexes)
+    def fetch_table_metadata(table_name)
+      return {} unless database_manager.respond_to?(:table_metadata)
+
+      begin
+        database_manager.table_metadata(table_name)
+      rescue => e
+        Rails.logger.warn("Failed to fetch table metadata: #{e.message}")
+        {}
+      end
+    end
+
+    # Fetch relationships between tables for ERD visualization
+    def fetch_table_relationships
+      relationships = []
+
+      @tables.each do |table|
+        table_name = table[:name]
+
+        # Get foreign keys defined in this table pointing to others
+        begin
+          metadata = database_manager.table_metadata(table_name)
+          if metadata && metadata[:foreign_keys].present?
+            metadata[:foreign_keys].each do |fk|
+              relationships << {
+                from_table: table_name,
+                to_table: fk[:to_table],
+                from_column: fk[:column],
+                to_column: fk[:primary_key],
+                name: fk[:name]
+              }
+            end
+          end
+        rescue => e
+          Rails.logger.error("Error fetching relationships for #{table_name}: #{e.message}")
+        end
+      end
+
+      relationships
+    end
+
+    # Prepare the SQL query - either from params or default
+    def prepare_query
+      quoted_table = safe_quote_table_name(@table_name)
+      default_query = "SELECT * FROM #{quoted_table} LIMIT 100"
+
+      # Use the raw query parameter, or fall back to default
+      @query = params[:query].present? ? params[:query].to_s : default_query
+
+      # Validate query for security
+      unless ::Dbviewer::SqlValidator.safe_query?(@query)
+        @query = default_query
+        flash.now[:warning] = "Only SELECT queries are allowed. Your query contained potentially unsafe operations. Using default query instead."
+      end
+    end
+
+    # Execute the prepared SQL query
+    def execute_query
+      begin
+        @records = database_manager.execute_query(@query)
+        @error = nil
+      rescue => e
+        @records = nil
+        @error = e.message
+        Rails.logger.error("SQL Query Error: #{e.message} for query: #{@query}")
+      end
+    end
+
+    # Helper to check if this is the current table in the UI
+    def current_table?(table_name)
+      params[:id] == table_name
+    end
+
+    # Export table data to CSV
+    def export_table_to_csv(table_name, limit = 10000, include_headers = true)
+      require "csv"
+
+      begin
+        records = database_manager.table_records(
+          table_name,
+          1, # First page
+          nil, # Default sorting
+          "asc",
+          limit # Limit number of records
+        )
+
+        csv_data = CSV.generate do |csv|
+          # Add headers if requested
+          csv << records.columns if include_headers
+
+          # Add rows
+          records.rows.each do |row|
+            csv << row.map { |cell| format_csv_value(cell) }
+          end
+        end
+
+        csv_data
+      rescue => e
+        Rails.logger.error("CSV Export error for table #{table_name}: #{e.message}")
+        raise "Error exporting to CSV: #{e.message}"
+      end
+    end
+
+    private
+
+    # Format cell values for CSV export to handle nil values and special characters
+    def format_csv_value(value)
+      return "" if value.nil?
+      value.to_s
+    end
+
+    # Check if a table has a created_at column for timestamp visualization
+    def has_timestamp_column?(table_name)
+      columns = fetch_table_columns(table_name)
+      columns.any? { |col| col[:name] == "created_at" && [ :datetime, :timestamp ].include?(col[:type]) }
+    end
+
+    # Fetch timestamp data for visualization (hourly, daily, weekly)
+    def fetch_timestamp_data(table_name, grouping = "daily")
+      return nil unless has_timestamp_column?(table_name)
+
+      quoted_table = safe_quote_table_name(table_name)
+      adapter = database_manager.connection.adapter_name.downcase
+
+      sql_query = case grouping
+      when "hourly"
+        case adapter
+        when /mysql/
+          "SELECT DATE_FORMAT(created_at, '%Y-%m-%d %H:00:00') as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 48"
+        when /postgres/
+          "SELECT date_trunc('hour', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 48"
+        else # SQLite and others
+          "SELECT strftime('%Y-%m-%d %H:00:00', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 48"
+        end
+      when "daily"
+        case adapter
+        when /mysql/
+          "SELECT DATE_FORMAT(created_at, '%Y-%m-%d') as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 30"
+        when /postgres/
+          "SELECT date_trunc('day', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 30"
+        else # SQLite and others
+          "SELECT strftime('%Y-%m-%d', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 30"
+        end
+      when "weekly"
+        case adapter
+        when /mysql/
+          "SELECT DATE_FORMAT(created_at, '%Y-%u') as time_group, YEARWEEK(created_at) as sort_key, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY sort_key DESC LIMIT 26"
+        when /postgres/
+          "SELECT date_trunc('week', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 26"
+        else # SQLite and others
+          "SELECT strftime('%Y-%W', created_at) as time_group, COUNT(*) as count FROM #{quoted_table} GROUP BY time_group ORDER BY time_group DESC LIMIT 26"
+        end
+      else
+        return nil
+      end
+
+      begin
+        result = database_manager.execute_query(sql_query)
+
+        # Format the data for the chart
+        result.map do |row|
+          time_str = row["time_group"].to_s
+          count = row["count"].to_i
+
+          # Format the label based on grouping type
+          label = case grouping
+          when "hourly"
+            # For hourly, show "May 10, 2PM"
+            time = time_str.is_a?(Time) ? time_str : Time.parse(time_str)
+            time.strftime("%b %d, %l%p")
+          when "daily"
+            # For daily, show "May 10"
+            time = time_str.is_a?(Time) ? time_str : (time_str.include?("-") ? Time.parse(time_str) : Time.now)
+            time.strftime("%b %d")
+          when "weekly"
+            # For weekly, show "Week 19" or the week's start date
+            if time_str.include?("-")
+              week_num = time_str.split("-").last.to_i
+              "Week #{week_num}"
+            else
+              time = time_str.is_a?(Time) ? time_str : Time.parse(time_str)
+              "Week #{time.strftime('%W')}"
+            end
+          end
+
+          { label: label, value: count, raw_date: time_str }
+        end
+      rescue => e
+        Rails.logger.error("[DBViewer] Error fetching timestamp data: #{e.message}")
+        nil
+      end
+    end
+  end
+end