ip-world-map 1.0.0

data/Rakefile

@@ -0,0 +1,45 @@
+# -*- coding: utf-8 -*-
+require 'rubygems'
+require 'rubygems/package_task'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+   t.pattern = 'spec/**/*.rb'
+   t.rcov = false
+   t.rcov_opts = %q[--exclude "spec"]
+   t.verbose = true
+end
+
+spec = Gem::Specification.new do |s|
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.8.7'
+  s.summary = 'A tool to generate images/videos of user locations based on Apache log files.'
+  s.name = 'ip-world-map'
+  s.version = '1.0.0'
+  s.license = 'GPL-2'
+  s.executables = ['ip-world-map']
+  s.files = FileList['{lib,spec}/**/*'].to_a +
+            ['Rakefile'] +
+            ['resources/maps/earthmap-1920x960.tif']
+  s.has_rdoc = false
+  s.description = s.summary
+  s.homepage = 'http://github.com/darxriggs/ip-world-map'
+  s.author = 'René Scheibe'
+  s.email = 'rene.scheibe@gmail.com'
+
+  s.requirements = ['ImageMagick (used by rmagick)', 'ffmpeg (only for animations)']
+  s.add_runtime_dependency('rmagick', '~> 2.13.1')
+  s.add_development_dependency('rspec', '~> 2.6.0')
+end
+
+Gem::PackageTask.new(spec) do |pkg|
+    pkg.need_tar = false
+end
+
+desc 'Install gem locally'
+task :install_gem => :package do
+  `sudo gem install pkg/*.gem --no-ri --no-rdoc`
+end
+
+task :default => :install_gem
+

data/bin/ip-world-map

