ruby_postal 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 4f086499e7f616564eb1b1fad3434ee4dd054405
+  data.tar.gz: 500ba8273135f3efb36e2ef9a5ccbd8611b8e934
+SHA512:
+  metadata.gz: 9698cada39c15abfe404155c8cf82a6b3c17ba7818e8736e0ca7e92d5fa62bd442fccf98b2beb58401035a935e0a92eab68ef54d7a54a73597d6ba9d53a45891
+  data.tar.gz: 0f4e2f17ec4593fda1b4e0107e1c45e4256fd1c1c1956089c12f6e6c1b8858f7af9c838fbc6e3e42405d688723b74b07c65b39db3481be7b17b9c219ce126fa5

data/ext/expand/expand.c

@@ -0,0 +1,243 @@
+#include <libpostal/libpostal.h>
+
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+static rb_encoding *utf8Encoding;
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  ({ \
+   VALUE _string = rb_str_new2((const char *)str); \
+   int _enc = rb_enc_get_index(encoding); \
+   rb_enc_associate_index(_string, _enc); \
+   _string; \
+   })
+
+#else
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  rb_str_new2((const char *)str)
+
+#endif
+
+/* Older versions of Ruby (< 1.8.6) need these */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+
+VALUE rb_expand = Qnil;
+
+
+VALUE hash_get_symbol_or_string(VALUE hash, char *key) {
+    VALUE value = rb_hash_aref(hash, rb_str_new2(key));
+
+    if (value != Qnil) {
+        return value;
+    }
+
+    return rb_hash_aref(hash, ID2SYM(rb_intern(key)));
+}
+
+
+VALUE rb_expand_address(int argc, VALUE *argv, VALUE self) {
+    if (argc < 2) {  // there should only be 1 or 2 arguments
+        rb_raise(rb_eArgError, "Usage: expand_address(address, options = {})");
+        return Qnil;
+    }
+
+    VALUE input;
+    VALUE rb_options;
+
+    rb_scan_args(argc, argv, "2", &input, &rb_options);
+
+    if (TYPE(rb_options) != T_HASH) {
+        rb_raise(rb_eArgError, "options must be a hash");
+        return Qnil;
+    }
+
+    VALUE rb_languages = hash_get_symbol_or_string(rb_options, "languages");
+    if (rb_languages != Qnil && (TYPE(rb_languages) != T_ARRAY || RARRAY_LEN(rb_languages) == 0)) {
+        rb_raise(rb_eArgError, "options['languages'] must be a non-empty array");
+        return Qnil;
+    }
+
+    size_t len_languages = 0;
+
+    if (rb_languages != Qnil) {
+        len_languages = (size_t)RARRAY_LEN(rb_languages);
+    }
+
+    normalize_options_t options = get_libpostal_default_options();
+
+    size_t i;
+    char **languages = NULL;
+    size_t num_languages = 0;
+
+    if (len_languages > 0) {
+        languages = malloc(sizeof(char *) * len_languages);
+
+        for (i = 0; i < len_languages; i++) {
+            VALUE rb_lang = rb_ary_entry(rb_languages, (int)i);
+            if (rb_lang != Qnil && TYPE(rb_lang) == T_STRING) {
+                size_t rb_lang_len = RSTRING_LEN(rb_lang);
+                if (rb_lang_len > 0 && rb_lang_len < MAX_LANGUAGE_LEN) {
+                    char *lang = RSTRING_PTR(rb_lang);
+                    languages[num_languages++] = lang;
+                }
+            }
+        }
+    }
+
+    options.num_languages = num_languages;
+    options.languages = languages;
+
+    char *address = RSTRING_PTR(input);
+
+    VALUE address_components = hash_get_symbol_or_string(rb_options, "languages");
+    if (address_components != Qnil && TYPE(address_components) == T_FIXNUM) {
+        options.address_components = (uint16_t) NUM2UINT(address_components);
+    }
+
+    VALUE latin_ascii = hash_get_symbol_or_string(rb_options, "latin_ascii");
+    if (latin_ascii != Qnil) {
+        options.latin_ascii = RTEST(latin_ascii);
+    }
+
+    VALUE transliterate = hash_get_symbol_or_string(rb_options, "transliterate");
+    if (transliterate != Qnil) {
+        options.transliterate = RTEST(transliterate);
+    }
+
+    VALUE strip_accents = hash_get_symbol_or_string(rb_options, "strip_accents");
+    if (strip_accents != Qnil) {
+        options.strip_accents = RTEST(strip_accents);
+    }
+
+    VALUE decompose = hash_get_symbol_or_string(rb_options, "decompose");
+    if (decompose != Qnil) {
+        options.decompose = RTEST(decompose);
+    }
+
+    VALUE lowercase = hash_get_symbol_or_string(rb_options, "lowercase");
+    if (lowercase != Qnil) {
+        options.lowercase = RTEST(lowercase);
+    }
+
+    VALUE trim_string = hash_get_symbol_or_string(rb_options, "trim_string");
+    if (trim_string != Qnil) {
+        options.trim_string = RTEST(trim_string);
+    }
+
+    VALUE drop_parentheticals = hash_get_symbol_or_string(rb_options, "drop_parentheticals");
+    if (drop_parentheticals != Qnil) {
+        options.drop_parentheticals = RTEST(drop_parentheticals);
+    }
+
+    VALUE replace_numeric_hyphens = hash_get_symbol_or_string(rb_options, "replace_numeric_hyphens");
+    if (replace_numeric_hyphens != Qnil) {
+        options.replace_numeric_hyphens = RTEST(replace_numeric_hyphens);
+    }
+
+    VALUE delete_numeric_hyphens = hash_get_symbol_or_string(rb_options, "delete_numeric_hyphens");
+    if (delete_numeric_hyphens != Qnil) {
+        options.delete_numeric_hyphens = RTEST(delete_numeric_hyphens);
+    }
+
+    VALUE split_alpha_from_numeric = hash_get_symbol_or_string(rb_options, "split_alpha_from_numeric");
+    if (split_alpha_from_numeric != Qnil) {
+        options.split_alpha_from_numeric = RTEST(split_alpha_from_numeric);
+    }
+
+    VALUE replace_word_hyphens = hash_get_symbol_or_string(rb_options, "replace_word_hyphens");
+    if (replace_word_hyphens != Qnil) {
+        options.replace_word_hyphens = RTEST(replace_word_hyphens);
+    }
+
+    VALUE delete_word_hyphens = hash_get_symbol_or_string(rb_options, "delete_word_hyphens");
+    if (delete_word_hyphens != Qnil) {
+        options.delete_word_hyphens = RTEST(delete_word_hyphens);
+    }
+
+    VALUE delete_final_periods = hash_get_symbol_or_string(rb_options, "delete_final_periods");
+    if (delete_final_periods != Qnil) {
+        options.delete_final_periods = RTEST(delete_final_periods);
+    }
+
+
+    VALUE delete_acronym_periods = hash_get_symbol_or_string(rb_options, "delete_acronym_periods");
+    if (delete_acronym_periods != Qnil) {
+        options.delete_acronym_periods = RTEST(delete_acronym_periods);
+    }
+
+    VALUE drop_english_possessives = hash_get_symbol_or_string(rb_options, "drop_english_possessives");
+    if (drop_english_possessives != Qnil) {
+        options.drop_english_possessives = RTEST(drop_english_possessives);
+    }
+
+    VALUE delete_apostrophes = hash_get_symbol_or_string(rb_options, "delete_apostrophes");
+    if (delete_apostrophes != Qnil) {
+        options.delete_apostrophes = RTEST(delete_apostrophes);
+    }
+
+    VALUE expand_numex = hash_get_symbol_or_string(rb_options, "expand_numex");
+    if (expand_numex != Qnil) {
+        options.expand_numex = RTEST(expand_numex);
+    }
+
+    VALUE roman_numerals = hash_get_symbol_or_string(rb_options, "roman_numerals");
+    if (roman_numerals != Qnil) {
+        options.roman_numerals = RTEST(roman_numerals);
+    }
+
+    size_t num_expansions = 0;
+    char **expansions = expand_address(address, options, &num_expansions);
+
+    VALUE rb_expansions = rb_ary_new2(num_expansions);
+    for (size_t i = 0; i < num_expansions; i++) {
+        char *expansion = expansions[i];
+        VALUE rb_expansion = rb_str_new2(expansion);
+        rb_ary_store(rb_expansions, i, rb_expansion);
+        free(expansion);
+    }
+    free(expansions);
+
+    return rb_expansions;
+}
+
+void Init_expand() {
+    if (!libpostal_setup() || !libpostal_setup_language_classifier()) {
+        rb_raise(rb_eLoadError, "Could not load libpostal");
+        return;
+    }
+
+    rb_expand = rb_define_module("CExpand");
+
+    rb_define_module_function(rb_expand, "expand_address", rb_expand_address, -1);
+
+    rb_define_global_const("ADDRESS_NONE", UINT2NUM(ADDRESS_NONE));
+    rb_define_global_const("ADDRESS_ANY", UINT2NUM(ADDRESS_ANY));
+    rb_define_global_const("ADDRESS_NAME", UINT2NUM(ADDRESS_NAME));
+    rb_define_global_const("ADDRESS_HOUSE_NUMBER", UINT2NUM(ADDRESS_HOUSE_NUMBER));
+    rb_define_global_const("ADDRESS_STREET", UINT2NUM(ADDRESS_STREET));
+    rb_define_global_const("ADDRESS_UNIT", UINT2NUM(ADDRESS_UNIT));
+    rb_define_global_const("ADDRESS_LOCALITY", UINT2NUM(ADDRESS_LOCALITY));
+    rb_define_global_const("ADDRESS_ADMIN1", UINT2NUM(ADDRESS_ADMIN1));
+    rb_define_global_const("ADDRESS_ADMIN2", UINT2NUM(ADDRESS_ADMIN2));
+    rb_define_global_const("ADDRESS_ADMIN3", UINT2NUM(ADDRESS_ADMIN3));
+    rb_define_global_const("ADDRESS_ADMIN4", UINT2NUM(ADDRESS_ADMIN4));
+    rb_define_global_const("ADDRESS_ADMIN_OTHER", UINT2NUM(ADDRESS_ADMIN_OTHER));
+    rb_define_global_const("ADDRESS_POSTAL_CODE", UINT2NUM(ADDRESS_POSTAL_CODE));
+    rb_define_global_const("ADDRESS_NEIGHBORHOOD", UINT2NUM(ADDRESS_NEIGHBORHOOD));
+    rb_define_global_const("ADDRESS_ALL", UINT2NUM(ADDRESS_ALL));
+}
+

