June 2018 Update

Task/Simple-database/Kotlin/simple-database.kotlin

@@ -0,0 +1,110 @@
+// version 1.2.31
+
+import java.text.SimpleDateFormat
+import java.util.Date
+import java.io.File
+import java.io.IOException
+
+val file = File("simdb.csv")
+
+class Item(
+    val name: String,
+    val date: String,
+    val category: String
+) : Comparable<Item> {
+
+    override fun compareTo(other: Item) = date.compareTo(other.date)
+
+    override fun toString() = "$name, $date, $category"
+}
+
+fun addItem(input: Array<String>) {
+    if (input.size < 2) {
+        printUsage()
+        return
+    }
+    val sdf = SimpleDateFormat("yyyy-MM-dd HH:mm:ss")
+    val date = sdf.format(Date())
+    val cat = if (input.size == 3) input[2] else "none"
+    store(Item(input[1], date, cat))
+}
+
+fun printLatest(a: Array<String>) {
+    val db = load()
+    if (db.isEmpty()) {
+        println("No entries in database.")
+        return
+    }
+    // no need to sort db as items are added chronologically
+    if (a.size == 2) {
+        var found = false
+        for (item in db.reversed()) {
+            if (item.category == a[1]) {
+                println(item)
+                found = true
+                break
+            }
+        }
+        if (!found) println("There are no items for category '${a[1]}'")
+    }
+    else println(db[db.lastIndex])
+}
+
+fun printAll() {
+    val db = load()
+    if (db.isEmpty()) {
+        println("No entries in database.")
+        return
+    }
+    // no need to sort db as items are added chronologically
+    for (item in db) println(item)
+}
+
+fun load(): MutableList<Item> {
+    val db = mutableListOf<Item>()
+    try {
+        file.forEachLine { line ->
+            val item = line.split(", ")
+            db.add(Item(item[0], item[1], item[2]))
+        }
+    }
+    catch (e: IOException) {
+        println(e)
+        System.exit(1)
+    }
+    return db
+}
+
+fun store(item: Item) {
+    try {
+        file.appendText("$item\n")
+    }
+    catch (e: IOException) {
+        println(e)
+    }
+}
+
+fun printUsage() {
+    println("""
+        |Usage:
+        |  simdb cmd [categoryName]
+        |  add     add item, followed by optional category
+        |  latest  print last added item(s), followed by optional category
+        |  all     print all
+        |  For instance: add "some item name" "some category name"
+    """.trimMargin())
+}
+
+fun main(args: Array<String>) {
+    if (args.size !in 1..3) {
+        printUsage()
+        return
+    }
+    file.createNewFile()  // create file if it doesn't already exist
+    when (args[0].toLowerCase()) {
+        "add"    -> addItem(args)
+        "latest" -> printLatest(args)
+        "all"    -> printAll()
+        else     -> printUsage()
+    }
+}

Task/Simple-database/Perl-6/simple-database-1.pl6

