local-geocoder 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGIwNmFlYmZlNGVmNDExZDZkOTMxZGJmODU4NGNhNDIyMzY3MTZkNA==
+  data.tar.gz: !binary |-
+    ZDIxMWZmNmVmZGYwZTZmYmFkYWVhNDg3YjhhYTY4ZTNhOGQ5YmJjMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ODc3YjAzMGNiNjQyZTU3NDgwOTAzOTI2ZWZjOGYzOTk1ODNjNWMyZDQ3MWIz
+    ZThkMjQwMDRmMTRkN2ZlOTdhYTQ0Njg0YzY3NWQzMTUxM2I4YWQ1MmQ3ZDc1
+    NTQ3ODE1N2MyMTFjYjIyYzMzOTEwZjkyZGM1N2JjYzM2NGFmZjY=
+  data.tar.gz: !binary |-
+    ZGRkNGQ3NjQ2OTE4MTUyYzU5Yjg3MzVhODg5Yjg4ZWI2MjNmY2UxZmE0YzQw
+    ZDAyZmNiZWNmYTJiNmY1ZjU5ODQ5MjRjMTlmODQ2OTgwMjYyMWY3YmE3ZTVj
+    YTg0NGExZjA1MDFiYzQ0ZGUyMjQ5MjIwN2FlODNlNWViZjA0OTU=

data/bin/local_geocode

@@ -0,0 +1,42 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), "../lib"))
+require "local_geocoder"
+require "trollop"
+require "csv"
+
+DEFAULT_TEMPLATE = '(?<lng>\-?\d+.?\d+)[,\t ]\s?(?<lat>\-?\d+.?\d+)'
+
+opts = Trollop::options do
+  version "local_geocode #{LocalGeocoder::VERSION}"
+  banner <<-EOS
+Local Geocoder
+---------------
+Reverse geocodes lng,lat pairs into Country codes (and State + County within the USA). Each line of Stdin is read and has lng,lat pairs extracted (see --template below for how) and the resulting reverse geocode is output to Stdout.
+
+Usage:
+  local_geocode [options] file
+
+Example:
+> echo "-122.4194155, 37.7749295" | local_geocode 
+> United States of America (USA), California (CA), San Francisco
+ 
+Options:
+EOS
+  opt 'template', "The regex used to parse lng,lat paris from the input stream", :default => DEFAULT_TEMPLATE, :short => :t
+end
+
+require "local_geocoder"
+
+lc = LocalGeocoder::Geocoder.new
+ARGF.each_line do |l|
+  data = l.match(Regexp.new(opts["template"]))
+  result = if data.nil?
+    LocalGeocoder::Result.new
+  else
+    lng, lat = data[:lng].to_f, data[:lat].to_f 
+    lc.reverse_geocode(lng, lat)
+  end
+  puts result.inspect
+
+end

data/ext/geometry/GeometryService.java

@@ -0,0 +1,49 @@
+package geometry;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+public class GeometryService implements BasicLibraryService {
+  private Ruby runtime;
+  
+  public boolean basicLoad(Ruby runtime) {
+    this.runtime = runtime;
+    RubyModule lc = runtime.defineModule("LocalGeocoder");
+    RubyModule geo = lc.defineModuleUnder("Geometry");
+    
+    RubyClass point = geo.defineClassUnder("Point", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new RPoint(runtime, rubyClass);
+      }
+    });
+
+    RubyClass rect = geo.defineClassUnder("Rect", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new RRect(runtime, rubyClass);
+      }
+    });
+
+    RubyClass polygon = geo.defineClassUnder("Polygon", runtime.getObject(), new ObjectAllocator() {
+      public IRubyObject allocate(Ruby runtime, RubyClass rubyClass) {
+        return new RPolygon(runtime, rubyClass);
+      }
+    });
+
+    point.defineAnnotatedMethods(RPoint.class);    
+    rect.defineAnnotatedMethods(RRect.class);
+    polygon.defineAnnotatedMethods(RPolygon.class);
+    return true;
+  }
+
+}
+

data/ext/geometry/Point.java

@@ -0,0 +1,27 @@
+package geometry;
+
+public class Point {
+
+  double x;
+  double y;
+
+  public Point(double x, double y) {
+    this.x = x;
+    this.y = y;
+  }
+
+  public double getX() {
+    return this.x;
+  }
+  
+  public double getY() {
+    return this.y;
+  }
+
+  public String toString() {
+    return String.format("[%s,%s]", x, y);
+  }
+  
+}
+
+

