rcsv 0.0.9 → 0.1.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    YjlmMDhlZWFkNzk3ZmJkYjc1Zjk4ZjFmM2FjYjc5YTVmNzZhOWYyOA==
+  data.tar.gz: !binary |-
+    ZjFkZDVmMDc0ZmJkODg2YzMzYzU2MjViODVkNjNhZDJhMjcxZWI0ZQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZmZjZjAzY2VlNjU4MTM0ZDBmZWQwY2NiNTZmNWY4NzBjMzdlNTBhMjJhZjQz
+    ODEzNDc3MjM5ZGJjNjE5MTgxMTQ3MjU3ZTU3YmQwZmQwNWZmNWFkMzlkNzZl
+    ZWExNTVmODFjOGJkNGIwNmFlMDI5MDA5OWY1ODBiNjhiMWNlZmU=
+  data.tar.gz: !binary |-
+    YjZhOWIwZjI0OGMwOTg3NjY1MzgxMjMwYTU4NmFkMzQ3MGU2MWZmNTFjY2Q4
+    MGU5MzM3M2EwOWEwNjVkMzllYzgzM2U2OTQwYTA5ZWZiMDVkMjBjZDJjYTIy
+    NzJiYTY1MzYyM2I0MzBkYjc3OTRkYmQwNjMwZDUyNGJkZmI1MWU=

data/.travis.yml

@@ -2,6 +2,7 @@ language: ruby
 rvm:
   - 1.9.3
   - 1.9.2