@@ -0,0 +1,183 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'optparse'
+require 'ostruct'
+require 'date'
+require 'ip-world-map'
+require 'RMagick'
+
+class App
+  VERSION = '0.0.1'
+
+  attr_reader :options
+
+  def initialize arguments, stdin
+    @arguments = arguments
+    @stdin = stdin
+
+    set_defaults
+  end
+
+  def run
+    if parsed_arguments? && arguments_valid?
+      output_options if @options.verbose
+      process_command
+    else
+      output_help
+      exit 1
+    end
+  end
+
+  protected
+
+  def set_defaults
+    @options = OpenStruct.new({
+      :verbose            => false,
+      :quiet              => false,
+      :map_filename       => File.join(File.dirname(__FILE__), '..' , 'resources', 'maps', 'earthmap-1920x960.tif'),
+      :map_width          => 800,
+      :map_height         => 400,
+      :frames_per_second  => 25,
+      :fill_dot_color     => 'red',
+      :fill_dot_scale     => 10,
+      :fill_dot_opacity   => 1.0,
+      :fill_dot_lifetime  => 15,
+      :time_format        => nil,
+      :group_seconds      => 24 * 1 * 60 * 60,
+      :output_format      => 'png',
+      :animate            => false
+    })
+  end
+
+  def parsed_arguments?
+    @opts = opts = OptionParser.new
+
+    opts.banner = 'Usage: ip-world-map [options] log_file1 [logfile2] ...'
+
+    opts.on('--version', 'Display the version') do
+      output_version
+      exit 0
+    end
+
+    opts.on('-h', '--help', 'Display this help message') do
+      output_help
+      exit 0
+    end
+
+    opts.on('-v', '--verbose', 'Verbose output') do
+      @options.verbose = true
+    end
+
+    opts.on('--map-filename VALUE', 'The image to use as background') do |filename|
+      raise 'invalid map file' unless File.readable? filename
+      @options.map_filename = filename
+    end
+
+    opts.on('--resolution VALUE', '(eg.: 640x480)') do |resolution|
+      raise 'invalid resolution format' unless resolution =~ /^[0-9]+x[0-9]+$/
+      width, height = resolution.split('x').collect{|v| v.to_i}
+      @options.map_width  = width
+      @options.map_height = height
+    end
+
+    opts.on('--fps VALUE', 'Animation frames per second (eg.: 25)') do |fps|
+      raise 'invalid fps format' unless fps =~ /^[1-9][0-9]*$/
+      @options.frames_per_second = fps.to_i
+    end
+
+    opts.on('--fill-dot-color VALUE', "(eg.: red, 'rgb(255,0,0)', '#FF0000')") do |color|
+      Magick::Pixel.from_color color rescue raise 'invalid color (see help for examples)'
+      @options.fill_dot_color = color
+    end
+
+    opts.on('--fill-dot-scale VALUE', '(eg.: 10.0)') do |scale|
+      raise 'invalid dot scale' unless scale =~ /^[1-9][0-9]*([.][0-9]*)?$/
+      @options.fill_dot_scale = scale.to_f
+    end
+
+    opts.on('--fill-dot-opacity VALUE', 'range 0.0-1.0 (eg.: 0.0, 0.5, 1.0)') do |opacity|
+      raise 'invalid dot opacity' unless opacity =~ /^(0([.][0-9]*)?|1([.]0*)?)$/
+      @options.fill_dot_opacity = opacity.to_f
+    end
+
+    opts.on('--fill-dot-lifetime VALUE', '(eg.: 15)') do |lifetime|
+      raise 'invalid dot lifetime' unless lifetime =~ /^[1-9][0-9]*$/
+      @options.fill_dot_lifetime = lifetime.to_i
+    end
+
+    opts.on('--time-slot VALUE', 'real life time visualized per video frame (eg.: 10secs, 1min, 99hours, 1day)') do |slot|
+      raise 'invalid time slot' unless slot =~ /^[1-9][0-9]*(sec|min|hour|day)s?$/
+      value = slot.scan(/[0-9]+/)[0].to_i
+      unit  = slot.scan(/[a-z]+[^s]/)[0]
+      unit2secs = {'sec' => 1, 'min' => 60, 'hour' => 60*60, 'day' => 24*60*60}
+      @options.group_seconds = value * unit2secs[unit]
+    end
+
+    # TODO
+    # opts.on('--time-format', 'gets auto-detected if not specified') { |v| @options.time_format = v }
+
+    opts.on('--output-format VALUE', 'image format (e.g.: gif, jpg, png) or video format (avi, mpg, mp4)') do |format|
+      video_formats = %w[avi mpg mp4]
+      is_supported = Magick.formats.any?{ |supported_format, properties| supported_format.upcase == format.upcase && properties.include?('w') }
+      is_supported |= video_formats.any?{ |supported_format| supported_format.upcase == format.upcase }
+      raise 'invalid output format' unless is_supported
+      @options.output_format = format
+    end
+
+    opts.on('--[no-]animate', 'generate an image or a video') do |animate|
+      @options.animate = animate
+    end
+
+    begin
+      opts.parse!(@arguments)
+      @log_files = Dir.glob(@arguments)
+      raise 'no log files given' if @log_files.empty?
+      raise 'invalid log file given' unless @log_files.all?{|file| File.readable? file}
+      process_options
+    rescue
+      puts 'Error: ' + $!
+      return false
+    end
+
+    true
+  end
+
+  # Performs post-parse processing on options
+  def process_options
+    $visualization_config = @options
+  end
+
+  def output_options
+    puts 'Options:'
+    @options.marshal_dump.sort{|a,b| a[0].to_s <=> b[0].to_s}.each do |name, val|
+      puts "  #{name} = #{val}"
+    end
+  end
+
+  # True if required arguments were provided
+  def arguments_valid?
+    video_formats = %w[avi mpg mp4]
+    is_video_format = video_formats.any?{ |video_format| video_format == @options.output_format.downcase }
+    return false if !@options.animate &&  is_video_format
+    return false if  @options.animate && !is_video_format
+    true
+  end
+
+  def output_help
+    puts @opts.help
+  end
+
+  def output_version
+    puts "#{File.basename(__FILE__)} version #{VERSION}"
+  end
+
+  def process_command
+    ApacheLogVisualizer.new(@log_files).visualize
+  end
+end
+
+# Create and run the application
+app = App.new(ARGV, STDIN)
+app.run
+

