dynamodb_geo 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 34aa9b9ef408a4556afbc74c173c40ccb5932fc0a47d29a3e519c0cb803fe043
+  data.tar.gz: f7dd0b6c92a94e7da2c14417ee67296af8f04f86b768bfb2c8acd32572bdd8e9
+SHA512:
+  metadata.gz: 9d3d2f46f82c2e9ece62dc006dbda654753d01fb7d82d06d803448171a9852cef5933ce814ce20057017ed9fcb318b9f6ff37dbe79cb7f5167c82aea65f3258c
+  data.tar.gz: 8df26e8041dfbb59020496faf2ae5014fae971b9b7d0f84274ff4eeb58c0c70487623a7a44343a4443647d08cfe72acc48c8115004c287853c2896dc46e91b9a

data/README.md

@@ -0,0 +1,55 @@
+# DynamoDB_Geo
+
+
+# Geohashing
+Includes a Geohash implimentation written in C  
+<https://github.com/simplegeo/libgeohash>
+
+
+### Methods
+Encoding a Geohash
+
+    Description: Takes in a latitude, longitude, and precision, and returns a geohash as a string
+    Input:  latitude  => Number
+            longitude => Number
+            precision => Number
+    Output: Geohash   => String
+
+    Geohash.encode(lat, long, precision) => String
+
+
+Decoding a Geohash
+
+    Description: Takes in a hash, and returns a Geocoord
+    Input:  Geohash  => String
+    Output: Geocoord => Object
+
+    Geohash.decode(hash) => Geocoord
+
+Viewing all my neighbours
+
+    Description: Takes in a Geohash and shows the surrounding 8 neighbours
+
+                 Physical representation:
+                 NW N NE       7 0 1
+                 W  X E   =>   6 X 2
+                 SW S SE       5 4 3
+
+                 Flat representation:
+                 N  NE E  SE S  SW W  NW
+                 0  1  2  3  4  5  6  7
+    Input:  Geohash => String
+    Output: Array[Geocoord]
+
+    Geohash.neighbours(hash) => Array[Geohash]
+
+Get width and height about a specific precision
+
+    Description: Takes in a precision value, returns the height and width of the box
+    Input:  precision => Number
+    Output: Dimension => Object
+
+    Geohash.dimensions(precision) => Dimension
+
+#### Geocoord(Object) => attr_accessor: :latitude, :longitude, :north, :south, :east, :west, :dimension
+#### Dimension(Object) => attr_accessor: :length, :width

data/ext/geohash_wrapper/Makefile