@@ -0,0 +1,104 @@
+#!/usr/bin/env perl6
+use JSON::Fast ;
+sub MAIN( :$server='0.0.0.0', :$port=3333, :$dbfile='db' ) {
+    my %db;
+    my %index;
+    my $dbdata = slurp "$dbfile.json" ;
+    my $indexdata = slurp "{$dbfile}_index.json" ;
+    %db = from-json($dbdata) if $dbdata ;
+    %index = from-json($indexdata) if $indexdata ;
+  react {
+    whenever IO::Socket::Async.listen( $server , $port ) -> $conn {
+        whenever $conn.Supply.lines -> $line {
+            my %response = 'status' => '' ;
+            my $msg = from-json $line ;
+            say $msg.perl ;
+            given $msg<function> {
+                when 'set' {
+                    %db{ $msg<topic> } = $msg<message> ;
+                    %response<status> = 'ok' ;
+                    %index<last_> = $msg<topic> ;
+                    for %index<keys_>.keys -> $key {
+                        if $msg<message>{$key} {
+                            %index<lastkey_>{ $key }{ $msg<message>{$key} } = $msg<topic> ;
+                            %index<idx_>{ $key }{ $msg<message>{$key} }{ $msg<topic> } = 1 ;
+                        }
+                    }
+                    spurt "$dbfile.json", to-json(%db);
+                    spurt "{$dbfile}_index.json", to-json(%index);
+                }
+                when 'get' {
+                    %response<topic> = $msg<topic> ;
+                    %response<message> = %db{ $msg<topic> } ;
+                    %response<status> = 'ok' ;
+                }
+                when 'dump' {
+                    %response{'data'} = %db ;
+                    %response<status> = 'ok' ;
+                }
+                when 'dumpindex' {
+                    %response{'data'} = %index ;
+                    %response<status> = 'ok' ;
+                }
+                when 'delete' {
+                    %db{ $msg<topic> }:delete;
+                    %response<status> = 'ok' ;
+                    spurt "$dbfile.json", to-json(%db);
+                    reindex();
+                }
+                when 'addindex' {
+                    %response<status> = 'ok' ;
+                    %index<keys_>{ $msg<key>} =1 ;
+                    reindex();
+                }
+                when 'reportlast' {
+                    %response{'data'} = %db{%index<last_>} ;
+                    %response<status> = 'ok' ;
+                }
+                when 'reportlastindex' {
+                    %response<key> = $msg<key> ;
+                    for %index<lastkey_>{$msg<key>}.keys -> $value {
+                        #%response{'data'}.push: %db{ %index<lastkey_>{ $msg<key>  }{ $value } } ;
+                        %response{'data'}{$value} = %db{ %index<lastkey_>{ $msg<key>  }{ $value } } ;
+                    }
+                    %response<status> = 'ok' ;
+                }
+                when 'reportindex' {
+                    %response<status> = 'ok' ;
+                    for %index<idx_>{$msg<key>}.keys.sort -> $value  {
+                        for %index<idx_>{ $msg<key> }{ $value }.keys.sort -> $topic {
+                            %response<data>.push:  %db{ $topic }  ;
+                            #%response<data>{$value} = %db{ $topic }  ;
+                        }
+                    }
+                }
+                when 'commit' {
+                    spurt "$dbfile.json", to-json(%db);
+                    spurt "{$dbfile}_index.json", to-json(%index);
+                    %response<status> = 'ok' ;
+                }
+                default {
+                    %response<status> = 'error';
+                    %response<error> = 'no function or not supported';
+                }
+            }
+            $conn.print( to-json(%response, :!pretty) ~ "\n" ) ;
+            LAST { $conn.close ; }
+            QUIT { default { $conn.close ; say "oh no, $_";}}
+            CATCH { default { say .^name, ': ', .Str ,  " handled in $?LINE";}}
+        }
+    }
+  }
+    sub reindex {
+        %index<idx_>:delete;
+        for %db.keys -> $topic {
+            my $msg = %db{$topic} ;
+            for %index<keys_>.keys -> $key {
+                if $msg{$key} {
+                    %index<idx_>{ $key }{ $msg{$key} }{ $topic } = 1 ;
+                }
+            }
+        }
+        spurt "{$dbfile}_index.json", to-json(%index) ;
+    }
+}

Task/Simple-database/Perl-6/simple-database-2.pl6