data/lib/ip-world-map.rb

@@ -0,0 +1,14 @@
+require 'rubygems'
+
+require 'ip-world-map/ip_lookup_service'
+require 'ip-world-map/log_analyzer'
+require 'ip-world-map/information_drawer'
+require 'ip-world-map/apache_log_analyzer'
+require 'ip-world-map/apache_log_visualizer'
+require 'ip-world-map/decay'
+require 'ip-world-map/file_utils'
+require 'ip-world-map/point_in_time'
+require 'ip-world-map/visualization'
+
+require 'ip-world-map/logfile_mock'
+

data/lib/ip-world-map/apache_log_analyzer.rb

@@ -0,0 +1,25 @@
+require 'time'
+
+class ApacheLogAnalyzer < LogAnalyzer
+  def initialize *filenames
+    super
+    @@host_regex = /^([\w.-]+)/
+    @@time_regex = /\[(\d{2})\/([a-zA-Z]{3})\/(\d{4}):(\d{2}):(\d{2}):(\d{2}) [+-](\d{2})(\d{2})\]/
+  end
+
+  def extract_host_from_line line
+    # IP: "123.1.2.3" or HOSTNAME: "hostname.domain"
+    host = $1 if line =~ @@host_regex
+  end
+
+  def extract_time_from_line line
+    # CLF format: "[dd/MMM/yyyy:hh:mm:ss +-hhmm]"
+
+    # TODO: add timezone information
+    #dd, mmm, yyyy, hh, mm, ss, tz_hh, tz_mm = $1, $2, $3, $4, $5, $6, $7, $8 if line =~ @@time_regex
+    #Time.utc(yyyy, mmm, dd, hh.to_i - tz_hh.to_i, mm, ss)
+    dd, mmm, yyyy, hh, mm, ss = $1, $2, $3, $4, $5, $6 if line =~ @@time_regex
+    Time.utc(yyyy, mmm, dd, hh, mm, ss)
+  end
+end
+

data/lib/ip-world-map/apache_log_visualizer.rb

@@ -0,0 +1,75 @@
+require 'RMagick'
+
+class ApacheLogVisualizer
+  def initialize log_files
+    @log_files = log_files
+  end
+
+  def self.detect_time_format times
+    some_samples = times.sort[0..99]
+    smallest_period = some_samples.each_cons(2).collect{ |time1, time2| (time1 - time2).abs }.min || 1
+
+    return '%b %d %Y %H:%M' if smallest_period <  3600 # scale: minutes
+    return '%b %d %Y %H:00' if smallest_period < 86400 # scale: hours
+    return '%b %d %Y'                                  # scale: days
+  end
+
+  def generate_image
+    analyzer = ApacheLogAnalyzer.new(@log_files)
+    details = analyzer.analyze
+    positions = details.collect{ |data| data[:coordinates] }.select{ |coords| coords.any? }
+
+    visualization = Visualization.new
+    image = visualization.draw_positions(positions)
+    save_image image
+  end
+
+  def generate_animation
+    analyzer = ApacheLogAnalyzer.new(@log_files)
+    details = analyzer.analyze
+    grouped_details = analyzer.group_by_time(details, $visualization_config.group_seconds)
+
+    animation = Magick::ImageList.new
+    visualization = Visualization.new
+    time_format = $visualization_config.time_format || ApacheLogVisualizer.detect_time_format(grouped_details.keys)
+    frame_number = 0
+
+    puts "\nGenerating frames:" if $visualization_config.verbose
+    grouped_details.sort.each do |time, details|
+      frame_number += 1
+      visualization.new_frame
+      positions = details.collect{ |data| data[:coordinates] }.select{ |coords| coords.any? }
+      p [time, details.size, positions.size] if $visualization_config.verbose
+      image = visualization.draw_positions(positions)
+
+      InformationDrawer.new.draw_info(image, visualization, time.strftime(time_format))
+      save_image image, frame_number
+    end
+
+    render_frames_as_video
+  end
+
+  def save_image image, frame_number = 0
+    if $visualization_config.animate
+      image.write "animation.#{'%09d' % frame_number}.bmp"
+    else
+      image.write "snapshot.#{$visualization_config.output_format}"
+    end
+  end
+
+  def render_frames_as_video
+    puts "\nGenerating video:" if $visualization_config.verbose
+    output = `ffmpeg -r #{$visualization_config.frames_per_second} -qscale 1 -y -i animation.%09d.bmp animation.#{$visualization_config.output_format} 2>&1`
+    puts output if $visualization_config.verbose
+    raise 'could not create the animation' unless $?.exitstatus == 0
+  end
+
+  def visualize
+    if $visualization_config.animate
+      generate_animation
+    else
+      generate_image
+    end
+  end
+end
+

