Image

head

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

JSON::Infer - Infer Raku Classes from JSON objects


=begin code


# Use the script to do it simply:
# Create the modules in the directory "foo"

raku-json-infer --uri=http://api.mixcloud.com/spartacus/party-time/ --out-dir=foo --class-name=Mixcloud::Show

# Or do it in your own code:

use JSON::Infer;

my $obj = JSON::Infer.new()
my $ret = $obj.infer(uri => 'http://api.mixcloud.com/spartacus/party-time/', class-name => 'Mixcloud::Show');

say $ret.make-class; # Print the class definition

=end code


JSON is nearly ubiquitous on the internet, developers love it for making
APIs.  However the webservices that use it for transfer of data rarely
have a machine readable specification that can be turned into code so
developers who want to consume these services usually have to make the
client definition themselves.


This module aims to provide a way to generate Raku classes that can represent
the data from a JSON source.  The structure and the types of the data is
inferred from a single data item so the accuracy may depend on the
consistency of the data.


multi method infer(Str:D :$uri!, Str :$class-name = 'My::JSON', Bool :$kebab = False) returns Class
multi method infer(Str:D :$file!, :$class-name = 'My::JSON', Bool :$kebab = False) returns Class
multi method infer(IO::Path:D :$file!, :$class-name = 'My::JSON', Bool :$kebab = False) returns Class
multi method infer(Str:D :$json!, Str :$class-name = 'My::JSON', Bool :$kebab = False) returns Class


This accepts a single path and returns a L<JSON::Infer::Class>
object, if there is an error retrieving the data or parsing the response
it will throw an exception.


It requires the following named arguments:


This is the uri that will be used to retrieve the content.  It will need
to be some protocol scheme that is understood by L<HTTP::UserAgent>. This
is required.


This is the name that will be used for the generated class, any child
classes that are discovered will parsing the attributes will have a name
based on this and the name of the attribute. If it is not supplied the
default is C<My::JSON> will be used.


If this is provided then the names of the attributes will be turned into the
more popular Raku style with underscores replaced with hyphens.


The L<HTTP::UserAgent> object that will be used.


Returns the default set of headers that will be applied to the
HTTP::UserAgent object.


This is the content type that we want to use.  The default is
"application/json".


This holds the infered definition of a class to be generated from
JSON input.


This is a L<Hash> of the L<JSON::Infer::Attribute> discovered in the object
keyed by the name of the attribute.


This is a L<Bool> that indicates whether the class is the first one
encountered.  It will be set by C<infer> method of L<JSON::Infer> on
the class that it will return.


This is used internally by C<make-class> to determine whether it should
add any preamble that might be required.


multi method new-from-data(:$class-name, :$content, :kebab) returns JSON::Infer::Class
multi method new-from-data(Str $name, $data, :kebab ) returns JSON::Infer::Class


This returns a L<JSON::Infer::Class> constructed from the provided
reference.  If the adverb C<kebab> is provided then this will be
applied to the attributes, causing the names to be adjusted accordingly.


method populate-from-data(JSON::Class:D: $datum)


This performs the actual inference from a single record.


method new-attribute(Str $name, $value) returns JSON::Infer::Attribute


This creates a new attribute with the supplied name and its type infered
from the supplied C<$value> and adds it to the class, returning the
new L<JSON::Infer::Attribute>.


method add-attribute(JSON::Infer::Attribute $attr)


Add the attribute to this class, along with any classes that may have been
discovered


multi method make-class(Int $level  = 0) returns Str


This returns the string representation of the class that has been
constructed. The argument C<$level> indicates the depth within the
nested structure and controls the indentation.



use JSON::Fast;
use HTTP::UserAgent;

class JSON::Infer:ver<0.0.18>:auth<github:jonathanstowe>:api<1.0> {


    role Classes        { ... }
    role Types          { ... }
    class Attribute     { ... }
    class Class         { ... }
    class Type          { ... }

    class X::Infer is Exception {
        has Str         $.message is rw;
        has Str         $.uri is rw;
        has Exception   $.inner-exception is rw;
    }


    role Entity {
        has Str $.name is rw;
    }

    class  Type does Entity {
        has Str     $.subtype-of is rw handles(has-subtype => 'defined');
        has Bool    $.array is rw = False;
        has Class   $.of-class is rw;
    }

