trifle 0.0.1

data/.gitignore

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

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,6 @@
+source :rubygems
+
+# Specify your gem's dependencies in messages.gemspec
+gemspec
+
+gem "fakeredis", github: "caius/fakeredis", branch: "redis-rb-3"

data/Gemfile.lock

@@ -0,0 +1,36 @@
+GIT
+  remote: git://github.com/caius/fakeredis.git
+  revision: ab336ff1edf50c259b557559f42316fe15a4feb7
+  branch: redis-rb-3
+  specs:
+    fakeredis (0.3.1)
+      redis (>= 3.0.0)
+
+PATH
+  remote: .
+  specs:
+    trifle (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.3)
+    redis (3.0.1)
+    rspec (2.10.0)
+      rspec-core (~> 2.10.0)
+      rspec-expectations (~> 2.10.0)
+      rspec-mocks (~> 2.10.0)
+    rspec-core (2.10.1)
+    rspec-expectations (2.10.0)
+      diff-lcs (~> 1.1.3)
+    rspec-mocks (2.10.1)
+    rujitsu (0.3.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  fakeredis!
+  rspec
+  rujitsu
+  trifle!

data/README.md

@@ -0,0 +1,54 @@
+# Trifle
+
+Stores the GeoIP databases in Redis and gives it a simple way to lookup IPs and map them to countries/country codes.
+
+Get your GeoIP country CSVs from http://www.maxmind.com/app/geolite.
+
+Trifle supports both the IPV4 and IPV6 databases.
+
+## Installation
+
+Install the gem
+
+```
+gem install trifle
+```
+
+or add it to your Gemfile and bundle
+
+```ruby
+gem "trifle"
+```
+
+## Usage
+
+### Loading
+
+```ruby
+# Initialize
+trifle = Trifle.new(Redis.new)
+# Load data from file
+trifle.load filename: "file.csv"
+# or files
+trifle.load filenames: ["file1.csv", "file2.csv"]
+# or directly as an array
+trifle.load data: preloaded_array
+```
+
+### Lookup
+
+```ruby
+# Initialize
+trifle = Trifle.new(Redis.new)
+
+# Lookup for existing data
+trifle.find "223.255.128.0"
+# => ["HK", "Hong Kong"]
+
+# Lookup for missing data
+trifle.find "192.168.1.1"
+# => nil
+```
+
+
+

data/Rakefile

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

data/lib/trifle.rb

@@ -0,0 +1,29 @@
+# Trifle is a simple storage and lookup gem for GeoIP data
+# using Redis as storage
+require "trifle/loader"
+require "trifle/finder"
+require "trifle/initialize_with_redis"
+
+class Trifle
+  include InitializeWithRedis
+
+  KEY = "trifle".freeze
+
+  def load options = {}
+    loader.handle options
+  end
+
+  def find ip
+    finder.handle ip
+  end
+
+  protected
+
+  def loader
+    @loader = Loader.new(redis)
+  end
+
+  def finder
+    @finder = Finder.new(redis)
+  end
+end

data/lib/trifle/finder.rb

@@ -0,0 +1,46 @@
+require_relative "initialize_with_redis"
+require 'ipaddr'
+
+class Trifle
+  class Finder
+    include InitializeWithRedis
+
+    def handle ip
+      ip_i = IPAddr.new(ip).to_i
+      find(ip_i, 0, max)
+    end
+
+    protected
+
+    def find ip_i, lower, upper
+      return nil if lower > upper
+
+      index = (lower+upper)/2
+
+      current = entry_for(index)
+
+      if in_range(current, ip_i)
+        current.last(2)
+      elsif ip_i < current[0]
+        find ip_i, lower, index-1
+      else
+        find ip_i, index+1, upper
+      end
+    end
+
+    def max
+      redis.llen Trifle::KEY
+    end
+
+    def entry_for index
+      entry = redis.lindex(Trifle::KEY, index).split(":")
+      entry[0] = entry[0].to_i
+      entry[1] = entry[1].to_i
+      entry
+    end
+
+    def in_range range, ip_i
+      ip_i >= range[0] && ip_i <= range[1]
+    end
+  end
+end

data/lib/trifle/initialize_with_redis.rb

@@ -0,0 +1,10 @@
+class Trifle
+  module InitializeWithRedis
+    attr_accessor :redis
+
+    def initialize redis
+      raise ArgumentError.new("Redis object expected") unless redis.is_a?(Redis)
+      self.redis = redis
+    end
+  end
+end

data/lib/trifle/loader.rb

@@ -0,0 +1,69 @@
+require_relative "initialize_with_redis"
+require "csv"
+
+class Trifle
+  class Loader
+    include InitializeWithRedis
+
+    def handle options = {}
+      if options[:filename]
+        load_files [options[:filename]]
+      elsif options[:filenames]
+        load_files options[:filenames]
+      elsif options[:data]
+        load_data options[:data]
+      else
+        raise ArgumentError.new("Please provide a :filename, :filenames or an array of :data as an argument.")
+      end
+    end
+
+    def load_files filenames
+      raise ArgumentError.new("filenames must be an array of strings") unless filenames.is_a?(Array) && !filenames.map{|element| element.is_a?(String)}.include?(false)
+
+      data = []
+      filenames.each do |filename|
+        contents = File.open(filename, "rb").read
+        data += parse(contents)
+      end
+      load_data data
+    end
+
+    def load_data data
+      raise ArgumentError.new("data must be an array as loaded from a GeoIP data set") unless valid?(data)
+      clear
+      sort(data)
+      data.each {|row| append(row) }
+    end
+
+    def append row
+      entry = row.values_at(2,3,4,5).join(":")
+      redis.rpush Trifle::KEY, entry
+    end
+
+    def sort data
+      data.sort {|a,b| a[2] <=> b[2] }
+    end
+
+    def parse contents
+      contents.gsub!('", "', '","')
+      CSV.parse(contents)
+    end
+
+    def valid? data
+      if data.is_a?(Array) && data.count > 0
+        return data.map do |row|
+          is_number(row[2]) && is_number(row[3])
+        end.select{|valid| !valid}.count == 0
+      end
+      false
+    end
+
+    def is_number field
+      field.is_a?(Numeric) || field =~ /^\d+$/
+    end
+
+    def clear
+      redis.del(Trifle::KEY)
+    end
+  end
+end

data/lib/trifle/version.rb

@@ -0,0 +1,3 @@
+class Trifle
+  VERSION = "0.0.1" unless defined? Trifle::VERSION
+end

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+require "trifle"
+require "rujitsu"
+require "fakeredis/rspec"

data/spec/trifle/finder_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Trifle::Finder do
+
+  before do
+    @valid_data = [
+      ["223.255.128.0","223.255.191.255","3758063616","3758079999","HK","Hong Kong"],
+      ["223.255.192.0","223.255.223.255","3758080000","3758088191","KR","Korea, Republic of"],
+      ["223.255.224.0","223.255.231.255","3758088192","3758090239","ID","Indonesia"],
+      ["223.255.232.0","223.255.235.255","3758090240","3758091263","AU","Australia"],
+      ["223.255.236.0","223.255.239.255","3758091264","3758092287","CN","China"],
+      ["223.255.240.0","223.255.243.255","3758092288","3758093311","HK","Hong Kong"],
+      ["223.255.244.0","223.255.247.255","3758093312","3758094335","IN","India"],
+      ["223.255.248.0","223.255.251.255","3758094336","3758095359","AU","Australia"],
+      ["223.255.252.0","223.255.253.255","3758095360","3758095871","CN","China"],
+      ["223.255.254.0","223.255.254.255","3758095872","3758096127","SG","Singapore"],
+      ["223.255.255.0","223.255.255.255","3758096128","3758096383","AU","Australia"]
+    ]
+    @redis = Redis.new
+    trifle = Trifle.new(@redis)
+    @finder = Trifle::Finder.new(@redis)
+    trifle.load(data: @valid_data)
+  end
+
+  describe "#handle" do
+    it "should find the right entry" do
+      @finder.handle("223.255.128.0").should be == ["HK", "Hong Kong"]
+      @finder.handle("223.255.244.10").should be == ["IN", "India"]
+      @finder.handle("223.255.255.255").should be == ["AU","Australia"]
+    end
+
+    it "should return nil if the entry wasn't found" do
+      @finder.handle("127.0.0.1").should be_nil
+    end
+  end
+
+end

data/spec/trifle/initialize_with_redis_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+describe Trifle::InitializeWithRedis do
+
+  describe "#initialize" do
+    before do
+      @klass = Class.new do
+        include Trifle::InitializeWithRedis
+      end
+    end
+
+    it "should accept a redis instance" do
+      @klass.new(Redis.new).should be_a(@klass)
+    end
+
+    it "should fail without a redis instance" do
+      -> { @klass.new(nil) }.should raise_error(ArgumentError)
+      -> { @klass.new("http://127.0.0.1:3000/") }.should raise_error(ArgumentError)
+    end
+  end
+
+end

data/spec/trifle/loader_spec.rb

@@ -0,0 +1,169 @@
+require "spec_helper"
+
+describe Trifle::Loader do
+
+  before do
+    @loader = Trifle::Loader.new(Redis.new)
+    @valid_data = [
+      ["223.255.254.0","223.255.254.255","3758095872","3758096127","SG","Singapore"],
+      ["223.255.255.0","223.255.255.255","3758096128","3758096383","AU","Australia"]
+    ]
+    @csv = <<-EOD
+"223.255.254.0","223.255.254.255","3758095872","3758096127","SG","Singapore"
+"223.255.255.0","223.255.255.255","3758096128","3758096383","AU","Australia"
+    EOD
+  end
+
+  it "should extend InitializeWithRedis" do
+    Trifle::Loader.included_modules.should include(Trifle::InitializeWithRedis)
+  end
+
+  describe "#handle" do
+
+    context "when given the :filename option" do
+      it "should pass it on to load_files" do
+        filename = 'data.csv'
+        @loader.should_receive(:load_files).with([filename])
+        @loader.handle(filename: filename)
+      end
+    end
+
+    context "when given the :filenames option" do
+      it "should pass it on to load_files" do
+        filenames = ['data1.csv', 'data2.csv']
+        @loader.should_receive(:load_files).with(filenames)
+        @loader.handle(filenames: filenames)
+      end
+    end
+
+    context "when given the :data option" do
+      it "should pass it on to load_data" do
+        data = [:foo, :bar]
+        @loader.should_receive(:load_data).with(data)
+        @loader.handle(data: data)
+      end
+    end
+
+    context "when given anything else" do
+      it "should raise an error" do
+        -> { @loader.handle(foo: :bar) }.should raise_error(ArgumentError)
+        -> { @loader.handle }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#load_files" do
+    context "when given a valid list of files" do
+      before do
+        @filenames = ['foo.csv', 'bar.csv']
+        file = mock File
+        file.should_receive(:read).twice.and_return(@csv)
+        File.should_receive(:open).twice.and_return(file)
+      end
+
+      it "should read the files" do
+        @loader.load_files @filenames
+        @loader.redis.llen(Trifle::KEY).should be == 4
+      end
+    end
+
+    context "when given anything but an array of strings" do
+      it "should raise an error" do
+        -> { @loader.load_files "" }.should raise_error(ArgumentError)
+        -> { @loader.load_files [:foo] }.should raise_error(ArgumentError)
+      end
+    end
+
+    context "when given a filename for a file that's missing" do
+      it "should raise an error" do
+        -> { @loader.load_files ["foobar.csv"] }.should raise_error(/No such file or directory - foobar.csv/)
+      end
+    end
+  end
+
+  describe "#load_data" do
+
+    context "when given valid data" do
+      it "should clear out existing data" do
+        @loader.should_receive(:clear)
+        @loader.load_data @valid_data
+      end
+
+      it "should validate the data" do
+        @loader.should_receive(:valid?).and_return(true)
+        @loader.load_data @valid_data
+      end
+
+      it "should load it in redis" do
+        @loader.load_data @valid_data
+        @loader.redis.llen(Trifle::KEY).should be == 2
+      end
+    end
+
+    context "when given invalid data" do
+      it "should raise an error" do
+        @loader.should_receive(:valid?).and_return(false)
+        -> { @loader.load_data @valid_data }.should raise_error(ArgumentError)
+      end
+    end
+
+    context "when given anything but an array" do
+      it "should raise an error" do
+        -> { @loader.load_data :rubbish }.should raise_error(ArgumentError)
+      end
+    end
+  end
+
+  describe "#parse" do
+    it "should parse valid csv data" do
+      @loader.parse(@csv).should be == @valid_data
+    end
+
+    it "should raise an error for invalid csv data" do
+      -> { @loader.parse('"foo",","#') }.should raise_error(CSV::MalformedCSVError)
+    end
+
+    it "should handle ipv6 data" do
+      @ipv6csv = <<-CSV
+"2c0f:ffe8::", "2c0f:ffe8:ffff:ffff:ffff:ffff:ffff:ffff", "58569106662796955307479896348547874816", "58569106742025117821744233942091825151", "NG", "Nigeria"
+"2c0f:fff0::", "2c0f:fff0:ffff:ffff:ffff:ffff:ffff:ffff", "58569107296622255421594597096899477504", "58569107375850417935858934690443427839", "NG", "Nigeria"
+      CSV
+      -> { @loader.parse(@ipv6csv) }.should_not raise_error
+    end
+  end
+
+  describe "#sort" do
+    it "should sort the data" do
+      @loader.sort(@valid_data.reverse).should be == @valid_data
+    end
+  end
+
+
+  describe "#valid?" do
+    it "should mark valid data as such" do
+      @loader.valid?(@valid_data).should be_true
+    end
+
+    it "should mark invalid data as such" do
+      invalid_data =  []
+      @loader.valid?(invalid_data).should be_false
+      invalid_data = [
+        ["223.255.254.0","223.255.254.255","not_a_number","3758096127","SG","Singapore"]
+      ]
+      @loader.valid?(invalid_data).should be_false
+      invalid_data = [
+        ["223.255.254.0","223.255.254.255","3758095872","not_a_number","SG","Singapore"]
+      ]
+      @loader.valid?(invalid_data).should be_false
+    end
+  end
+
+  describe "#clear" do
+    it "should clear existing data" do
+      @loader.load_data @valid_data
+      @loader.clear
+      @loader.redis.llen(Trifle::KEY).should be == 0
+    end
+  end
+
+end

data/spec/trifle_spec.rb

@@ -0,0 +1,37 @@
+require "spec_helper"
+
+describe Trifle do
+
+  it "should extend InitializeWithRedis" do
+    Trifle.included_modules.should include(Trifle::InitializeWithRedis)
+  end
+
+  describe "#load" do
+    before do
+      @trifle = Trifle.new(Redis.new)
+      @options = { filenames: "foobar.csv" }
+    end
+
+    it "should pass this to the loader" do
+      loader = mock Trifle::Loader
+      Trifle::Loader.should_receive(:new).and_return(loader)
+      loader.should_receive(:handle).with(@options)
+      @trifle.load @options
+    end
+  end
+
+  describe "#find" do
+    before do
+      @trifle = Trifle.new(Redis.new)
+      @ip = "127.0.0.1"
+    end
+
+    it "should pass this to the finder" do
+      finder = mock Trifle::Finder
+      Trifle::Finder.should_receive(:new).and_return(finder)
+      finder.should_receive(:handle).with(@ip)
+      @trifle.find @ip
+    end
+  end
+
+end

data/trifle.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "trifle/version"
+
+Gem::Specification.new do |s|
+  s.name        = "trifle"
+  s.version     = Trifle::VERSION
+  s.authors     = ["Cristiano Betta"]
+  s.email       = ["cristiano@emberads.com"]
+  s.homepage    = "http://emberads.com"
+  s.summary     = "A GeoIP lookup in Redis"
+  s.description = "Stores the GeoIP databases in Redis and gives it a simple way to lookup IPs and map them to countries"
+
+  s.rubyforge_project = "trifle"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'rujitsu'
+  s.add_development_dependency "fakeredis", "~> 0.3.0"
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: trifle
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Cristiano Betta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70353203055680 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70353203055680
+- !ruby/object:Gem::Dependency
+  name: rujitsu
+  requirement: &70353203079000 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70353203079000
+- !ruby/object:Gem::Dependency
+  name: fakeredis
+  requirement: &70353203078460 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: *70353203078460
+description: Stores the GeoIP databases in Redis and gives it a simple way to lookup
+  IPs and map them to countries
+email:
+- cristiano@emberads.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- README.md
+- Rakefile
+- lib/trifle.rb
+- lib/trifle/finder.rb
+- lib/trifle/initialize_with_redis.rb
+- lib/trifle/loader.rb
+- lib/trifle/version.rb
+- spec/spec_helper.rb
+- spec/trifle/finder_spec.rb
+- spec/trifle/initialize_with_redis_spec.rb
+- spec/trifle/loader_spec.rb
+- spec/trifle_spec.rb
+- trifle.gemspec
+homepage: http://emberads.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: trifle
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: A GeoIP lookup in Redis
+test_files:
+- spec/spec_helper.rb
+- spec/trifle/finder_spec.rb
+- spec/trifle/initialize_with_redis_spec.rb
+- spec/trifle/loader_spec.rb
+- spec/trifle_spec.rb