data/lib/ip-world-map/decay.rb

@@ -0,0 +1,12 @@
+# see http://en.wikipedia.org/wiki/Exponential_decay
+class Decay
+  def initialize initial_value, lifetime
+    @initial_value = initial_value.to_f
+    @lifetime = lifetime.to_f
+  end
+
+  def value time
+    @initial_value * Math::exp(-time / @lifetime)
+  end
+end
+

data/lib/ip-world-map/file_utils.rb

@@ -0,0 +1,16 @@
+require 'zlib'
+
+module FileUtils
+  def self.zipped? filename
+    %w[.gz .Z].include? File.extname(filename)
+  end
+
+  def self.open filename, &block
+    if zipped? filename
+      Zlib::GzipReader.open(filename, &block)
+    else
+      File.open(filename, &block)
+    end
+  end
+end
+

data/lib/ip-world-map/information_drawer.rb

@@ -0,0 +1,34 @@
+require 'RMagick'
+
+# Draws the timestamp.
+class InformationDrawer
+
+  def initialize
+    @draw = Magick::Draw.new
+  end
+
+  def draw_info image, visualization, info
+    size = { :width => visualization.map_size[:width], :height => visualization.map_size[:height] }
+    draw_background(size)
+    draw_message(size, info)
+    @draw.draw(image)
+  end
+
+  protected
+
+  def draw_background size
+    width, height = size[:width], size[:height]
+    @draw.fill('grey')
+    @draw.fill_opacity('50%')
+    @draw.rectangle(0.2 * width, 0.9 * height, 0.8 * width, 0.9 * height + 30)
+  end
+
+  def draw_message size, info
+    @draw.fill('black')
+    @draw.fill_opacity('100%')
+    @draw.text_align(Magick::CenterAlign)
+    @draw.pointsize(20)
+    @draw.text(0.5 * size[:width], 0.9 * size[:height] + 20, info)
+  end
+end
+

data/lib/ip-world-map/ip_lookup_service.rb

@@ -0,0 +1,69 @@
+require 'net/http'
+require 'typhoeus'
+require 'yaml'
+
+class IpLookupService
+
+  def initialize filename = nil
+    @filename = filename || File.join(File.dirname(__FILE__), '..', '..', 'resources', 'coordinates.yml') 
+    reset
+  end
+
+  def reset
+    @host_coordinates = {}
+    @host_ips = {}
+  end
+
+  def coordinates_for_hosts hosts
+    uniq_hosts = hosts.uniq
+
+    uniq_hosts.each do |host|
+      @host_ips[host] ||= IPSocket.getaddress(host) rescue nil
+    end
+
+    hydra = Typhoeus::Hydra.new
+    uniq_hosts.each do |host|
+      unless @host_coordinates[host]
+        request = Typhoeus::Request.new("http://api.hostip.info/get_html.php?position=true&ip=#{@host_ips[host]}")
+        request.on_complete do |response|
+          @host_coordinates[host] = extract_longitude_and_latitude(response.body)
+        end
+        hydra.queue(request)
+      end
+    end
+    hydra.run
+
+    @host_coordinates
+  end
+
+  def coordinates_for_host host
+    unless @host_coordinates[host]
+      @host_ips[host] ||= IPSocket.getaddress(host) rescue nil
+      response = Net::HTTP.get('api.hostip.info', "/get_html.php?position=true&ip=#{@host_ips[host]}")
+      @host_coordinates[host] = extract_longitude_and_latitude(response)
+    end
+
+    @host_coordinates[host]
+  end
+
+  def extract_longitude_and_latitude string
+    latitude  = string.match(/Latitude: (-?[0-9.]+)/)[1].to_f  rescue nil
+    longitude = string.match(/Longitude: (-?[0-9.]+)/)[1].to_f rescue nil
+    [longitude, latitude]
+  end
+
+  def save_coordinates
+    File.open(@filename, 'w'){ |f| f.write @host_coordinates.to_yaml }
+  end
+
+  def load_coordinates
+    @host_coordinates = YAML.load_file(@filename) if File.readable? @filename
+  end
+
+  def stats
+    unknown_coordinates, known_coordinates = @host_coordinates.partition{ |ip, coords| coords.include? nil }
+
+    { :unknown_coordinates => unknown_coordinates.size, :known_coordinates => known_coordinates.size }
+  end
+end
+