data/ext/expand/extconf.rb

@@ -0,0 +1,40 @@
+require 'mkmf'
+require 'rbconfig'
+
+LIBDIR      = RbConfig::CONFIG['libdir']
+INCLUDEDIR  = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/include',
+
+  # Then search /usr/local for people that installed from source
+  '/usr/local/include',
+
+  # Check the ruby install locations
+  INCLUDEDIR,
+
+  # Finally fall back to /usr
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/lib',
+
+  # Then search /usr/local for people that installed from source
+  '/usr/local/lib',
+
+  # Check the ruby install locations
+  LIBDIR,
+
+  # Finally fall back to /usr
+  '/usr/lib',
+]
+
+dir_config('libpostal', HEADER_DIRS, LIB_DIRS)
+
+$CFLAGS << " -std=gnu99"
+$LIBS << " -lpostal"
+
+create_makefile('cpostal/expand')

data/ext/parser/extconf.rb

@@ -0,0 +1,40 @@
+require 'mkmf'
+require 'rbconfig'
+
+LIBDIR      = RbConfig::CONFIG['libdir']
+INCLUDEDIR  = RbConfig::CONFIG['includedir']
+
+HEADER_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/include',
+
+  # Then search /usr/local for people that installed from source
+  '/usr/local/include',
+
+  # Check the ruby install locations
+  INCLUDEDIR,
+
+  # Finally fall back to /usr
+  '/usr/include',
+]
+
+LIB_DIRS = [
+  # First search /opt/local for macports
+  '/opt/local/lib',
+
+  # Then search /usr/local for people that installed from source
+  '/usr/local/lib',
+
+  # Check the ruby install locations
+  LIBDIR,
+
+  # Finally fall back to /usr
+  '/usr/lib',
+]
+
+dir_config('libpostal', HEADER_DIRS, LIB_DIRS)
+
+$CFLAGS << " -std=gnu99"
+$LIBS << " -lpostal"
+
+create_makefile('cpostal/parser')