data/ext/geometry/Polygon.java

@@ -0,0 +1,88 @@
+package geometry;
+
+public class Polygon {
+
+  Point[] points;
+  Rect boundingBox;
+
+  public Polygon(Point[] points) {
+    this.points = points;
+  } 
+
+  public Point[] getPoints() {
+    return this.points;
+  }
+ 
+  public int numberOfPoints() {
+    return this.points.length;
+  }
+ 
+  public Rect boundingBox() {
+    if (boundingBox == null) {
+      double minX, minY, maxX, maxY;
+      minX = minY = Double.POSITIVE_INFINITY; 
+      maxX = maxY = Double.NEGATIVE_INFINITY;
+
+      for (Point p: this.points) {
+        
+        double x = p.getX();
+        double y = p.getY();
+
+        if (x < minX) 
+          minX = x;
+        if (x > maxX)
+          maxX = x;
+
+        if (y < minY) 
+          minY = y;
+        if (y > maxY)
+          maxY = y;
+      }
+       
+      this.boundingBox = new Rect(minX, minY, maxX-minX, maxY-minY); 
+    }
+ 
+    return this.boundingBox;
+  }
+  
+  public String toString() {
+    StringBuilder sb = new StringBuilder();
+
+    for (Point p : points) {
+      sb.append( p.toString() + "," );
+    }
+    return sb.toString();   
+  }
+
+  public boolean containsPoint(Point point) {
+    if (!this.boundingBox().containsPoint(point))
+      return false;
+
+    boolean containsPoint = false;
+    int i = -1;
+    int j = this.points.length - 1;
+    while (++i < this.points.length) {
+      Point p1 = this.points[i];
+      Point p2 = this.points[j];
+      if (this.withinYBounds(point, p1, p2)) {
+        if (this.intersectsLineSegment(point, p1, p2)) {
+          containsPoint = !containsPoint;
+        }
+      }
+      j = i;
+    }
+    return containsPoint; 
+  }
+  
+  private boolean intersectsLineSegment(Point point, Point p1, Point p2) {
+    return (point.getX() < (p2.getX() - p1.getX()) * (point.getY() - p1.getY()) / (p2.getY() - p1.getY()) + p1.getX());   
+  }      
+
+  private boolean withinYBounds(Point point, Point p1, Point p2) {
+    return (p1.getY() <= point.getY() && point.getY() < p2.getY()) ||
+      (p2.getY() <= point.getY() && point.getY() < p1.getY());
+  }
+
+}
+
+

data/ext/geometry/RPoint.java

@@ -0,0 +1,72 @@
+package geometry;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+@JRubyClass(name = "LocalGeocoder::Geometry::Point")
+public class RPoint extends RubyObject {
+
+  Point point;
+  IRubyObject data;
+
+  public RPoint(final Ruby runtime, RubyClass rubyClass) {
+    super(runtime, rubyClass);
+  }
+  
+  @JRubyMethod(name = "initialize", required = 2, optional = 1)
+  public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+    Ruby ruby = context.getRuntime();
+    double x = args[0].convertToFloat().getDoubleValue();
+    double y = args[1].convertToFloat().getDoubleValue();
+    
+    this.point = new Point(x,y);
+    this.data = context.nil;
+    if (args.length > 2) {
+      this.data = args[2];
+    }
+    
+    return context.nil;
+  }
+  
+  public void setPoint(Point point) {
+    this.point = point;
+  }
+
+  public Point getJava() {
+    return this.point;
+  }
+ 
+  @JRubyMethod(name = "x")
+  public IRubyObject x(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    return ruby.newFloat(point.getX());
+  }
+
+  @JRubyMethod(name = "y")
+  public IRubyObject y(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    return ruby.newFloat(point.getY());
+  }
+
+  @JRubyMethod(name = "data")
+  public IRubyObject data(ThreadContext context) {
+    return data;
+  }
+
+  @JRubyMethod(name = "inspect")
+  public IRubyObject inspect(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    return ruby.newString(point.toString());
+  }
+  
+}

data/ext/geometry/RPolygon.java