data/lib/ip-world-map/log_analyzer.rb

@@ -0,0 +1,60 @@
+class LogAnalyzer
+  attr_accessor :host_coordinates
+
+  def initialize *filenames
+    @filenames = filenames.flatten.sort.uniq
+    @ip_lookup_service = IpLookupService.new
+    @ip_lookup_service.load_coordinates
+  end
+
+  def analyze
+    details = []
+
+    puts "\nReading files:" if $visualization_config.verbose
+    @filenames.each do |filename|
+      puts filename if $visualization_config.verbose
+      FileUtils.open(filename).each_line do |line|
+        details << details_from_line(line)
+      end
+    end
+
+    hosts = details.collect{|detail| detail[:host]}
+    coordinates = @ip_lookup_service.coordinates_for_hosts(hosts)
+
+    details.collect! do |detail|
+      detail[:coordinates] = coordinates[detail[:host]]
+      detail
+    end
+
+    details
+  end
+
+  def details_from_line line
+    host = extract_host_from_line(line)
+    time = extract_time_from_line(line)
+    { :time => time, :host => host }
+  end
+
+  def calculate_oldest_time details
+    details.min{ |a, b| a[:time] <=> b[:time] }[:time]
+  end
+
+  def group_by_time details, slot_in_seconds
+    return {} unless details && slot_in_seconds
+    details_per_slot = {}
+
+    # TODO: maybe assign empty arrays to missing slots where no traffic was detected
+    details.each do |detail|
+      slot_start_time = calculate_slot_start_time(detail[:time], slot_in_seconds)
+      details_per_slot[slot_start_time] ||= []
+      details_per_slot[slot_start_time] << detail
+    end
+
+    details_per_slot
+  end
+
+  def calculate_slot_start_time time, slot_in_seconds
+    Time.at(time.tv_sec - (time.tv_sec % slot_in_seconds))
+  end
+end
+

data/lib/ip-world-map/logfile_mock.rb

@@ -0,0 +1,18 @@
+class LogfileMock
+  attr_accessor :min_random_positions, :max_random_positions
+
+  def initialize
+    @min_random_positions = 5
+    @max_random_positions = 50
+  end
+
+  def random_longitude_latitude
+    [ -10 + rand(25) + rand, 40 + rand(15) + rand ]
+  end
+
+  def positions
+    amount = @min_random_positions + rand(@max_random_positions - @min_random_positions + 1)
+    Array.new(amount){ random_longitude_latitude }
+  end
+end
+

data/lib/ip-world-map/point_in_time.rb

@@ -0,0 +1,23 @@
+class PointInTime
+  attr_reader :x, :y
+
+  def initialize x, y, initial_opacity, lifetime
+    @x, @y = x, y
+    @time = 0
+    @decay = Decay.new(initial_opacity, lifetime)
+  end
+
+  def opacity_in_time time
+    @time = time if time
+    opacity
+  end
+
+  def opacity
+    @decay.value(@time)
+  end
+
+  def age
+    @time += 1
+  end
+end
+

data/lib/ip-world-map/visualization.rb