data/ext/parser/parser.c

@@ -0,0 +1,112 @@
+#include <libpostal/libpostal.h>
+
+#include <ruby.h>
+
+#ifdef HAVE_RUBY_ENCODING_H
+#include <ruby/encoding.h>
+static rb_encoding *utf8Encoding;
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  ({ \
+   VALUE _string = rb_str_new2((const char *)str); \
+   int _enc = rb_enc_get_index(encoding); \
+   rb_enc_associate_index(_string, _enc); \
+   _string; \
+   })
+
+#else
+
+#define ENCODED_STR_NEW2(str, encoding) \
+  rb_str_new2((const char *)str)
+
+#endif
+
+/* Older versions of Ruby (< 1.8.6) need these */
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+#ifndef RARRAY_PTR
+#define RARRAY_PTR(s) (RARRAY(s)->ptr)
+#endif
+#ifndef RARRAY_LEN
+#define RARRAY_LEN(s) (RARRAY(s)->len)
+#endif
+
+VALUE rb_parser = Qnil;
+
+VALUE hash_get_symbol_or_string(VALUE hash, char *key) {
+    VALUE value = rb_hash_aref(hash, rb_str_new2(key));
+
+    if (value != Qnil) {
+        return value;
+    }
+
+    return rb_hash_aref(hash, ID2SYM(rb_intern(key)));
+}
+
+
+VALUE rb_parse_address(int argc, VALUE *argv, VALUE self) {
+    if (argc < 2) {  // there should only be 1 or 2 arguments
+        rb_raise(rb_eArgError, "Usage: parse_address(address, options = {})");
+    }
+
+    VALUE input;
+    VALUE rb_options;
+
+    rb_scan_args(argc, argv, "2", &input, &rb_options);
+
+    if (TYPE(rb_options) != T_HASH) {
+        rb_raise(rb_eArgError, "options must be a hash");
+        return Qnil;
+    }
+
+    VALUE rb_language = hash_get_symbol_or_string(rb_options, "language");
+    VALUE rb_country = hash_get_symbol_or_string(rb_options, "country");
+
+    char *address = RSTRING_PTR(input);
+
+    address_parser_response_t *parsed;
+    address_parser_options_t options = get_libpostal_address_parser_default_options();
+    if (rb_language != Qnil) {
+        options.language = RSTRING_PTR(rb_language);
+    }
+
+    if (rb_country != Qnil) {
+        options.country = RSTRING_PTR(rb_country);
+    }
+
+    if ((parsed = parse_address(address, options))) {
+        size_t n = parsed->num_components;
+        VALUE rb_parse_result = rb_ary_new2(n);
+
+        for (size_t i = 0; i < n; i++) {
+            VALUE rb_component = rb_ary_new2(2);
+            rb_ary_store(rb_component, 0, rb_str_new2(parsed->components[i]));
+            rb_ary_store(rb_component, 1, ID2SYM(rb_intern(parsed->labels[i])));
+
+            rb_ary_store(rb_parse_result, i, rb_component);
+        }
+
+        address_parser_response_destroy(parsed);
+
+        return rb_parse_result;
+    }
+
+    return Qnil;
+
+}
+
+void Init_parser() {
+    if (!libpostal_setup() || !libpostal_setup_parser()) {
+        rb_raise(rb_eLoadError, "Could not load libpostal");
+        return;
+    }
+
+    rb_parser = rb_define_module("CParser");
+
+    rb_define_module_function(rb_parser, "parse_address", rb_parse_address, -1);
+}
+

