kernaux 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '078f989c6f70ebb33c1ff245a798297a7a49cc4ba74d85419fc96b95b10cbdac'
+  data.tar.gz: 721beddda4f2298c0ca5dc3def0f89433233bde20e81d132c6d9837e7e6618dc
+SHA512:
+  metadata.gz: ddf579b82989bd3a934d77decdef1abf0b7a0bb8efbe6aea31413da8408bc896b12eed1c5062e03d40df5104ed9a80e195ab26d952d8b570bd045c753cc7045d
+  data.tar.gz: 867170c6daa04632b286ecd91855d9a4cd5b407d63e433eb37e99cd68d56c4ae247e0e98424df8377bf2a7604f409f83db580d11b80663a3bbffeff9f681372d

data/.gitignore

@@ -0,0 +1,44 @@
+*.gem
+*.rbc
+*.so
+
+/.byebug_history
+/.config/
+/.rake_tasks~
+/InstalledFiles/
+/pkg/
+/tmp/
+
+# Used by dotenv library to load environment variables.
+/.env
+
+# RSpec configuration and generated files.
+/.rspec
+/coverage/
+/spec/examples.txt
+/spec/reports/
+/test/tmp/
+/test/version_tmp/
+
+# Documentation cache and generated files.
+/.yardoc/
+/_yardoc/
+/doc/
+/rdoc/
+
+# Environment normalization.
+/.bundle/
+/vendor/bundle/
+/lib/bundler/man/
+
+# For a library or gem, you might want to ignore these files since the code is
+# intended to run in multiple environments; otherwise, check them in.
+/Gemfile.lock
+/.ruby-version
+/.ruby-gemset
+
+# Unless supporting rvm < 1.11.0 or doing something fancy, ignore this.
+/.rvmrc
+
+# Used by RuboCop. Remote config files pulled in from inherit_from directive.
+/.rubocop-https?--*

data/.rubocop.yml

@@ -0,0 +1,77 @@
+require:
+  - rubocop-performance
+  - rubocop-rake
+  - rubocop-rspec
+
+AllCops:
+  TargetRubyVersion: 3.0
+  DisplayCopNames: true
+  NewCops: enable
+
+Layout/AccessModifierIndentation:
+  EnforcedStyle: outdent
+
+Layout/LineLength:
+  Max: 80
+  Exclude:
+    - 'spec/lib/kernaux/sprintf_spec.rb'
+
+Lint/AmbiguousOperatorPrecedence:
+  Enabled: false
+
+Lint/ReturnInVoidContext:
+  Enabled: false
+
+Metrics/BlockLength:
+  Exclude:
+    - '*.gemspec'
+    - 'Rakefile'
+    - 'spec/**/*_spec.rb'
+
+RSpec/ContextWording:
+  Prefixes:
+    - 'and'
+    - 'for'
+    - 'using'
+    - 'when'
+    - 'with'
+    - 'without'
+
+RSpec/FilePath:
+  CustomTransform:
+    KernAux: kernaux
+
+RSpec/ExampleLength:
+  CountAsOne: ['array', 'hash', 'heredoc']
+
+Style/AndOr:
+  EnforcedStyle: conditionals
+
+Style/Documentation:
+  Exclude:
+    - 'Rakefile'
+
+Style/DoubleNegation:
+  Enabled: false
+
+Style/GlobalVars:
+  Exclude:
+    - 'ext/*/extconf.rb'
+
+Style/HashAsLastArrayItem:
+  Enabled: false
+
+Style/PerlBackrefs:
+  Enabled: false
+
+Style/TrailingCommaInArguments:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInArrayLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/TrailingCommaInHashLiteral:
+  EnforcedStyleForMultiline: comma
+
+Style/VariableInterpolation:
+  Enabled: false

data/.simplecov

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+if ENV['SKIP_COVERAGE'].to_s.empty?
+  SimpleCov.start do
+    minimum_coverage 95
+
+    add_filter '/spec/'
+  end
+end

data/.yardopts

@@ -0,0 +1,4 @@
+--markup markdown
+--readme README.md
+--protected
+--private

data/Gemfile

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in kernaux.gemspec
+gemspec
+
+gem 'simplecov', require: false

data/README.md