@@ -0,0 +1,50 @@
+#!/usr/bin/env perl6
+use JSON::Fast ;
+multi MAIN('set', $topic,  $message='', :$server='localhost', :$port='3333', :$json='') {
+    my %msg = function => 'set' , topic=> $topic , message=> $message ;
+    %msg{"message"} = from-json( $json ) if $json ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('add', $topic,  $json, :$server='localhost', :$port='3333' ) {
+    my %msg = function => 'set' , topic=> $topic;
+    %msg{"message"} = from-json( $json ) if $json ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('get', $topic, :$server='localhost', :$port='3333') {
+    my %msg = function => 'get' , topic=> $topic ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('delete', $topic, :$server='localhost', :$port='3333') {
+    my %msg = function => 'delete' , topic=> $topic ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('dump', :$server='localhost', :$port='3333') {
+    my %msg = function => 'dump'  ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('addindex', $key, :$server='localhost', :$port='3333') {
+    my %msg = function => 'addindex', key => $key  ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('reportindex', $key, :$server='localhost', :$port='3333') {
+    my %msg = function => 'reportindex', key => $key  ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('reportlastindex', $key, :$server='localhost', :$port='3333') {
+    my %msg = function => 'reportlastindex', key => $key  ;
+    sendmsg( %msg , $server, $port) ;
+}
+multi MAIN('reportlast', :$server='localhost', :$port='3333') {
+    my %msg = function => 'reportlast' ;
+    sendmsg( %msg , $server, $port) ;
+}
+sub sendmsg( %msg , $server, $port){
+    my $conn = await IO::Socket::Async.connect( $server , $port );
+    $conn.print: to-json( %msg,:!pretty)~"\n";
+    react {
+        whenever $conn.Supply -> $data {
+            print $data;
+            $conn.close;
+        }
+    }
+}

Task/Simple-database/Perl/simple-database.pl

@@ -0,0 +1,118 @@
+#!/usr/bin/perl
+use warnings;
+use strict;
+use feature qw{ say };
+
+use JSON::PP;
+use Time::Piece;
+
+use constant {
+    NAME     => 0,
+    CATEGORY => 1,
+    DATE     => 2,
+    DB       => 'simple-db',
+};
+
+my $operation = shift // "";
+
+my %dispatch = (
+    n => \&add_new,
+    l => \&print_latest,
+    L => \&print_latest_for_categories,
+    a => \&print_all,
+);
+
+if ($dispatch{$operation}) {
+    $dispatch{$operation}->(@ARGV);
+} else {
+    die "Invalid option. Use one of n, l, L, a.\n"
+}
+
+sub add_new {
+    my ($name, $category, $date) = @_;
+    my $db = eval { load() } || {};
+    if (defined $date) {
+        eval { 'Time::Piece'->strptime($date, '%Y-%m-%d'); 1 }
+            or die "Invalid date format: YYYY-MM-DD.\n";
+
+    } else {
+        $date //= localtime->ymd;
+    }
+
+    my @ids = keys %{ $db->{by_id} };
+    my $max_id = max(num => @ids) || 0;
+    $db->{by_id}{ ++$max_id } = [ $name, $category, $date ];
+    save($db);
+}
+
+sub print_latest {
+    build_indexes( my $db = load(), 0, 1 );
+    _print_latest($db);
+}
+
+sub _print_latest {
+    my ($db, $category) = @_;
+    my @dates = keys %{ $db->{by_date} };
+    @dates = grep {
+        grep $db->{by_id}{$_}[CATEGORY] eq $category,
+            @{ $db->{by_date}{$_} };
+    } @dates if defined $category;
+
+    my $last_date = max(str => @dates);
+    say for map $db->{by_id}{$_}[NAME],
+            grep ! defined $category
+                 || $db->{by_id}{$_}[CATEGORY] eq $category,
+            @{ $db->{by_date}{$last_date} };
+}
+
+sub max {
+    my $type = shift;
+    my $max = $_[0];
+    { num => sub { $_ >  $max },
+      str => sub { $_ gt $max},
+    }->{$type}->() and $max = $_
+        for @_[ 1 .. $#_ ];
+    return $max
+}
+
+sub print_latest_for_categories {
+    build_indexes( my $db = load(), 1, 1 );
+
+    for my $category (sort keys %{ $db->{by_category} }){
+        say "* $category";
+        _print_latest($db, $category);
+    }
+}
+
+sub print_all {
+    build_indexes( my $db = load(), 0, 1 );
+
+    for my $date (sort keys %{ $db->{by_date} }) {
+        for my $id (@{ $db->{by_date}{$date} }) {
+            say $db->{by_id}{$id}[NAME];
+        }
+    }
+}
+
+sub load {
+    open my $in, '<', DB or die "Can't open database: $!\n";
+    local $/;
+    return { by_id => decode_json(<$in>) };
+}
+
+sub save {
+    my ($db) = @_;
+    open my $out, '>', DB or die "Can't save database: $!\n";
+    print {$out} encode_json($db->{by_id});
+    close $out;
+}
+
+sub build_indexes {
+    my ($db, $by_category, $by_date) = @_;
+    for my $id (keys %{ $db->{by_id} }) {
+        push @{ $db->{by_category}{ $db->{by_id}{$id}[CATEGORY] } }, $id
+            if $by_category;
+        push @{ $db->{by_date}{ $db->{by_id}{$id}[DATE] } }, $id
+            if $by_date;
+    }
+}