@@ -0,0 +1,111 @@
+package geometry;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+@JRubyClass(name = "LocalGeocoder::Geometry::Polygon")  
+public class RPolygon extends RubyObject {
+
+  Polygon polygon;
+
+  public RPolygon(final Ruby runtime, RubyClass rubyClass) {
+    super(runtime, rubyClass);
+  }
+
+  public void setPolygon(Polygon polygon) {
+    this.polygon = polygon; 
+  }
+
+  @JRubyMethod(name = "initialize")
+  public IRubyObject initialize(ThreadContext context, IRubyObject rps) {
+    Ruby ruby = context.getRuntime();
+
+    RubyArray rPoints = (RubyArray) rps;
+
+    Point[] points = new Point[rPoints.getLength()];
+    for (int i = 0; i < rPoints.getLength(); i++) {
+      points[i] = ((RPoint) rPoints.get(i)).getJava();
+    }
+    
+    this.polygon = new Polygon(points);
+
+    return context.nil;
+  }
+
+  @JRubyMethod(meta = true, name = "from_point_array")
+  public static IRubyObject fromPointArray(ThreadContext context, IRubyObject klazz, IRubyObject pts) {
+    Ruby ruby = context.getRuntime();
+
+    RubyArray rpts = (RubyArray) pts;
+
+    Point[] points = new Point[rpts.getLength()];
+    for (int i = 0; i < rpts.getLength(); i++) {
+      double x = ((Number) ((RubyArray) rpts.get(i)).get(0)).doubleValue();
+      double y = ((Number) ((RubyArray) rpts.get(i)).get(1)).doubleValue();
+      points[i] = new Point(x,y);
+    }
+   
+    IRubyObject obj = ((RubyClass) klazz).allocate();
+    ((RPolygon) obj).setPolygon(new Polygon(points));
+
+    return obj;
+  }
+
+  @JRubyMethod
+  public IRubyObject number_of_points(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    int i = this.polygon.numberOfPoints();
+    return ruby.newFixnum(i);
+  }
+
+  @JRubyMethod(name = "points")
+  public IRubyObject points(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+
+    Point[] points = this.polygon.getPoints();
+    RPoint[] rPoints = new RPoint[points.length];
+    for (int i = 0; i < points.length; i++) {
+      RPoint rPoint = new RPoint(ruby, (RubyClass)ruby.getClassFromPath("LocalGeocoder::Geometry::Point"));
+      rPoint.setPoint(points[i]);
+      rPoints[i] = rPoint;
+    }
+
+    return ruby.newArray(rPoints);
+  }
+
+  @JRubyMethod(name = "bounding_box")
+  public IRubyObject boundingBox(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    
+    Rect rect = this.polygon.boundingBox();
+    RRect rRect = new RRect(ruby, (RubyClass)ruby.getClassFromPath("LocalGeocoder::Geometry::Rect"));
+    rRect.setRect(rect);
+
+    return rRect;
+  }
+
+  @JRubyMethod(name = "contains_point?")
+  public IRubyObject containsPoint(ThreadContext context, IRubyObject rPoint) {
+    Ruby ruby = context.getRuntime();
+    
+    boolean result = this.polygon.containsPoint(((RPoint)rPoint).getJava());
+    return ruby.newBoolean(result);
+  }
+
+  @JRubyMethod(name = "inspect")
+  public IRubyObject inspect(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    return ruby.newString(polygon.toString());
+  }
+  
+}

data/ext/geometry/RRect.java