-  - ruby-head
+#  - ruby-head
+  - 2.0.0
   - 1.8.7
   - ree

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    rcsv (0.0.9)
+    rcsv (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -40,7 +40,7 @@ First, check out the master branch. Then cd there and run:
 
 ## Usage
 
-Currently, Rcsv only supports CSV parsing. CSV write support is planned.
+Currently, Rcsv only supports CSV parsing. CSV write support is under works.
 
 Quickstart:
 
@@ -89,7 +89,8 @@ If CSV has a header, :columns keys can be strings that are equal to column names
 * :alias - Object of any type (though usually a Symbol) that is used as a key that represents column name when :row_as_hash is set.
 * :type - A Ruby Symbol that specifies Ruby data type that CSV cell value should be converted into. Supported types: :int, :float, :string, :bool. :string is the default.
 * :default - Object of any type (though usually of the same type that is specified by :type option). If CSV doesn't have any value for a cell, this default value is used.
-* :match - A string. If set, makes Rcsv skip all the rows where any column doesn't match its :match value. Useful for filtering data.
+* :match - An array of Ruby objects of supported type (see :type). If set, makes Rcsv skip all the rows where any column isn't included in its :match value. Useful for filtering data.
+* :not_match - An array of Ruby objects of supported type (see :type). If set, makes Rcsv skip all the rows where any column is included in its :not_match value. Useful for skipping data and is an opposite of :match.
 
 
 ### :header
@@ -116,13 +117,13 @@ Specifies a number of bytes that are read at once, thus allowing to read drectly
 
 ## Examples
 
-This example parses a 3-column CSV file and only returns parsed rows where "Age" values are set to "35".
+This example parses a 3-column CSV file and only returns parsed rows where "Age" values are parsed to 35, 36 or 37.
 
     Rcsv.parse some_csv, :row_as_hash => true,
                          :columns => {
       'First Name' => { :alias => :first_name, :default => "Unknown" },
       'Last Name' => { :alias => :last_name, :default => "Unknown"},
-      'Age' => { :alias => :age, :type => :int, :match => "35"}
+      'Age' => { :alias => :age, :type => :int, :match => [35, 36, 37]]
     }
 
 The result would look like this:
@@ -170,9 +171,9 @@ This way it is possible to read from a File directly, with a 20MiB buffer and pa
 
 ## To do
 
-* More specs for boolean values
-* Specs for Ruby parse
-* Add CSV write support
+* More tests for boolean values
+* More tests for Ruby parse
+* Finish CSV write support
 
 
 ## Contributing

data/RELNOTES

@@ -1,3 +1,12 @@
+Version 0.1.1
+  * added :not_match filter that skips rows with values listed in that option
+  * eliminated many potential memory leaks related to exception handling
+
+Version 0.1.0
+  * backwards-incompatible change in :match option: filtering now happens after creating Ruby objects and thus rows can now be filtered not only as CSV field strings
+  * fixed a bug where field's key was being set to nil if :row_as_hash was enabled and :alias wasn't defined
+  * fixed assert_equal parameters order in tests
+
 Version 0.0.9
   * preliminary write support
 

data/ext/rcsv/rcsv.c

@@ -12,22 +12,24 @@ static VALUE rcsv_parse_error; /* class Rcsv::ParseError << StandardError; end *
 struct rcsv_metadata {
   /* Derived from user-specified options */
   bool row_as_hash;           /* Used to return array of hashes rather than array of arrays */
-  bool empty_field_is_nil;   /* Do we convert empty fields to nils? */
+  bool empty_field_is_nil;    /* Do we convert empty fields to nils? */
   size_t offset_rows;         /* Number of rows to skip before parsing */
 
   char * row_conversions;     /* A pointer to string/array of row conversions char specifiers */
-  char ** only_rows;          /* A pointer to array of strings for only_rows filter */
+  VALUE * only_rows;          /* A pointer to array of row filters */
+  VALUE * except_rows;        /* A pointer to array of negative row filters */
   VALUE * row_defaults;       /* A pointer to array of row defaults */
   VALUE * column_names;       /* A pointer to array of column names to be used with hashes */
 
   /* Pointer options lengths */
   size_t num_row_conversions; /* Number of converter types in row_conversions array */
   size_t num_only_rows;       /* Number of items in only_rows filter */
+  size_t num_except_rows;     /* Number of items in except_rows filter */
   size_t num_row_defaults;    /* Number of default values in row_defaults array */
   size_t num_columns;         /* Number of columns detected from column_names.size */
 
   /* Internal state */
-  bool skip_current_row;      /* Used by only_rows filter to skip parsing of the row remainder */
+  bool skip_current_row;      /* Used by only_rows and except_rows filters to skip parsing of the row remainder */
   size_t current_col;         /* Current column's index */
   size_t current_row;         /* Current row's index */
 
@@ -55,16 +57,6 @@ void end_of_field_callback(void * field, size_t field_size, void * data) {
     return;
   }
 
-  /* Filter by string row values listed in meta->only_rows */
-  if ((meta->only_rows != NULL) &&
-      (field_str != NULL) && /* TODO: What if we want to filter out NULLs? */
-      (meta->current_col < meta->num_only_rows) &&
-      (meta->only_rows[meta->current_col] != NULL) &&
-      (strcmp(meta->only_rows[meta->current_col], field_str))) {
-    meta->skip_current_row = true;
-    return;
-  }
-
   /* Get row conversion char specifier */
   if (meta->current_col < meta->num_row_conversions) {
     row_conversion = (char)meta->row_conversions[meta->current_col];
@@ -130,6 +122,24 @@ void end_of_field_callback(void * field, size_t field_size, void * data) {
       }
     }
 
+    /* Filter by row values listed in meta->only_rows */
+    if ((meta->only_rows != NULL) &&
+        (meta->current_col < meta->num_only_rows) &&
+        (meta->only_rows[meta->current_col] != Qnil) &&
+        (!rb_ary_includes(meta->only_rows[meta->current_col], parsed_field))) {
+      meta->skip_current_row = true;
+      return;
+    }
+
+    /* Filter out by row values listed in meta->except_rows */
+    if ((meta->except_rows != NULL) &&
+        (meta->current_col < meta->num_except_rows) &&
+        (meta->except_rows[meta->current_col] != Qnil) &&
+        (rb_ary_includes(meta->except_rows[meta->current_col], parsed_field))) {
+      meta->skip_current_row = true;
+      return;
+    }
+
     /* Assign the value to appropriate hash key if parsing into Hash */
     if (meta->row_as_hash) {
       if (meta->current_col >= meta->num_columns) {
@@ -187,110 +197,136 @@ void end_of_line_callback(int last_char, void * data) {
   return;
 }
 
-void custom_end_of_line_callback(int last_char, void * data) {
-  struct rcsv_metadata * meta = (struct rcsv_metadata *) data;
-
-  if (!meta->skip_current_row) {
+/* Filter rows need to be either nil or Arrays of Strings/bools/nil, so we validate this here */
+VALUE validate_filter_row(const char * filter_name, VALUE row) {
+  if (row == Qnil) {
+    return Qnil;
+  } else if (TYPE(row) == T_ARRAY) {
+    size_t j;
+    for (j = 0; j < (size_t)RARRAY_LEN(row); j++) {
+      switch (TYPE(rb_ary_entry(row, j))) {
+        case T_NIL:
+        case T_TRUE:
+        case T_FALSE:
+        case T_FLOAT:
+        case T_FIXNUM:
+        case T_BIGNUM:
+        case T_REGEXP:
+        case T_STRING:
+          break;
+        default:
+          rb_raise(rcsv_parse_error,
+            ":%s can only accept nil or Array consisting of String, boolean or nil elements, but %s was provided.",
+            filter_name, RSTRING_PTR(rb_inspect(row)));
+      }
+    }
+    return row;
+  } else {
+    rb_raise(rcsv_parse_error,
+      ":%s can only accept nil or Array as an element, but %s was provided.",
+      filter_name, RSTRING_PTR(rb_inspect(row)));
   }
 }
 
-/* C API */
-
-/* The main method that handles parsing */
-static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
-  struct rcsv_metadata meta;
-  VALUE csvio, csvstr, buffer_size, options, option;
+/* All the possible free()'s should be listed here.
+   This function should be invoked before returning the result to Ruby or raising an exception. */
+void free_memory(struct csv_parser * cp, struct rcsv_metadata * meta) {
+  if (meta->only_rows != NULL) {
+    free(meta->only_rows);
+  }
 
-  struct csv_parser cp;
-  unsigned char csv_options = CSV_STRICT_FINI | CSV_APPEND_NULL;
-  char * csv_string;
-  size_t csv_string_len;
-  int error;
-  size_t i = 0;
+  if (meta->except_rows != NULL) {
+    free(meta->except_rows);
+  }
 
-  /* Setting up some sane defaults */
-  meta.row_as_hash = false;
-  meta.empty_field_is_nil = false;
-  meta.skip_current_row = false;
-  meta.num_columns = 0;
-  meta.current_col = 0;
-  meta.current_row = 0;
-  meta.offset_rows = 0;
-  meta.num_only_rows = 0;
-  meta.num_row_defaults = 0;
-  meta.num_row_conversions = 0;
-  meta.only_rows = NULL;
-  meta.row_defaults = NULL;
-  meta.row_conversions = NULL;
-  meta.column_names = NULL;
-  meta.result = (VALUE[]){rb_ary_new()}; /* [] */
+  if (meta->row_defaults != NULL) {
+    free(meta->row_defaults);
+  }
 
-  /* csvio is required, options is optional (pun intended) */
-  rb_scan_args(argc, argv, "11", &csvio, &options);
+  if (meta->column_names != NULL) {
+    free(meta->column_names);
+  }
 
-  /* options ||= nil */
-  if (NIL_P(options)) {
-    options = rb_hash_new();
+  if (cp != NULL) {
+    csv_free(cp);
   }
+}
 
-  buffer_size = rb_hash_aref(options, ID2SYM(rb_intern("buffer_size")));
+/* An rb_rescue()-compatible free_memory() wrapper that unpacks C pointers from Ruby's Fixnums */
+VALUE rcsv_free_memory(VALUE ensure_container) {
+  free_memory(
+    (struct csv_parser *)NUM2LONG(rb_ary_entry(ensure_container, 3)),
+    (struct rcsv_metadata *)NUM2LONG(rb_ary_entry(ensure_container, 2))
+  );
 
-  /* By default, parsing is strict */
-  option = rb_hash_aref(options, ID2SYM(rb_intern("nostrict")));
-  if (!option || (option == Qnil)) {
-    csv_options |= CSV_STRICT;
-  }
+  return Qnil;
+}
 
-  /* By default, empty strings are treated as Nils and quoted empty strings are treated as empty Ruby strings */
-  option = rb_hash_aref(options, ID2SYM(rb_intern("parse_empty_fields_as")));
-  if ((option == Qnil) || (option == ID2SYM(rb_intern("nil_or_string")))) {
-    csv_options |= CSV_EMPTY_IS_NULL;
-  } else if (option == ID2SYM(rb_intern("nil"))) {
-    meta.empty_field_is_nil = true;
-  } else if (option == ID2SYM(rb_intern("string"))) {
-    meta.empty_field_is_nil = false;
-  } else {
-    rb_raise(rcsv_parse_error, "The only valid options for :parse_empty_fields_as are :nil, :string and :nil_or_string, but %s was supplied.", RSTRING_PTR(rb_inspect(option)));
-  }
+/* An rb_rescue()-compatible Ruby pseudo-method that handles the actual parsing */
+VALUE rcsv_raw_parse(VALUE ensure_container) {
+  /* Unpacking multiple variables from a single Ruby VALUE */
+  VALUE options = rb_ary_entry(ensure_container, 0);
+  VALUE csvio   = rb_ary_entry(ensure_container, 1);
+  struct rcsv_metadata * meta = (struct rcsv_metadata *)NUM2LONG(rb_ary_entry(ensure_container, 2));
+  struct csv_parser * cp = (struct csv_parser *)NUM2LONG(rb_ary_entry(ensure_container, 3));
 
-  /* Try to initialize libcsv */
-  if (csv_init(&cp, csv_options) == -1) {
-    rb_raise(rcsv_parse_error, "Couldn't initialize libcsv");
-  }
+  /* Helper temporary variables */
+  VALUE option, csvstr, buffer_size;
+
+  /* libcsv-related temporary variables */
+  char * csv_string;
+  size_t csv_string_len;
+  int error;
+
+  /* Generic iterator */
+  size_t i = 0;
+
+  /* IO buffer size can be controller via an option */
+  buffer_size = rb_hash_aref(options, ID2SYM(rb_intern("buffer_size")));
 
   /* By default, parse as Array of Arrays */
   option = rb_hash_aref(options, ID2SYM(rb_intern("row_as_hash")));
   if (option && (option != Qnil)) {
-    meta.row_as_hash = true;
+    meta->row_as_hash = true;
   }
 
   /* :col_sep sets the column separator, default is comma (,) */
   option = rb_hash_aref(options, ID2SYM(rb_intern("col_sep")));
   if (option != Qnil) {
-    csv_set_delim(&cp, (unsigned char)*StringValuePtr(option));
+    csv_set_delim(cp, (unsigned char)*StringValuePtr(option));
   }
 
   /* Specify how many rows to skip from the beginning of CSV */
   option = rb_hash_aref(options, ID2SYM(rb_intern("offset_rows")));
   if (option != Qnil) {
-    meta.offset_rows = (size_t)NUM2INT(option);
+    meta->offset_rows = (size_t)NUM2INT(option);
   }
 
-  /* :only_rows is a string mask where row is only parsed
+  /* :only_rows is a list of values where row is only parsed
      if its fields match those in the passed array.
-     [nil, nil, "ABC"] skips all rows where 3rd column isn't equal to "ABC" */
+     [nil, nil, ["ABC", nil, 1]] skips all rows where 3rd column isn't equal to "ABC", nil or 1 */
   option = rb_hash_aref(options, ID2SYM(rb_intern("only_rows")));
   if (option != Qnil) {
-    meta.num_only_rows = (size_t)RARRAY_LEN(option);
-    meta.only_rows = (char **)malloc(meta.num_only_rows * sizeof(char *));
+    meta->num_only_rows = (size_t)RARRAY_LEN(option);
+    meta->only_rows = (VALUE *)malloc(meta->num_only_rows * sizeof(VALUE));
 
-    for (i = 0; i < meta.num_only_rows; i++) {
+    for (i = 0; i < meta->num_only_rows; i++) {
       VALUE only_row = rb_ary_entry(option, i);
-      if (only_row == Qnil) {
-        meta.only_rows[i] = NULL;
-      } else {
-        meta.only_rows[i] = StringValueCStr(only_row);
-      }
+      meta->only_rows[i] = validate_filter_row("only_rows", only_row);
+    }
+  }
+
+  /* :except_rows is a list of values where row is only parsed
+     if its fields don't match those in the passed array.
+     [nil, nil, ["ABC", nil, 1]] skips all rows where 3rd column is equal to "ABC", nil or 1 */
+  option = rb_hash_aref(options, ID2SYM(rb_intern("except_rows")));
+  if (option != Qnil) {
+    meta->num_except_rows = (size_t)RARRAY_LEN(option);
+    meta->except_rows = (VALUE *)malloc(meta->num_except_rows * sizeof(VALUE));
+
+    for (i = 0; i < meta->num_except_rows; i++) {
+      VALUE except_row = rb_ary_entry(option, i);
+      meta->except_rows[i] = validate_filter_row("except_rows", except_row);
     }
   }
 
@@ -298,12 +334,12 @@ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
      according to matching field positions */
   option = rb_hash_aref(options, ID2SYM(rb_intern("row_defaults")));
   if (option != Qnil) {
-    meta.num_row_defaults = RARRAY_LEN(option);
-    meta.row_defaults = (VALUE*)malloc(meta.num_row_defaults * sizeof(VALUE*));
+    meta->num_row_defaults = RARRAY_LEN(option);
+    meta->row_defaults = (VALUE*)malloc(meta->num_row_defaults * sizeof(VALUE*));
 
-    for (i = 0; i < meta.num_row_defaults; i++) {
+    for (i = 0; i < meta->num_row_defaults; i++) {
       VALUE row_default = rb_ary_entry(option, i);
-      meta.row_defaults[i] = row_default;
+      meta->row_defaults[i] = row_default;
     }
   }
 
@@ -311,27 +347,27 @@ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
      Each char of row_conversions string represents Ruby type for CSV field with matching position. */
   option = rb_hash_aref(options, ID2SYM(rb_intern("row_conversions"))); 
   if (option != Qnil) {
-    meta.num_row_conversions = RSTRING_LEN(option);
-    meta.row_conversions = StringValuePtr(option);
+    meta->num_row_conversions = RSTRING_LEN(option);
+    meta->row_conversions = StringValuePtr(option);
   }
 
  /* Column names should be declared explicitly when parsing fields as Hashes */
-  if (meta.row_as_hash) { /* Only matters for hash results */
+  if (meta->row_as_hash) { /* Only matters for hash results */
     option = rb_hash_aref(options, ID2SYM(rb_intern("column_names"))); 
     if (option == Qnil) {
       rb_raise(rcsv_parse_error, ":row_as_hash requires :column_names to be set.");
     } else {
-      meta.last_entry = rb_hash_new();
+      meta->last_entry = rb_hash_new();
 
-      meta.num_columns = (size_t)RARRAY_LEN(option);
-      meta.column_names = (VALUE*)malloc(meta.num_columns * sizeof(VALUE*));
+      meta->num_columns = (size_t)RARRAY_LEN(option);
+      meta->column_names = (VALUE*)malloc(meta->num_columns * sizeof(VALUE*));
 
-      for (i = 0; i < meta.num_columns; i++) {
-        meta.column_names[i] = rb_ary_entry(option, i);
+      for (i = 0; i < meta->num_columns; i++) {
+        meta->column_names[i] = rb_ary_entry(option, i);
       }
     }
   } else {
-    meta.last_entry = rb_ary_new();
+    meta->last_entry = rb_ary_new();
   }
 
   while(true) {
@@ -342,9 +378,9 @@ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
     csv_string_len = strlen(csv_string);
 
     /* Actual parsing and error handling */
-    if (csv_string_len != csv_parse(&cp, csv_string, csv_string_len,
-                                    &end_of_field_callback, &end_of_line_callback, &meta)) {
-      error = csv_error(&cp);
+    if (csv_string_len != csv_parse(cp, csv_string, csv_string_len,
+                                    &end_of_field_callback, &end_of_line_callback, meta)) {
+      error = csv_error(cp);
       switch(error) {
         case CSV_EPARSE:
           rb_raise(rcsv_parse_error, "Error when parsing malformed data");
@@ -364,22 +400,85 @@ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
     }
   }
 
-  /* Flushing libcsv's buffer and freeing up allocated memory */
-  csv_fini(&cp, &end_of_field_callback, &end_of_line_callback, &meta);
-  csv_free(&cp);
+  /* Flushing libcsv's buffer */
+  csv_fini(cp, &end_of_field_callback, &end_of_line_callback, meta);
+
+  return Qnil;
+}
+
+/* C API */
+
+/* The main method that handles parsing */
+static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
+  struct rcsv_metadata meta;
+  VALUE csvio, options, option;
+  VALUE ensure_container = rb_ary_new(); /* [] */
+
+  struct csv_parser cp;
+  unsigned char csv_options = CSV_STRICT_FINI | CSV_APPEND_NULL;
+
+  /* Setting up some sane defaults */
+  meta.row_as_hash = false;
+  meta.empty_field_is_nil = false;
+  meta.skip_current_row = false;
+  meta.num_columns = 0;
+  meta.current_col = 0;
+  meta.current_row = 0;
+  meta.offset_rows = 0;
+  meta.num_only_rows = 0;
+  meta.num_except_rows = 0;
+  meta.num_row_defaults = 0;
+  meta.num_row_conversions = 0;
+  meta.only_rows = NULL;
+  meta.except_rows = NULL;
+  meta.row_defaults = NULL;
+  meta.row_conversions = NULL;
+  meta.column_names = NULL;
+  meta.result = (VALUE[]){rb_ary_new()}; /* [] */
+
+  /* csvio is required, options is optional (pun intended) */
+  rb_scan_args(argc, argv, "11", &csvio, &options);
+
+  /* options ||= {} */
+  if (NIL_P(options)) {
+    options = rb_hash_new();
+  }
+
+  /* First of all, we parse libcsv-related params so that it fails early if something is wrong with them */
 
-  if (meta.only_rows != NULL) {
-    free(meta.only_rows);
+  /* By default, parsing is strict */
+  option = rb_hash_aref(options, ID2SYM(rb_intern("nostrict")));
+  if (!option || (option == Qnil)) {
+    csv_options |= CSV_STRICT;
   }
 
-  if (meta.row_defaults != NULL) {
-    free(meta.row_defaults);
+  /* By default, empty strings are treated as Nils and quoted empty strings are treated as empty Ruby strings */
+  option = rb_hash_aref(options, ID2SYM(rb_intern("parse_empty_fields_as")));
+  if ((option == Qnil) || (option == ID2SYM(rb_intern("nil_or_string")))) {
+    csv_options |= CSV_EMPTY_IS_NULL;
+  } else if (option == ID2SYM(rb_intern("nil"))) {
+    meta.empty_field_is_nil = true;
+  } else if (option == ID2SYM(rb_intern("string"))) {
+    meta.empty_field_is_nil = false;
+  } else {
+    rb_raise(rcsv_parse_error, "The only valid options for :parse_empty_fields_as are :nil, :string and :nil_or_string, but %s was supplied.", RSTRING_PTR(rb_inspect(option)));
   }
 
-  if (meta.column_names != NULL) {
-    free(meta.column_names);
+  /* rb_ensure() only expects callback functions to accept and return VALUEs */
+  /* This ugly hack converts C pointers into Ruby Fixnums in order to pass them in Array */
+  rb_ary_push(ensure_container, options);               /* [options] */
+  rb_ary_push(ensure_container, csvio);                 /* [options, csvio] */
+  rb_ary_push(ensure_container, LONG2NUM((long)&meta)); /* [options, csvio, &meta] */
+  rb_ary_push(ensure_container, LONG2NUM((long)&cp));   /* [options, csvio, &meta, &cp] */
+
+  /* Try to initialize libcsv */
+  if (csv_init(&cp, csv_options) == -1) {
+    rb_raise(rcsv_parse_error, "Couldn't initialize libcsv");
   }
 
+  /* From now on, cp handles allocated data and should be free'd on exit or exception */
+  rb_ensure(rcsv_raw_parse, ensure_container, rcsv_free_memory, ensure_container);
+
   /* Remove the last row if it's empty. That happens if CSV file ends with a newline. */
   if (RARRAY_LEN(*(meta.result)) && /* meta.result.size != 0 */
       RARRAY_LEN(rb_ary_entry(*(meta.result), -1)) == 0) {
@@ -393,7 +492,6 @@ static VALUE rb_rcsv_raw_parse(int argc, VALUE * argv, VALUE self) {
   }
 }
 
-
 /* Define Ruby API */
 void Init_rcsv(void) {
   VALUE klass = rb_define_class("Rcsv", rb_cObject); /* class Rcsv; end */

data/lib/rcsv.rb

@@ -59,6 +59,7 @@ class Rcsv
 
     if options[:columns]
       only_rows = []
+      except_rows = []
       row_defaults = []
       column_names = []
       row_conversions = ''
@@ -67,10 +68,29 @@ class Rcsv
         column_options = options[:columns][column_header]
         if column_options
           if (options[:row_as_hash])
-            column_names << column_options[:alias] || column_header
+            column_names << (column_options[:alias] || column_header)
           end
+
           row_defaults << column_options[:default] || nil
-          only_rows << column_options[:match] || nil
+
+          only_rows << case column_options[:match]
+          when Array
+            column_options[:match]
+          when nil
+            nil
+          else
+            [column_options[:match]]
+          end
+
+          except_rows << case column_options[:not_match]
+          when Array
+            column_options[:not_match]
+          when nil
+            nil
+          else
+            [column_options[:not_match]]
+          end
+
           row_conversions << case column_options[:type]
           when :int
             'i'
@@ -83,24 +103,27 @@ class Rcsv
           when nil
             's' # strings by default
           else
-            fail "Unknown column type"
+            fail "Unknown column type #{column_options[:type].inspect}."
           end
         elsif options[:only_listed_columns]
           column_names << nil
           row_defaults << nil
           only_rows << nil
+          except_rows << nil
           row_conversions << ' '
         else
           column_names << column_header
           row_defaults << nil
           only_rows << nil
+          except_rows << nil
           row_conversions << 's'
         end
       end
 
       raw_options[:column_names] = column_names if options[:row_as_hash]
-      raw_options[:only_rows] = only_rows
-      raw_options[:row_defaults] = row_defaults
+      raw_options[:only_rows] = only_rows unless only_rows.compact.empty?
+      raw_options[:except_rows] = except_rows unless except_rows.compact.empty?
+      raw_options[:row_defaults] = row_defaults unless row_defaults.compact.empty?
       raw_options[:row_conversions] = row_conversions
     end
 

data/lib/rcsv/version.rb

@@ -1,3 +1,3 @@
 class Rcsv
-  VERSION = "0.0.9"
+  VERSION = "0.1.1"
 end

data/test/test_rcsv.csv

@@ -1,4 +1,4 @@
-DSAdsfksjh,iii ooo iii,EDADEDADEDADEDADEDADEDAD,111 333 555,NMLKTF,---==---,//,###,0000000000,Asdad bvd qwert,;'''sd,@@@,OCTZ,$$$908080, """",true/false
+DSAdsfksjh,iii ooo iii,EDADEDADEDADEDADEDADEDAD,111 333 555,NMLKTF,---==---,//,###,0000000000,Asdad bvd qwert,;sd,@@@,OCTZ,$$$908080, ,true/false
 C85A5B9F,85259637,,96,6838,1983-06-14,"""""C4CA-=; **1679; .. 79","210,11",908e,1281-03-09,7257.4654049904275,20efe749-50fe-4b6a-a603-7f9cd1dc6c6d,3,"New York, NY",u,2.228169203286535,t
 3ABC8DF7,83229030,,79,9134,1987-05-24,"""""8F14-=; **C9F0; .. 74","321,42",b896,1358-04-08,-139.10142026231654,3e18cc6f-8ef0-41ac-bd4c-79a0120f65fd,8,"San Jose, CA",,-9.549296585513721,1
 F0A83489,69118080,,73,7008,2016-10-03,"""""C81E-=; **ECCB; .. 89","130,86",a3eb,1341-04-10,7612.699237971538,5b5e3fce-2ea5-4ca9-9749-90fd6dc8dd66,9,"Los Angeles, CA",e,6.047887837492023,f

data/test/test_rcsv_parse.rb

@@ -0,0 +1,79 @@
+require 'test/unit'
+require 'rcsv'
+
+class RcsvParseTest < Test::Unit::TestCase
+  def setup
+    @options = {
+      :header => true,
+      :columns => {
+        'Date' => {
+          :type => :string
+        }
+      }
+    }
+  end
+
+  def test_rcsv_parse_unknown_rows
+    csv = "a,b,c,d,e\n1,2,3,4,5"
+    parsed_data = Rcsv.parse(csv,
+      :row_as_hash => true,
+      :columns => {
+        'b' => {
+          :type => :int,
+          :alias => 'B'
+        },
+        'd' => {
+          :type => :int
+        }
+      }
+    )
+
+    assert_equal({
+      'a' => '1',
+      'B' => 2,
+      'c' => '3',
+      'd' => 4,
+      'e' => '5'
+    }, parsed_data.first)
+  end
+
+  def test_rcsv_parse_only_rows
+    csv = "a,1,t\nb,2,false\nc,3,0"
+    parsed_data = Rcsv.parse(csv,
+      :header => :none,
+      :columns => [
+        {
+          :match => ['z', 'a', '1']
+        },
+        {},
+        {
+          :match => true,
+          :type => :bool
+        }
+      ]
+    )
+
+    assert_equal([["a", "1", true]], parsed_data)
+  end
+
+  def test_rcsv_parse_only_rows_not_match
+    csv = "a,1,t\nb,2,false\nc,3,0"
+    parsed_data = Rcsv.parse(csv,
+      :header => :none,
+      :columns => [
+        {
+          :not_match => ['z', 'a', '1']
+        },
+        {
+          :type => :int
+        },
+        {
+          :not_match => true,
+          :type => :bool
+        }
+      ]
+    )
+
+    assert_equal([["b", 2, false], ["c", 3, false]], parsed_data)
+  end
+end

data/test/test_rcsv_raw_parse.rb

@@ -9,47 +9,47 @@ class RcsvRawParseTest < Test::Unit::TestCase
   def test_rcsv
     raw_parsed_csv_data = Rcsv.raw_parse(@csv_data)
 
-    assert_equal(raw_parsed_csv_data[0][2], 'EDADEDADEDADEDADEDADEDAD')
-    assert_equal(raw_parsed_csv_data[0][13], '$$$908080')
-    assert_equal(raw_parsed_csv_data[0][14], '"')
-    assert_equal(raw_parsed_csv_data[0][15], 'true/false')
-    assert_equal(raw_parsed_csv_data[0][16], nil)
-    assert_equal(raw_parsed_csv_data[9][2], nil)
-    assert_equal(raw_parsed_csv_data[3][6], '""C81E-=; **ECCB; .. 89')
-    assert_equal(raw_parsed_csv_data[888][13], 'Dallas, TX')
+    assert_equal('EDADEDADEDADEDADEDADEDAD', raw_parsed_csv_data[0][2])
+    assert_equal('$$$908080', raw_parsed_csv_data[0][13])
+    assert_equal('"', raw_parsed_csv_data[0][14])
+    assert_equal('true/false', raw_parsed_csv_data[0][15])
+    assert_equal(nil, raw_parsed_csv_data[0][16])
+    assert_equal(nil, raw_parsed_csv_data[9][2])
+    assert_equal('""C81E-=; **ECCB; .. 89', raw_parsed_csv_data[3][6])
+    assert_equal('Dallas, TX', raw_parsed_csv_data[888][13])
   end
 
   def test_rcsv_col_sep
     tsv_data = StringIO.new(@csv_data.read.tr(",", "\t"))
     raw_parsed_tsv_data = Rcsv.raw_parse(tsv_data, :col_sep => "\t")
 
-    assert_equal(raw_parsed_tsv_data[0][2], 'EDADEDADEDADEDADEDADEDAD')
-    assert_equal(raw_parsed_tsv_data[0][13], '$$$908080')
-    assert_equal(raw_parsed_tsv_data[0][14], '"')
-    assert_equal(raw_parsed_tsv_data[0][15], 'true/false')
-    assert_equal(raw_parsed_tsv_data[0][16], nil)
-    assert_equal(raw_parsed_tsv_data[9][2], nil)
-    assert_equal(raw_parsed_tsv_data[3][6], '""C81E-=; **ECCB; .. 89')
-    assert_equal(raw_parsed_tsv_data[888][13], "Dallas\t TX")
+    assert_equal('EDADEDADEDADEDADEDADEDAD', raw_parsed_tsv_data[0][2])
+    assert_equal('$$$908080', raw_parsed_tsv_data[0][13])
+    assert_equal('"', raw_parsed_tsv_data[0][14])
+    assert_equal('true/false', raw_parsed_tsv_data[0][15])
+    assert_equal(nil, raw_parsed_tsv_data[0][16])
+    assert_equal(nil, raw_parsed_tsv_data[9][2])
+    assert_equal('""C81E-=; **ECCB; .. 89', raw_parsed_tsv_data[3][6])
+    assert_equal("Dallas\t TX", raw_parsed_tsv_data[888][13])
   end
 
   def test_buffer_size
     raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :buffer_size => 10)
 
-    assert_equal(raw_parsed_csv_data[0][2], 'EDADEDADEDADEDADEDADEDAD')
-    assert_equal(raw_parsed_csv_data[0][13], '$$$908080')
-    assert_equal(raw_parsed_csv_data[0][14], '"')
-    assert_equal(raw_parsed_csv_data[0][15], 'true/false')
-    assert_equal(raw_parsed_csv_data[0][16], nil)
-    assert_equal(raw_parsed_csv_data[9][2], nil)
-    assert_equal(raw_parsed_csv_data[3][6], '""C81E-=; **ECCB; .. 89')
-    assert_equal(raw_parsed_csv_data[888][13], 'Dallas, TX')
+    assert_equal('EDADEDADEDADEDADEDADEDAD', raw_parsed_csv_data[0][2])
+    assert_equal('$$$908080', raw_parsed_csv_data[0][13])
+    assert_equal('"', raw_parsed_csv_data[0][14])
+    assert_equal('true/false', raw_parsed_csv_data[0][15])
+    assert_equal(nil, raw_parsed_csv_data[0][16])
+    assert_equal(nil, raw_parsed_csv_data[9][2])
+    assert_equal('""C81E-=; **ECCB; .. 89', raw_parsed_csv_data[3][6])
+    assert_equal('Dallas, TX', raw_parsed_csv_data[888][13])
   end
 
   def test_single_item_csv
     raw_parsed_csv_data = Rcsv.raw_parse(StringIO.new("Foo"))
 
-    assert_equal(raw_parsed_csv_data, [["Foo"]])
+    assert_equal([["Foo"]], raw_parsed_csv_data)
   end
 
   def test_broken_data
@@ -68,60 +68,68 @@ class RcsvRawParseTest < Test::Unit::TestCase
   end
 
   def test_only_rows
-    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => ['GBP'])
+    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => [['GBP', 'NO SUCH THING']])
 
-    assert_equal(raw_parsed_csv_data[0][0], 'GBP')
-    assert_equal(raw_parsed_csv_data[-1][3], '15')
-    assert_equal(raw_parsed_csv_data.size, 3)
+    assert_equal('GBP', raw_parsed_csv_data[0][0])
+    assert_equal('15', raw_parsed_csv_data[-1][3])
+    assert_equal(3, raw_parsed_csv_data.size)
+  end
+
+  def test_except_rows
+    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :except_rows => [['GBP', 'NO SUCH THING']])
+
+    assert_equal('C85A5B9F', raw_parsed_csv_data[1][0])
+    assert_equal('4971', raw_parsed_csv_data[28][4])
+    assert_equal(886, raw_parsed_csv_data.size)
   end
 
   def test_only_rows_with_nil_and_empty_string_filter
-    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => ['GBP', nil, '', '51'])
+    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => [['GBP'], nil, ['zzz', nil], ['51']])
 
-    assert_equal(raw_parsed_csv_data[0][0], 'GBP')
-    assert_equal(raw_parsed_csv_data[0][2], nil)
-    assert_equal(raw_parsed_csv_data.size, 1)
+    assert_equal('GBP', raw_parsed_csv_data[0][0])
+    assert_equal(nil, raw_parsed_csv_data[0][2])
+    assert_equal(1, raw_parsed_csv_data.size)
   end
 
   def test_only_rows_with_nil_beginning
-    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => [nil, nil, nil, '96', nil])
+    raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :only_rows => [nil, nil, nil, [123, 96], nil], :row_conversions => 'sssi')
 
-    assert_equal(raw_parsed_csv_data[1][0], 'C3B87A6B')
-    assert_equal(raw_parsed_csv_data[0][2], nil)
-    assert_equal(raw_parsed_csv_data[3][3], '96')
-    assert_equal(raw_parsed_csv_data.size, 5)
+    assert_equal('C3B87A6B', raw_parsed_csv_data[1][0])
+    assert_equal(nil, raw_parsed_csv_data[0][2])
+    assert_equal(96, raw_parsed_csv_data[3][3])
+    assert_equal(5, raw_parsed_csv_data.size)
   end
 
   def test_row_defaults
     raw_parsed_csv_data = Rcsv.raw_parse(@csv_data, :row_defaults => [nil, nil, :booya, nil, 'never ever'])
 
-    assert_equal(raw_parsed_csv_data[0][2], 'EDADEDADEDADEDADEDADEDAD')
-    assert_equal(raw_parsed_csv_data[1][2], :booya)
-    assert_equal(raw_parsed_csv_data[1][0], 'C85A5B9F')
-    assert_equal(raw_parsed_csv_data[2][4], '9134')
+    assert_equal('EDADEDADEDADEDADEDADEDAD', raw_parsed_csv_data[0][2])
+    assert_equal(:booya, raw_parsed_csv_data[1][2])
+    assert_equal('C85A5B9F', raw_parsed_csv_data[1][0])
+    assert_equal('9134', raw_parsed_csv_data[2][4])
   end
 
   def test_row_conversions
     raw_parsed_csv_data = Rcsv.raw_parse(StringIO.new(@csv_data.each_line.to_a[1..-1].join), # skipping string headers
                                          :row_conversions => 'sisiisssssfsissf')
 
-    assert_equal(raw_parsed_csv_data[0][2], nil)
-    assert_equal(raw_parsed_csv_data[0][3], 96)
-    assert_equal(raw_parsed_csv_data[0][8], '908e')
-    assert_equal(raw_parsed_csv_data[1][15], -9.549296585513721)
-    assert_equal(raw_parsed_csv_data[3][5], '2015-12-22')
+    assert_equal(nil, raw_parsed_csv_data[0][2])
+    assert_equal(96, raw_parsed_csv_data[0][3])
+    assert_equal('908e', raw_parsed_csv_data[0][8])
+    assert_equal(-9.549296585513721, raw_parsed_csv_data[1][15])
+    assert_equal('2015-12-22', raw_parsed_csv_data[3][5])
   end
 
   def test_row_conversions_with_column_exclusions
     raw_parsed_csv_data = Rcsv.raw_parse(StringIO.new(@csv_data.each_line.to_a[1..-1].join), # skipping string headers
                                          :row_conversions => 's f issss fsis fb')
 
-    assert_equal(raw_parsed_csv_data[0][1], nil)
-    assert_equal(raw_parsed_csv_data[0][2], 6838)
-    assert_equal(raw_parsed_csv_data[0][8], '20efe749-50fe-4b6a-a603-7f9cd1dc6c6d')
-    assert_equal(raw_parsed_csv_data[0][12], true)
-    assert_equal(raw_parsed_csv_data[0][13], nil)
-    assert_equal(raw_parsed_csv_data[4][3], '2020-12-09')
+    assert_equal(nil, raw_parsed_csv_data[0][1])
+    assert_equal(6838, raw_parsed_csv_data[0][2])
+    assert_equal('20efe749-50fe-4b6a-a603-7f9cd1dc6c6d', raw_parsed_csv_data[0][8])
+    assert_equal(true, raw_parsed_csv_data[0][12])
+    assert_equal(nil, raw_parsed_csv_data[0][13])
+    assert_equal('2020-12-09', raw_parsed_csv_data[4][3])
   end
 
   def test_offset_rows
@@ -181,14 +189,14 @@ class RcsvRawParseTest < Test::Unit::TestCase
     }
 
     assert_equal(nil, result)
-    assert_equal(raw_parsed_csv_data[0][2], 'EDADEDADEDADEDADEDADEDAD')
-    assert_equal(raw_parsed_csv_data[0][13], '$$$908080')
-    assert_equal(raw_parsed_csv_data[0][14], '"')
-    assert_equal(raw_parsed_csv_data[0][15], 'true/false')
-    assert_equal(raw_parsed_csv_data[0][16], nil)
-    assert_equal(raw_parsed_csv_data[9][2], nil)
-    assert_equal(raw_parsed_csv_data[3][6], '""C81E-=; **ECCB; .. 89')
-    assert_equal(raw_parsed_csv_data[888][13], 'Dallas, TX')
+    assert_equal('EDADEDADEDADEDADEDADEDAD', raw_parsed_csv_data[0][2])
+    assert_equal('$$$908080', raw_parsed_csv_data[0][13])
+    assert_equal('"', raw_parsed_csv_data[0][14])
+    assert_equal('true/false', raw_parsed_csv_data[0][15])
+    assert_equal(nil, raw_parsed_csv_data[0][16])
+    assert_equal(nil, raw_parsed_csv_data[9][2])
+    assert_equal('""C81E-=; **ECCB; .. 89', raw_parsed_csv_data[3][6])
+    assert_equal('Dallas, TX', raw_parsed_csv_data[888][13])
   end
 
   def test_hash_block_streaming

data/test/test_rcsv_write.rb

@@ -1,5 +1,6 @@
 require 'test/unit'
 require 'rcsv'
+require 'date'
 
 class RcsvWriteTest < Test::Unit::TestCase
   def setup

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rcsv
 version: !ruby/object:Gem::Version
-  version: 0.0.9
-  prerelease: 
+  version: 0.1.1
 platform: ruby
 authors:
 - Arthur Pirogovski
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-01-22 00:00:00.000000000 Z
+date: 2013-08-18 00:00:00.000000000 Z
 dependencies: []
 description: A libcsv-based CSV parser for Ruby
 email:
@@ -39,36 +38,36 @@ files:
 - lib/rcsv/version.rb
 - rcsv.gemspec
 - test/test_rcsv.csv
+- test/test_rcsv_parse.rb
 - test/test_rcsv_raw_parse.rb
 - test/test_rcsv_write.rb
 homepage: http://github.com/fiksu/rcsv
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 - ext
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Fast CSV parsing library for MRI based on libcsv. Supports type conversion,
   non-strict parsing and basic filtering.
 test_files:
 - test/test_rcsv.csv
+- test/test_rcsv_parse.rb
 - test/test_rcsv_raw_parse.rb
 - test/test_rcsv_write.rb
-has_rdoc: