geminfo 0.1.0 → 0.1.1

data/path/gems/listen-3.0.3/lib/listen/silencer.rb

@@ -1,97 +0,0 @@
-module Listen
-  class Silencer
-    # The default list of directories that get ignored.
-    DEFAULT_IGNORED_DIRECTORIES = %r{^(?:
-      \.git
-      | \.svn
-      | \.hg
-      | \.rbx
-      | \.bundle
-      | bundle
-      | vendor/bundle
-      | log
-      | tmp
-      |vendor/ruby
-    )(/|$)}x
-
-    # The default list of files that get ignored.
-    DEFAULT_IGNORED_EXTENSIONS  = /(?:
-      # Kate's tmp\/swp files
-      \..*\d+\.new
-      | \.kate-swp
-
-      # Gedit tmp files
-      | \.goutputstream-.{6}
-
-      # Intellij files
-      | ___jb_bak___
-      | ___jb_old___
-
-      # Vim swap files and write test
-      | \.sw[px]
-      | \.swpx
-      | ^4913
-
-      # Sed temporary files - but without actual words, like 'sedatives'
-      | (?:^
-         sed
-
-         (?:
-          [a-zA-Z0-9]{0}[A-Z]{1}[a-zA-Z0-9]{5} |
-          [a-zA-Z0-9]{1}[A-Z]{1}[a-zA-Z0-9]{4} |
-          [a-zA-Z0-9]{2}[A-Z]{1}[a-zA-Z0-9]{3} |
-          [a-zA-Z0-9]{3}[A-Z]{1}[a-zA-Z0-9]{2} |
-          [a-zA-Z0-9]{4}[A-Z]{1}[a-zA-Z0-9]{1} |
-          [a-zA-Z0-9]{5}[A-Z]{1}[a-zA-Z0-9]{0}
-         )
-        )
-
-      # other files
-      | \.DS_Store
-      | \.tmp
-      | ~
-    )$/x
-
-    attr_accessor :only_patterns, :ignore_patterns
-
-    def initialize
-      configure({})
-    end
-
-    def configure(options)
-      @only_patterns = options[:only] ? Array(options[:only]) : nil
-      @ignore_patterns = _init_ignores(options[:ignore], options[:ignore!])
-    end
-
-    # Note: relative_path is temporarily expected to be a relative Pathname to
-    # make refactoring easier (ideally, it would take a string)
-
-    # TODO: switch type and path places - and verify
-    def silenced?(relative_path, type)
-      path = relative_path.to_s
-
-      if only_patterns && type == :file
-        return true unless only_patterns.any? { |pattern| path =~ pattern }
-      end
-
-      ignore_patterns.any? { |pattern| path =~ pattern }
-    end
-
-    private
-
-    attr_reader :options
-
-    def _init_ignores(ignores, overrides)
-      patterns = []
-      unless overrides
-        patterns << DEFAULT_IGNORED_DIRECTORIES
-        patterns << DEFAULT_IGNORED_EXTENSIONS
-      end
-
-      patterns << ignores
-      patterns << overrides
-
-      patterns.compact.flatten
-    end
-  end
-end

data/path/gems/listen-3.0.3/lib/listen/silencer/controller.rb

@@ -1,48 +0,0 @@
-module Listen
-  class Silencer
-    class Controller
-      def initialize(silencer, default_options)
-        @silencer = silencer
-
-        opts = default_options
-
-        @prev_silencer_options = {}
-        rules = [:only, :ignore, :ignore!].map do |option|
-          [option, opts[option]] if opts.key? option
-        end
-
-        _reconfigure_silencer(Hash[rules.compact])
-      end
-
-      def append_ignores(*regexps)
-        prev_ignores = Array(@prev_silencer_options[:ignore])
-        _reconfigure_silencer(ignore: [prev_ignores + regexps])
-      end
-
-      def replace_with_bang_ignores(regexps)
-        _reconfigure_silencer(ignore!: regexps)
-      end
-
-      def replace_with_only(regexps)
-        _reconfigure_silencer(only: regexps)
-      end
-
-      private
-
-      def _reconfigure_silencer(extra_options)
-        opts = extra_options.dup
-        opts = opts.map do |key, value|
-          [key, Array(value).flatten.compact]
-        end
-        opts = Hash[opts]
-
-        if opts.key?(:ignore) && opts[:ignore].empty?
-          opts.delete(:ignore)
-        end
-
-        @prev_silencer_options = opts
-        @silencer.configure(@prev_silencer_options.dup.freeze)
-      end
-    end
-  end
-end

data/path/gems/listen-3.0.3/lib/listen/version.rb

