Remove annotation support

diff --git a/lib/TOML/Tiny/Parser.pm b/lib/TOML/Tiny/Parser.pm
index ab0733eb5cc5d1a3dff910bf71d4b8cf76e72b33..e2ff7f557b0c07fcceb01b70d9efa6147b5851d1 100644 (file)
--- a/lib/TOML/Tiny/Parser.pm
+++ b/lib/TOML/Tiny/Parser.pm
@@ -28,7 +28,6 @@ sub new {
     inflate_datetime => $param{inflate_datetime} || sub{ shift },
     inflate_boolean  => $param{inflate_boolean}  || sub{ shift eq 'true' ? $TRUE : $FALSE },
     strict_arrays    => $param{strict_arrays},
-    annotated        => $param{annotated},
   }, $class;
 }
 
@@ -52,14 +51,13 @@ sub parse {
   delete $self->{root};
   delete $self->{tables};
 
-  return annotate($result) if $self->{annotated};
   return $result;
 }
 
 sub parse_error {
   my ($self, $token, $msg) = @_;
   my $line = $token ? $token->{line} : 'EOF';
-  if ($self->{annotated} || $ENV{TOML_TINY_DEBUG}) {
+  if ($ENV{TOML_TINY_DEBUG}) {
     my $root = Dumper($self->{root});
     my $tok  = Dumper($token);
     my $src  = substr $self->{tokenizer}{source}, $self->{tokenizer}{position}, 30;
@@ -264,37 +262,29 @@ sub parse_value {
 
   for ($token->{type}) {
     when (/float/) {
-      if ($self->{annotated}) {
-        return $token->{value};
-      } else {
-        use bignum;
-        return $token->{value} + 0;
-      }
+      use bignum;
+      return $token->{value} + 0;
     }
 
     when (/integer/) {
-      if ($self->{annotated}) {
-        return $token->{value};
-      } else {
-        for (my $n = $token->{value}) {
-          use bigint;
+      for (my $n = $token->{value}) {
+        use bigint;
 
-          when (/(?&Oct) $TOML/x) {
-            $n =~ s/^0o/0/; # convert to perl's octal format
-            return oct $n;
-          }
+        when (/(?&Oct) $TOML/x) {
+          $n =~ s/^0o/0/; # convert to perl's octal format
+          return oct $n;
+        }
 
-          when (/(?&Bin) $TOML/x) {
-            return oct $n;
-          }
+        when (/(?&Bin) $TOML/x) {
+          return oct $n;
+        }
 
-          when (/(?&Hex) $TOML/x) {
-            return hex $n;
-          }
+        when (/(?&Hex) $TOML/x) {
+          return hex $n;
+        }
 
-          default{
-            return $n + 0;
-          }
+        default{
+          return $n + 0;
         }
       }
     }
@@ -360,57 +350,4 @@ sub parse_inline_table {
   return $table;
 }
 
-sub annotate {
-  my $value = shift;
-
-  for (ref $value) {
-    when ('HASH') {
-      $value->{$_} = annotate($value->{$_})
-        for keys %$value;
-
-      return $value;
-    }
-
-    when ('ARRAY') {
-      my $is_table_array = @$value == 0 || grep{ ref($_) ne 'HASH' } @$value;
-
-      $value->[$_] = annotate($value->[$_])
-        for 0..(scalar(@$value) - 1);
-
-      if ($is_table_array) {
-        return {type => 'array', value => $value};
-      } else {
-        return $value;
-      }
-    }
-
-    when ('JSON::PP::Boolean') {
-      return {type => 'bool', value => $value ? 'true' : 'false'};
-    }
-
-    default{
-      if ($value =~ /^(true|false)$/) {
-        return {type => 'bool', value => $value};
-      }
-
-      if ($value =~ /^(?&Float)$ $TOML/x) {
-        return {type => 'float', value => $value};
-      }
-
-      if ($value =~ /^(?&Integer)$ $TOML/x) {
-        return {type => 'integer', value => $value};
-      }
-
-      if ($value =~ /^(?&DateTime)$ $TOML/x) {
-        return {type => 'datetime', value => $value};
-      }
-
-      return {
-        type  => 'string',
-        value => $value,
-      };
-    }
-  }
-}
-
 1;

diff --git a/lib/TOML/Tiny/Writer.pm b/lib/TOML/Tiny/Writer.pm
index f5ee59f9b38ec1fe8709dc086ac58af5ff171c7b..28c8146abc06867001ac1295c8127b6e2735dbb0 100644 (file)
--- a/lib/TOML/Tiny/Writer.pm
+++ b/lib/TOML/Tiny/Writer.pm
@@ -17,11 +17,6 @@ my @KEYS;
 sub to_toml {
   my $data = shift;
   my %param = @_;
-
-  if ($param{annotated} && caller ne 'TOML:Tiny::Writer') {
-    $data = deannotate($data);
-  }
-
   my @buff;
 
   for (ref $data) {
@@ -183,56 +178,4 @@ sub to_toml_string {
   return '"' . $arg . '"';
 }
 
-sub deannotate {
-  my $data = shift;
-
-  for (ref $data) {
-    when ('HASH') {
-      if (exists $data->{type} && exists $data->{value} && keys(%$data) == 2) {
-        for ($data->{type}) {
-          when ('bool') {
-            my $bool = !!($data->{value} eq 'true');
-            return bless \$bool, 'JSON::PP::Boolean';
-          }
-
-          when ('integer') {
-            return Math::BigInt->new($data->{value});
-          }
-
-          when ('float') {
-            # Math::BigFloat's constructor will return a Math::BigInt for
-            # non-fractional values. This works around that to force a
-            # BigFloat.
-            return Math::BigFloat->bzero + Math::BigFloat->new($data->{value});
-          }
-
-          when ('datetime') {
-            return DateTime::Format::RFC3339->parse_datetime($data->{value});
-          }
-
-          when ('array') {
-            return [ map{ deannotate($_) } @{$data->{value}} ];
-          }
-
-          default{
-            return $data->{value};
-          }
-        }
-      }
-
-      my %object;
-      $object{$_} = deannotate($data->{$_}) for keys %$data;
-      return \%object;
-    }
-
-    when ('ARRAY') {
-      return [ map{ deannotate($_) } @$data ];
-    }
-
-    default{
-      return $data;
-    }
-  }
-}
-
 1;

diff --git a/test-bin/from-toml b/test-bin/from-toml
deleted file mode 100755 (executable)
index 3aeb569..0000000
--- a/test-bin/from-toml
+++ /dev/null
@@ -1,25 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-use v5.18;
-use lib './lib';
-
-use JSON::PP   qw();
-use TOML::Tiny qw(from_toml);
-
-binmode STDIN,  ':encoding(UTF-8)';
-binmode STDOUT, ':encoding(UTF-8)';
-
-my $toml = do{ local $/; <STDIN> };
-my ($parsed, $error) = from_toml $toml,
-  annotated     => 1,
-  strict_arrays => 1;
-
-if ($error) {
-  warn $error;
-  exit 1;
-}
-
-say JSON::PP->new->encode($parsed);
-exit 0;

diff --git a/test-bin/to-toml b/test-bin/to-toml
deleted file mode 100755 (executable)
index 0862230..0000000
--- a/test-bin/to-toml
+++ /dev/null
@@ -1,21 +0,0 @@
-#!/usr/bin/env perl
-
-use strict;
-use warnings;
-no warnings 'experimental';
-use lib './lib';
-use v5.18;
-
-use JSON::PP;
-use TOML::Tiny qw(to_toml);
-
-binmode STDIN,  ':encoding(UTF-8)';
-binmode STDOUT, ':encoding(UTF-8)';
-
-my $src  = do{ local $/; <STDIN> };
-my $json = JSON::PP->new->utf8(0)->decode($src);
-my $toml = to_toml($json, strict_arrays => 1, annotated => 1);
-
-say $toml;
-
-exit 0;