data/ext/rb_utils.c

@@ -0,0 +1,11 @@
+#include "rb_utils.h"
+
+VALUE hash_get_symbol_or_string(VALUE hash, char *key) {
+    VALUE value = rb_hash_aref(hash, rb_str_new2(key));
+
+    if (value != Qnil) {
+        return value;
+    }
+
+    return rb_hash_aref(hash, ID2SYM(rb_intern(key)));
+}

data/lib/ruby_postal.rb

@@ -0,0 +1,5 @@
+require "ruby_postal/version"
+
+module Postal
+
+end

data/lib/ruby_postal/expand.rb

@@ -0,0 +1,9 @@
+require 'ruby_postal/cpostal/expand'
+
+module Postal
+    class Expand
+        def self.expand_address(address, options={})
+            CExpand.expand_address address, options
+        end
+    end
+end

data/lib/ruby_postal/parser.rb

@@ -0,0 +1,10 @@
+require 'ruby_postal/cpostal/parser'
+
+module Postal
+    class Parser
+        def self.parse_address(address, options={})
+            parse_result = CParser.parse_address address, options
+            parse_result.map{|s, c| {:label => c, :value => s}}
+        end
+    end
+end

data/lib/ruby_postal/version.rb

@@ -0,0 +1,3 @@
+module Postal
+  VERSION = "0.3.0"
+end

metadata

@@ -0,0 +1,113 @@
+--- !ruby/object:Gem::Specification
+name: ruby_postal
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Al Barrentine
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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
+  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: minitest
+  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:
+- pelias@mapzen.com
+executables: []
+extensions:
+- ext/expand/extconf.rb
+- ext/parser/extconf.rb
+extra_rdoc_files: []
+files:
+- ext/expand/expand.c
+- ext/expand/extconf.rb
+- ext/parser/extconf.rb
+- ext/parser/parser.c
+- ext/rb_utils.c
+- lib/ruby_postal.rb
+- lib/ruby_postal/expand.rb
+- lib/ruby_postal/parser.rb
+- lib/ruby_postal/version.rb
+homepage: https://github.com/openvenues/ruby_postal
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- ext
+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.4.1
+signing_key: 
+specification_version: 4
+summary: Ruby bindings for libpostal (fast address parsing/normalization)
+test_files: []