@@ -0,0 +1,266 @@
+
+SHELL = /bin/sh
+
+# V=0 quiet, V=1 verbose.  other values don't work.
+V = 0
+Q1 = $(V:1=)
+Q = $(Q1:0=@)
+ECHO1 = $(V:1=@ :)
+ECHO = $(ECHO1:0=@ echo)
+NULLCMD = :
+
+#### Start of system configuration section. ####
+
+srcdir = .
+topdir = /home/justin/.rvm/rubies/ruby-2.7.0/include/ruby-2.7.0
+hdrdir = $(topdir)
+arch_hdrdir = /home/justin/.rvm/rubies/ruby-2.7.0/include/ruby-2.7.0/x86_64-linux
+PATH_SEPARATOR = :
+VPATH = $(srcdir):$(arch_hdrdir)/ruby:$(hdrdir)/ruby
+prefix = $(DESTDIR)/home/justin/.rvm/rubies/ruby-2.7.0
+rubysitearchprefix = $(rubylibprefix)/$(sitearch)
+rubyarchprefix = $(rubylibprefix)/$(arch)
+rubylibprefix = $(libdir)/$(RUBY_BASE_NAME)
+exec_prefix = $(prefix)
+vendorarchhdrdir = $(vendorhdrdir)/$(sitearch)
+sitearchhdrdir = $(sitehdrdir)/$(sitearch)
+rubyarchhdrdir = $(rubyhdrdir)/$(arch)
+vendorhdrdir = $(rubyhdrdir)/vendor_ruby
+sitehdrdir = $(rubyhdrdir)/site_ruby
+rubyhdrdir = $(includedir)/$(RUBY_VERSION_NAME)
+vendorarchdir = $(vendorlibdir)/$(sitearch)
+vendorlibdir = $(vendordir)/$(ruby_version)
+vendordir = $(rubylibprefix)/vendor_ruby
+sitearchdir = $(sitelibdir)/$(sitearch)
+sitelibdir = $(sitedir)/$(ruby_version)
+sitedir = $(rubylibprefix)/site_ruby
+rubyarchdir = $(rubylibdir)/$(arch)
+rubylibdir = $(rubylibprefix)/$(ruby_version)
+sitearchincludedir = $(includedir)/$(sitearch)
+archincludedir = $(includedir)/$(arch)
+sitearchlibdir = $(libdir)/$(sitearch)
+archlibdir = $(libdir)/$(arch)
+ridir = $(datarootdir)/$(RI_BASE_NAME)
+mandir = $(datarootdir)/man
+localedir = $(datarootdir)/locale
+libdir = $(exec_prefix)/lib
+psdir = $(docdir)
+pdfdir = $(docdir)
+dvidir = $(docdir)
+htmldir = $(docdir)
+infodir = $(datarootdir)/info
+docdir = $(datarootdir)/doc/$(PACKAGE)
+oldincludedir = $(DESTDIR)/usr/include
+includedir = $(prefix)/include
+runstatedir = $(localstatedir)/run
+localstatedir = $(prefix)/var
+sharedstatedir = $(prefix)/com
+sysconfdir = $(prefix)/etc
+datadir = $(datarootdir)
+datarootdir = $(prefix)/share
+libexecdir = $(exec_prefix)/libexec
+sbindir = $(exec_prefix)/sbin
+bindir = $(exec_prefix)/bin
+archdir = $(rubyarchdir)
+
+
+CC_WRAPPER = 
+CC = gcc
+CXX = g++
+LIBRUBY = $(LIBRUBY_SO)
+LIBRUBY_A = lib$(RUBY_SO_NAME)-static.a
+LIBRUBYARG_SHARED = -Wl,-rpath,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)
+LIBRUBYARG_STATIC = -Wl,-rpath,$(libdir) -L$(libdir) -l$(RUBY_SO_NAME)-static $(MAINLIBS)
+empty =
+OUTFLAG = -o $(empty)
+COUTFLAG = -o $(empty)
+CSRCFLAG = $(empty)
+
+RUBY_EXTCONF_H = extconf.h
+cflags   = $(optflags) $(debugflags) $(warnflags)
+cxxflags = 
+optflags = -O3
+debugflags = -ggdb3
+warnflags = -Wall -Wextra -Wdeprecated-declarations -Wduplicated-cond -Wimplicit-function-declaration -Wimplicit-int -Wmisleading-indentation -Wpointer-arith -Wwrite-strings -Wimplicit-fallthrough=0 -Wmissing-noreturn -Wno-cast-function-type -Wno-constant-logical-operand -Wno-long-long -Wno-missing-field-initializers -Wno-overlength-strings -Wno-packed-bitfield-compat -Wno-parentheses-equality -Wno-self-assign -Wno-tautological-compare -Wno-unused-parameter -Wno-unused-value -Wsuggest-attribute=format -Wsuggest-attribute=noreturn -Wunused-variable
+cppflags = 
+CCDLFLAGS = -fPIC
+CFLAGS   = $(CCDLFLAGS) $(cflags)  -fPIC $(ARCH_FLAG)
+INCFLAGS = -I. -I$(arch_hdrdir) -I$(hdrdir)/ruby/backward -I$(hdrdir) -I$(srcdir)
+DEFS     = 
+CPPFLAGS = -DRUBY_EXTCONF_H=\"$(RUBY_EXTCONF_H)\"  $(DEFS) $(cppflags)
+CXXFLAGS = $(CCDLFLAGS) -g -O2 $(ARCH_FLAG)
+ldflags  = -L. -fstack-protector-strong -rdynamic -Wl,-export-dynamic
+dldflags = -Wl,--compress-debug-sections=zlib 
+ARCH_FLAG = 
+DLDFLAGS = $(ldflags) $(dldflags) $(ARCH_FLAG)
+LDSHARED = $(CC) -shared
+LDSHAREDXX = $(CXX) -shared
+AR = ar
+EXEEXT = 
+
+RUBY_INSTALL_NAME = $(RUBY_BASE_NAME)
+RUBY_SO_NAME = ruby
+RUBYW_INSTALL_NAME = 
+RUBY_VERSION_NAME = $(RUBY_BASE_NAME)-$(ruby_version)
+RUBYW_BASE_NAME = rubyw
+RUBY_BASE_NAME = ruby
+
+arch = x86_64-linux
+sitearch = $(arch)
+ruby_version = 2.7.0
+ruby = $(bindir)/$(RUBY_BASE_NAME)
+RUBY = $(ruby)
+ruby_headers = $(hdrdir)/ruby.h $(hdrdir)/ruby/backward.h $(hdrdir)/ruby/ruby.h $(hdrdir)/ruby/defines.h $(hdrdir)/ruby/missing.h $(hdrdir)/ruby/intern.h $(hdrdir)/ruby/st.h $(hdrdir)/ruby/subst.h $(arch_hdrdir)/ruby/config.h $(RUBY_EXTCONF_H)
+
+RM = rm -f
+RM_RF = $(RUBY) -run -e rm -- -rf
+RMDIRS = rmdir --ignore-fail-on-non-empty -p
+MAKEDIRS = /usr/bin/mkdir -p
+INSTALL = /usr/bin/install -c
+INSTALL_PROG = $(INSTALL) -m 0755
+INSTALL_DATA = $(INSTALL) -m 644
+COPY = cp
+TOUCH = exit >
+
+#### End of system configuration section. ####
+
+preload = 
+libpath = . $(libdir)
+LIBPATH =  -L. -L$(libdir) -Wl,-rpath,$(libdir)
+DEFFILE = 
+
+CLEANFILES = mkmf.log
+DISTCLEANFILES = 
+DISTCLEANDIRS = 
+
+extout = 
+extout_prefix = 
+target_prefix = /dynamodb-geo
+LOCAL_LIBS = 
+LIBS = $(LIBRUBYARG_SHARED)  -lm   -lc
+ORIG_SRCS = geohash.c geohash_wrapper.c
+SRCS = $(ORIG_SRCS) 
+OBJS = geohash.o geohash_wrapper.o
+HDRS = $(srcdir)/extconf.h $(srcdir)/geohash.h
+LOCAL_HDRS = 
+TARGET = dynamodb-geo
+TARGET_NAME = dynamodb
+TARGET_ENTRY = Init_$(TARGET_NAME)
+DLLIB = $(TARGET).so
+EXTSTATIC = 
+STATIC_LIB = 
+
+TIMESTAMP_DIR = .
+BINDIR        = $(bindir)
+RUBYCOMMONDIR = $(sitedir)$(target_prefix)
+RUBYLIBDIR    = $(sitelibdir)$(target_prefix)
+RUBYARCHDIR   = $(sitearchdir)$(target_prefix)
+HDRDIR        = $(rubyhdrdir)/ruby$(target_prefix)
+ARCHHDRDIR    = $(rubyhdrdir)/$(arch)/ruby$(target_prefix)
+TARGET_SO_DIR =
+TARGET_SO     = $(TARGET_SO_DIR)$(DLLIB)
+CLEANLIBS     = $(TARGET_SO) 
+CLEANOBJS     = *.o  *.bak
+
+all:    $(DLLIB)
+static: $(STATIC_LIB)
+.PHONY: all install static install-so install-rb
+.PHONY: clean clean-so clean-static clean-rb
+
+clean-static::
+clean-rb-default::
+clean-rb::
+clean-so::
+clean: clean-so clean-static clean-rb-default clean-rb
+		-$(Q)$(RM) $(CLEANLIBS) $(CLEANOBJS) $(CLEANFILES) .*.time
+
+distclean-rb-default::
+distclean-rb::
+distclean-so::
+distclean-static::
+distclean: clean distclean-so distclean-static distclean-rb-default distclean-rb
+		-$(Q)$(RM) Makefile $(RUBY_EXTCONF_H) conftest.* mkmf.log
+		-$(Q)$(RM) core ruby$(EXEEXT) *~ $(DISTCLEANFILES)
+		-$(Q)$(RMDIRS) $(DISTCLEANDIRS) 2> /dev/null || true
+
+realclean: distclean
+install: install-so install-rb
+
+install-so: $(DLLIB) $(TIMESTAMP_DIR)/.sitearchdir.-.dynamodb-geo.time
+	$(INSTALL_PROG) $(DLLIB) $(RUBYARCHDIR)
+clean-static::
+	-$(Q)$(RM) $(STATIC_LIB)
+install-rb: pre-install-rb do-install-rb install-rb-default
+install-rb-default: pre-install-rb-default do-install-rb-default
+pre-install-rb: Makefile
+pre-install-rb-default: Makefile
+do-install-rb:
+do-install-rb-default:
+pre-install-rb-default:
+	@$(NULLCMD)
+$(TIMESTAMP_DIR)/.sitearchdir.-.dynamodb-geo.time:
+	$(Q) $(MAKEDIRS) $(@D) $(RUBYARCHDIR)
+	$(Q) $(TOUCH) $@
+
+site-install: site-install-so site-install-rb
+site-install-so: install-so
+site-install-rb: install-rb
+
+.SUFFIXES: .c .m .cc .mm .cxx .cpp .o .S
+
+.cc.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cc.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.mm.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.mm.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cxx.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cxx.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.cpp.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.cpp.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CXX) $(INCFLAGS) $(CPPFLAGS) $(CXXFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.c.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.c.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+.m.o:
+	$(ECHO) compiling $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -c $(CSRCFLAG)$<
+
+.m.S:
+	$(ECHO) translating $(<)
+	$(Q) $(CC) $(INCFLAGS) $(CPPFLAGS) $(CFLAGS) $(COUTFLAG)$@ -S $(CSRCFLAG)$<
+
+$(TARGET_SO): $(OBJS) Makefile
+	$(ECHO) linking shared-object dynamodb-geo/$(DLLIB)
+	-$(Q)$(RM) $(@)
+	$(Q) $(LDSHARED) -o $@ $(OBJS) $(LIBPATH) $(DLDFLAGS) $(LOCAL_LIBS) $(LIBS)
+
+
+
+$(OBJS): $(HDRS) $(ruby_headers)

data/ext/geohash_wrapper/extconf.h

@@ -0,0 +1,3 @@
+#ifndef EXTCONF_H
+#define EXTCONF_H
+#endif

data/ext/geohash_wrapper/extconf.rb

@@ -0,0 +1,3 @@
+require 'mkmf'
+create_header
+create_makefile('geohash_wrapper/geohash_wrapper')

data/ext/geohash_wrapper/geohash.c

@@ -0,0 +1,293 @@
+/*
+ *  geohash.c
+ *  libgeohash
+ *
+ *  Created by Derek Smith on 10/6/09.
+ *  Copyright (c) 2010, SimpleGeo
+ *      All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions are met:
+
+ *  Redistributions of source code must retain the above copyright notice, this list
+ *  of conditions and the following disclaimer. Redistributions in binary form must 
+ *  reproduce the above copyright notice, this list of conditions and the following 
+ *  disclaimer in the documentation and/or other materials provided with the distribution.
+ *  Neither the name of the SimpleGeo nor the names of its contributors may be used
+ *  to endorse or promote products derived from this software without specific prior 
+ *  written permission. 
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+ *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
+ *  THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ *  OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "geohash.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+
+#define MAX_LAT             90.0
+#define MIN_LAT             -90.0
+
+#define MAX_LONG            180.0
+#define MIN_LONG            -180.0
+
+#define NORTH               0
+#define EAST                1
+#define SOUTH               2
+#define WEST                3
+
+#define LENGTH_OF_DEGREE	111100				// meters
+
+typedef struct IntervalStruct {
+    
+    double high;
+    double low;
+    
+} Interval;
+
+
+/* Normal 32 characer map used for geohashing */
+static char char_map[32] =  "0123456789bcdefghjkmnpqrstuvwxyz";
+
+/*
+ *  The follow character maps were created by Dave Troy and used in his Javascript Geohashing
+ *  library. http://github.com/davetroy/geohash-js
+ */
+static char *even_neighbors[] = {"p0r21436x8zb9dcf5h7kjnmqesgutwvy",
+                                "bc01fg45238967deuvhjyznpkmstqrwx", 
+                                "14365h7k9dcfesgujnmqp0r2twvyx8zb",
+                                "238967debc01fg45kmstqrwxuvhjyznp"
+                                };
+
+static char *odd_neighbors[] = {"bc01fg45238967deuvhjyznpkmstqrwx", 
+                               "p0r21436x8zb9dcf5h7kjnmqesgutwvy",
+                                "238967debc01fg45kmstqrwxuvhjyznp",
+                               "14365h7k9dcfesgujnmqp0r2twvyx8zb"    
+                                };
+
+static char *even_borders[] = {"prxz", "bcfguvyz", "028b", "0145hjnp"};
+static char *odd_borders[] = {"bcfguvyz", "prxz", "0145hjnp", "028b"};
+
+unsigned int index_for_char(char c, char *string) {
+    
+    int index = -1;
+    int string_amount = strlen(string);
+    int i;
+    for(i = 0; i < string_amount; i++) {
+        
+        if(c == string[i]) {
+            
+            index = i; 
+            break;
+        }
+        
+    }
+    
+    return index;
+}
+
+char* get_neighbor(char *hash, int direction) {
+    
+    int hash_length = strlen(hash);
+    
+	char last_char = hash[hash_length - 1];
+    
+    int is_odd = hash_length % 2;
+    char **border = is_odd ? odd_borders : even_borders;
+    char **neighbor = is_odd ? odd_neighbors : even_neighbors; 
+    
+    char *base = malloc(sizeof(char) * 1);
+    base[0] = '\0';
+    strncat(base, hash, hash_length - 1);
+    
+	if(index_for_char(last_char, border[direction]) != -1)
+		base = get_neighbor(base, direction);
+    
+    int neighbor_index = index_for_char(last_char, neighbor[direction]);
+    last_char = char_map[neighbor_index];
+        
+    char *last_hash = malloc(sizeof(char) * 2);
+    last_hash[0] = last_char;
+    last_hash[1] = '\0';
+    strcat(base, last_hash);
+    free(last_hash);
+    
+	return base;
+}
+
+char* geohash_encode(double lat, double lng, int precision) {
+    
+    if(precision < 1 || precision > 12)
+        precision = 6;
+    
+    char* hash = NULL;
+    
+    if(lat <= 90.0 && lat >= -90.0 && lng <= 180.0 && lng >= -180.0) {
+        
+        hash = (char*)malloc(sizeof(char) * (precision + 1));
+        hash[precision] = '\0';
+        
+        precision *= 5.0;
+        
+        Interval lat_interval = {MAX_LAT, MIN_LAT};
+        Interval lng_interval = {MAX_LONG, MIN_LONG};
+
+        Interval *interval;
+        double coord, mid;
+        int is_even = 1;
+        unsigned int hashChar = 0;
+        int i;
+        for(i = 1; i <= precision; i++) {
+         
+            if(is_even) {
+            
+                interval = &lng_interval;
+                coord = lng;                
+                
+            } else {
+                
+                interval = &lat_interval;
+                coord = lat;   
+            }
+            
+            mid = (interval->low + interval->high) / 2.0;
+            hashChar = hashChar << 1;
+            
+            if(coord > mid) {
+                
+                interval->low = mid;
+                hashChar |= 0x01;
+                
+            } else
+                interval->high = mid;
+            
+            if(!(i % 5)) {
+                
+                hash[(i - 1) / 5] = char_map[hashChar];
+                hashChar = 0;
+
+            }
+            
+            is_even = !is_even;
+        }
+     
+        
+    }
+    
+    return hash;
+}
+
+GeoCoord geohash_decode(char *hash) {
+    
+    GeoCoord coordinate = {0.0, 0.0, 0.0, 0.0, 0.0, 0.0};
+    
+    if(hash) {
+        
+        int char_amount = strlen(hash);
+        
+        if(char_amount) {
+            
+            unsigned int char_mapIndex;
+            Interval lat_interval = {MAX_LAT, MIN_LAT};
+            Interval lng_interval = {MAX_LONG, MIN_LONG};
+            Interval *interval;
+        
+            int is_even = 1;
+            double delta;
+            int i, j;
+            for(i = 0; i < char_amount; i++) {
+            
+                char_mapIndex = index_for_char(hash[i], (char*)char_map);
+                
+                if(char_mapIndex < 0)
+                    break;
+            
+                // Interpret the last 5 bits of the integer
+                for(j = 0; j < 5; j++) {
+                
+                    interval = is_even ? &lng_interval : &lat_interval;
+                
+                    delta = (interval->high - interval->low) / 2.0;
+                
+                    if((char_mapIndex << j) & 0x0010)
+                        interval->low += delta;
+                    else
+                        interval->high -= delta;
+                
+                    is_even = !is_even;
+                }
+            
+            }
+            
+            coordinate.latitude = lat_interval.high - ((lat_interval.high - lat_interval.low) / 2.0);
+            coordinate.longitude = lng_interval.high - ((lng_interval.high - lng_interval.low) / 2.0);
+            
+            coordinate.north = lat_interval.high;
+            coordinate.east = lng_interval.high;
+            coordinate.south = lat_interval.low;
+            coordinate.west = lng_interval.low;
+        }
+    }
+    
+    return coordinate;
+}
+
+
+char** geohash_neighbors(char *hash) {
+
+    char** neighbors = NULL;
+    
+    if(hash) {
+        
+        // N, NE, E, SE, S, SW, W, NW
+        neighbors = (char**)malloc(sizeof(char*) * 8);
+        
+        neighbors[0] = get_neighbor(hash, NORTH);
+        neighbors[1] = get_neighbor(neighbors[0], EAST);
+        neighbors[2] = get_neighbor(hash, EAST);
+        neighbors[3] = get_neighbor(neighbors[2], SOUTH);
+        neighbors[4] = get_neighbor(hash, SOUTH);
+        neighbors[5] = get_neighbor(neighbors[4], WEST);                
+        neighbors[6] = get_neighbor(hash, WEST);
+        neighbors[7] = get_neighbor(neighbors[6], NORTH);        
+
+    }
+    
+    return neighbors;
+}
+
+GeoBoxDimension geohash_dimensions_for_precision(int precision) {
+	
+	GeoBoxDimension dimensions = {0.0, 0.0};
+	
+	if(precision > 0) {
+	
+		int lat_times_to_cut = precision * 5 / 2;
+		int lng_times_to_cut = precision * 5 / 2 + (precision % 2 ? 1 : 0);
+	
+		double width = 360.0;
+		double height = 180.0;
+	
+		int i;
+		for(i = 0; i < lat_times_to_cut; i++)
+			height /= 2.0;
+		
+		for(i = 0; i < lng_times_to_cut; i++)
+			width /= 2.0;
+		
+		dimensions.width = width;
+		dimensions.height = height;
+		
+	}
+	
+	return dimensions;
+}

data/ext/geohash_wrapper/geohash.h

@@ -0,0 +1,77 @@
+/*
+ *  geohash.h
+ *  libgeohash
+ *
+ *  Created by Derek Smith on 10/6/09.
+ *  Copyright (c) 2010, SimpleGeo
+ *	All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without 
+ *  modification, are permitted provided that the following conditions are met:
+
+ *  Redistributions of source code must retain the above copyright notice, this list
+ *  of conditions and the following disclaimer. Redistributions in binary form must 
+ *  reproduce the above copyright notice, this list of conditions and the following 
+ *  disclaimer in the documentation and/or other materials provided with the distribution.
+ *  Neither the name of the SimpleGeo nor the names of its contributors may be used
+ *  to endorse or promote products derived from this software without specific prior 
+ *  written permission. 
+ *
+ *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY
+ *  EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
+ *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL 
+ *  THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ *  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE 
+ *  GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 
+ *  AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED 
+ *  OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Metric in meters
+typedef struct GeoBoxDimensionStruct {
+	
+	double height;
+	double width;
+
+} GeoBoxDimension;
+
+typedef struct GeoCoordStruct {
+    
+    double latitude;
+    double longitude;
+    
+    double north;
+    double east;
+    double south;
+    double west;
+
+	GeoBoxDimension dimension;
+    
+} GeoCoord;
+
+/*
+ * Creates a the hash at the specified precision. If precision is set to 0.
+ * or less than it defaults to 12.
+ */
+extern char* geohash_encode(double lat, double lng, int precision);
+
+/* 
+ * Returns the latitude and longitude used to create the hash along with
+ * the bounding box for the encoded coordinate.
+ */
+extern GeoCoord geohash_decode(char* hash);
+
+/* 
+ * Return an array of geohashes that represent the neighbors of the passed
+ * in value. The neighbors are indexed as followed:
+ *
+ *                  N, NE, E, SE, S, SW, W, NW
+ * 					0, 1,  2,  3, 4,  5, 6, 7
+ */ 
+extern char** geohash_neighbors(char* hash);
+
+/*
+ * Returns the width and height of a precision value.
+ */
+extern GeoBoxDimension geohash_dimensions_for_precision(int precision);

data/ext/geohash_wrapper/geohash_wrapper.c

@@ -0,0 +1,70 @@
+#include "ruby.h"
+#include "extconf.h"
+#include "geohash.h"
+#include <stdio.h>
+
+void Init_geohash_wrapper();
+VALUE wrap_geohash_encode(VALUE self, VALUE lat, VALUE lng, VALUE precision);
+VALUE wrap_geohash_decode(VALUE self, VALUE hash);
+VALUE wrap_geohash_neighbors(VALUE self, VALUE hash);
+VALUE wrap_geohash_dimensions_for_precision(VALUE self, VALUE precision);
+
+
+void Init_geohash_wrapper()
+{
+  VALUE Geohash;
+  Geohash = rb_define_class("Geohash", rb_cObject);
+
+  rb_define_singleton_method(Geohash, "encode",                   wrap_geohash_encode, 3);
+  rb_define_singleton_method(Geohash, "wrap_decode",              wrap_geohash_decode, 1);
+  rb_define_singleton_method(Geohash, "neighbours",               wrap_geohash_neighbors, 1);
+  rb_define_singleton_method(Geohash, "dimensions_for_precision", wrap_geohash_dimensions_for_precision, 1);
+}
+
+VALUE wrap_geohash_encode(VALUE self, VALUE lat, VALUE lng, VALUE precision) {
+  return rb_str_new_cstr(geohash_encode(NUM2DBL(lat), NUM2DBL(lng), NUM2INT(precision)));
+}
+
+VALUE wrap_geohash_decode(VALUE self, VALUE hash) {
+  GeoCoord decode;
+  VALUE r_hash      = rb_hash_new();
+  VALUE r_dimension = rb_hash_new();
+
+  decode = geohash_decode(StringValueCStr(hash));
+
+  rb_hash_aset(r_dimension, rb_str_new2("height"), DBL2NUM(decode.dimension.height));
+  rb_hash_aset(r_dimension, rb_str_new2("width"),  DBL2NUM(decode.dimension.width));
+
+  rb_hash_aset(r_hash, rb_str_new2("latitude"),  DBL2NUM(decode.latitude));
+  rb_hash_aset(r_hash, rb_str_new2("longitude"), DBL2NUM(decode.longitude));
+  rb_hash_aset(r_hash, rb_str_new2("north"),     DBL2NUM(decode.north));
+  rb_hash_aset(r_hash, rb_str_new2("south"),     DBL2NUM(decode.south));
+  rb_hash_aset(r_hash, rb_str_new2("east"),      DBL2NUM(decode.east));
+  rb_hash_aset(r_hash, rb_str_new2("west"),      DBL2NUM(decode.west));
+  rb_hash_aset(r_hash, rb_str_new2("dimension"), r_dimension);
+
+  return r_hash;
+}
+
+VALUE wrap_geohash_neighbors(VALUE self, VALUE hash) {
+  char** hashed_neighbours = geohash_neighbors(StringValueCStr(hash));
+  VALUE neighbours = rb_ary_new2(8);
+  int i;
+
+  for (i = 0; i <= 7; i++) {
+    rb_ary_store(neighbours, i, rb_str_new_cstr(hashed_neighbours[i]));
+  }
+  return neighbours;
+}
+
+VALUE wrap_geohash_dimensions_for_precision(VALUE self, VALUE precision) {
+  GeoBoxDimension dimension;
+  VALUE r_hash = rb_hash_new();
+
+  dimension = geohash_dimensions_for_precision(NUM2INT(precision));
+
+  rb_hash_aset(r_hash, rb_str_new2("height"), DBL2NUM(dimension.height));
+  rb_hash_aset(r_hash, rb_str_new2("width"),  DBL2NUM(dimension.width));
+
+  return r_hash;
+}

data/lib/dynamodb_geo.rb

@@ -0,0 +1 @@
+require 'geohash'

data/lib/dynamodb_geo/version.rb

@@ -0,0 +1,5 @@
+module DynamodbGeo
+  module Version
+    STRING = '0.0.1'
+  end
+end

data/lib/geohash.rb

@@ -0,0 +1,35 @@
+require 'geohash/geohash_wrapper'
+
+class Geohash
+  class << self
+    def decode(hash)
+      Geocoord.new(wrap_decode(hash)).freeze
+    end
+
+    def dimensions(precision)
+      Dimension.new(dimensions_for_precision(precision)).freeze
+    end
+  end
+end
+
+class Geocoord
+  attr_accessor :latitude, :longitude, :north, :south, :east, :west, :dimension
+  def initialize(geocoord)
+    @latitude  = geocoord['latitude']
+    @longitude = geocoord['longitude']
+    @north     = geocoord['north']
+    @south     = geocoord['south']
+    @east      = geocoord['east']
+    @west      = geocoord['west']
+    @dimension = Dimension.new(geocoord['dimension'])
+  end
+end
+
+class Dimension
+  attr_accessor :length, :width
+
+  def initialize(geobox)
+    length = geobox['length']
+    width  = geobox['width']
+  end
+end

data/spec/dynamodb_geo.rb

@@ -0,0 +1 @@
+require 'spec_helper'

data/spec/geohash_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+# Quick note, I'm not actually testing if the Geohash is accurate or not.
+# I'm assuming the C Lib I imported is doing that for me properly.
+describe Geohash do
+  describe '.encode' do
+    it 'encodes' do
+      encode = Geohash.encode(1,1,1)
+      expect(encode).to be_a String
+    end
+  end
+
+  describe '.decode' do
+    it 'decodes' do
+      decode = Geohash.decode('s')
+      expect(decode).to be_a Geocoord
+    end
+  end
+
+  describe '.neighbours' do
+    it 'finds my neighbours' do
+      neighbours = Geohash.neighbours('s')
+      expect(neighbours.sample).to be_a String
+      expect(neighbours.length).to be 8
+    end
+  end
+
+  describe '.precision' do
+    it 'calculates the dimensions for precision' do
+      dimensions = Geohash.dimensions(1)
+      expect(dimensions).to be_a Dimension
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'geohash'
+require 'byebug'
+
+RSpec.configure do |config|
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: dynamodb_geo
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Justin Ahn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-08-04 00:00:00.000000000 Z
+dependencies:
+- !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: byebug
+  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'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-dynamodbstreams
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+description: A port of dynamodb_geo to Ruby. Includes a geohash module.
+email: justin@soonahn.ca
+executables: []
+extensions:
+- ext/geohash_wrapper/extconf.rb
+extra_rdoc_files:
+- README.md
+files:
+- README.md
+- ext/geohash_wrapper/Makefile
+- ext/geohash_wrapper/extconf.h
+- ext/geohash_wrapper/extconf.rb
+- ext/geohash_wrapper/geohash.c
+- ext/geohash_wrapper/geohash.h
+- ext/geohash_wrapper/geohash_wrapper.c
+- lib/dynamodb_geo.rb
+- lib/dynamodb_geo/version.rb
+- lib/geohash.rb
+- lib/geohash/geohash_wrapper.so
+- spec/dynamodb_geo.rb
+- spec/geohash_spec.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- Beerware
+metadata:
+  source_code_uri: https://github.com/JA-Soonahn/dynamodb_geo
+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: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: dynamodb_geo-0.0.1
+test_files:
+- spec/dynamodb_geo.rb
+- spec/geohash_spec.rb
+- spec/spec_helper.rb