@@ -0,0 +1,29 @@
+::KernAux
+=========
+
+[![Build status](https://github.com/tailix/libkernaux/actions/workflows/ruby.yml/badge.svg)](https://github.com/tailix/libkernaux/actions/workflows/ruby.yml)
+[![Build status (FreeBSD)](https://api.cirrus-ci.com/github/tailix/libkernaux.svg?task=Ruby%20(FreeBSD))](https://cirrus-ci.com/github/tailix/libkernaux)
+
+Binding to [libkernaux](https://github.com/tailix/libkernaux) - auxiliary
+library for kernel development.
+
+
+
+Install
+-------
+
+Add the following to your `Gemfile`:
+
+```ruby
+gem 'kernaux', '~> 0.3.0'
+```
+
+Or add the following to your `*.gemspec`:
+
+```ruby
+Gem::Specification.new do |spec|
+  # ...
+  spec.add_runtime_dependency 'kernaux', '~> 0.3.0'
+  # ...
+end
+```

data/Rakefile

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+
+module Bundler
+  class GemHelper
+    def tag_version(*)
+      yield if block_given?
+    end
+
+    def git_push(*); end
+
+    def perform_git_push(*); end
+  end
+end
+
+CLEAN << '.yardoc'
+CLEAN << 'coverage'
+CLEAN << 'doc'
+CLEAN << 'spec/examples.txt'
+
+desc 'Run default checks'
+task default: %i[test lint yard:cov]
+
+desc 'Run tests'
+task test: :spec
+
+desc 'Run code analysis tools'
+task lint: :rubocop
+
+desc 'Fix code style (rubocop --auto-correct)'
+task fix: 'rubocop:auto_correct'
+
+begin
+  require 'rspec/core/rake_task'
+  RSpec::Core::RakeTask.new
+rescue LoadError
+  nil
+end
+
+begin
+  require 'rubocop/rake_task'
+  RuboCop::RakeTask.new
+rescue LoadError
+  nil
+end
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  nil
+end
+
+begin
+  require 'rake/extensiontask'
+  Rake::ExtensionTask.new 'default' do |ext|
+    ext.lib_dir = 'lib/kernaux'
+  end
+rescue LoadError
+  nil
+end
+
+desc 'Open development console'
+task :console do
+  sh 'bundle', 'exec', File.expand_path(File.join('bin', 'console'), __dir__)
+end
+
+namespace :yard do
+  desc 'Measure documentation coverage'
+  task :cov do
+    result = `bundle exec yard stats`.lines.last.strip.freeze
+    m = result.match(/\A(\d+(\.\d+)?)% documented\z/)
+    raise 'Invalid result' if m.nil?
+
+    coverage = m[1].to_f.round(2)
+    puts "Documentation coverage: #{coverage}%"
+    raise 'Not fully documented!' if coverage != 100
+  end
+end

data/bin/console

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'kernaux'
+require 'pry'
+
+Pry.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/sh
+
+set -eux
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/default/assert.c

@@ -0,0 +1,62 @@
+#include <kernaux.h>
+#include <ruby.h>
+
+static void assert_cb(const char *file, int line, const char *msg);
+
+static VALUE rb_KernAux_assert_cb(VALUE self);
+static VALUE rb_KernAux_assert_cb_EQ(VALUE self, VALUE assert_cb);
+static
+VALUE rb_KernAux_assert_do(VALUE self, VALUE file, VALUE line, VALUE msg);
+
+static ID rb_intern_call = Qnil;
+static VALUE rb_KernAux = Qnil;
+
+void init_assert()
+{
+    rb_gc_register_mark_object(ID2SYM(rb_intern_call = rb_intern("call")));
+    rb_gc_register_mark_object(rb_KernAux = rb_define_module("KernAux"));
+
+    kernaux_assert_cb = assert_cb;
+
+    rb_define_singleton_method(rb_KernAux, "assert_cb",
+                               rb_KernAux_assert_cb, 0);
+    rb_define_singleton_method(rb_KernAux, "assert_cb=",
+                               rb_KernAux_assert_cb_EQ, 1);
+    rb_define_singleton_method(rb_KernAux, "assert_do",
+                               rb_KernAux_assert_do, 3);
+}
+
+void assert_cb(const char *const file, const int line, const char *const msg)
+{
+    const VALUE assert_cb_rb = rb_iv_get(rb_KernAux, "@assert_cb");
+    if (assert_cb_rb == Qnil) return;
+    const VALUE file_rb = rb_str_new2(file);
+    const VALUE line_rb = INT2FIX(line);
+    const VALUE msg_rb = rb_str_new2(msg);
+    rb_funcall(assert_cb_rb, rb_intern_call, 3, file_rb, line_rb, msg_rb);
+}
+
+VALUE rb_KernAux_assert_cb(const VALUE self)
+{
+    return rb_iv_get(self, "@assert_cb");
+}
+
+VALUE rb_KernAux_assert_cb_EQ(const VALUE self, const VALUE assert_cb_rb)
+{
+    return rb_iv_set(self, "@assert_cb", assert_cb_rb);
+}
+
+VALUE rb_KernAux_assert_do(
+    const VALUE self_rb __attribute__((unused)),
+    VALUE file_rb,
+    const VALUE line_rb,
+    VALUE msg_rb
+) {
+    const char *const file = StringValueCStr(file_rb);
+    const int line = FIX2INT(line_rb);
+    const char *const msg = StringValueCStr(msg_rb);
+
+    kernaux_assert_do(file, line, msg);
+
+    return Qnil;
+}

data/ext/default/cmdline.c

@@ -0,0 +1,95 @@
+#include <kernaux.h>
+#include <ruby.h>
+
+#ifdef HAVE_KERNAUX_CMDLINE
+
+#define ARGV_COUNT_MAX 256
+#define BUFFER_SIZE 4096
+
+struct Data {
+    char error_msg[KERNAUX_CMDLINE_ERROR_MSG_SIZE_MAX];
+    char *argv[ARGV_COUNT_MAX];
+    char buffer[BUFFER_SIZE];
+};
+
+static VALUE rb_ANON_Data_ALLOC(VALUE klass);
+static VALUE rb_KernAux_cmdline(VALUE self, VALUE cmdline);
+
+static const struct rb_data_type_struct info = {
+    .wrap_struct_name = "cmdline",
+    .function = {
+        .dmark = NULL,
+        .dfree = RUBY_DEFAULT_FREE,
+        .dsize = NULL,
+        .dcompact = NULL,
+        .reserved = { 0 },
+    },
+    .parent = NULL,
+    .data = NULL,
+    .flags = RUBY_TYPED_FREE_IMMEDIATELY,
+};
+
+static ID rb_intern_freeze = Qnil;
+static ID rb_intern_new = Qnil;
+
+static VALUE rb_KernAux = Qnil;
+static VALUE rb_KernAux_Error = Qnil;
+static VALUE rb_KernAux_CmdlineError = Qnil;
+static VALUE rb_ANON_Data = Qnil;
+
+void init_cmdline()
+{
+    rb_gc_register_mark_object(ID2SYM(rb_intern_freeze = rb_intern("freeze")));
+    rb_gc_register_mark_object(ID2SYM(rb_intern_new    = rb_intern("new")));
+
+    rb_gc_register_mark_object(rb_KernAux = rb_define_module("KernAux"));
+    rb_gc_register_mark_object(rb_KernAux_Error =
+        rb_define_class_under(rb_KernAux, "Error", rb_eRuntimeError));
+    rb_gc_register_mark_object(rb_KernAux_CmdlineError =
+        rb_define_class_under(rb_KernAux, "CmdlineError", rb_KernAux_Error));
+    rb_gc_register_mark_object(rb_ANON_Data =
+        rb_funcall(rb_cClass, rb_intern_new, 1, rb_cObject));
+
+    rb_define_alloc_func(rb_ANON_Data, rb_ANON_Data_ALLOC);
+    rb_define_singleton_method(rb_KernAux, "cmdline", rb_KernAux_cmdline, 1);
+}
+
+VALUE rb_ANON_Data_ALLOC(const VALUE klass)
+{
+    struct Data *data;
+    return TypedData_Make_Struct(klass, struct Data, &info, data);
+}
+
+VALUE rb_KernAux_cmdline(const VALUE self_rb, VALUE cmdline_rb)
+{
+    const char *const cmdline = StringValueCStr(cmdline_rb);
+    size_t argc;
+
+    const VALUE data_rb = rb_funcall(rb_ANON_Data, rb_intern_new, 0);
+    struct Data *data;
+    TypedData_Get_Struct(data_rb, struct Data, &info, data);
+    if (!data) rb_raise(rb_KernAux_CmdlineError, "internal error");
+
+    const bool result = kernaux_cmdline(
+        cmdline,
+        data->error_msg,
+        &argc,
+        data->argv,
+        data->buffer,
+        ARGV_COUNT_MAX,
+        BUFFER_SIZE
+    );
+
+    if (!result) rb_raise(rb_KernAux_CmdlineError, "%s", data->error_msg);
+
+    VALUE result_rb = rb_ary_new2(argc);
+    for (size_t index = 0; index < argc; ++index) {
+        rb_ary_push(
+            result_rb,
+            rb_funcall(rb_str_new2(data->argv[index]), rb_intern_freeze, 0)
+        );
+    }
+    return rb_funcall(result_rb, rb_intern_freeze, 0);
+}
+
+#endif // HAVE_KERNAUX_CMDLINE

data/ext/default/dynarg.c

@@ -0,0 +1,45 @@
+#include "dynarg.h"
+
+struct DynArg DynArg_create()
+{
+    struct DynArg dynarg;
+    DynArg_init(&dynarg);
+    return dynarg;
+}
+
+void DynArg_init(struct DynArg *const dynarg)
+{
+    dynarg->use_dbl = false;
+    dynarg->dbl = 0.0;
+    dynarg->arg.str = "";
+}
+
+void DynArg_use_char(struct DynArg *const dynarg, const char chr)
+{
+    dynarg->use_dbl = false;
+    dynarg->arg.chr = chr;
+}
+
+void DynArg_use_double(struct DynArg *const dynarg, const double dbl)
+{
+    dynarg->use_dbl = true;
+    dynarg->dbl = dbl;
+}
+
+void DynArg_use_long_long(struct DynArg *const dynarg, const long long ll)
+{
+    dynarg->use_dbl = false;
+    dynarg->arg.ll = ll;
+}
+
+void DynArg_use_str(struct DynArg *const dynarg, const char *const str)
+{
+    dynarg->use_dbl = false;
+    dynarg->arg.str = str;
+}
+
+void DynArg_use_unsigned_long_long(struct DynArg *const dynarg, const unsigned long long ull)
+{
+    dynarg->use_dbl = false;
+    dynarg->arg.ull = ull;
+}

data/ext/default/dynarg.h

@@ -0,0 +1,35 @@
+#ifndef INCLUDED_DYNARG
+#define INCLUDED_DYNARG
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+
+struct DynArg {
+    bool use_dbl;
+    double dbl;
+    // TODO: check if this will work on different endianness.
+    union {
+        char chr;
+        long long ll;
+        const char *str;
+        unsigned long long ull;
+    } __attribute__((packed)) arg;
+};
+
+struct DynArg DynArg_create();
+void DynArg_init(struct DynArg *dynarg);
+
+void DynArg_use_char(struct DynArg *dynarg, char chr);
+void DynArg_use_double(struct DynArg *dynarg, double dbl);
+void DynArg_use_long_long(struct DynArg *dynarg, long long ll);
+void DynArg_use_str(struct DynArg *dynarg, const char *str);
+void DynArg_use_unsigned_long_long(struct DynArg *dynarg, unsigned long long ull);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

data/ext/default/extconf.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'mkmf'
+
+$CFLAGS += ' -pedantic -Wall -Wextra'
+
+raise 'libkernaux not found' unless have_library 'kernaux'
+
+raise 'kernaux_assert_do not found' unless have_func 'kernaux_assert_do'
+unless have_var 'kernaux_assert_cb', 'kernaux.h'
+  raise 'kernaux_assert_cb not found'
+end
+
+have_func 'kernaux_utoa'
+have_func 'kernaux_itoa'
+have_func 'kernaux_utoa10'
+have_func 'kernaux_itoa10'
+have_func 'kernaux_utoa16'
+have_func 'kernaux_itoa16'
+
+have_func 'kernaux_snprintf'
+
+# TODO: do something if not found?
+have_func 'KernAux_PrintfFmt_Spec_create'
+have_func 'KernAux_PrintfFmt_Spec_parse'
+have_func 'KernAux_PrintfFmt_Spec_set_width'
+have_func 'KernAux_PrintfFmt_Spec_set_precision'
+
+have_func 'kernaux_cmdline'
+
+raise 'can\'t create Makefile' unless create_makefile 'kernaux/default'

data/ext/default/main.c

@@ -0,0 +1,28 @@
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <kernaux.h>
+#include <ruby.h>
+
+void init_assert();
+void init_ntoa();
+#ifdef HAVE_KERNAUX_SNPRINTF
+void init_printf();
+#endif // HAVE_KERNAUX_SNPRINTF
+#ifdef HAVE_KERNAUX_CMDLINE
+void init_cmdline();
+#endif // HAVE_KERNAUX_CMDLINE
+
+void Init_default()
+{
+    init_assert();
+    init_ntoa();
+#ifdef HAVE_KERNAUX_SNPRINTF
+    init_printf();
+#endif // HAVE_KERNAUX_SNPRINTF
+#ifdef HAVE_KERNAUX_CMDLINE
+    init_cmdline();
+#endif // HAVE_KERNAUX_CMDLINE
+}