    role Classes {
        has @.classes is rw;

        method  add-classes(Mu:D $object) {

            if $object.does($?ROLE) {
                for $object.classes -> $class {
                    if !?@!classes.grep({$class.name eq $_.name}) {
                        @!classes.push($class);
                    }
                }
            }
            if  $object ~~ Class {
                @!classes.push($object);
            }
        }
    }


    role Types {
        has @.types is rw;
        method  add-types(Mu:D $object ) {
            if $object.does($?ROLE) {
                for $object.types -> $type {
                    @!types.push($type);
                }
            }

            if $object ~~ Type {
                @!types.push($object);
            }
        }
    }

    class Class does Classes does Types {

        has Bool $.inner-class  = False;
        has Bool $.kebab        = False;

        multi method new-from-data(:$class-name, :$content, Bool :$inner-class = False, Bool :$kebab = False --> Class ) {
            self.new-from-data($class-name, $content, $inner-class, :$kebab);
        }

        multi method new-from-data(Str $name, $data, $inner-class = False, Bool :$kebab = False --> Class ) {
            my $obj = self.new(:$name, :$inner-class, :$kebab);

            my @data;

            given $data {
                when Array {
                    @data = $data.list;
                }
                default {
                    @data.push($data);
                }
            }

            for @data -> $datum {
                $obj.populate-from-data($datum);
            }

            $obj;
        }


        method populate-from-data($datum) {
            for $datum.kv -> $attr, $value {
                if not %!attributes{$attr}:exists {
                    my $new = self.new-attribute($attr, $value);
                }
            }
        }


        method new-attribute(Str $name, $value --> Attribute ) {

            my $new = Attribute.new-from-value($name, $value, $!name, $!inner-class, :$!kebab);
            self.add-attribute($new);
            $new;
        }

        has Str $.name is rw;

        has Bool $.top-level is rw = False;

        has Attribute %.attributes is rw;

        method add-attribute(Attribute $attr) {
            %!attributes{$attr.name} = $attr;
            self.add-classes($attr);
            self.add-types($attr);
        }

        multi method make-class(Int $level  = 0 --> Str ) {
            my $indent = "    " x $level;
            my Str $ret;

            if $!top-level {
                $ret ~= "\n{ $indent }use JSON::Name;\n{ $indent }use JSON::Class;\n";
            }

            $ret ~= $indent ~ "class { self.name } does JSON::Class \{";
            my $next-level = $level + 1;

            for self.classes -> $class {
                $ret ~= "\n" ~ $class.make-class($next-level);
            }

            for self.attributes.kv -> $name, $attr {
                $ret ~= "\n" ~ $attr.make-attribute($next-level) ;
            }

            $ret ~= "\n$indent\}";
            $ret;
        }

        method file-path( --> Str ) {
            my $path = $*SPEC.catfile($!name.split('::'));
            $path ~= '.pm';
            $path;
        }
    }


    class Attribute does Classes does Types {

        method  new-from-value(Str $name, $value, $class, Bool $inner-class = False, Bool :$kebab = False --> Attribute ) {
            my $obj = self.new(:$name, :$class, :$inner-class, :$kebab );
            $obj.infer-from-value($value);
            $obj;
        }


        method infer-from-value($value) {
            my $type_constraint;
            given $value {
                when Array {
                    $!is-array = True;
                    if ?$_.grep(Array|Hash) {
                        my $obj = self.process-object($_);
                        $type_constraint = $obj.name;
                    }
                    else {
                        $type_constraint = '';
                    }
                }
                when Hash {
                    my $obj = self.process-object($_);
                    $type_constraint = $obj.name;

                }
                default {
                    $type_constraint = $_.WHAT.^name;
                }
            }
            $!type-constraint = $type_constraint;
        }

        method process-object($value) {
            my $obj = Class.new-from-data(self.child-class-name(), $value, True, :$!kebab);
            self.add-classes($obj);
            self.add-types($obj);
            $obj;
        }


        has Str $.name is rw;
        has Str $.raku-name is rw;

        has Bool $.is-array     = False;
        has Bool $.inner-class  = False;
        has Bool $.kebab        = False;

        method sigil( --> Str ) {
            $!is-array ?? '@' !! '$';
        }

        method !kebab(Str $name --> Str ) {
            if $!kebab {
                my $no_underscore = $name.subst(/_/, '-', :g);
                $no_underscore.subst(/<!after ( ^^ || '-' ) >$<up>=<upper>+/, {  "-{ $/<up>.lc }" }, :g).lc
            }
            else {
                $name;
            }
        }

