पर्ल मूस - जांच करें कि चर एक मूस डेटा प्रकार

Question

है, मैं मूस (और उत्प्रेरक) का उपयोग करने के लिए एक विरासत अनुप्रयोग को परिवर्तित कर रहा हूं और निम्न प्रश्न है।

मैं उपयोगकर्ता द्वारा डेटा इनपुट के मूस प्रकार का निर्धारण कैसे करूं?

निम्नलिखित में, कच्चे, उदाहरण मैं कई प्रश्न सबमिट करता हूं और अपेक्षित फॉर्म फ़ील्ड्स 'आईडी', 'नाम' और 'ईमेल' के खिलाफ डेटा को मूलभूत 'मान्य' विधि का उपयोग करके सत्यापित करता हूं।

use MooseX::Declare; 
class CheckFields 
{ 
    #has '_field' => (is => 'rw', isa => 'Any'); 

    # Fields on form and type to which they must match. 
    method fields() 
    { 
     return [ { name => 'id', type => 'Int' }, 
       { name => 'name', type => 'Str' }, 
       { name => 'email', type => 'Email' } 
       ]; 
    } 

    # Dummy form posted requests. 
    method queries() 
    { 
     return [ { 'id' => 1, 
        'name' => 'John Doe', 
        'email' => 'john@doe.net' 
       }, 
       { 'id' => 'John Doe', 
        'name' => 1, 
        'email' => 'john.at.doe.net' 
       } 
       ]; 
    } 

    method validate_fields() 
    { 
     my $fields = $self->fields(); 

     # Loop through dummy form post requests 
     foreach my $query (@{ $self->queries }) 
     { 
      # Validate each field in posted form. 
      foreach my $field (@{ $fields }) 
      { 
       my $type = $field->{'type'}; 
       my $name = $field->{'name'}; 

       my $res = $self->validate->{ $type }($query->{ $name}); 
       print "$name is $res\n"; 
      } 
      print "\n"; 
     } 
    } 

    # Very basic, slightly crude field validation. 
    method validate() 
    { 
     return { 'Int' => sub { my $val = shift; return $val =~ /^\d+$/ ? "ok" : "not ok" }, 
       'Str' => sub { my $val = shift; return $val =~ /^[a-zA-Z\s]+$/ ?"ok" : "not ok" }, 
       'Email' => sub { my $val = shift; return $val =~ /^(.+)\@(.+)$/ ?"ok" : "not ok" } 
       }; 
    } 
} 

परीक्षण करने के लिए इस कोड को बस चलाने ...

#!/usr/bin/perl 
use Moose; 
use CheckFields; 

CheckFields->new()->validate_fields(); 

1; 

इस तरह कुछ करने के लिए यह संभव है जहां इसा 'कोई भी' ...

has '_validate_field' => (is => 'rw', isa => 'Any'); 

करने के लिए सेट के साथ एक चर सेटअप

... फिर निम्न प्रकार के लिए परीक्षण निम्नानुसार है?

$self->validate_field(1); 
print $self->validate_field->meta->isa('Int') ? 'Int found' : 'Int not found'; 

$self->validate_field('ABC'); 
print $self->validate_field->meta->isa('Int') ? 'Int found' : 'Int not found'; 

अग्रिम धन्यवाद

संपादित: @bvr - जवाब देने के लिए समय निकालने के लिए धन्यवाद, मैं इतना MooseX :: पैरामीटर के आपके उपयोग :: मान्य हो सकता है अपेक्षाकृत मूस के लिए नया हूँ अच्छी तरह से अंत समाधान हो, हालांकि मैं जो कुछ भी ढूंढ रहा हूं वह काफी नहीं है। मेरा इरादा पूरी तरह से सत्यापन विफलता की रिपोर्ट करने के बजाय त्रुटि में मौजूद प्रत्येक विशिष्ट फ़ील्ड की रिपोर्ट करने में सक्षम होना है। उस अंत में मैंने सोचा कि मैं एक डिफ़ॉल्ट, मूस अनुकूल, इनपुट धारक को आईएसए 'पर सेट' पर सेट कर सकता हूं। फिर 'eval' (या कुछ ऐसे) को देखने के लिए कि डेटा किसी विशेष प्रकार (Int, Str या मेरे द्वारा परिभाषित कुछ अनुकूलित प्रकार) के अनुरूप है या नहीं।

मैं "$ self-> validate_field-> मेटा-> आईएसए ('इंट') के साथ प्राप्त करने का प्रयास कर रहा था ..." संदर्भ सी/सी ++ में एक संघ की तर्ज पर कुछ था जहां एक चर विभिन्न प्रकार के हो सकते हैं - इस उदाहरण में मैं परीक्षण करने की कोशिश कर रहा हूं कि डेटा किसी निश्चित डेटा प्रकार के अनुरूप है या नहीं।

Answer 1

मुझे यकीन नहीं है कि मैं आपके प्रश्न के अंतिम भाग का पालन करता हूं, लेकिन आपका प्रारंभिक उदाहरण MooseX::Params::Validate के उपयोग से लाभान्वित हो सकता है।

संपादित करें: मैंने अपने सुझाव का मूल्यांकन करने के लिए कुछ कोड बनाया है।

use MooseX::Declare; 
class CheckFields { 

    use Moose::Util::TypeConstraints; 
    use MooseX::Params::Validate; 
    use Try::Tiny; 
    use Data::Dump qw(pp); 

    subtype 'Email' 
     => as 'Str' 
     => where {/^(.+)\@(.+)$/}; 

    method fields() { 
     return [ 
      id => {isa => 'Int'}, 
      name => {isa => 'Str'}, 
      email => {isa => 'Email'}, 
     ]; 
    } 

    method queries() { 
     return [ 
      { 'id' => 1, 
       'name' => 'John Doe', 
       'email' => 'john@doe.net' 
      }, 
      { 'id' => 'John Doe', 
       'name' => 1, 
       'email' => 'john.at.doe.net' 
      } 
     ]; 
    } 

    method validate_fields() { 
     my $fields = $self->fields(); 

     foreach my $query (@{$self->queries}) { 
      try { 
       my (%params) = validated_hash([%$query], @{$fields}); 
       warn pp($query) . " - OK\n"; 
      } 
      catch { 
       warn pp($query) . " - Failed\n"; 
      } 
     } 
    } 
} 

package main; 

CheckFields->new()->validate_fields(); 

अन्य दृष्टिकोण मैं देख सकता हूँ डेटा के लिए एक मूस वर्ग बनाने के लिए है (मान्यता इस तरह से शामिल है) और जाँच उदाहरण सत्यापन त्रुटि के बिना बनाया जा सकता है। कुछ इस तरह:

use MooseX::Declare; 
class Person { 
    use Moose::Util::TypeConstraints; 

    subtype 'Email' 
     => as 'Str' 
     => where {/^(.+)\@(.+)$/}; 

    has id => (is => 'ro', isa => 'Int'); 
    has name => (is => 'ro', isa => 'Str'); 
    has email => (is => 'ro', isa => 'Email'); 
} 

package main; 

use Try::Tiny; 
use Data::Dump qw(pp); 

my @tests = (
    { id => 1,   name => 'John Doe', email => 'john@doe.net'}, 
    { id => 'John Doe', name => 1,   email => 'john.at.doe.net'}, 
); 

for my $query (@tests) { 
    try { 
     my $person = Person->new(%$query); 
     warn pp($query) . " - OK\n"; 
    } 
    catch { 
     warn pp($query) . " - Failed\n"; 
    }; 
}