Rosetta Code/Find unimplemented tasks: Difference between revisions

{{libheader|AWS}}

Parsing XML with XMLAda from Adacore

with Dom.Readers, Dom.Core, Dom.Core.Documents, Dom.Core.Nodes, Dom.Core.Attrs;

with Input_Sources.Strings, Unicode, Unicode.Ces.Utf8;

("Numbers of tasks not implemented :=" &

Integer'Image (Last_Index ((All_Tasks))));

 

=={{header|AutoHotkey}}==

 

The GUI overkill version with comments.

#NoEnv ; do not resolve environment variables (speed)

#SingleInstance force ; allow only one instance

ExitApp ; exit the script

Return

===Output===

Loads a list of all languages. Pick the language you would like to see the unimplemented tasks of, press the button, double click the selected task to launch in default browser. It will download the languages to file and redownload if older than 3 days (to save unnecessary bandwith).

 

[[Image:Ahk_find_unimplemented.png‎]]

 

=={{header|C sharp|C#}}==

Using JSON (not parsed, just Regex.)

To help demonstrate paging, the cmlimit parameter has been omitted from the search query so that 10 rows are returned by default

 

using System.Collections.Generic;

using System.Linq;

foreach (string i in unimpl) Console.WriteLine(i);

}

 

=={{header|Clojure}}==

This uses a couple of core libraries, and a Java method for URL encoding.

'[clojure.xml :as xml]

'[clojure.set :as set]

'[clojure.string :as string])

 

The ''titles-cont'' function fetches and parses an XML response, and walks over it extracting titles. It also extracts the ''cmcontinue'' value, if present. Returns a pair ''[titles,cmcontinue]''.

(let [docseq (-> url xml/parse xml-seq)]

((juxt #(filter string? %), #(-> (filter map? %) first :cmcontinue))

(if (= tag :cm)

(attrs :title)

 

The ''get-titles'' function has 1- and 2-argument versions. The former takes the name of a category, composes the appropriate URL query, and calls the 2-argument version. The 2-argument version gets a title list (with possible ''cmcontinue'' value), chaining further calls as necessary into the lazy sequence result.

(defn param [p v] (str p (urlencode v)))

 

(if continue

(lazy-cat titles (get-titles url continue))

The ''unimplemented'' function gets a set of all titles and of language-implemented titles and returns the difference. It uses ''future'' in order to do the necessary URL requests in parallel.

(let [title-set #(future (apply sorted-set (get-titles %)))

all-titles (title-set "Programming_Tasks")

(doseq [title titles] (println title))

(println "count: " (count titles)))

 

=={{header|E}}==

Using JSON.

 

 

# NOTE: This program will not work in released E, because TermL is an

# If you build E from the latest source in SVN then it will work.

#

#

# Prints a list of tasks which have not been completed in the language.

# Whoops, something went wrong

stderr.println(`$p${p.eStack()}`)

 

=={{header|Erlang}}==

init_http/0 is used by many tasks. rosetta_code_list_of/1 is used by [[Rosetta_Code/Rank_languages_by_popularity]]

-module( find_unimplemented_tasks ).

-include_lib( "xmerl/include/xmerl.hrl" ).

xml_8211( 1052 ) -> $\s;

xml_8211( Character ) -> Character.

{{out}}

<pre>

=={{header|Go}}==

XML, stepping through the elements.

 

import (

continueAt = req(taskQuery+"&cmcontinue="+continueAt, printUnImp)

}

 

=={{header|Haskell}}==

{{libheader|HTTP XML}} from [http://hackage.haskell.org/packages/hackage.html HackageDB]

 

import Network.HTTP

import Network.URI

xml = onlyElems $ parseXML allTasks

allxx = concatMap (map (fromJust.findAttr (unqual "title")). filterElementsName (== unqual "cm")) xml

 

With only standard libraries

import Data.Text (splitOn, pack, unpack)

import Data.List

implTasks <- getTasks $ "http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:" ++ lang ++ "&format=json&cmlimit=500"

allTasks <- getTasks "http://rosettacode.org/mw/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&format=json&cmlimit=500"

 

=={{header|Icon}} and {{header|Unicon}}==

The following code only works in Unicon.

 

$define RCTASK "http://rosettacode.org/mw/index.php?action=raw&title="

$define RCUA "User-Agent: Unicon Rosetta 0.1"

close(page)

return text

 

Sample output (abridged):

=={{header|J}}==

'''Solution:'''

 

findUnimpTasks=: ('Programming_Tasks' -.&getCategoryMembers ,&'/Omit') ([ #~ -.@e.) getCategoryMembers

uri=. url ,'?', buildqry urlencode y

catmbrs=. qrycont=. ''

catmbrs=. catmbrs, parseTitles jsondat

end.

catmbrs

 

'''Example Usage:'''

 

=={{header|JavaScript}}==

For the narrower context of a browser in which the 'not implemented' page has been fetched for a particular language, we can however, evaluate an XPath expression in JavaScript to generate an array of titles for the unimplemented tasks.

 

var xr = document.evaluate(

strXPath,

})(

'//*[@id="mw-content-text"]/div[2]/table/tbody/tr/td/ul/li/a'

 

Output begins with:

Find limit of recursion

...</pre>

 

=={{header|Julia}}==

 

const enduri = "&cmlimit=500&format=json"

queries(x) = baseuri * HTTP.Strings.escapehtml(x) * enduri

showunimp("Julia")

showunimp("C++")

<pre>

Unimplemented in Julia:

{{libheader|lua-requests}}

 

local lang = arg[1]

 

for _, t in ipairs(open_tasks) do

io.write(string.format(' %s\n', t))

{{out}}

<pre>

 

=={{header|Maple}}==

lan := "Maple":

x := URL:-Get(cat("http://rosettacode.org/wiki/Reports:Tasks_not_implemented_in_", StringTools:-SubstituteAll(lan, " ", "_")), output = content):

for problem in x do

printf("%s\n", StringTools:-SubstituteAll(StringTools:-Decode(StringTools:-StringSplit(problem, "\" title=")[1], 'percent'), "_", " "));

{{Out|Output}}

<pre>#10:09 AM 10/05/2018

=={{header|Mathematica}}/{{header|Wolfram Language}}==

Two implementations are considered, the first will use the API to get all the programming tasks, then the ones implemented for a certain language, and take the difference. The other will use the Tasks not implemented page and strip the html.

ImportAll[lang_String] :=

Module[{data, continue, cmcontinue, extra, xml, next},

Cases[Flatten[data], HoldPattern["title" -> x_] :> x, \[Infinity]]

]

which outputs a list of items not implemented:

{{out}}

<pre>{Abstract type,Active Directory/Connect,Active Directory/Search for a user,Address of a variable,<<139>>,Write to Windows event log,Xiaolin Wu's line algorithm,Zeckendorf arithmetic}</pre>

Another method is by getting the Tasks not implemented page:

html = Import[url, "XMLObject"];

pos = Position[html, XMLElement["div", {"class" -> "mw-content-ltr", "dir" -> "ltr", "lang" -> "en"}, ___]];

newb = data[[All, 1]];

data = Hyperlink @@@ data;

{{out}}

<pre>Append a record to the end of a text file

 

=={{header|Nim}}==

 

 

 

var

cmcontinue = ""

client = newHttpClient()

 

cmcontinue.setLen(0)

let u = node.attr("cmcontinue")

if u.len != 0: cmcontinue = u.encodeUrl()

for task in alltasks:

if task notin langTasks:

 

{{out}}

 

By parsing XML and using an XPath-like mechanism:

[HTTPClient] = {Link ['x-ozlib://mesaros/net/HTTPClient.ozf']}

[XMLParser] = {Link ['x-oz://system/xml/Parser.ozf']}

in

%% show tasks not implemented in Oz

 

=={{header|Perl}}==

 

my $ua = LWP::UserAgent->new;

sub tasks {

my($category) = shift;

'action=query&generator=categorymembers&gcmtitle=Category:%s&gcmlimit=500&format=json&rawcontinue=';

my @tasks;

 

my %language = map {$_, 1} tasks shift || 'perl';

 

'''See also:''' [[User:ImplSearchBot/Code]]

{{libheader|Phix/libcurl}}

{{trans|Go}}

{{out}}

<pre>

 

=={{header|PicoLisp}}==

 

(de rosettaCategory (Cat)

(diff

(rosettaCategory "Programming_Tasks")

 

=={{header|PowerShell}}==

I don't think this script follows the spirit of the task, but it works.

function Find-UnimplementedTask

{

Select-String -Pattern "[^0-9A-Z]$" -CaseSensitive)

}

$tasks = Find-UnimplementedTask -Language PowerShell

 

$tasks[0..5],".`n.`n.",$tasks[-6..-1]

Write-Host "`nTotal unimplemented Tasks: $($tasks.Count)"

{{Out}}

<pre>

=={{header|Python}}==

==={{libheader|mwclient}}===

Given the name of a language on Rosetta Code,

finds all tasks which are not implemented in that language.

tasks = unimplemented_tasks('Python', url=URL, api_path=API_PATH)

print(*tasks, sep='\n')

 

==={{libheader|Requests}}===

Given the name of a language on Rosetta Code,

finds all tasks which are not implemented in that language.

request_params=REQUEST_PARAMETERS)

print(*tasks, sep='\n')

 

==={{libheader|urllib}}===

import urllib, sys

for i in [i for i in alltasks if i not in lang]:

 

=={{header|R}}==

{{libheader|XML (R)}}

find.unimplemented.tasks <- function(lang="R"){

PT <- xmlInternalTreeParse( paste("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml",sep="") )

find.unimplemented.tasks(lang="Python")

langs <- c("R","python","perl")

 

=={{header|Racket}}==

#lang racket

 

 

(show-unimplemented 'Racket) ; see all of the Racket entries

 

=={{header|Raku}}==

(formerly Perl 6)

{{works with|Rakudo|2018.04.1}}

use URI::Escape;

use JSON::Fast;

 

my $client = HTTP::UserAgent.new;

 

my @total;

 

say "Unimplemented tasks in $lang:";

 

sub get-cat ($category) {

}

 

 

=={{header|Ring}}==

# Project: Rosetta Code/Find unimplemented tasks

end

return sum

Output:

<pre>

 

Uses the <code>RosettaCode</code> module from [[Count programming examples#Ruby]]

require 'time'

 

]

end

 

Output for Ruby

Find tasks not implemented.

Select Language from DropDown and click [GO] or [Exit].

a$ = httpGet$("http://rosettacode.org/wiki/Category:Programming_Languages")

a$ = word$(a$,2,"mw-subcategories")

print "Total unImplemented Tasks:";c

[exit]

<table border=1>

<tr></tr>

 

=={{header|Rust}}==

use std::collections::{BTreeMap, HashSet};

 

}

}

{{out}}

<pre style="height: 32ex; overflow: scroll">

"com.softwaremill.sttp"%%"json4s"%"1.5.11")

 

import com.softwaremill.sttp.json4s._

import com.softwaremill.sttp.quick._

.foldRight(Set.empty[Task])((acc: Set[Task], ele: Set[Task]) => acc -- ele)

 

 

=={{header|Tcl}}==

 

{{tcllib|json}}{{tcllib|struct::set}}

package require http

package require json

foreach lang {Perl Python Ruby Tcl} {

get_unimplemented $lang

 

=={{header|Wren}}==

{{libheader|Wren-pattern}}

An embedded program so we can use the libcurl library.

 

import "./pattern" for Pattern

 

var findTasks = Fn.new { |category|

var cmcontinue = ""

var tasks = []

for (task in tasks2) {

if (!langTasks.contains(task)) System.print(" " + task)

<br>

which we embed in the following C program, build and run.

 

#include <stdio.h>

WrenVM* vm = wrenNewVM(&config);

const char* module = "main";

char *script = readFile(fileName);

WrenInterpretResult result = wrenInterpret(vm, module, script);

free(script);

return 0;

 

{{out}}

<pre>

Unimplemented 'full' tasks in Wren:

 

Unimplemented 'draft' tasks in Wren:

</pre>

 

=={{header|zkl}}==

Uses shared libraries YAJL and cURL.

 

fcn getTasks(language){

}

 

tasks:=getTasks(language);

langTasks:=Dictionary(); tasks.pump(Void,langTasks.add.fp1(Void));

println("Found %d unimplemented tasks for %s:"

.fmt(unimplementedTasks.len(1),language));

{{out}}

<pre>