rails_db_browser 0.0.9

data/.gitignore

@@ -0,0 +1,3 @@
+pkg
+*.swp
+

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Sokolov Yura aka funny_falcon
+
+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

@@ -0,0 +1,60 @@
+= RailsDbBrowser
+
+Simple database browser for Rails application backed by ActiveRecord
+
+== Instalation
+
+=== Rails 2.3
+
+in config/environment.rb
+
+    config.gem 'rails_db_browser'
+
+and then create an app/metal/db_browse.rb
+
+    DbBrowse = RailsDbBrowser::Runner.new('/db_browse')
+    
+=== Rails 3
+
+in Rails 3 in Gemfile
+
+    gem 'rails_db_browser'
+
+in config/routes.rb
+
+  match "db_browse(/*s)", :to => RailsDbBrowser::Runner.new('/db_browse')
+
+== Security
+
+It is up to you to provide security.
+
+You could check environment and run browser only in development.
+If you user Rails 2.3 then you still should provide empty Rack application as metal
+
+  class DbBrowse
+    def self.call(env)
+      [404, nil, nil]
+    end
+  end
+  
+You could use Rack::Builder with combination of any Rack authentication middleware
+
+  DbBrowse = Rack::Builder.new do
+    use RailsDbBrowser::URLTruncate, '/db_browse'
+    use Rack::Auth::Basic, 'db_browser' do |user, password|
+      user == 'admin' && password == 'iamgod'
+    end
+    run RailsDbBrowser::DbBrowser
+  end
+  
+(Well, I've tested it in Rails2.3. Rails3 application with Devise falls on wrong password) 
+
+== Repository
+
+Source is hosted on github
+
+http://github.com/funny-falcon/rails_db_browser
+
+== Copyright
+
+Copyright (c) 2010 Sokolov Yura aka funny_falcon, released under the MIT license

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/rdoctask'
+
+desc 'Generate documentation for the db_browser plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'DbBrowser'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "rails_db_browser"
+    gemspec.summary = "Simple database browser for Rails application backed by ActiveRecord"
+    gemspec.description = "Simple sinatra Rack application that allowes to run sql queries from a web page. Usable for administrative tasks."
+    gemspec.email = "funny.falcon@gmail.com"
+    gemspec.homepage = "http://github.com/funny-falcon/rails_db_browser"
+    gemspec.authors = ["Sokolov Yura aka funny_falcon"]
+    gemspec.add_dependency('sinatra')
+    gemspec.add_dependency('haml')
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.9

data/init.rb

@@ -0,0 +1,2 @@
+# Include hook code here
+require 'rails_db_browser'

data/lib/rails_db_browser.rb

@@ -0,0 +1,17 @@
+# RailsDbBrowser
+require 'sinatra/base'
+require 'rails_db_browser/url_truncate'
+require 'rails_db_browser/connection_keeper'
+require 'rails_db_browser/db_browser'
+
+module RailsDbBrowser
+  class Runner
+    def initialize(path)
+      @url_truncate = URLTruncate.new(DbBrowser, path)
+    end
+    
+    def call(env)
+      @url_truncate.call(env)
+    end
+  end
+end

data/lib/rails_db_browser/connection_keeper.rb

@@ -0,0 +1,169 @@
+module RailsDbBrowser
+  # Abstract class holding connection staff
+  class ConnectionKeeper
+    # get connection names
+    def connection_names
+      ActiveRecord::Base.configurations.keys
+    end
+
+    def connection(name=nil)
+      underlying = unless name.present?
+        ActiveRecord::Base.connection
+      else
+        FakeModel.get_connection(name)
+      end
+      Connection.new(underlying)
+    end
+
+    class FakeModel < ActiveRecord::Base
+      @abstract_class = true
+      CONNECTS = {}
+      def self.get_connection(name)
+        CONNECTS[name] ||= begin
+          establish_connection(name)
+          connection
+        end
+      end
+    end
+
+    # performs common operations on connection
+    class Connection
+      attr_accessor :connection
+      delegate :quote_table_name, :quote_column_name, :quote,
+               :select_value, :select_all,
+               :update, :insert, :delete,
+               :add_limit_offset!,
+               :to => :connection
+
+      def initialize(connection)
+        @connection = connection
+      end
+
+      # getting list of column definitions 
+      # and order them to be more human readable
+      def columns(table)
+        columns = get_column_definitions(table)
+        columns.sort_by{|c| 
+          [
+            fields_to_head.index(c.name) || 1e6,
+            -(fields_to_tail.index(c.name) || 1e6),
+            c.name
+          ]
+        }
+      end
+
+      def column_names(table)
+        columns(table).map{|c| c.name}
+      end
+
+      def table_names
+        @connection.tables.sort
+      end
+
+      # fields to see first
+      def fields_to_head
+        @fields_to_head ||= %w{id name login value}
+      end
+
+      # fields to see last
+      def fields_to_tail
+        @fields_to_tail ||= %w{created_at created_on updated_at updated_on}
+      end
+
+      attr_writer :fields_to_head, :fields_to_tail
+
+      # sort field names in a rezult
+      def sort_fields(fields)
+        fields = (fields_to_head & fields) | (fields - fields_to_head)
+        fields = (fields - fields_to_tail) | (fields_to_tail & fields)
+        fields
+      end
+
+      # performs query with appropriate method
+      def query(sql, opts={})
+        per_page = (opts[:perpage] || nil).to_i
+        page     = (opts[:page]    || 1  ).try(:to_i)
+        fields   = opts[:fields]   || nil
+        case sql
+        when /\s*select/i , /\s*(update|insert|delete).+returning/im
+          rez = {:fields => fields}
+          if sql =~ /\s*select/i && per_page > 0
+            rez[:count] = select_value("select count(*) from (#{sql}) as t").to_i
+            rez[:pages] = (rez[:count].to_f / per_page).ceil
+            sql = "select * from (#{sql}) as t"
+            add_limit_offset!( sql, 
+                              :limit => per_page,
+                              :offset => per_page * (page - 1))
+          end
+
+          rez[:rows] = select_all( sql )
+
+          unless rez[:rows].blank?
+            rez[:fields] ||= []
+            rez[:fields].concat( self.sort_fields(rez[:rows].first.keys) - rez[:fields] )
+          end
+
+          Result.new(rez)
+        when /\s*update/i
+          Result.new :value => update( sql )
+        when /\s*insert/i
+          Result.new :value => insert( sql )
+        when /\s*delete/i
+          Result.new :value => delete( sql )
+        end
+      rescue StandardError => e
+        Result.new :error => e
+      end
+
+      private
+      def get_column_definitions(table)
+        @connection.columns(table).map{|c|
+          Column.new(c.name, c.sql_type, c.default, c.null)
+        }
+      end
+
+    end
+
+    class Column
+      attr_accessor :name, :type, :default, :null
+      def initialize(name, type, default, null)
+        @name = name
+        @type = type
+        @default = default
+        @null = null
+      end
+    end
+
+    class Result
+      attr_accessor :rows, :count, :pages, :fields, :error
+      def initialize(opts={})
+        if opts[:value]
+          @value = [opts[:value]]
+        elsif opts[:rows]
+          @rows = opts[:rows]
+          @count = opts[:count] || @rows.size
+          @pages = opts[:pages] || 1
+          @fields = opts[:fields]
+        elsif opts[:error]
+          @error = opts[:error]
+        end
+      end
+
+      def value
+        @value && @value[0]
+      end
+
+      def value?
+        @value.present?
+      end
+
+      def error?
+        @error.present?
+      end
+
+      def rows?
+        @rows != nil
+      end
+    end
+  end
+end

data/lib/rails_db_browser/db_browser.rb

@@ -0,0 +1,189 @@
+module RailsDbBrowser
+  class TableColumns < Struct.new(:table, :columns)
+  end
+
+  class DbBrowser < Sinatra::Base
+    enable :session
+    set :views, File.join(File.dirname(__FILE__), '../../views')
+    set :public, File.join(File.dirname(__FILE__), '../../public')
+    set :connect_keeper, ConnectionKeeper.new
+    enable :show_exceptions
+
+    helpers do
+      def logger
+        ActiveRecord::Base.logger
+      end
+
+      def keeper
+        settings.connect_keeper
+      end
+      
+      def connection
+        keeper.connection(params[:connection])
+      end
+      
+      def connection_names
+        keeper.connection_names
+      end
+      
+      def url(path, add_params={})
+        path = path.sub(%r{/+$},'')
+        query = add_params.to_query
+        relative = query.present? ? "#{path}?#{query}" : path
+        "#{request.script_name}#{relative}"
+      end
+
+      def keep_params(path, add_params={})
+        url path, params.slice("connection", "perpage").merge(add_params)
+      end
+      
+      def merge_params(add_params)
+        query = params.merge(add_params).to_query
+        query.present? ? "?#{query}" : ""
+      end
+      
+      def connection_field
+        haml :_connection_field, :layout => false
+      end
+      
+      def per_page_field
+        haml :_per_page_field, :layout => false
+      end
+       
+      def columns(table)
+        connection.columns(table)
+      end
+
+      def column_names(table)
+        connection.column_names(table)
+      end
+
+      def extract_tables(fields)
+        tables = []
+        for field in fields
+          if field =~ /(?:([\w\.]+)\.)?(\w+)/
+            table, column = $1, $2
+          else
+            table, column = nil, field
+          end
+          if !tables.last || tables.last.table != table
+            tables << TableColumns.new(table, [column])
+          else
+            tables.last.columns << column
+          end
+        end
+        tables
+      end
+      
+      def inspect_env
+        haml <<'HAML', :layout => false
+%pre
+  \ 
+  - env.sort.each do |k, v|
+    & #{k} = #{v.inspect}
+HAML
+      end
+
+      def table_content_url(table)
+        keep_params("", 
+          :query => "SELECT [[#{table}.*]] FROM #{quote_table_name(table)}\nWHERE 1=1\nORDER BY id")
+      end
+
+      def table_scheme_url(table)
+        keep_params("/s/#{table}")
+      end
+    end
+
+    def quote_table_name(t)
+      connection.quote_table_name(t)
+    end
+
+    def quote_column_name(c)
+      connection.quote_column_name(c)
+    end
+
+    def quote(v)
+      connection.quote(v)
+    end
+    
+    def set_default_perpage
+      params['perpage'] = '25' unless params.has_key?('perpage')
+    end
+
+    def extract_fields_from_special(sql)
+      fields = []
+      sql = sql.gsub(/\[\[([\w.]+)\.\*(?:\s*-\s*((?:\w+[,\s]+)*(?:\w+))\s*)?\]\]/) do 
+        table, without = $1, ($2 || '').scan(/\w+/)
+        table_fields = column_names(table) - without
+
+        table_fields.map{|fld|
+          as = "#{table}.#{fld}"
+          fields << as
+          "#{quote_table_name(table)}.#{quote_column_name(fld)} as #{quote_column_name(as)}"
+        }.join(',')
+      end
+      [ sql, fields ]
+    end
+    
+    def select_all(sql, fields=nil)
+      set_default_perpage
+      unless fields.present?
+        sql, fields = extract_fields_from_special(sql)
+      end
+      connection.query(sql,
+                       :perpage => params[:perpage],
+                       :page    => params[:page],
+                       :fields  => fields
+                      )
+    end
+   
+    get '/d' do
+      File.mtime(__FILE__).to_s+"<br/>\n"+
+        env.map{|k,v| "#{k.inspect} => #{v.inspect} <br/>\n" }.join
+    end
+    get '/s/:table' do
+      @columns = columns(params[:table])
+      haml :table_structure
+    end
+    
+    post '/t/:table' do
+      logger.warn(params.inspect)
+      table = quote_table_name(params[:table])
+      attrs = params[:attrs]
+      if id = attrs.delete('id')
+        names = []
+        sets = attrs.map{|name, value|
+          names << name
+          value = value == 'null' ? nil : value[1..-1]
+          "#{quote_column_name(name)} = #{quote(value)}"
+        }.join(', ')
+        sql = "UPDATE #{table} SET #{sets} WHERE id=#{quote(id)}"
+        rez = select_all(sql)
+        if !rez.error && rez.value > 0
+          names_sql = names.map{|n| quote_column_name(n)}.join(', ')
+          rez = select_all("SELECT #{names_sql} FROM #{table} WHERE id=#{quote(id)}")
+          return rez.rows[0].to_json
+        end
+      end
+      if rez.error
+        response.status = 500
+        "<pre>#{rez.error.message}</pre>"
+      end
+    end
+    
+    DEFAULT_QUERY = 'select * from'
+    get '/' do
+      if params[:query] && params[:query] != DEFAULT_QUERY
+        @result = select_all(params[:query])
+      else
+        set_default_perpage
+      end
+      @query = params[:query] || DEFAULT_QUERY
+      haml :index
+    end
+
+    get '/css.css' do
+      sass :css
+    end
+  end
+end

data/lib/rails_db_browser/url_truncate.rb

@@ -0,0 +1,29 @@
+module RailsDbBrowser
+  # do mostly same thing as Rack::URLMap
+  # but UrlMapper could not work under Rails
+  # usage:
+  #    mounted_app = RailsDbBrowser::URLTruncate.new( RackApplication, '/path')
+  #    mounted_app = RailsDbBrowser::URLTruncate.new( '/path') do |env| [200, {'Content-type': 'text/plain'}, [env.inspect]] end
+  #    app = Rack::Builder.app do
+  #      use RailsDbBrowser::URLTruncate, '/path'
+  #      run RackApplication
+  #    end
+  class URLTruncate
+    def initialize(app_or_path, path = nil, &block)
+      @path = path || app_or_path 
+      @app = block || app_or_path
+    end
+    
+    def call(env)
+      path, script_name = env.values_at("PATH_INFO", "SCRIPT_NAME")
+      if path.start_with?(@path)
+        env.merge!('SCRIPT_NAME' => (script_name + @path), 'PATH_INFO' => path[@path.size .. -1] )
+        @app.call(env)
+      else
+        [404, {"Content-Type" => "text/plain", "X-Cascade" => "pass"}, ["Not Found: #{path}"]]
+      end
+    ensure
+      env.merge!  'PATH_INFO' => path, 'SCRIPT_NAME' => script_name
+    end
+  end
+end

data/public/result.js

@@ -0,0 +1,161 @@
+function fill_id_with_edit_delete($trs) {
+  $trs.find('td[data-column=id] span.actions').html(
+      ' <a href="javascript:void(0)" class="edit">edit</a>' // <a href="javascript:void(0)" class="delete">delete</a>'
+      );
+}
+
+$(function(){
+    function get_cells(that) {
+      var $td = $(that).closest('td');
+      var $tr = $td.closest('tr');
+      var table = $td.data('table');
+      var id = $td.data('id');
+      var $tds = $tr.find('td[data-table="'+table+'"]').not($td);
+      return {
+        $td: $td,
+        $tr: $tr,
+        table: table,
+        $tds: $tds,
+        id: id
+      }
+    }
+
+    $('td[data-column=id] a.edit').live('click', function(){
+      var cells = get_cells(this);
+      cells.$tds.each(function(){
+        var $textarea = $('<textarea></textarea>');
+        var $this = $(this);
+        var nil = $this.data('nil');
+        $this.data('saved-nil', nil);
+        if ( !nil ) {
+          var value = $this.attr('data-value');
+          $this.attr('data-saved-value', value);
+          var lines = value.split(/\n\r|\r\n|\n|\r/);
+          var max = 12;
+          for(var i=0; i < lines.length; i++) {
+            max = Math.max( max, lines[i].length );
+          }
+          $textarea.attr('rows', Math.max(lines.length + 1, 3));
+          $textarea.attr('cols', max + 1);
+        } else {
+          $textarea.attr('disabled', true);
+          $this.attr('data-saved-value', '');
+          $textarea.attr('rows', 3);
+          $textarea.attr('cols', 13);
+        }
+        $textarea.val(value);
+        var $checkbox = $('<input type="checkbox" name="nil" />');
+        $checkbox.attr('checked', !!nil);
+        var chbx_id = cells.table + '_' + cells.id + '_' +
+                      $(this).data('column') + '_nil';
+        $checkbox.attr('id', chbx_id);
+        var $label = $('<label>NULL:</label>').attr('for', chbx_id);
+        $this.html($textarea).append('<br />').
+                append($label).append($checkbox);
+      })
+      cells.$td.find(".actions").html('<a href="javascript:void(0)" class="save">save</a> <a href="javascript:void(0)" class="cancel">cancel</a>');
+    });
+
+    $('td[data-table] input[type=checkbox][name=nil]').live('change', function() {
+        var $td = $(this).closest('td');
+        var $textarea = $td.find('textarea')
+        if ( this.checked ) {
+          $td.attr('data-value', $textarea.val());
+          $textarea.val('').attr('disabled', true);
+          $td.data('nil', true);
+        } else {
+          $textarea.val($td.attr('data-value')).attr('disabled',false);
+          $td.data('nil', false);
+        }
+    });
+
+    function fill_td_with_value($td, value, nil) {
+      if ( value.match(/^\S+$/) ) {
+        $td.text(value);
+        $td.removeClass('inspect');
+      } else {
+        if ( nil ) {
+          value = 'nil';
+          $td.addClass('inspect');
+        } else if ( value.match(/^\s*$/) ){
+          value = '"'+value+'"';
+          $td.addClass('inspect');
+        } else {
+          $td.removeClass('inspect');
+        }
+        var $pre = $('<pre></pre>');
+        $pre.text(value);
+        $td.html($pre);
+      }
+    }
+
+    $('td .actions a.cancel').live('click', function() {
+        var cells = get_cells(this);
+        cells.$tds.each(function(){
+          var $td = $(this);
+          $td.attr('data-value', $td.attr('data-saved-value'));
+          $td.data('nil', $td.data('saved-nil'));
+          var value = $td.attr('data-value');
+          var nil = $td.data('nil');
+          fill_td_with_value($td, value, nil);
+        });
+        fill_id_with_edit_delete(cells.$tr);
+    });
+
+    $('td .actions a.save').live('click', function() {
+        var cells = get_cells(this);
+        var attrs = { "id": cells.id };
+        cells.$tds.each(function(){
+          var $td = $(this);
+          var value = $td.find('input:checkbox[name=nil]').attr('checked') ?
+                    "null" : '!'+$td.find('textarea').val();
+          attrs[$td.attr('data-column')] = value;
+        });
+        $.ajax({
+            url: ROOT+'/t/'+cells.table,
+            dataType: 'json',
+            data: {attrs: attrs},
+            type: 'post',
+            success: function(data) {
+              cells.$tds.each(function(){
+                var $td = $(this);
+                if ( $td.data('column') in data ) {
+                  var value = data[$td.data('column')];
+                  var nil = value === null;
+                  value = value ? value : '';
+                  $td.attr('data-value', value);
+                  $td.data('nil', nil);
+                  fill_td_with_value($td, value, nil);
+                }
+              });
+              fill_id_with_edit_delete(cells.$tr);
+            },
+            error: function(xhr) {
+              var $error = $('#error');
+              var $error_mask = $('#error_mask');
+              $error.find('.content').html(xhr.responseText);
+              
+              var docHeight = $(document).height();
+              var winHeight = $(window).height();
+              var winWidth  = $(window).width();
+              
+              $error_mask.css({ height: winHeight, width: winWidth});
+              $error_mask.show();
+
+              $error.css('display', 'hidden');
+              var topleft = ({
+                    top: Math.max(winHeight - $error.height(), 0)/2,
+                    left: Math.max(winWidth - $error.width(), 0)/2
+                  });
+              $error.css(topleft);
+
+              $error.show();
+            }
+        });
+    });
+
+    $('#error .close, #error_mask').live('click', function() {
+        $('#error').hide();
+        $('#error_mask').hide();
+    });
+});

data/rails/init.rb

@@ -0,0 +1,2 @@
+# encoding: utf-8
+require File.expand_path(File.join(File.dirname(__FILE__), "..", "init"))

data/views/_connection_field.haml

@@ -0,0 +1,5 @@
+%label(for="connection_name") Connection:
+%select.connection_name(name="connection")
+  %option(value="") Default
+  - connection_names.each do |n|
+    %option{:value=>n, :selected=>n == params[:connection]}= n

data/views/_per_page_field.haml

@@ -0,0 +1,6 @@
+%label(for="rezult_perpage") Per page:
+%select.rezult_perpage(name="perpage")
+  %option(value="") No Limits
+  - %w{10 25 50 100 250 500 1000}.each do |n|
+    %option{:value=>n, :selected=> n == params[:perpage]}= n
+

data/views/css.sass

@@ -0,0 +1,58 @@
+body
+  font-size: 0.8em
+$hover-background-color: #dfd
+table
+  font-size: 100%
+  border-spacing: 0
+  thead tr
+    background-color: lightgrey
+  thead tr th
+    border-bottom: 1px solid black
+  td, th
+    border-right: 1px solid black
+    &:last-child
+      border-right: 0 none
+  td.inspect
+    background-color: grey
+  td.id
+    white-space: nowrap
+  &.result tbody
+    td, td pre
+      font-family: monospace
+      margin: 0
+    td span.actions
+      font-family: serif
+      font-size: 0.8em
+    tr:nth-child(odd)
+      background-color: lightcyan
+    tr:hover
+      background-color: $hover-background-color
+.dbtables
+  float: left
+  width: 200px
+  padding-right: 10px
+  h4
+    margin: 0.5em 0
+    padding: 0
+  .list
+    height: 20em
+    overflow: auto
+    .dbtable
+      a.q
+        display: inline-block
+        width: 155px
+.rezult
+  clear: left
+#error
+  position: absolute
+  display: none
+  //width: 440px
+  z-index: 9999
+  border: red 2px solid
+  background-color: #FFEEEE
+#error_mask
+  position: absolute
+  z-index: 9000
+  display: none
+  left: 0
+  top: 0

data/views/dbtables.haml

@@ -0,0 +1,7 @@
+%div.dbtables
+  %h4 Tables list:
+  .list
+    - connection.table_names.each do |tname|
+      .dbtable
+        %a.q{:href=>table_content_url(tname)}= tname
+        %a.s{:href=>table_scheme_url(tname)} (s)

data/views/index.haml

@@ -0,0 +1,8 @@
+%form(method="get")
+  = connection_field
+  = per_page_field
+  %br
+  %textarea(name="query" cols="60" rows=10)&= @query
+  %br
+  %input(type="submit")
+  = haml :rezult, :layout => false

data/views/layout.haml

@@ -0,0 +1,13 @@
+%html
+  %link(rel="stylesheet" type="text/css" href="#{env['SCRIPT_NAME']}/css.css")
+  %script(type="text/javascript" src="//ajax.googleapis.com/ajax/libs/jquery/1.5/jquery.min.js")
+  :javascript
+    ROOT= '#{url('')}'
+  %body
+    &= @flash if @flash 
+    = haml :dbtables, :layout => false
+    %div.main= yield
+    %div#error
+      %a.close(href="javascript: void(0)") Close
+      %div.content
+    %div#error_mask

data/views/pages.haml

@@ -0,0 +1,15 @@
+.pages
+  - page = params[:page].to_i
+  - nums = (1..5).to_a
+  - nums |= ((page-3)..(page+3)).to_a
+  - nums |= ((@result.pages-5)..@result.pages).to_a
+  - nums = nums.sort.find_all{|i| (1..@result.pages).include?(i)}
+  - last_i = 0
+  - nums.each do |i|
+    - if i > last_i + 1
+      …
+    - last_i = i
+    - unless i == page
+      %a{:href=> merge_params("page" => i)}= i
+    - else
+      = i

data/views/rezult.haml

@@ -0,0 +1,75 @@
+%script{:src => url('/result.js')} 
+.rezult
+  - if @result
+    - if @result.rows?
+      - if @result.count > 0
+        - fields = @result.fields
+        %strong= "Total: #{@result.count}"
+        - if @result.pages > 1
+          = haml :pages, :layout => false
+        %table.result
+          %thead
+            - if fields.any?{|f| f.include?('.')}
+              - tables = extract_tables(fields)
+              %tr
+                - tables.each do |t|
+                  %th{:colspan => t.columns.size}&= t.table
+              %tr
+                - tables.map(&:columns).flatten.each do |column|
+                  %th&= column
+            - else
+              %tr
+                - fields.each do |field|
+                  %th&= field
+          %tbody
+            - @result.rows.each do |row|
+              - row_ids = {}
+              %tr
+                - fields.each do |field|
+                  - value = row[field]
+                  - if field =~ /([\w\.]+)\.(\w+)/
+                    - table, column = $1, $2
+                    - if column == 'id'
+                      - row_ids[table] = value
+                      - is_id = true
+                    - else
+                      - is_id = false
+                    - data = { :table => table, :column => column, :id => row_ids[table], :value => value, :nil => value.nil? }
+                  - else
+                    - data = nil
+                  - if value == nil
+                    - value = 'nil'
+                    - empty = true
+                  - elsif value =~ /^\s*$/
+                    - value = '"'+value+'"'
+                    - empty = true
+                  %td{:class => [(empty && 'inspect'), data && data[:column] == 'id' && 'id'], :data => data}
+                    - if value !~ /^\S+$/
+                      %pre= preserve(html_escape(value))
+                    - elsif is_id
+                      %span.actions  
+                      = value
+                    - else
+                      = value
+        - if @result.pages > 1
+          = haml :pages, :layout => false
+        :javascript
+          fill_id_with_edit_delete($('table.result'));
+      - else
+        Has no returned rows
+    - elsif @result.value? 
+      Rezult:
+      &= @result.value.inspect
+    - elsif @result.error?
+      Error:
+      &= @result.error.class.name
+      %br/
+      Message:
+      &= @result.error.message
+      %br/
+      Traceback:
+      %pre
+        - @result.error.backtrace.each do |l|
+          &= l.sub(Rails.root, '')
+  - else
+    Has no result

data/views/table_structure.haml

@@ -0,0 +1,21 @@
+%h1&= "Table #{params[:table]}"
+%a{:href=>url('')} goto queries
+%a{:href=>table_content_url(params[:table])} goto table
+%form(method="get")
+  = connection_field
+  %input{:type=>"hidden", :name=>"perpage", :value=>params[:perpage]}
+  %input(type="submit")
+%table.columns
+  %thead
+    %tr
+      %th Name
+      %th Type
+      %th Default
+      %th Not Null
+  %tbody
+    - @columns.each do |col|
+      %tr
+        %td= col.name
+        %td= col.type
+        %td&= col.default.inspect
+        %td= col.null

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification 
+name: rails_db_browser
+version: !ruby/object:Gem::Version 
+  hash: 13
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 9
+  version: 0.0.9
+platform: ruby
+authors: 
+- Sokolov Yura aka funny_falcon
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-04 00:00:00 +03:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sinatra
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: haml
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: Simple sinatra Rack application that allowes to run sql queries from a web page. Usable for administrative tasks.
+email: funny.falcon@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- MIT-LICENSE
+- README
+- Rakefile
+- VERSION
+- init.rb
+- lib/rails_db_browser.rb
+- lib/rails_db_browser/connection_keeper.rb
+- lib/rails_db_browser/db_browser.rb
+- lib/rails_db_browser/url_truncate.rb
+- public/result.js
+- rails/init.rb
+- views/_connection_field.haml
+- views/_per_page_field.haml
+- views/css.sass
+- views/dbtables.haml
+- views/index.haml
+- views/layout.haml
+- views/pages.haml
+- views/rezult.haml
+- views/table_structure.haml
+has_rdoc: true
+homepage: http://github.com/funny-falcon/rails_db_browser
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.2
+signing_key: 
+specification_version: 3
+summary: Simple database browser for Rails application backed by ActiveRecord
+test_files: []
+