@@ -0,0 +1,80 @@
+require 'RMagick'
+
+class Visualization
+  attr_accessor :position_quantization_in_degrees, :circle_radius
+
+  def initialize
+    @map_filename = $visualization_config.map_filename
+    @raw_image = Magick::ImageList.new(@map_filename).first
+    if $visualization_config.map_width || $visualization_config.map_height
+        width  = $visualization_config.map_width  || @raw_image.columns
+        height = $visualization_config.map_height || @raw_image.rows
+        @raw_image.resize! width, height
+    end
+    new_frame
+    @position_quantization_in_degrees = 0
+    @opacity_visibility_threshold = 0.1
+    @circle_radius = (map_size[:width] ** 1.25) / (map_size[:width] * $visualization_config.fill_dot_scale).to_f
+    @points = {}
+  end
+
+  def map_size
+    @map_size ||= { :width => @frame.columns, :height => @frame.rows }
+  end
+
+  def scale
+    @scale ||= { :x => 360.0 / map_size[:width], :y => 180.0 / map_size[:height] }
+  end
+
+  def x_y_from_longitude_latitude longitude, latitude
+    [ (180 + longitude) / scale[:x], (90 - latitude) / scale[:y] ]
+  end
+
+  def circle_parameters center_x, center_y
+    [ center_x, center_y, center_x + circle_radius, center_y ]
+  end
+
+  def quantize_position *position
+    return position if @position_quantization_in_degrees == 0
+    position.collect{ |element| element - element.remainder(@position_quantization_in_degrees) }
+  end
+
+  def select_visible_points points
+    #points.select{ |point| point.opacity >= @opacity_visibility_threshold }
+    selected_points = {}
+    points.each{ |key, point| selected_points[key] = point if point.opacity >= @opacity_visibility_threshold }
+  end
+
+  def draw_positions positions_lon_lat
+    @draw.fill($visualization_config.fill_dot_color)
+
+    new_points = {}
+    positions_lon_lat.each do |longitude, latitude|
+      x, y = x_y_from_longitude_latitude(longitude, latitude)
+      x, y = quantize_position(x, y)
+      new_points[[x,y]] = PointInTime.new(x, y, $visualization_config.fill_dot_opacity, $visualization_config.fill_dot_lifetime)
+    end
+
+    @points = select_visible_points(@points)
+    @points.merge!(new_points)
+
+    @points.each do |key, point|
+      @draw.fill_opacity(point.opacity)
+      @draw.circle(*circle_parameters(point.x, point.y))
+      point.age
+    end
+
+    @draw.draw(@frame)
+    @frame
+  end
+
+  def display
+    @frame.display
+  end
+
+  def new_frame
+    @draw = Magick::Draw.new
+    @frame = @raw_image.clone
+  end
+end
+

data/spec/ip-world-map/decay.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+describe Decay do
+  it 'should be initialized with either Integers and/or Floats' do
+    Decay.new(10,   5  )
+    Decay.new(10,   5.0)
+    Decay.new(10.0, 5  )
+    Decay.new(10.0, 5.0)
+  end
+
+  it 'should return a value depending on the time' do
+    decay = Decay.new(10, 5)
+
+    decay.value(0).should == 10.0
+    decay.value(5).should < 5.0
+  end
+end
+

