Rosetta Code/Find unimplemented tasks

Given the name of a language on Rosetta Code, find all tasks which are not implemented in that language. Use these JSON files as source information.

Haskell

Library: HTTP XML

from HackageDB

<lang haskell>import Network.Browser import Network.HTTP import Network.URI import Data.List import Data.Maybe import Text.XML.Light import Control.Arrow import Data.Char

getRespons url = do

 rsp <- Network.Browser.browse $ do
   setAllowRedirects True
   setOutHandler $ const (return ())   -- quiet
   request $ getRequest url
 return $ rspBody $ snd rsp

replaceWithSpace c = (\x -> if c==x then ' ' else x)

encl = chr 34

unimpTasks lang = do

 allTasks <- getRespons "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:Programming_Tasks&cmlimit=500&format=xml"
 impl <-  getRespons ( "http://rosettacode.org/json/isb/" ++ lang ++ ".json")
 let langxx = map (map(replaceWithSpace '_')) $ filter (/=",") $ words $ map (replaceWithSpace encl ) $ init $ drop 1 impl
     xml = onlyElems $ parseXML allTasks
     allxx = concatMap (map (fromJust.findAttr (unqual "title")). filterElementsName (== unqual "cm")) xml
 mapM_ putStrLn $ sort $ allxx \\ langxx</lang>

Example Usage: <lang j> 4{. findUnimpTasks 'J' NB. get first 4 unimplemented tasks for J +-------------+--------------+----------------+------------------------------+ |Active object|Atomic updates|Basic input loop|Call foreign language function| +-------------+--------------+----------------+------------------------------+</lang>

Perl

Using JSON (not parsed, just Regex.)

<lang perl>use LWP::Simple 'get';

my $fmt = 'http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:%s&cmlimit=500&format=json'; my $lang = shift

   or die "No language given.\n";

sub urlencode

  {join , map {sprintf '%%%02x', ord} split //, shift}

sub tasks

  {my $category = urlencode shift;
   my @tasks;
   my $json = get sprintf $fmt, $category;
   for (;;)
      {push @tasks, $json =~ /"title":"(.+?)"}/g;
       $json =~ /"cmcontinue":"(.+?)"}/ or last;
       $json = get sprintf $fmt . '&cmcontinue=%s',
           $category, urlencode $1;}
   return @tasks;}

my @all = tasks 'Programming_Tasks'; my %lang = map {$_, 1} tasks $lang

   or die "No such category.\n";

$lang{$_} or print "$_\n"

   foreach @all;</lang>

See also: User:ImplSearchBot/Code

Python

Using XML.

<lang python>import xml.dom.minidom import urllib, sys

def findrc(category):

   name = "http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:%s&cmlimit=500&format=xml" % urllib.quote(category)
   cmcontinue, titles = , []
   while True:
       u = urllib.urlopen(name + cmcontinue)
       xmldata = u.read()
       u.close()
       x = xml.dom.minidom.parseString(xmldata)
       titles += [i.getAttribute("title") for i in x.getElementsByTagName("cm")]
       cmcontinue = filter( None,
                            (urllib.quote(i.getAttribute("cmcontinue"))
                             for i in x.getElementsByTagName("categorymembers")) )
       if cmcontinue:
           cmcontinue = '&cmcontinue=' + cmcontinue[0]
       else:
           break
   return titles

alltasks = findrc("Programming_Tasks") lang = findrc(sys.argv[1])

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

   print i</lang>

R

Library: XML (R)

<lang R>library(XML) 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="") ) PT.nodes <- getNodeSet(PT,"//cm") PT.titles = as.character( sapply(PT.nodes, xmlGetAttr, "title") ) language <- xmlInternalTreeParse( paste("http://www.rosettacode.org/w/api.php?action=query&list=categorymembers&cmtitle=Category:", lang, "&cmlimit=500&format=xml",sep="") ) lang.nodes <- getNodeSet(language,"//cm") lang.titles = as.character( sapply(lang.nodes, xmlGetAttr, "title") ) unimplemented <- setdiff(PT.titles, lang.titles) unimplemented }

