shp 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmM2OGJlZGRjZWFjYjJiY2VlNjBkMGJjNDM1NTU1MTJkZTRmZmMwZQ==
+  data.tar.gz: !binary |-
+    ODliN2NiZmI1OWUzYmEwNTYzNTgzZTlhYjdjMjhlNzA0ZTU5OWU1Yg==
+SHA512:
+  metadata.gz: !binary |-
+    NjhiMzMwYmE1NWI2NTFjNWY4NzkyMmI3OGVkY2UzZDMzODdjMjVjMzEzMmUz
+    MDE4YzcxMDYzMDYzZmVhNjIxYjE2Njc4MDY5YWQwYTA5MDViMjRhNmY5MDZk
+    NzZlNjQ3YjdhZWY1NDNlZDdlOWIwNmE0ZWQwNTVjYjYxM2Q4YTQ=
+  data.tar.gz: !binary |-
+    ZjZkMThlYTE1NDE1ZGEwOGEyMDI2NzEwOGUyZTIyMmY4ZDhlN2Q4ZDc1ZTU0
+    ZmU3MzAzNWRkMTM4ODRhM2JhYTE5M2RjOTdhNmI5YjViYjkwMTIwY2NkNmJh
+    ZDFlNzQxOGUxMzE0MjhjYTcxNWM3NzUxNjVmNjE1YzA0NzU2ZWY=

data/.gitignore

@@ -0,0 +1,34 @@
+*.gem
+*.rbc
+.bundle
+*.so
+*.o
+*.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*dbfadd*
+*dbfcreate*
+*dbfdump*
+*shpadd*
+*shpcreate*
+*shpdump*
+*shprewind*
+*shptest*
+*shptreedump*
+ext/shp/Makefile
+test/testfile*
+testfile*
+ext/shp/mkmf.log
+ext/shp/shapelib/libshp.a

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 1.9.2
+  - 1.9.3

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2013, Spatial Networks
+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 author nor the names of other
+      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
+OWNER 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.

data/README.md