        method raku-name( --> Str ) is rw {
            $!raku-name //= do {
                my $name = $!name;
                if $name !~~ /^<.ident>$/ {
                    my $prefix = $!class.split('::')[*-1].lc;
                    $name = $prefix ~ $name;
                }
                self!kebab($name);
            }
        }

        method has-alternate-name( --> Bool ) {
            self.raku-name ne $!name;
        }

        has Str $.type-constraint is rw;
        has Str $.class is rw;


        has Str $.child-class-name is rw;

        method child-class-name( --> Str ) is rw {
            $!child-class-name //= do {
                my Str $name = $!name;
                $name ~~ s:g/_(.)/{ $0.uc }/;
                if self.is-array {
                    $name ~~ s/s$//;
                }
                $!child-class-name =  $name.tc;
            }
        }

        multi method make-attribute(Int $level = 0 --> Str ) {
            my $indent = "    " x $level;
            my Str $attr-str = $indent ~ "has { self.type-constraint } { self.sigil}.{ self.raku-name }";
            if self.has-alternate-name {
                $attr-str ~= " is json-name('{ self.name }')";

            }
            $attr-str ~ ';';
        }
    }

    proto method infer(|c) { * }

    multi method infer(Str:D :$uri!, Str :$class-name = 'My::JSON', Bool :$kebab = False --> Class ) {
        my $ret;
        my $resp =  self.get($uri);
        if $resp.is-success() {
            my $json = $resp.decoded-content();
            $ret = self.infer(:$json, :$class-name, :$kebab);
        }
        else {
            X::Infer.new(:$uri, message => "Couldn't retrieve URI $uri").throw;
        }
        $ret;
    }

    multi method infer(Str:D :$file!, :$class-name = 'My::JSON', Bool :$kebab = False --> Class ) {
        my $io = $file.IO;
        if $io.e {
            self.infer(file => $io, :$class-name, :$kebab);
        }
        else {
            X::Infer.new(uri => $file, message => "File $file does not exist").throw;
        }
    }

    multi method infer(IO::Path:D :$file!, :$class-name = 'My::JSON', Bool :$kebab = False --> Class ) {
        my $json = $file.slurp();
        self.infer(:$json, :$class-name, :$kebab);
    }

    multi method infer(Str:D :$json!, Str :$class-name = 'My::JSON', Bool :$kebab = False --> Class ) {
        my $content = self.decode-json($json);
        my $ret = Class.new-from-data(:$class-name, :$content, :$kebab);
        $ret.top-level = True;
        $ret;
    }


    has $.ua is rw;

    method get(|c) {
        self.ua.get(|c);
    }

    method ua( --> HTTP::UserAgent ) is rw {
        $!ua //=  HTTP::UserAgent.new( default-headers   => $.headers, useragent => $?PACKAGE.^name ~ '/' ~ $?PACKAGE.^ver);
    }


    has HTTP::Header $.headers is rw;

    method headers( --> HTTP::Header ) is rw {
        $!headers //= do {
            my $headers = HTTP::Header.new();
            $headers.field('Content-Type'  => $!content-type);
            $headers.field('Accept'  => $!content-type);
            $headers;
        }
    }


    has Str $.content-type  is rw =  "application/json";

    method decode-json(Str $content --> Any ) {
        from-json($content);
    }

}
# vim: expandtab shiftwidth=4 ft=raku


Infer

use v6;
unit module JSON::Hjson:ver<0.0.3>;

use JSON::Hjson::Actions;
use JSON::Hjson::Grammar;

class X::JSON::Hjson::Invalid is Exception {
    has $.source;
    method message { "Input ($.source.chars() characters) is not a valid JSON string" }
}

sub from-hjson($text) is export {
    my $a = JSON::Hjson::Actions.new();
    my $o = JSON::Hjson::Grammar.parse($text, :actions($a));
    unless $o {
        X::JSON::Hjson::Invalid.new(source => $text).throw;
    }
    return $o.made;
}



JSON::Hjson - Human JSON (Hjson) deserializer


my $text = q:to'...';
{
  // specify delay in
  // seconds
  delay: 1
  message: wake up!
}
...
say from-hjson($text).raku;


JSON::Hjson implements Human JSON (Hjson) in Raku grammar.


This library is free software; you can redistribute it and/or modify it under the Artistic License 2.0.


Hjson

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

NAME

SYNOPSIS

DESCRIPTION

SEE ALSO

AUTHOR

COPYRIGHT AND LICENSE

JSON::Hjson v0.0.3

Authors

License

Dependencies

Test Dependencies

Provides

Documentation