Usage

find.unimplemented.tasks(lang="Python") langs <- c("R","python","perl") sapply(langs, find.unimplemented.tasks) # fetching data for multiple languages</lang>

Ruby

Uses the RosettaCode module from Count programming examples#Ruby <lang ruby>require 'rosettacode'

module RosettaCode

 def RosettaCode.rc_unimplemented(lang)
   programming_tasks = []
   rc_tasks("Programming_Tasks") {|task| programming_tasks << task}
   lang_tasks = []
   rc_tasks(lang) {|task| lang_tasks << task}
   programming_tasks - lang_tasks
 end

end

lang = "Ruby" unimplemented = RosettaCode.rc_unimplemented(lang) puts "#{lang} has #{unimplemented.length} unimplemented tasks:" puts unimplemented.join("\n")</lang>

Tcl

First, find all members of the Programming_Tasks category, then find all members of the $lang category. The difference is the list of unimplemented tasks.

This uses the json and struct::set packages from

Library: tcllib

<lang tcl>package require Tcl 8.5 package require http package require json package require struct::set

fconfigure stdout -buffering none

Initialize a cache of lookups

array set cache {} proc log msg {

   #puts -nonewline $msg

}

proc get_tasks {category} {

   global cache
   if {[info exists cache($category)]} {

return $cache($category)

   }
   set base_url http://www.rosettacode.org/w/api.php
   set query {

action query list categorymembers cmtitle Category:%s format json cmlimit 500

   }
   set query [list {*}$query]; # remove excess whitespace
   set this_query [dict create {*}[split [format $query $category]]]
   set tasks [list]

   while {1} {
       set url [join [list $base_url [http::formatQuery {*}$this_query]] ?]
       while 1 {
           set response [http::geturl $url]

# Process redirects

           if {[http::ncode $response] == 301} {
               set newurl [dict get [http::meta $response] Location]
               if {[string match http://* $newurl]} {
                   set url $newurl
               } else {
                   set url [regexp -inline {http://[^/]+} $url]
                   append url $newurl
               }
               continue
           }

# Check for oopsies!

           if {

[set s [http::status $response]] ne "ok" || [http::ncode $response] != 200 } then {

               error "Oops: url=$url\nstatus=$s\nhttp code=[http::code $response]"
           }
           break
       }

# Get the data out of the message

       set data [json::json2dict [http::data $response]]
       http::cleanup $response

       # add tasks to list
       foreach task [dict get $data query categorymembers] {
           lappend tasks [dict get [dict create {*}$task] title]
       }

       if {[catch {

dict get $data query-continue categorymembers cmcontinue } continue_task]} then {

           # no more continuations, we're done
           break
       }
       dict set this_query cmcontinue $continue_task
   }
   return [set cache($category) $tasks]

}

proc get_unimplemented {lang} {

   set tasks [get_tasks Programming_Tasks]
   set collected [get_tasks Collection_Members]
   set doneTasks [get_tasks $lang]
   set omittedTasks [get_tasks $lang/Omit]

   # Map generic collection task categories to specific ones
   set tasks [regsub -all {Category:(\S+)} $tasks "\\1/$lang"]

   set collectOfLang [struct::set intersect $collected $doneTasks]
   set ignorable [struct::set union $doneTasks $omittedTasks $collectOfLang]
   set unimplemented [struct::set difference $tasks $ignorable]

   puts "\n$lang has [llength $unimplemented] unimplemented programming tasks:"
   if {[llength $unimplemented]} {

puts " [join [lsort $unimplemented] "\n "]"

}

foreach lang {Perl Python Ruby Tcl} {

   get_unimplemented $lang

}</lang>

Rosetta Code/Find unimplemented tasks

Contents

AutoHotkey

C#

E

Haskell

J

Perl

Python

R

Ruby

Tcl