@@ -0,0 +1,30 @@
+# shp-ruby [![Build Status](https://secure.travis-ci.org/spatialnetworks/shp-ruby.png)](http://travis-ci.org/spatialnetworks/shp-ruby)
+
+Native bindings for Shapelib. This gem includes an embedded copy of Shapelib so it doesn't require any
+system libraries to be installed and can be installed with just gem/bundler.
+
+This gem is intentionally low level and aims to be a 1:1 mapping of the native C API. It does not
+add any Ruby sugar on top of Shapelib. A more Ruby-like API can be implemented *in ruby* on top of this core API.
+
+Docs for the native API:
+
+* [SHP](http://shapelib.maptools.org/shp_api.html)
+* [DBF](http://shapelib.maptools.org/dbf_api.html)
+
+## Installation
+
+Add this to your `Gemfile`
+
+```rb
+gem 'shp'
+```
+
+- OR install manually -
+
+```sh
+gem install shp
+```
+
+## License
+
+BSD

data/Rakefile

@@ -0,0 +1,23 @@
+#!/usr/bin/env rake
+require 'rubygems'
+require 'bundler'
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+require 'rake'
+require 'rake/extensiontask'
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+Bundler.setup
+
+Rake::ExtensionTask.new('shp') do |ext|
+  ext.name = 'shp'
+  ext.lib_dir = "lib/shp"
+end
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  Rake::Task['compile'].invoke
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec

data/ext/shp/base.hpp

@@ -0,0 +1,113 @@
+#ifndef __SHP_BASE_HPP__
+#define __SHP_BASE_HPP__
+
+#include <vector>
+#include <algorithm>
+#include "shp.hpp"
+
+namespace shp {
+  template <typename T> class base {
+  public:
+    base<T>() : _value(0), dependencies() {}
+
+    static VALUE initialize_instance(int argc, VALUE *argv, VALUE self) {
+      return unwrap(self)->initialize(argc, argv);
+    }
+
+    static VALUE new_instance(int argc, VALUE *argv, VALUE klass) {
+      T *instance = new T();
+      VALUE rvalue = instance->wrapped();
+      rb_obj_call_init(rvalue, argc, argv);
+      return rvalue;
+    }
+
+    static VALUE new_instance_not_allowed(int argc, VALUE *argv, VALUE klass) {
+      rb_raise(rb_eRuntimeError, "You cannot use #new on this class.");
+      return Qnil;
+    }
+
+    static VALUE initialize_instance_not_allowed(int argc, VALUE *argv, VALUE klass) {
+      rb_raise(rb_eRuntimeError, "You cannot use #initialize on this class.");
+      return Qnil;
+    }
+
+    VALUE wrapped() {
+      if (!_value) {
+        _value = Data_Wrap_Struct(klass(), base<T>::mark_dependencies, base<T>::dispose, this);
+      }
+      return _value;
+    }
+
+    void gc_mark() {
+      if (_value) {
+        rb_gc_mark(_value);
+      }
+    }
+
+    virtual void mark_dependencies() {
+      for (typename std::vector<base *>::iterator it = dependencies.begin(); it != dependencies.end(); ++it) {
+        (*it)->gc_mark();
+      }
+    }
+
+    virtual void dispose() {}
+    virtual VALUE initialize(int argc, VALUE *argv) { return wrapped(); }
+
+    virtual VALUE klass() {
+      return Qnil;
+    }
+
+    virtual ~base() {}
+
+    static T *unwrap(VALUE self) {
+      T *obj = NULL;
+      Data_Get_Struct(self, T, obj);
+      return obj;
+    }
+
+    void add_dependency(base *dep) {
+      dependencies.push(dep);
+    }
+
+    void remove_dependency(base *dep) {
+      dependencies.erase(std::remove(dependencies.begin(), dependencies.end(), dep), dependencies.end());
+    }
+
+  protected:
+    VALUE _value;
+
+    std::vector<base *> dependencies;
+
+    static T *object(void *ptr) {
+      return static_cast<T *>(ptr);
+    }
+
+    static void mark_dependencies(void *ptr) {
+      base::object(ptr)->mark_dependencies();
+    }
+
+    static void dispose(void *ptr) {
+      delete base::object(ptr);
+    }
+
+    static void define(VALUE klass, bool allowNew) {
+      if (allowNew) {
+        rb_define_singleton_method(klass, "new", SHP_METHOD(base<T>::new_instance), -1);
+        rb_define_method(klass, "initialize", SHP_METHOD(base<T>::initialize_instance), -1);
+      }
+      else {
+        rb_define_singleton_method(klass, "new", SHP_METHOD(base<T>::new_instance_not_allowed), -1);
+        rb_define_method(klass, "initialize", SHP_METHOD(base<T>::initialize_instance_not_allowed), -1);
+      }
+    }
+
+    VALUE initialize_not_allowed()
+    {
+      rb_raise(rb_eRuntimeError, "You cannot use #new on this class.");
+      return Qnil;
+    }
+
+  };
+}
+
+#endif

data/ext/shp/dbf.cpp

@@ -0,0 +1,381 @@
+
+#include "dbf.hpp"
+
+namespace shp {
+
+VALUE dbf::_klass = Qnil;
+
+VALUE dbf::klass() {
+  return dbf::_klass;
+}
+
+dbf::dbf(DBFHandle handle)
+  : _handle(handle)
+{
+}
+
+dbf::~dbf() {
+  if (_handle) {
+    DBFClose(_handle);
+    _handle = NULL;
+  }
+}
+
+VALUE dbf::create(VALUE klass, VALUE filename)
+{
+  CHECK_ARGUMENT_STRING(filename);
+
+  DBFHandle handle = DBFCreate(RSTRING_PTR(filename));
+
+  if (handle == NULL) {
+    SHP_FATAL("Failed to create dbf file.");
+    return Qnil;
+  }
+
+  dbf *file = new dbf(handle);
+
+  return file->wrapped();
+}
+
+VALUE dbf::open(VALUE klass, VALUE filename, VALUE access)
+{
+  CHECK_ARGUMENT_STRING(filename);
+  CHECK_ARGUMENT_STRING(access);
+
+  DBFHandle handle = DBFOpen(RSTRING_PTR(filename), RSTRING_PTR(access));
+
+  if (handle == NULL) {
+    SHP_FATAL("Failed to open dbf file.");
+    return Qnil;
+  }
+
+  dbf *file = new dbf(handle);
+
+  return file->wrapped();
+}
+
+VALUE dbf::add_field(VALUE self, VALUE fieldName, VALUE fieldType, VALUE fieldWidth, VALUE fieldDecimals)
+{
+  CHECK_ARGUMENT_STRING(fieldName);
+  CHECK_ARGUMENT_FIXNUM(fieldType);
+  CHECK_ARGUMENT_FIXNUM(fieldWidth);
+  CHECK_ARGUMENT_FIXNUM(fieldDecimals);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  std::string theFieldName(RSTRING_PTR(fieldName));
+
+  int result = DBFAddField(db->value(),
+                           theFieldName.c_str(),
+                           (DBFFieldType)FIX2INT(fieldType),
+                           FIX2INT(fieldWidth),
+                           FIX2INT(fieldDecimals));
+
+  if (result == -1) {
+    SHP_FATAL("Failed to add new field");
+    return Qnil;
+  }
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::write_integer_attribute(VALUE self, VALUE recordNumber, VALUE fieldIndex, VALUE fieldValue)
+{
+  CHECK_ARGUMENT_FIXNUM(recordNumber);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+  CHECK_ARGUMENT_FIXNUM(fieldValue);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFWriteIntegerAttribute(db->value(),
+                                        FIX2INT(recordNumber),
+                                        FIX2INT(fieldIndex),
+                                        FIX2INT(fieldValue));
+
+  if (result == 0) {
+    SHP_FATAL("Failed to write new attribute.");
+    return Qnil;
+  }
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::write_double_attribute(VALUE self, VALUE recordNumber, VALUE fieldIndex, VALUE fieldValue)
+{
+  CHECK_ARGUMENT_FIXNUM(recordNumber);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+  CHECK_ARGUMENT_FLOAT(fieldValue);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFWriteDoubleAttribute(db->value(),
+                                       FIX2INT(recordNumber),
+                                       FIX2INT(fieldIndex),
+                                       NUM2DBL(fieldValue));
+
+  if (result == 0) {
+    SHP_FATAL("Failed to write new attribute.");
+    return Qnil;
+  }
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::write_string_attribute(VALUE self, VALUE recordNumber, VALUE fieldIndex, VALUE fieldValue)
+{
+  CHECK_ARGUMENT_FIXNUM(recordNumber);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+  CHECK_ARGUMENT_STRING(fieldValue);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFWriteStringAttribute(db->value(),
+                                       FIX2INT(recordNumber),
+                                       FIX2INT(fieldIndex),
+                                       RSTRING_PTR(fieldValue));
+
+  if (result == 0) {
+    SHP_FATAL("Failed to write new attribute.");
+    return Qnil;
+  }
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::write_null_attribute(VALUE self, VALUE recordNumber, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordNumber);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFWriteNULLAttribute(db->value(),
+                                     FIX2INT(recordNumber),
+                                     FIX2INT(fieldIndex));
+
+  if (result == 0) {
+    SHP_FATAL("Failed to write new attribute.");
+    return Qnil;
+  }
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::read_integer_attribute(VALUE self, VALUE recordIndex, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFReadIntegerAttribute(db->value(),
+                                       FIX2INT(recordIndex),
+                                       FIX2INT(fieldIndex));
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::read_double_attribute(VALUE self, VALUE recordIndex, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  double result = DBFReadDoubleAttribute(db->value(),
+                                         FIX2INT(recordIndex),
+                                         FIX2INT(fieldIndex));
+
+  return rb_float_new(result);
+}
+
+VALUE dbf::read_string_attribute(VALUE self, VALUE recordIndex, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  const char *result = DBFReadStringAttribute(db->value(),
+                                              FIX2INT(recordIndex),
+                                              FIX2INT(fieldIndex));
+
+  return rb_str_new2(result);
+}
+
+VALUE dbf::is_attribute_null(VALUE self, VALUE recordIndex, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFIsAttributeNULL(db->value(),
+                                  FIX2INT(recordIndex),
+                                  FIX2INT(fieldIndex));
+
+  return INT2NUM(result);
+}
+
+VALUE dbf::close(VALUE self)
+{
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  DBFClose(db->value());
+
+  db->_handle = NULL;
+
+  return Qnil;
+}
+
+VALUE dbf::get_field_count(VALUE self)
+{
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int fieldCount = DBFGetFieldCount(db->value());
+
+  return INT2FIX(fieldCount);
+}
+
+VALUE dbf::get_record_count(VALUE self)
+{
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int recordCount = DBFGetRecordCount(db->value());
+
+  return INT2FIX(recordCount);
+}
+
+VALUE dbf::get_field_index(VALUE self, VALUE fieldName)
+{
+  CHECK_ARGUMENT_STRING(fieldName);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int fieldIndex = DBFGetFieldIndex(db->value(), RSTRING_PTR(fieldName));
+
+  return INT2FIX(fieldIndex);
+}
+
+VALUE dbf::get_field_info(VALUE self, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  char fieldName[12];
+  int fieldWidth = -1;
+  int fieldDecimals = -1;
+
+  DBFFieldType type = DBFGetFieldInfo(db->value(),
+                                      FIX2INT(fieldIndex),
+                                      fieldName,
+                                      &fieldWidth,
+                                      &fieldDecimals);
+
+  VALUE hash = rb_hash_new();
+
+  rb_hash_aset(hash, ID2SYM(rb_intern("name")), rb_str_new2(fieldName));
+  rb_hash_aset(hash, ID2SYM(rb_intern("type")), INT2FIX((int)type));
+  rb_hash_aset(hash, ID2SYM(rb_intern("width")), INT2FIX(fieldWidth));
+  rb_hash_aset(hash, ID2SYM(rb_intern("decimals")), INT2FIX(fieldDecimals));
+
+  return hash;
+}
+
+VALUE dbf::is_record_deleted(VALUE self, VALUE recordIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFIsRecordDeleted(db->value(), FIX2INT(recordIndex));
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::mark_record_deleted(VALUE self, VALUE recordIndex, VALUE isDeleted)
+{
+  CHECK_ARGUMENT_FIXNUM(recordIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  int result = DBFMarkRecordDeleted(db->value(), FIX2INT(recordIndex), FIX2INT(isDeleted));
+
+  return INT2FIX(result);
+}
+
+VALUE dbf::get_native_field_type(VALUE self, VALUE fieldIndex)
+{
+  CHECK_ARGUMENT_FIXNUM(fieldIndex);
+
+  dbf *db = unwrap(self);
+
+  CHECK_VALID_HANDLE(db->value());
+
+  char result = DBFGetNativeFieldType(db->value(), FIX2INT(fieldIndex));
+
+  char resultAsString[2] = { result, '\0' };
+
+  return rb_str_new2(resultAsString);
+}
+
+void dbf::define(VALUE module)
+{
+  dbf::_klass = rb_define_class_under(module, "DBF", rb_cObject);
+  base::define(dbf::_klass, false);
+  rb_define_singleton_method(dbf::_klass, "create", SHP_METHOD(dbf::create), 1);
+  rb_define_singleton_method(dbf::_klass, "open", SHP_METHOD(dbf::open), 2);
+  rb_define_method(dbf::_klass, "add_field", SHP_METHOD(dbf::add_field), 4);
+  rb_define_method(dbf::_klass, "write_integer_attribute", SHP_METHOD(dbf::write_integer_attribute), 3);
+  rb_define_method(dbf::_klass, "write_double_attribute", SHP_METHOD(dbf::write_double_attribute), 3);
+  rb_define_method(dbf::_klass, "write_string_attribute", SHP_METHOD(dbf::write_string_attribute), 3);
+  rb_define_method(dbf::_klass, "write_null_attribute", SHP_METHOD(dbf::write_null_attribute), 2);
+  rb_define_method(dbf::_klass, "read_integer_attribute", SHP_METHOD(dbf::read_integer_attribute), 2);
+  rb_define_method(dbf::_klass, "read_double_attribute", SHP_METHOD(dbf::read_double_attribute), 2);
+  rb_define_method(dbf::_klass, "read_string_attribute", SHP_METHOD(dbf::read_string_attribute), 2);
+  rb_define_method(dbf::_klass, "is_attribute_null", SHP_METHOD(dbf::is_attribute_null), 2);
+  rb_define_method(dbf::_klass, "close", SHP_METHOD(dbf::close), 0);
+  rb_define_method(dbf::_klass, "get_field_count", SHP_METHOD(dbf::get_field_count), 0);
+  rb_define_method(dbf::_klass, "get_record_count", SHP_METHOD(dbf::get_record_count), 0);
+  rb_define_method(dbf::_klass, "get_field_index", SHP_METHOD(dbf::get_field_index), 1);
+  rb_define_method(dbf::_klass, "get_field_info", SHP_METHOD(dbf::get_field_info), 1);
+  rb_define_method(dbf::_klass, "is_record_deleted", SHP_METHOD(dbf::is_record_deleted), 1);
+  rb_define_method(dbf::_klass, "mark_record_deleted", SHP_METHOD(dbf::mark_record_deleted), 2);
+  rb_define_method(dbf::_klass, "get_native_field_type", SHP_METHOD(dbf::get_native_field_type), 1);
+}
+
+}
+