digup 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZGU1YjNlNDZhNmJmMWJiNjI5ZWRlYzFjYTM5OGFiNWMyMjdlMmY4OQ==
+  data.tar.gz: !binary |-
+    Yjg0OWQ4Yjg3ZGNjM2M2ZmI3YzAwOTRjN2QzZGZiMmZhZTc0NThmMA==
+SHA512:
+  metadata.gz: !binary |-
+    YjM4ZDg2NDMxZDlhMWU5YjY4YTVhZWZiYmRlNmVmNTA3ZmRkNGYxZTg5ZGQ0
+    ZGZiNTJkNTMwYzhhM2FkMzBkN2JjODdiODIyYzFjZWE1Y2Y3ZTI3OTVkM2Q0
+    YzFhZWI1YmVlMzllYWMwYjk4NGM3YmRiOTA2MWVlOWIyOTg1NDU=
+  data.tar.gz: !binary |-
+    OWFmOWRjZWQyNjAzY2FkYjFlNDcxOGM2ZmZiOTFjZDA4YmE1NWZhZmZhZTZj
+    Y2Y0MmNmYjBiMjNhMjU0YWNiYzU5ZTQ0MzIwNGQ1ZWI5OWZlZGU3MDM5M2Ey
+    OTJiMWJmYmRhMjI0ZjVmOGE2MjhlOGQ3OGI2OTMzNmY4M2YxMjM=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in digup.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Rohan Pujari
+
+MIT License
+
+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,74 @@
+# Digup
+
+Digup is a simple gem for debugging errors by printing outputs.
+Digup allows you to debug your application by printing everything in html page or web console. Digup have diffrent logging mode file, db logging and logging data directly to console and html page.
+It is a gem for those who still follow old debugging techniques of printing output and inspecting bug by using methods like 'puts' and 'p'. Digup can also be used as logger as it alows logging data to file.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'digup'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install digup
+
+## Usage
+
+Digup have several settings to be set to operate diffrently.
+Once gem is installed go to config/environment/development.rb file and configure the gem. Paste following code
+
+      config.after_initialize do
+         Digup::Setting.options = :default
+      end
+
+Above setting will make Digup operate with default setting
+
+After you have configured Digup gem you can use digup_write method to out data you want.
+
+     digup_write 'Print this to web console and other places'
+
+Digup uses following setting as default
+
+        Digup::Setting.options = {
+          :response_type => [:js, :json, :html],
+          :log_to => [:console, :html_body],
+          :cursor_info => true
+        }
+
+You can configure digup to operate the way you want.
+- response_type: It takes single value as symbol or array of symbols to specify multiple options. It sets response_type for which the log will be sent
+
+     eg) If it includes :json, then log will be appended to json response otherwise it would not be appended
+
+     Possible options for responset type are :js, :json, :html
+- log_to: It takes single value as symbol or array of symbol to specify multiple options. It sets places where the output should be logged.
+
+     Possible options
+     1. :console => When this option is used then the data printed through digup_write method is shown on browser web console.
+     2. :html_body => When this option is used then the data printed through digup_write method is displayed as footer in web page. You can generate default view that the digup provides using digup:view generator. It is recommended to generate the default view if this option is to be used.
+
+            rails generate digup:view
+     Above command will generate file named _hook.html.erb inside app/views/diup folde. This view will be apended to html page when :html_body option is set. You can customize this view as you want.
+     3. :db => When this option is used then the data printed through digup_write method is stored in database. Before you can use this option you should generate model and migration file required. You can do this using digup:model generators.
+
+             rails generate digup:model
+Above command will generate two model file(digup_write.rb, request_response_info.rb) and corresponding migration files. You should run migration before you can use :db option
+
+     NOTE => If you are using :db option ActiveRecord is mandatory.
+
+     4. :file => When this option is used then the data printed through digup_write method is logged inside digup.log file. digup.log is inside log folder.
+
+- cursor_info => If this option is true then file name along with the line number where digup_write method was used will be diplayed along with message that is printed.
+
+If :db or :file logging is used then some extra information is also logged. Extra informations logged are request method(get, post, put etc), request accepts([text/html, application/xml, */*] etc), response status(it would always 200), response type(text/html, application/json etc), params
+
+
+## License
+
+Licensed under the MIT license, see the separate LICENSE.txt file.

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/digup.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'digup/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "digup"
+  spec.version       = Digup::VERSION
+  spec.authors       = ["Rohan Pujari"]
+  spec.email         = ["rohanpujaris@gmail.com"]
+  spec.description   = %q{Debug by printing data directly as html or in web console. Digup have diffrent logging mode file logging, db logging and logging debug data directly to console and html page. Digup can also be used as a logger}
+  spec.summary       = %q{Digup allows you to debug your application by printing everything in html page. Digup have diffrent logging mode file, db logging and logging debug data directly to console and html page}
+  spec.homepage      = "https://github.com/rohanpujaris/digup"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_runtime_dependency 'rails', '>= 3.0.0', '< 4.2.0'
+end

data/lib/digup/digup_railtie.rb

@@ -0,0 +1,7 @@
+module Digup
+  class DigupRailtie < Rails::Railtie
+    initializer "digup.configure_rails_initialization" do |app|
+      app.middleware.use Digup::Rack
+    end
+  end
+ end

data/lib/digup/extension.rb

@@ -0,0 +1,7 @@
+class Object
+
+  def digup_write(msg)
+    Digup.log(msg)
+  end
+
+end

data/lib/digup/logger.rb

@@ -0,0 +1,78 @@
+module Digup
+
+  class Logger
+
+    def self.file_path
+      Rails.root.join('log', 'digup.log').to_s
+    end
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    # appends log as html footer
+    def log_to_html_body
+      template = case
+        when @responder.html_response?
+          Template.html_template
+        when @responder.javascript_response?
+          Template.javascript_template
+        else
+          new_json_template
+      end
+      @responder.append_template_to_response(template)
+    end
+
+    # appends log as web console
+    def log_to_console
+      template = case
+        when @responder.html_response?
+          Template.console_template_for_html_response
+        when @responder.javascript_response?
+          Template.console_template_for_javascript_response
+        else
+          new_json_template
+      end
+      @responder.append_template_to_response(template)
+    end
+
+    # Add log to database. ActiveRecord required
+    def log_to_db
+      RequestResponseInfo.create(
+        :request_method => @responder.request.request_method,
+        :request_accepts => @responder.request.accepts,
+        :response_type => @responder.response.content_type,
+        :response_status => @responder.status,
+        :params => @responder.request.filtered_parameters
+      ).digup_logs.create(Digup.message_store)
+    end
+
+    # add log to file inside log/digup.log
+    def log_to_file
+      File.open(Logger.file_path, 'a') do |f|
+        f.write(Template.file_template(@responder))
+      end
+    end
+
+    # log to every available option
+    def log_all
+      if Digup.message_store.present?
+        log_to_html_body if Setting.log_to_html_body?
+        log_to_console if Setting.log_to_console?
+        log_to_db if Setting.log_to_db?
+        log_to_file if Setting.log_to_file?
+      end
+    end
+
+    def response_body
+      @responder.response_body
+    end
+
+    # creates json template depending on the last character of response(} or ])
+    def new_json_template
+      Template.json_template(response_body[response_body.length - 1])
+    end
+
+  end
+
+end

data/lib/digup/rack.rb

@@ -0,0 +1,26 @@
+module Digup
+
+  class Rack
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      responder = Responder.new(@app.call(env))
+      if Setting.enabled? && responder.valid?
+        logger = Logger.new(responder)
+        logger.log_all
+        responder.append_javascript_to_evaluate_json if Setting.handle_json? && responder.html_response?
+        responder.headers['Content-Length'] = responder.response_body.bytesize.to_s
+        responder.clear_digup_message_store
+        responder.build_response
+      else
+        responder.clear_digup_message_store
+      end
+      responder.build_response
+    end
+
+  end
+
+end

data/lib/digup/responder.rb

@@ -0,0 +1,87 @@
+module Digup
+
+  class Responder
+
+    attr_accessor :status, :headers, :response, :response_body
+
+    def initialize(original_response)
+      @original_response = original_response
+      @status, @headers, @response = original_response
+    end
+
+    def request
+      response.request
+    end
+
+    # Appends template to reponse depending on the settings
+    def append_template_to_response(template)
+      position = if response_body.include?('</body>')
+        response_body.rindex('</body>')
+      else
+        javascript_response? ? response_body.length : response_body.length - 1
+      end
+      response_body.insert(position, (json_response? ? '' : "\n") + template )
+    end
+
+    # Appends javascript to every page when response_type Setting includes :json
+    # Appends javascript to display json response appendes to original response
+    def append_javascript_to_evaluate_json
+      if response_body.include?('</body>')
+        position = response_body.rindex('</body>')
+        response_body.insert(position, Template.javascript_template_to_evaluate_json)
+      else
+        response_body << Template.javascript_template_to_evaluate_json
+      end
+    end
+
+    def response_not_a_file?
+      headers["Content-Transfer-Encoding"] != "binary"
+    end
+
+    def empty_response?
+      (@response.is_a?(Array) && @response.size <= 1) ||
+      !@response.respond_to?(:body) ||
+      !response_body.respond_to?(:empty?) ||
+      response_body.empty?
+    end
+
+    # If responsder is valid, then only response is modified
+    def valid?
+      !empty_response? && !response_body.frozen? && response_not_a_file? &&
+      status == 200  && can_handle_response?
+    end
+
+    # build a response to be sent to client
+    def build_response
+      valid? ? [status, headers, [response_body]] : @original_response
+    end
+
+    # clears log message unless its not a redirection
+    # If its redirection log needs to be displayed on redirected page. So its not cleared
+    def clear_digup_message_store
+      Digup.message_store.clear unless [301, 302].include?(status)
+    end
+
+    def response_body
+      @response_body ||= response.body.instance_of?(Array) ? response.body.first : response.body
+    end
+
+    def can_handle_response?
+      Setting.content_type_to_handle.include?(response.content_type)
+    end
+
+    def html_response?
+      response.content_type == 'text/html'
+    end
+
+    def javascript_response?
+      response.content_type == 'text/javascript'
+    end
+
+    def json_response?
+      response.content_type == 'application/json'
+    end
+
+  end
+
+end

data/lib/digup/setting.rb

@@ -0,0 +1,68 @@
+module Digup
+
+  class Setting
+
+    RESPONSE_TYPE = [:js, :json, :html]
+    LOG_TO = [:console, :html_body, :db, :file]
+    BOOLEAN_SETTINGS = [:cursor_info]
+    DEFAULT_SETTINGS = {
+      :response_type => [:js, :json, :html],
+      :log_to => [:console, :html_body],
+      :cursor_info => true
+    }
+
+    class << self
+      attr_accessor :options
+
+      def build_functions
+        RESPONSE_TYPE.each do |rt|
+          self.class.send(:define_method, "handle_#{rt}?") { options[:response_type].include?(rt) }
+        end
+
+        LOG_TO.each do |lt|
+          self.class.send(:define_method, "log_to_#{lt}?") { options[:log_to].include?(lt) }
+        end
+
+        BOOLEAN_SETTINGS.each do |s|
+          self.class.send(:define_method, "#{s}?") { options[s] }
+        end
+      end
+
+      def enabled?
+        @options.present?
+      end
+
+      def options=(options)
+        if options.is_a? Hash
+          options.slice!(:response_type, :log_to, :cursor_info)
+          options[:response_type] = option_to_array(options, :response_type)
+          options[:log_to] = option_to_array(options, :log_to)
+          @options = DEFAULT_SETTINGS.merge(options)
+        elsif options == :default
+          @options = DEFAULT_SETTINGS
+        end
+        build_functions
+      end
+
+      def option_to_array(options, key)
+        return DEFAULT_SETTINGS[key] unless options[key]
+        if options[key].is_a? Array
+          options[key]
+        else
+          [options[key]]
+        end & DEFAULT_SETTINGS[key]
+      end
+
+      def content_type_to_handle
+        content_type = []
+        content_type << 'text/html' if handle_html?
+        content_type << 'text/javascript' if handle_js?
+        content_type << 'application/json' if handle_json?
+        content_type
+      end
+
+    end
+
+  end
+
+end

data/lib/digup/template.rb

@@ -0,0 +1,134 @@
+module Digup
+
+  class Template
+
+    HTML_TEMPLATE_FORMAT = <<-HTML
+      <div class='digup-content'>
+        <div class='digup-html-message'>
+          {notification_message}
+        </div>
+      </div>
+    HTML
+
+    class << self
+
+      # hook.html.haml is appended to response
+      # html_message and message_store is passed as locals to view which can be used
+      # to design custom template for displaying log.
+      # html_message is inside li tag so its prefered to use it instead of raw log in message_store
+      def html_template
+        begin
+          ApplicationController.new.render_to_string(
+            :partial => 'digup/hook',
+            :locals => {
+              :html_message => Digup.html_message,
+              :message_store => Digup.message_store
+            }
+          )
+        rescue
+          HTML_TEMPLATE_FORMAT.sub('{notification_message}', Digup.html_message)
+        end.html_safe
+      end
+
+      def javascript_template
+        code = <<-CODE
+          if ($('.digup-html-message').length) {
+            $('.digup-html-message').html("#{Digup.html_message}")
+          } else {
+            $('body').append("#{html_template.squish}")
+          }
+        CODE
+        code.html_safe
+      end
+
+      # code for printing log in console when response is js
+      def console_template_for_javascript_response
+        code = <<-CODE
+          if (typeof(console) !== 'undefined' && console.log) {
+            if (console.groupCollapsed && console.groupEnd) {
+              console.groupCollapsed('Digup');
+              console.log("#{Digup.console_message}");
+              console.groupEnd();
+            } else {
+              console.log("#{Digup.console_message}");
+            }
+          }
+        CODE
+        code.html_safe
+      end
+
+      # code for printing log in console when response is html.
+      # console_template_for_javascript_response is enclosed in script tag
+      def console_template_for_html_response
+        code = <<-CODE
+        <script type='text/javascript'>
+          #{console_template_for_javascript_response}
+        </script>
+        CODE
+      end
+
+      # json message to be appended is decided depending on last character(} or ])
+      def json_template(end_character)
+        Digup.json_message(end_character).html_safe
+      end
+
+      # This code is appended to every page if Setting response_type includes :json
+      def javascript_template_to_evaluate_json
+        executable_javascript = ''
+        if Setting.log_to_html_body?
+          executable_javascript = <<-CODE
+            if (!$('.digup-html-message').length) {
+              $('body').append("#{html_template.squish}")
+            }
+            var list = '<ul>'
+            $.each(digupData, function(index, value) {
+              list += #{html_for_json_evaluation}
+            })
+            list += '</ul>'
+            $('.digup-html-message').html(list)
+          CODE
+        end
+        executable_javascript += console_template_for_javascript_response if Setting.log_to_console?
+        code = <<-CODE
+        <script type='text/javascript'>
+          $(document).bind("ajaxComplete", function(event, xhr, settings){
+            jsonResponse = xhr.responseJSON;
+            if (jsonResponse) {
+              if ($.isArray(jsonResponse)) {
+                digupData = jsonResponse[jsonResponse.length - 1]
+                } else {
+                digupData = jsonResponse.digup
+              }
+              #{executable_javascript}
+            }
+          });
+        </script>
+        CODE
+      end
+
+      def html_for_json_evaluation
+        list = ''
+        if Setting.cursor_info?
+          list += "'<li>' + value['cursor_info'] + ' : ' + value['message'] + '</li>'"
+        else
+          list += "'<li>' + value['message'] + '</li>'"
+        end
+      end
+
+      # template for logginf in log/digup.log
+      def file_template(responder)
+        file_log = "Time #{Time.now}\n"
+        file_log += "Request method: #{responder.request.request_method} | "
+        file_log += "Request accepts: #{responder.request.accepts}\n"
+        file_log += "response status: #{responder.status} | "
+        file_log += "response type: #{responder.response.content_type}\n"
+        file_log += "params: #{responder.request.filtered_parameters}"
+        file_log += Digup.text_message
+        file_log += "\n\n#{'=' * 180}\n\n"
+      end
+
+    end
+
+  end
+
+end

data/lib/digup/version.rb

@@ -0,0 +1,3 @@
+module Digup
+  VERSION = "0.0.2"
+end

data/lib/digup.rb

@@ -0,0 +1,68 @@
+require 'digup/setting'
+require 'digup/rack'
+require 'digup/template'
+require 'digup/responder'
+require 'digup/logger'
+require 'digup/digup_railtie'
+require 'digup/extension'
+
+module Digup
+
+  class << self
+    attr_accessor :message_store
+
+    def message_store
+      @message_store ||= []
+    end
+
+    def html_message
+      html = '<ul>'
+      message_store.each do |record|
+        html += '<li>'
+        html += "#{record[:cursor_info]} => " if cursor_info?(record)
+        html += "#{record[:message]}"
+        html += '</li>'
+      end
+      (html + '</ul>').html_safe
+    end
+
+    def console_message
+      console_data = ''
+      message_store.each do |record|
+        console_data += "#{record[:cursor_info]} : " if cursor_info?(record)
+        console_data += "#{record[:message]}\\n"
+      end
+      console_data
+    end
+
+    def json_message(end_character)
+      if end_character == ']'
+        ", {\"digup\": #{message_store.to_json}}"
+      else
+        ", \"digup\": #{message_store.to_json}"
+      end
+    end
+
+    def text_message
+      text = ''
+      message_store.each do |record|
+        text += "\n#{record[:cursor_info]} : "
+        text += "#{record[:message]}"
+      end
+      text
+    end
+
+    def write_up(message, args=nil)
+      message_hash = {:date => Time.now, :message => message}
+      message_hash.merge!(:cursor_info => caller[0].sub(Rails.root.to_s, ''))
+      message_store.push(message_hash)
+    end
+
+    alias_method :log, :write_up
+
+    def cursor_info?(record)
+      Setting.cursor_info? && record[:cursor_info]
+    end
+  end
+
+end

data/lib/generators/digup/model_generator.rb

@@ -0,0 +1,25 @@
+require 'rails/generators/migration'
+
+module Digup
+  module Generators
+    class ModelGenerator < Rails::Generators::Base
+
+      include Rails::Generators::Migration
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def self.next_migration_number(dirname)
+        next_migration_number = current_migration_number(dirname) + 1
+        ActiveRecord::Migration.next_migration_number(next_migration_number)
+      end
+
+      def create_digup_models
+        template 'digup_log.rb', 'app/models/digup_log.rb'
+        migration_template 'create_digup_log.rb', 'db/migrate/create_digup_log.rb'
+        template 'request_response_info.rb', 'app/models/request_response_info.rb'
+        migration_template 'create_request_response_info.rb', 'db/migrate/create_request_response_info.rb'
+      end
+
+    end
+  end
+end

data/lib/generators/digup/templates/_hook.html.erb

@@ -0,0 +1,42 @@
+<div id='digup-wrapper'>
+  <style type='text/css'>
+    .digup-content{
+      background-color: #333;
+      bottom: 0px;
+      height: 50px;
+      left: 0px;
+      opacity: 0.9;
+      overflow-y: auto;
+      padding: 3px 0px;
+      position: fixed;
+      width: 100%;
+    }
+    .digup-content li {
+      color: #eee;
+      word-break: break-all;
+    }
+    .vertical{
+      -webkit-transform:rotate(-90deg);
+      -moz-transform:rotate(-90deg);
+      -o-transform: rotate(-90deg);
+      -ms-transform:rotate(-90deg);
+      white-space:nowrap;
+      background-color: #FF2222;
+      bottom:14px;
+      color: #fff;
+      display:block;
+      left:-14px;
+      padding: 5px 0px;
+      position: fixed;
+      text-align: center;
+      width: 56px;
+    }
+    .digup-html-message {
+      margin: 0px 20px;
+    }
+  </style>
+  <div class='hook digup-content'>
+    <div><div class='vertical'>Digup</div></div>
+    <div class='digup-html-message'><%= html_message %></div>
+  </div>
+</div>

data/lib/generators/digup/templates/create_digup_log.rb

@@ -0,0 +1,16 @@
+class CreateDigupLog < ActiveRecord::Migration
+
+  def self.up
+    create_table :digup_logs do |t|
+      t.string :cursor_info
+      t.string :message
+      t.references :request_response_info
+      t.datetime :date
+    end
+  end
+
+  def self.down
+    remove_table :digup_logs
+  end
+
+end

data/lib/generators/digup/templates/create_request_response_info.rb

@@ -0,0 +1,18 @@
+class CreateRequestResponseInfo < ActiveRecord::Migration
+
+  def self.up
+    create_table :request_response_infos do |t|
+      t.string :request_method
+      t.string :request_accepts
+      t.string :response_type
+      t.string :response_status
+      t.string :params
+      t.timestamps
+    end
+  end
+
+  def self.down
+    remove_table :digup_logs
+  end
+
+end

data/lib/generators/digup/templates/digup_log.rb

@@ -0,0 +1,5 @@
+class DigupLog < ActiveRecord::Base
+
+  belongs_to :request_response_info
+
+end

data/lib/generators/digup/templates/request_response_info.rb

@@ -0,0 +1,5 @@
+class RequestResponseInfo < ActiveRecord::Base
+
+  has_many :digup_logs
+
+end

data/lib/generators/digup/view_generator.rb

@@ -0,0 +1,15 @@
+require 'rails/generators/migration'
+
+module Digup
+  module Generators
+    class ViewGenerator < Rails::Generators::Base
+
+      source_root File.expand_path('../templates', __FILE__)
+
+      def create_hook
+        copy_file '_hook.html.erb', 'app/views/digup/_hook.html.erb'
+      end
+
+    end
+  end
+end

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification
+name: digup
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Rohan Pujari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - <
+      - !ruby/object:Gem::Version
+        version: 4.2.0
+description: Debug by printing data directly as html or in web console. Digup have
+  diffrent logging mode file logging, db logging and logging debug data directly to
+  console and html page. Digup can also be used as a logger
+email:
+- rohanpujaris@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- digup.gemspec
+- lib/digup.rb
+- lib/digup/digup_railtie.rb
+- lib/digup/extension.rb
+- lib/digup/logger.rb
+- lib/digup/rack.rb
+- lib/digup/responder.rb
+- lib/digup/setting.rb
+- lib/digup/template.rb
+- lib/digup/version.rb
+- lib/generators/digup/model_generator.rb
+- lib/generators/digup/templates/_hook.html.erb
+- lib/generators/digup/templates/create_digup_log.rb
+- lib/generators/digup/templates/create_request_response_info.rb
+- lib/generators/digup/templates/digup_log.rb
+- lib/generators/digup/templates/request_response_info.rb
+- lib/generators/digup/view_generator.rb
+homepage: https://github.com/rohanpujaris/digup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Digup allows you to debug your application by printing everything in html
+  page. Digup have diffrent logging mode file, db logging and logging debug data directly
+  to console and html page
+test_files: []