data/spec/ip-world-map/ip_lookup_service.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe IpLookupService do
+  describe 'hostname -> coordinates resolval' do
+    it 'should return the coordinates for an IP' do
+      stubbed_result = "Country: GERMANY (DE)\nCity: Berlin\n\nLatitude: 52.5\nLongitude: 13.4167\nIP: 1.1.1.1\n"
+      Net::HTTP.stub!(:get).and_return(stubbed_result)
+
+      IpLookupService.new.coordinates_for_host('1.1.1.1').should == [13.4167, 52.5]
+    end
+
+    it 'should return the coordinates for a hostname' do
+      stubbed_result = "Country: GERMANY (DE)\nCity: Berlin\n\nLatitude: 52.5\nLongitude: 13.4167\nIP: 1.1.1.1\n"
+      Net::HTTP.stub!(:get).and_return(stubbed_result)
+      IPSocket.stub!(:getaddr).and_return('1.1.1.1')
+
+      IpLookupService.new.coordinates_for_host('some hostname').should == [13.4167, 52.5]
+    end
+
+    it 'should handle the case that no IP can be resolved for a hostname' do
+      stubbed_result = "Country: GERMANY (DE)\nCity: Berlin\n\nLatitude: \nLongitude: \nIP: 1.1.1.1\n"
+      Net::HTTP.stub!(:get).and_return(stubbed_result)
+      IPSocket.stub!(:getaddrinfo).and_raise(SocketError)
+   
+      IpLookupService.new.coordinates_for_host('some hostname').should == [nil, nil]
+    end
+   
+    it 'should handle the case that no coordinates can be resolved for a hostname' do
+      stubbed_result = "Country: GERMANY (DE)\nCity: Berlin\n\nLatitude: \nLongitude: \nIP: 1.1.1.1\n"
+      Net::HTTP.stub!(:get).and_return(stubbed_result)
+      IPSocket.stub!(:getaddr)
+   
+      IpLookupService.new.coordinates_for_host('some hostname').should == [nil, nil]
+    end
+  end
+end
+

data/spec/ip-world-map/time_format.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe ApacheLogVisualizer do
+  describe 'time format' do
+    it 'should return a minute based time format for times within an hour' do
+      now = Time.now
+      times = [now, now + 3599]
+
+      ApacheLogVisualizer.detect_time_format(times).should == '%b %d %Y %H:%M'
+    end
+
+    it 'should return a hour based time format for times within a day' do
+      now = Time.now
+      times = [now, now + 86399]
+
+      ApacheLogVisualizer.detect_time_format(times).should == '%b %d %Y %H:00'
+    end
+
+    it 'should return a day based time format for times greater than a day' do
+      now = Time.now
+      times = [now, now + 86400]
+
+      ApacheLogVisualizer.detect_time_format(times).should == '%b %d %Y'
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+lib_path = File.join(File.dirname(__FILE__), '..', 'lib')
+$LOAD_PATH.unshift lib_path unless $LOAD_PATH.include?(lib_path)
+
+require 'ip-world-map'
+

metadata

@@ -0,0 +1,118 @@
+--- !ruby/object:Gem::Specification 
+name: ip-world-map
+version: !ruby/object:Gem::Version 
+  hash: 23
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- "Ren\xC3\xA9 Scheibe"
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-07-26 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rmagick
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 57
+        segments: 
+        - 2
+        - 13
+        - 1
+        version: 2.13.1
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 2
+        - 6
+        - 0
+        version: 2.6.0
+  type: :development
+  version_requirements: *id002
+description: A tool to generate images/videos of user locations based on Apache log files.
+email: rene.scheibe@gmail.com
+executables: 
+- ip-world-map
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/ip-world-map/information_drawer.rb
+- lib/ip-world-map/logfile_mock.rb
+- lib/ip-world-map/decay.rb
+- lib/ip-world-map/log_analyzer.rb
+- lib/ip-world-map/apache_log_analyzer.rb
+- lib/ip-world-map/apache_log_visualizer.rb
+- lib/ip-world-map/point_in_time.rb
+- lib/ip-world-map/ip_lookup_service.rb
+- lib/ip-world-map/file_utils.rb
+- lib/ip-world-map/visualization.rb
+- lib/ip-world-map.rb
+- spec/ip-world-map/decay.rb
+- spec/ip-world-map/time_format.rb
+- spec/ip-world-map/ip_lookup_service.rb
+- spec/spec_helper.rb
+- Rakefile
+- resources/maps/earthmap-1920x960.tif
+- bin/ip-world-map
+has_rdoc: true
+homepage: http://github.com/darxriggs/ip-world-map
+licenses: 
+- GPL-2
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 57
+      segments: 
+      - 1
+      - 8
+      - 7
+      version: 1.8.7
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: 
+- ImageMagick (used by rmagick)
+- ffmpeg (only for animations)
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A tool to generate images/videos of user locations based on Apache log files.
+test_files: []
+