@@ -1,3 +0,0 @@
-module Listen
-  VERSION = '3.0.3'
-end

data/path/gems/lumberjack-1.0.9/MIT_LICENSE

@@ -1,20 +0,0 @@
-Copyright (c) 2011 Brian Durand
-
-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/path/gems/lumberjack-1.0.9/README.rdoc

@@ -1,132 +0,0 @@
-= Lumberjack
-
-Lumberjack is a simple, powerful, and fast logging implementation in Ruby. It uses nearly the same API as the Logger class in the Ruby standard library and as ActiveSupport::BufferedLogger in Rails.
-
-== Usage
-
-This code aims to be extremely simple to use. The core interface it the Lumberjack::Logger which is used to log messages (which can be any object) with a specified Severity. Each logger has a level associated with it and messages are only written if their severity is greater than or equal to the level.
-
-  logger = Lumberjack::Logger.new("logs/application.log")  # Open a new log file with INFO level
-  logger.info("Begin request")
-  logger.debug(request.params)  # Message not written unless the level is set to DEBUG
-  begin
-    # do something
-  rescue => exception
-    logger.error(exception)
-    raise
-  end
-  logger.info("End request")
-
-This is all you need to know to log messages.
-
-== Features
-
-=== Meta data
-
-When messages are added to the log, additional data about the message is kept in a Lumberjack::LogEntry. This means you don't need to worry about adding the time or process id to your log messages as they will be automatically recorded.
-
-The following information is recorded for each message:
-
-* severity - The severity recorded for the message.
-* time - The time at which the message was recorded.
-* program name - The name of the program logging the message. This can be either set for all messages or customized with each message.
-* process id - The process id (pid) of the process that logged the message.
-* unit of work id - The unique 12 byte hexadecimal number generated for a unit of work.
-
-=== Units Of Work
-
-A unit of work can be used to tie together all log messages within a block. This can be very useful to isolate a group of messages that represent one path through the system. For instance, in a web application, a single request represents a natural unit of work,  and when you are looking through a log file, it is useful to see the entire set of log entries as a unit instead of interspersed with messages from other concurrent requests.
-
-  # All log entries in this block will get a common unit of work id.
-  Lumberjack.unit_of_work do
-    logger.info("Begin request")
-    yield
-    logger.info("End request")
-  end
-
-=== Pluggable Devices
-
-When a Logger logs a LogEntry, it sends it to a Lumberjack::Device. Lumberjack comes with a variety of devices for logging to IO streams or files.
-
-* Lumberjack::Device::Writer - Writes log entries to an IO stream.
-* Lumberjack::Device::LogFile - Writes log entries to a file.
-* Lumberjack::Device::DateRollingLogFile - Writes log entries to a file that will automatically roll itself based on date.
-* Lumberjack::Device::SizeRollingLogFile - Writes log entries to a file that will automatically roll itself based on size.
-* Lumberjack::Device::Null - This device produces no output and is intended for testing environments.
-
-If you'd like to send you log to a different kind of output, you just need to extend the Device class and implement the +write+ method. Or check out these plugins:
-
-* lumberjack_syslog_device[https://github.com/bdurand/lumberjack_syslog_device] - send your log messages to the system wide syslog service
-* lumberjack_mongo_device[https://github.com/bdurand/lumberjack_mongo_device] - store your log messages to a MongoDB[http://www.mongodb.org/] NoSQL data store
-* lumberjack-couchdb-driver[https://github.com/narkisr/lumberjack-couchdb-driver] - store your log messages to a CouchDB[http://couchdb.apache.org/] NoSQL data store
-
-=== Customize Formatting
-
-When a message is logged, it is first converted into a string. You can customize how it is converted by adding mappings to a Formatter.
-
-  logger.formatter.add(Hash, :pretty_print)  # use the Formatter::PrettyPrintFormatter for all Hashes
-  logger.formatter.add(MyClass){|obj| "#{obj.class}@#{obj.id}"}  # use a block to provide a custom format
-
-If you use the built in devices, you can also customize the Template used to format the LogEntry.
-  
-  # Change the format of the time in the log
-  Lumberjack::Logger.new("application.log", :time_format => "%m/%d/%Y %H:%M:%S")
-
-  # Use a simple template that only includes the time and the message
-  Lumberjack::Logger.new("application.log", :template => ":time - :message")
-
-  # Use a custom template as a block that only includes the first character of the severity
-  template = lambda{|e| "#{e.severity_label[0, 1]} #{e.time} - #{e.message}"}
-  Lumberjack::Logger.new("application.log", :template => template)
-
-=== Buffered Performance
-
-The logger has hooks for devices that support buffering to increase performance by batching physical writes. Log entries are not guaranteed to be written until the Lumberjack::Logger#flush method is called.
-
-You can use the <tt>:flush_seconds</tt> option on the logger to periodically flush the log. This is usually a good idea so you can more easily debug hung processes. Without periodic flushing, a process that hangs may never write anything to the log because the messages are sitting in a buffer. By turning on periodic flushing, the logged messages will be written which can greatly aid in debugging the problem.
-
-The built in stream based logging devices use an internal buffer. The size of the buffer (in bytes) can be set with the <tt>:buffer_size</tt> options when initializing a logger. The default behavior is to not to buffer.
-
-  # Set buffer to flush after 8K has been written to the log.
-  logger = Lumberjack::Logger.new("application.log", :buffer_size => 8192)
-  
-  # Turn off buffering so entries are immediately written to disk.
-  logger = Lumberjack::Logger.new("application.log", :buffer_size => 0)
-
-=== Automatic Log Rolling
-
-The built in devices include two that can automatically roll log files based either on date or on file size. When a log file is rolled, it will be renamed with a suffix and a new file will be created to receive new log entries. This can keep your log files from growing to unusable sizes and removes the need to schedule an external process to roll the files.
-
-There is a similar feature in the standard library Logger class, but the implementation here is safe to use with multiple processes writing to the same log file.
-
-== Examples
-
-These example are for Rails applications, but there is no dependency on Rails for using this gem. Most of the examples are applicable to any Ruby application.
-
-In a Rails application you can replace the default production logger by adding this to your config/environments/production.rb file:
-
-  # Add the unit of work id to each request
-  config.middleware.insert(0, Lumberjack::Rack::UnitOfWork)
-  # Change the logger to use Lumberjack
-  log_file_path = Rails.root + "log" + "#{Rails.env}.log"
-  config.logger = Lumberjack::Logger.new(log_file, :level => :warn)
-
-To set up a logger to roll every day at midnight, you could use this code (you can also specify :weekly or :monthly):
-
-  config.logger = Lumberjack::Logger.new(log_file_path, :roll => :daily)
-
-To set up a logger to roll log files when they get to 100Mb, you could use this:
-
-  config.logger = Lumberjack::Logger.new(log_file_path, :max_size => 100.megabytes)
-  
-To change the log message format, you could use this code:
-
-  config.logger = Lumberjack::Logger.new(log_file_path, :template => ":time - :message")
-
-To change the log message format to output JSON, you could use this code (this example requires the multi-json gem):
-  
-  config.logger = Lumberjack::Logger.new(log_file_path, :template => lambda{|e| MultiJson.dump(e)})
-
-To send log messages to syslog instead of to a file, you could use this (require the lumberjack_syslog_device gem):
-
-  config.logger = Lumberjack::Logger.new(Lumberjack::SyslogDevice.new)

data/path/gems/lumberjack-1.0.9/Rakefile

@@ -1,40 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rubygems/package_task'
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'RVM likes to call it tests'
-task :tests => :test
-
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
-  desc 'Run the unit tests'
-  RSpec::Core::RakeTask.new(:test)
-rescue LoadError
-  task :test do
-    STDERR.puts "You must have rspec 2.0 installed to run the tests"
-  end
-end
-
-namespace :rbx do
-  desc "Cleanup *.rbc files in lib directory"
-  task :delete_rbc_files do
-    FileList["**/*.rbc"].each do |rbc_file|
-      File.delete(rbc_file)
-    end
-    nil
-  end
-end
-
-spec_file = File.expand_path('../lumberjack.gemspec', __FILE__)
-if File.exist?(spec_file)
-  spec = eval(File.read(spec_file))
-
-  Gem::PackageTask.new(spec) do |p|
-    p.gem_spec = spec
-  end
-  Rake.application["package"].prerequisites.unshift("rbx:delete_rbc_files")
-end

data/path/gems/lumberjack-1.0.9/VERSION

@@ -1 +0,0 @@
-1.0.9

data/path/gems/lumberjack-1.0.9/lib/lumberjack.rb

@@ -1,43 +0,0 @@
-require 'rbconfig'
-require 'time'
-require 'thread'
-
-module Lumberjack
-  LINE_SEPARATOR = (RbConfig::CONFIG['host_os'].match(/mswin/i) ? "\r\n" : "\n")
-
-  load File.expand_path("../lumberjack/severity.rb", __FILE__)
-  load File.expand_path("../lumberjack/log_entry.rb", __FILE__)
-  load File.expand_path("../lumberjack/formatter.rb", __FILE__)
-  load File.expand_path("../lumberjack/device.rb", __FILE__)
-  load File.expand_path("../lumberjack/logger.rb", __FILE__)
-  load File.expand_path("../lumberjack/template.rb", __FILE__)
-
-  autoload :Rack, File.expand_path("../lumberjack/rack.rb", __FILE__)
-  
-  class << self
-    # Define a unit of work within a block. Within the block supplied to this
-    # method, calling +unit_of_work_id+ will return the same value that can
-    # This can then be used for tying together log entries.
-    #
-    # You can specify the id for the unit of work if desired. If you don't supply
-    # it, a 12 digit hexidecimal number will be automatically generated for you.
-    #
-    # For the common use case of treating a single web request as a unit of work, see the
-    # Lumberjack::Rack::UnitOfWork class.
-    def unit_of_work(id = nil)
-      save_val = Thread.current[:lumberjack_logger_unit_of_work_id]
-      id ||= rand(0xFFFFFFFFFFFF).to_s(16).rjust(12, '0').upcase
-      Thread.current[:lumberjack_logger_unit_of_work_id] = id
-      begin
-        return yield
-      ensure
-        Thread.current[:lumberjack_logger_unit_of_work_id] = save_val
-      end
-    end
-    
-    # Get the UniqueIdentifier for the current unit of work.
-    def unit_of_work_id
-      Thread.current[:lumberjack_logger_unit_of_work_id] 
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device.rb

@@ -1,26 +0,0 @@
-module Lumberjack
-  # This is an abstract class for logging devices. Subclasses must implement the +write+ method and
-  # may implement the +close+ and +flush+ methods if applicable.
-  class Device
-    load File.expand_path("../device/writer.rb", __FILE__)
-    load File.expand_path("../device/log_file.rb", __FILE__)
-    load File.expand_path("../device/rolling_log_file.rb", __FILE__)
-    load File.expand_path("../device/date_rolling_log_file.rb", __FILE__)
-    load File.expand_path("../device/size_rolling_log_file.rb", __FILE__)
-    load File.expand_path("../device/null.rb", __FILE__)
-
-    # Subclasses must implement this method to write a LogEntry.
-    def write(entry)
-      raise NotImplementedError
-    end
-    
-    # Subclasses may implement this method to close the device.
-    def close
-      flush
-    end
-    
-    # Subclasses may implement this method to flush any buffers used by the device.
-    def flush
-    end
-  end
-end

data/path/gems/lumberjack-1.0.9/lib/lumberjack/device/date_rolling_log_file.rb

@@ -1,58 +0,0 @@
-require 'date'
-
-module Lumberjack
-  class Device
-    # This log device will append entries to a file and roll the file periodically by date. Files
-    # are rolled at midnight and can be rolled daily, weekly, or monthly. Archive file names will
-    # have the date appended to them in the format ".YYYY-MM-DD" for daily, ".week-of-YYYY-MM-DD" for weekly
-    # and ".YYYY-MM" for monthly. It is not guaranteed that log messages will break exactly on the
-    # roll period as buffered entries will always be written to the same file.
-    class DateRollingLogFile < RollingLogFile
-      # Create a new logging device to the specified file. The period to roll the file is specified
-      # with the <tt>:roll</tt> option which may contain a value of <tt>:daily</tt>, <tt>:weekly</tt>,
-      # or <tt>:monthly</tt>.
-      def initialize(path, options = {})
-        @file_date = Date.today
-        if options[:roll] && options[:roll].to_s.match(/(daily)|(weekly)|(monthly)/i)
-          @roll_period = $~[0].downcase.to_sym
-          options.delete(:roll)
-        else
-          raise ArgumentError.new("illegal value for :roll (#{options[:roll].inspect})")
-        end
-        super
-      end
-
-      def archive_file_suffix
-        case @roll_period
-        when :weekly
-          "#{@file_date.strftime('week-of-%Y-%m-%d')}"
-        when :monthly
-          "#{@file_date.strftime('%Y-%m')}"
-        else
-          "#{@file_date.strftime('%Y-%m-%d')}"
-        end
-      end
-
-      def roll_file?
-        date = Date.today
-        if date.year > @file_date.year
-          true
-        elsif @roll_period == :daily && date.yday > @file_date.yday
-          true
-        elsif @roll_period == :weekly && date.cweek > @file_date.cweek
-          true
-        elsif @roll_period == :monthly && date.month > @file_date.month
-          true
-        else
-          false
-        end
-      end
-      
-      protected
-      
-      def after_roll
-        @file_date = Date.today
-      end
-    end
-  end
-end