@@ -0,0 +1,96 @@
+package geometry;
+
+import org.jruby.Ruby;
+import org.jruby.RubyArray;
+import org.jruby.RubyClass;
+import org.jruby.RubyFixnum;
+import org.jruby.RubyModule;
+import org.jruby.RubyObject;
+import org.jruby.anno.JRubyClass;
+import org.jruby.anno.JRubyMethod;
+import org.jruby.runtime.ObjectAllocator;
+import org.jruby.runtime.ThreadContext;
+import org.jruby.runtime.builtin.IRubyObject;
+import org.jruby.runtime.load.BasicLibraryService;
+
+@JRubyClass(name = "LocalGeocoder::Geometry::Rect")  
+public class RRect extends RubyObject {
+
+  Rect rect;
+
+  public RRect(final Ruby runtime, RubyClass rubyClass) {
+    super(runtime, rubyClass);
+  }
+ 
+  @JRubyMethod(name = "initialize", required = 4)
+  public IRubyObject initialize(ThreadContext context, IRubyObject[] args) {
+    Ruby ruby = context.getRuntime();
+
+    double dX = args[0].convertToFloat().getDoubleValue();
+    double dY = args[1].convertToFloat().getDoubleValue();
+    double dWidth = args[2].convertToFloat().getDoubleValue();
+    double dHeight = args[3].convertToFloat().getDoubleValue();
+    
+    this.rect = new Rect(dX,dY,dWidth,dHeight);
+      
+    return context.nil;
+  }
+
+  public void setRect(Rect rect) {
+    this.rect = rect;
+  }
+
+  public Rect getJava() {
+    return this.rect;
+  }
+  
+  @JRubyMethod(name = "x")
+  public IRubyObject x(ThreadContext context) {
+    Ruby ruby = context.getRuntime(); 
+    return ruby.newFloat(rect.getX());
+  }
+
+  @JRubyMethod(name = "y")
+  public IRubyObject y(ThreadContext context) {
+    Ruby ruby = context.getRuntime(); 
+    return ruby.newFloat(rect.getY());
+  }
+  
+
+  @JRubyMethod(name = "width")
+  public IRubyObject widht(ThreadContext context) {
+    Ruby ruby = context.getRuntime(); 
+    return ruby.newFloat(rect.getWidth());
+  }
+  
+
+  @JRubyMethod(name = "height")
+  public IRubyObject height(ThreadContext context) {
+    Ruby ruby = context.getRuntime(); 
+    return ruby.newFloat(rect.getHeight());
+  }
+
+  @JRubyMethod(name = "==")
+  public IRubyObject r_eql(ThreadContext context, IRubyObject rRect) {
+    Ruby ruby = context.getRuntime(); 
+
+    
+    return ruby.newBoolean(rect.equals(((RRect) rRect).getJava()));
+  } 
+
+  @JRubyMethod(name = "contains_point?")
+  public IRubyObject containsPoint(ThreadContext context, IRubyObject point) {
+    Ruby ruby = context.getRuntime();
+    boolean result = this.rect.containsPoint(((RPoint)point).getJava());
+      
+    return ruby.newBoolean(result);
+  }
+
+  @JRubyMethod(name = "inspect")
+  public IRubyObject inspect(ThreadContext context) {
+    Ruby ruby = context.getRuntime();
+    String str = String.format("[%s,%s],[%s,%s]", rect.getX(),rect.getY(),rect.getX()+rect.getWidth(),rect.getY()+rect.getHeight()); 
+    return ruby.newString(str);
+  }
+  
+}

data/ext/geometry/Rect.java

@@ -0,0 +1,49 @@
+package geometry;
+
+public class Rect {
+
+  double x;
+  double y;
+  double width;
+  double height;
+
+  public Rect(double x, double y, double width, double height) {
+    this.x = x;
+    this.y = y;
+    this.width = width;
+    this.height = height;
+  } 
+  
+  public boolean containsPoint(Point point) {
+    return point.getX() >= this.x && point.getY() >= this.y &&
+           point.getX() <= (this.x + this.width) && point.getY() <= (this.y + this.height);
+  }
+
+  public double getX() {
+    return this.x;
+  }
+    
+  public double getY() {
+    return this.y;
+  }
+  
+  public double getWidth() {
+    return this.width;
+  }
+
+  public double getHeight() {
+    return this.height;
+  }
+  
+  @Override public boolean equals(Object other) {
+    boolean result = false;
+    if (other instanceof Rect) {
+      Rect rect = (Rect) other;
+      result = (this.x == rect.getX() && this.y == rect.getY() && 
+        this.width == rect.getWidth() && this.height == rect.getHeight());
+    }
+    return result;
+  }
+  
+}
+

data/ext/geometry/extconf.rb

@@ -0,0 +1,5 @@
+require 'mkmf'
+extension_name = 'geometry'
+dir_config(extension_name)
+create_makefile(extension_name)
+

data/lib/local_geocoder.rb

