inih 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ddb0233107d7ad4ce1121c75fd29a94de7d5dc42
+  data.tar.gz: 42fc11b4b2f16e971e61c189b45ecf652ae71ffb
+SHA512:
+  metadata.gz: 4727253857a6bdc0472b47792631ded48e2a125bfc0acfeb649b19f7869d92e4f02dded4f215e32d9dd8a307ecd29bd5c83c211ec6c404cc902f59afb7c00824
+  data.tar.gz: fcd4cd91b83fb9316a0366818c653e5f3c867f144ebb6c34761a7b904751c32f85251861c4f9f5e280affcdc523e76a6f06aebc053c15e9c4f9cde59ec906dfb

data/.yardopts

@@ -0,0 +1 @@
+--no-private --markup-provider=redcarpet --markup=markdown - README.md LICENSE ext/inih/LICENSE

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 William Woodruff <william @ yossarian.net>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+ruby-inih
+=========
+
+A Ruby wrapper for [inih](https://github.com/benhoyt/inih), a simple INI parser.
+
+### Installation
+
+```ruby
+$ gem install inih
+```
+
+### Example
+
+Given the following INI data:
+
+```ini
+; example.ini
+[example]
+foo=bar
+baz = quux
+integer = 10
+float = 3.14
+bool = true
+```
+
+```ruby
+# load directly from a file
+INIH.load "example.ini"
+# => {"example"=>{"foo"=>"bar", "baz"=>"quux", "integer"=>10, "float"=>3.14, "bool"=>true}}
+
+# parse from a string
+INIH.parse "[section]\nkey=value"
+#=> {"section"=>{"key"=>"value"}}
+```
+
+Integers, floating-point numbers, and booleans are coerced into their respective Ruby types.
+
+### TODO
+
+* Unit tests
+* Coerce scientific-notation?
+
+### License
+
+inih itself is licensed under the BSD License.
+
+For the exact terms, see the [LICENSE](ext/inih/LICENSE) file.
+
+ruby-inih is licensed under the MIT License.
+
+For the exact terms, see the [LICENSE](./LICENSE) file.

data/ext/inih/extconf.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+require "mkmf"
+
+$CFLAGS << " -DINI_MAX_LINE=1024 "
+
+create_makefile "ext/inih"

data/ext/inih/ini.c

@@ -0,0 +1,244 @@
+/* inih -- simple .INI file parser
+
+inih is released under the New BSD license (see LICENSE.txt). Go to the project
+home page for more info:
+
+https://github.com/benhoyt/inih
+
+*/
+
+#if defined(_MSC_VER) && !defined(_CRT_SECURE_NO_WARNINGS)
+#define _CRT_SECURE_NO_WARNINGS
+#endif
+
+#include <stdio.h>
+#include <ctype.h>
+#include <string.h>
+
+#include "ini.h"
+
+#if !INI_USE_STACK
+#include <stdlib.h>
+#endif
+
+#define MAX_SECTION 50
+#define MAX_NAME 50
+
+/* Used by ini_parse_string() to keep track of string parsing state. */
+typedef struct {
+    const char* ptr;
+    size_t num_left;
+} ini_parse_string_ctx;
+
+/* Strip whitespace chars off end of given string, in place. Return s. */
+static char* rstrip(char* s)
+{
+    char* p = s + strlen(s);
+    while (p > s && isspace((unsigned char)(*--p)))
+        *p = '\0';
+    return s;
+}
+
+/* Return pointer to first non-whitespace char in given string. */
+static char* lskip(const char* s)
+{
+    while (*s && isspace((unsigned char)(*s)))
+        s++;
+    return (char*)s;
+}
+
+/* Return pointer to first char (of chars) or inline comment in given string,
+   or pointer to null at end of string if neither found. Inline comment must
+   be prefixed by a whitespace character to register as a comment. */
+static char* find_chars_or_comment(const char* s, const char* chars)
+{
+#if INI_ALLOW_INLINE_COMMENTS
+    int was_space = 0;
+    while (*s && (!chars || !strchr(chars, *s)) &&
+           !(was_space && strchr(INI_INLINE_COMMENT_PREFIXES, *s))) {
+        was_space = isspace((unsigned char)(*s));
+        s++;
+    }
+#else
+    while (*s && (!chars || !strchr(chars, *s))) {
+        s++;
+    }
+#endif
+    return (char*)s;
+}
+
+/* Version of strncpy that ensures dest (size bytes) is null-terminated. */
+static char* strncpy0(char* dest, const char* src, size_t size)
+{
+    strncpy(dest, src, size);
+    dest[size - 1] = '\0';
+    return dest;
+}
+
+/* See documentation in header file. */
+int ini_parse_stream(ini_reader reader, void* stream, ini_handler handler,
+                     void* user)
+{
+    /* Uses a fair bit of stack (use heap instead if you need to) */
+#if INI_USE_STACK
+    char line[INI_MAX_LINE];
+#else
+    char* line;
+#endif
+    char section[MAX_SECTION] = "";
+    char prev_name[MAX_NAME] = "";
+
+    char* start;
+    char* end;
+    char* name;
+    char* value;
+    int lineno = 0;
+    int error = 0;
+
+#if !INI_USE_STACK
+    line = (char*)malloc(INI_MAX_LINE);
+    if (!line) {
+        return -2;
+    }
+#endif
+
+#if INI_HANDLER_LINENO
+#define HANDLER(u, s, n, v) handler(u, s, n, v, lineno)
+#else
+#define HANDLER(u, s, n, v) handler(u, s, n, v)
+#endif
+
+    /* Scan through stream line by line */
+    while (reader(line, INI_MAX_LINE, stream) != NULL) {
+        lineno++;
+
+        start = line;
+#if INI_ALLOW_BOM
+        if (lineno == 1 && (unsigned char)start[0] == 0xEF &&
+                           (unsigned char)start[1] == 0xBB &&
+                           (unsigned char)start[2] == 0xBF) {
+            start += 3;
+        }
+#endif
+        start = lskip(rstrip(start));
+
+        if (*start == ';' || *start == '#') {
+            /* Per Python configparser, allow both ; and # comments at the
+               start of a line */
+        }
+#if INI_ALLOW_MULTILINE
+        else if (*prev_name && *start && start > line) {
+            /* Non-blank line with leading whitespace, treat as continuation
+               of previous name's value (as per Python configparser). */
+            if (!HANDLER(user, section, prev_name, start) && !error)
+                error = lineno;
+        }
+#endif
+        else if (*start == '[') {
+            /* A "[section]" line */
+            end = find_chars_or_comment(start + 1, "]");
+            if (*end == ']') {
+                *end = '\0';
+                strncpy0(section, start + 1, sizeof(section));
+                *prev_name = '\0';
+            }
+            else if (!error) {
+                /* No ']' found on section line */
+                error = lineno;
+            }
+        }
+        else if (*start) {
+            /* Not a comment, must be a name[=:]value pair */
+            end = find_chars_or_comment(start, "=:");
+            if (*end == '=' || *end == ':') {
+                *end = '\0';
+                name = rstrip(start);
+                value = end + 1;
+#if INI_ALLOW_INLINE_COMMENTS
+                end = find_chars_or_comment(value, NULL);
+                if (*end)
+                    *end = '\0';
+#endif
+                value = lskip(value);
+                rstrip(value);
+
+                /* Valid name[=:]value pair found, call handler */
+                strncpy0(prev_name, name, sizeof(prev_name));
+                if (!HANDLER(user, section, name, value) && !error)
+                    error = lineno;
+            }
+            else if (!error) {
+                /* No '=' or ':' found on name[=:]value line */
+                error = lineno;
+            }
+        }
+
+#if INI_STOP_ON_FIRST_ERROR
+        if (error)
+            break;
+#endif
+    }
+
+#if !INI_USE_STACK
+    free(line);
+#endif
+
+    return error;
+}
+
+/* See documentation in header file. */
+int ini_parse_file(FILE* file, ini_handler handler, void* user)
+{
+    return ini_parse_stream((ini_reader)fgets, file, handler, user);
+}
+
+/* See documentation in header file. */
+int ini_parse(const char* filename, ini_handler handler, void* user)
+{
+    FILE* file;
+    int error;
+
+    file = fopen(filename, "r");
+    if (!file)
+        return -1;
+    error = ini_parse_file(file, handler, user);
+    fclose(file);
+    return error;
+}
+
+/* An ini_reader function to read the next line from a string buffer. This
+   is the fgets() equivalent used by ini_parse_string(). */
+static char* ini_reader_string(char* str, int num, void* stream) {
+    ini_parse_string_ctx* ctx = (ini_parse_string_ctx*)stream;
+    const char* ctx_ptr = ctx->ptr;
+    size_t ctx_num_left = ctx->num_left;
+    char* strp = str;
+    char c;
+
+    if (ctx_num_left == 0 || num < 2)
+        return NULL;
+
+    while (num > 1 && ctx_num_left != 0) {
+        c = *ctx_ptr++;
+        ctx_num_left--;
+        *strp++ = c;
+        if (c == '\n')
+            break;
+        num--;
+    }
+
+    *strp = '\0';
+    ctx->ptr = ctx_ptr;
+    ctx->num_left = ctx_num_left;
+    return str;
+}
+
+/* See documentation in header file. */
+int ini_parse_string(const char* string, ini_handler handler, void* user) {
+    ini_parse_string_ctx ctx;
+
+    ctx.ptr = string;
+    ctx.num_left = strlen(string);
+    return ini_parse_stream((ini_reader)ini_reader_string, &ctx, handler,
+                            user);
+}

data/ext/inih/inih.c

@@ -0,0 +1,79 @@
+#include "inih.h"
+
+VALUE mINIH = Qnil;
+
+static int mINIH_ini_handler(void *data, const char *sect, const char *name, const char *val);
+
+/*
+    @overload parse(string)
+        Parse an INI-formatted string into a Hash.
+        @param string [String] the INI-formatted string to parse
+        @return [Hash] the resulting hash
+        @raise [RuntimeError] if a parse error occurs
+*/
+static VALUE mINIH_parse(VALUE self, VALUE string);
+
+/*
+    @overload load(filename)
+        Parse an INI-formatted file into a Hash.
+        @param filename [String] the INI-formatted file to parse
+        @return [Hash] the resulting hash
+        @raise [RuntimeError] if a parse or I/O error occurs
+*/
+static VALUE mINIH_load(VALUE self, VALUE filename);
+
+void Init_inih()
+{
+    mINIH = rb_define_module("INIH");
+
+    rb_define_singleton_method(mINIH, "parse", mINIH_parse, 1);
+    rb_define_singleton_method(mINIH, "load", mINIH_load, 1);
+}
+
+static int mINIH_ini_handler(void *data, const char *sect, const char *name, const char *val)
+{
+    VALUE sect_s = rb_str_new_cstr(sect);
+    VALUE name_s = rb_str_new_cstr(name);
+    VALUE hash = *((VALUE *) data);
+    VALUE subh = rb_hash_aref(hash, sect_s);
+
+    if (NIL_P(subh)) {
+        subh = rb_hash_new();
+    }
+
+    rb_hash_aset(subh, name_s, rb_str_new_cstr(val));
+    rb_hash_aset(hash, sect_s, subh);
+
+    return 1;
+}
+
+static VALUE mINIH_parse(VALUE self, VALUE string)
+{
+    char *str = StringValueCStr(string);
+    VALUE hash = rb_hash_new();
+    int result;
+
+    if ((result = ini_parse_string(str, mINIH_ini_handler, &hash)) != 0) {
+        rb_raise(rb_eRuntimeError, "parse error, line %d", result);
+    }
+
+    return rb_funcall(mINIH, rb_intern("normalize"), 1, hash);
+}
+
+static VALUE mINIH_load(VALUE self, VALUE filename)
+{
+    char *file = StringValueCStr(filename);
+    VALUE hash = rb_hash_new();
+    int result;
+
+    if ((result = ini_parse(file, mINIH_ini_handler, &hash)) != 0) {
+        if (result < 0) {
+            rb_raise(rb_eRuntimeError, "I/O error");
+        }
+        else {
+            rb_raise(rb_eRuntimeError, "parse error, line %d", result);
+        }
+    }
+
+    return rb_funcall(mINIH, rb_intern("normalize"), 1, hash);
+}

data/lib/inih.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../ext/inih/inih"
+
+# The primary namespace for {INIH}.
+module INIH
+  # The current version of ruby-inih.
+  VERSION = "0.0.1"
+
+  # Normalize a parsed INI file's values.
+  # @api private
+  def self.normalize(hsh)
+    hsh.map do |k, sect|
+      [k, normalize_sect(sect)]
+    end.to_h
+  end
+
+  # Normalize the values in a section of a parsed INI file.
+  # @api private
+  def self.normalize_sect(sect)
+    sect.map do |k, v|
+      nv = case v
+           when "true" then true
+           when "false" then false
+           when /\A\d+\Z/ then Integer v
+           when /\A\d+\.\d+\Z/ then Float v
+           else v
+           end
+
+      [k, nv]
+    end.to_h
+  end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: inih
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- William Woodruff
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-21 00:00:00.000000000 Z
+dependencies: []
+description: A native library for parsing INI files.
+email: william@tuffbizz.com
+executables: []
+extensions:
+- ext/inih/extconf.rb
+extra_rdoc_files: []
+files:
+- ".yardopts"
+- LICENSE
+- README.md
+- ext/inih/extconf.rb
+- ext/inih/ini.c
+- ext/inih/inih.c
+- lib/inih.rb
+homepage: https://github.com/woodruffw/ruby-ini
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.11
+signing_key: 
+specification_version: 4
+summary: inih - a Ruby wrapper for a simple C INI parser
+test_files: []