@@ -0,0 +1,23 @@
+require "json"
+
+module LocalGeocoder
+  DATA_DIR = "data"
+end
+
+require "local_geocoder/version"
+require "local_geocoder/data_source"
+require "local_geocoder/geocoder"
+
+if RUBY_PLATFORM =~ /java/
+  require 'jruby'
+  require 'geometry.jar' 
+
+  java_import 'geometry.GeometryService' 
+  
+  Java::Geometry::GeometryService.new.basicLoad(JRuby.runtime)
+else
+  require "local_geocoder/geometry/point"
+  require "local_geocoder/geometry/rect"
+  require "local_geocoder/geometry/polygon"
+end
+

data/lib/local_geocoder/data_source.rb

@@ -0,0 +1,57 @@
+module LocalGeocoder
+
+  Entity = Struct.new(:short_name, :long_name, :geometries) do
+    def inspect
+      "#{self.long_name}#{self.short_name.empty? ? "" : ' ('+self.short_name+')' }"
+    end
+  end
+
+  class DataSource
+
+    def initialize(dir)
+      @countries = load_data(dir, "countries/features.geo.json")
+      @administrative_areas_level_1 = Hash.new do |h,k|
+        h[k] = load_data(File.join(dir, "countries", k), "features.geo.json")
+      end
+      @administrative_areas_level_2 = Hash.new do |h,k|
+        h[k] = load_data(File.join(dir, "countries", *k), "features.geo.json")
+      end
+    end
+
+    def countries
+      @countries
+    end
+    
+    def administrative_areas_level_1(country_id)
+      return nil if country_id.nil?      
+      @administrative_areas_level_1[country_id]
+    end
+
+    def administrative_areas_level_2(country_id, aa1_id)
+      return nil if country_id.nil? || aa1_id.nil?
+      @administrative_areas_level_2[[country_id, aa1_id]]
+    end 
+
+    private
+ 
+    def load_data(dir, file)
+      features = JSON.load(File.open(File.join(dir, file)))['features']
+      features.map do |f|
+        id = f['id'] ? f['id'][/\w+$/] : ""
+
+        # Note: Perimeter is always first element in GeoJSON.
+        geometries = case f['geometry']['type']
+        when "MultiPolygon"
+          f['geometry']['coordinates'].map { |g| Geometry::Polygon.from_point_array(g.first) }
+        when "Polygon"
+          Array(Geometry::Polygon.from_point_array(f['geometry']['coordinates'].first))
+        else
+          raise "Don't know how to handle geometry type: #{f['geometry']['type']}"
+        end
+        Entity.new(id, f['properties']['name'], geometries)
+      end
+    end
+    
+  end
+
+end

data/lib/local_geocoder/geocoder.rb

@@ -0,0 +1,48 @@
+module LocalGeocoder
+  
+  Result = Struct.new(:country, :administrative_area_level_1, :administrative_area_level_2) do
+    alias_method :state, :administrative_area_level_1
+    alias_method :county, :administrative_area_level_2
+    def inspect
+      "#{self.country.inspect}, #{self.administrative_area_level_1.inspect}, #{self.administrative_area_level_2.inspect}"
+    end    
+  end
+  
+  class Geocoder
+    
+    def initialize
+      @data_source = DataSource.new(DATA_DIR) 
+    end
+
+    def reverse_geocode(lng, lat)
+      country = find_result(lng, lat)
+    end
+   
+    private
+    
+    def find_result(lng, lat)
+      cnt = find_country(lng, lat)
+      aa1, aa2 = find_administrative_areas(cnt.short_name, lng, lat) if cnt && cnt.short_name == "USA"
+      Result.new(cnt, aa1, aa2) 
+    end
+    
+    def find_country(lng, lat)
+      @data_source.countries.find { |c|  contains_location?(c, lng, lat); }
+    end
+
+    def find_administrative_areas(country_id, lng, lat)
+      aa1 = @data_source.administrative_areas_level_1(country_id).find { |a| contains_location?(a, lng, lat) }
+      return nil,nil if aa1.nil?
+
+      aa2 = @data_source.administrative_areas_level_2(country_id, aa1.short_name).find { |a| contains_location?(a, lng, lat) }
+      return aa1, aa2
+    end
+
+    def contains_location?(entity, lng, lat)
+      entity.geometries.any? { |g| g.contains_point?(Geometry::Point.new(lng, lat)) }
+    end
+
+  end
+
+end
+

data/lib/local_geocoder/geometry/point.rb

@@ -0,0 +1,18 @@
+module LocalGeocoder
+  module Geometry
+
+    class Point
+      attr_accessor :x, :y, :data
+      def initialize(x, y, data=nil)
+        @x = x
+        @y = y
+        @data = data
+      end
+
+      def inspect
+        "[#{x}, #{y}]"
+      end
+    end
+      
+  end
+end

data/lib/local_geocoder/geometry/polygon.rb

@@ -0,0 +1,69 @@
+module LocalGeocoder  
+  module Geometry
+
+    class Polygon
+      attr_accessor :points
+      
+      def initialize(points)
+        @points = points
+      end
+      
+      def self.from_point_array(points)
+        Polygon.new(points.map { |p| Point.new(*p) })
+      end
+      
+      def number_of_points
+        @points.size
+      end
+
+      def [](i)
+        @points[i]
+      end
+      
+      def bounding_box
+        @bounding_box ||= begin
+          min_x, max_x = @points.minmax_by { |p| p.x }.map { |p| p.x }
+          min_y, max_y = @points.minmax_by { |p| p.y }.map { |p| p.y }
+          Rect.new(min_x, min_y, max_x-min_x, max_y-min_y)
+        end
+      end
+
+      def contains_point?(point)
+        return false if !self.bounding_box.contains_point?(point)
+        
+        contains_point = false
+        i = -1
+        j = self.number_of_points - 1
+        while (i += 1) < self.number_of_points
+          p1 = self[i]; p2 = self[j]
+          if within_y_bounds?(point, p1, p2)
+            if intersects_line_segment?(point, p1, p2)
+              contains_point = !contains_point
+            end
+          end
+          j = i
+        end
+        return contains_point
+      end
+
+      def inspect
+        @points.map { |p| p.inspect }.join(",")
+      end
+
+      private
+
+      def within_y_bounds?(point, p1, p2)
+        (p1.y <= point.y && point.y < p2.y) || 
+          (p2.y <= point.y && point.y < p1.y)
+      end
+
+      def intersects_line_segment?(point, p1, p2)
+        (point.x < (p2.x - p1.x) * (point.y - p1.y) / 
+                  (p2.y - p1.y) + p1.x)
+      end
+      
+    end
+
+  end
+end
+

data/lib/local_geocoder/geometry/rect.rb

@@ -0,0 +1,22 @@
+module LocalGeocoder
+  module Geometry
+
+    Rect = Struct.new(:x, :y, :width, :height) do
+      def contains_point?(point)
+        point.x >= self.x && point.y >= self.y &&
+          point.x <= (self.x+self.width) && point.y <= (self.y+self.height)
+      end
+    
+      def ==(rect)
+        self.x == rect.x && self.y == rect.y &&
+          self.width == rect.width && self.height == rect.height
+      end
+    
+      def inspect
+        "[#{x},#{y}],[#{x+width},#{y+height}]"
+      end
+      
+    end
+
+  end
+end

data/lib/local_geocoder/version.rb

@@ -0,0 +1,3 @@
+module LocalGeocoder
+  VERSION = '0.1.1'
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: local-geocoder
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Aish Fenton
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trollop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: rspec
+  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: rake-compiler
+  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'
+description: 
+email: 
+executables:
+- local_geocode
+extensions: []
+extra_rdoc_files: []
+files:
+- ext/geometry/GeometryService.java
+- ext/geometry/Point.java
+- ext/geometry/Polygon.java
+- ext/geometry/Rect.java
+- ext/geometry/RPoint.java
+- ext/geometry/RPolygon.java
+- ext/geometry/RRect.java
+- ext/geometry/extconf.rb
+- lib/local_geocoder/data_source.rb
+- lib/local_geocoder/geocoder.rb
+- lib/local_geocoder/geometry/point.rb
+- lib/local_geocoder/geometry/polygon.rb
+- lib/local_geocoder/geometry/rect.rb
+- lib/local_geocoder/version.rb
+- lib/local_geocoder.rb
+- bin/local_geocode
+homepage: 
+licenses: []
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Reverse geocodes lng, lat pairs into country codes (plus State and Counties
+  within the US). Runs locally, with no external dependancies, and is fast enough
+  for large batch jobs
+test_files: []