• 名前
• VERSION
• 概要
• 説明
  • Concepts
  • Concepts
• INTERFACE
  • Data::Validator->new( $arg_name => $rule [, ...]) :Validator
  • $validator->find_rule($name :Str)
  • $validator->with(@extentions) :Validator
  • $validator->validate(@args) :HashRef
  • Data::Validator->new( $arg_name => $rule [, ...]) :Validator
  • $validator->find_rule($name :Str)
  • $validator->with(@extentions) :Validator
  • $validator->validate(@args) :HashRef
• EXTENTIONS
  • Method
  • Sequenced
  • AllowExtra
  • NoThrow
  • Croak
  • Method
  • Sequenced
  • AllowExtra
  • NoThrow
  • Croak
• DEPENDENCIES
• バグ
• SEE ALSO
• 作者
• LICENSE AND COPYRIGHT

    use 5.10.0;
    use Data::Validator;

    # for functions
    sub get {
        state $rule = Data::Validator->new(
            uri        => { isa => 'Str', xor => [qw(schema host path_query)] },

            schema     => { isa => 'Str', default => 'http' },
            host       => { isa => 'Str' },
            path_query => { isa => 'Str', default => '/' },

            method     => { isa => 'Str', default => 'GET' },
        );

        my $args = $rule->validate(@_);
        # ...
    }
    get( uri => 'http://example.com/' );

    # for methods
    sub method {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with('Method');

        my($self, $args) = $rule->validate(@_);
        # ...
    }
    Foo->method( foo => 'bar' );


    # using sequenced parameters
    sub seq {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with('Sequenced');

        my $args = $rule->validate(@_);
        # ...
    }
    seq( 'bar' );          # seq() will get { foo => 'bar' }
    seq({ foo => 'bar' }); # named style are available!


    # using Method and Sequenced together
    sub seq_method {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with( 'Method', 'Sequenced');

        my($self, $args) = $rule->validate(@_);
        # ...
    }
    Foo->seq_method( 'bar' ); # seq() will get { foo => 'bar' }

    use 5.10.0;
    use Data::Validator;

    # 関数の場合
    sub get {
        state $rule = Data::Validator->new(
            uri        => { isa => 'Str', xor => [qw(schema host path_query)] },

            schema     => { isa => 'Str', default => 'http' },
            host       => { isa => 'Str' },
            path_query => { isa => 'Str', default => '/' },

            method     => { isa => 'Str', default => 'GET' },
        );

        my $args = $rule->validate(@_);
        # ...
    }
    get( uri => 'http://example.com/' );

    # メソッドの場合
    sub method {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with('Method');

        my($self, $args) = $rule->validate(@_);
        # ...
    }
    Foo->method( foo => 'bar' );


    # 引数をリストを使って渡す場合
    sub seq {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with('Sequenced');

        my $args = $rule->validate(@_);
        # ...
    }
    seq( 'bar' );          # seq()は { foo => 'bar' }として受け取ることになります
    seq({ foo => 'bar' }); # 名前付きの方式も利用できます!


    # メソッドとリスト渡しを同時に使用する場合
    sub seq_method {
        state $rule = Data::Validator->new(
            foo => 'Str',
        )->with( 'Method', 'Sequenced');

        my($self, $args) = $rule->validate(@_);
        # ...
    }
    Foo->seq_method( 'bar' ); # seq() will get { foo => 'bar' }

説明¶

このモジュールは Smart::Argsに基づくバリデーションライブラリです. ただし少しばかり機能が劣っています.

このモジュールは開発段階です. <APIは予告なしに変更されるかもしれません>

Concepts¶

Perlらしいコード

私は洗練された Smart::Argsが大好きですが, Perlらしくないと思います.

そこで私は Smart::Argsの全機能を, より Perlらしく使える Data::Validatorを設計しました.

型制約システムの基本

Mooseの型制約システムは見事なものです. Mouseも同様です. 実のところ Mouseの型制約システムは Mooseのものより高速であるため, 型チェックを 行うことを躊躇する必要はありません.

そこで Data::Validatorは Mouse'sの型制約システムが利用するようにしました.

Pure Perl

私は XSモジュールの依存についてを遠慮しませんが, XSモジュールのインストールが 困難と考える人もいるでしょう.

そこで Data::Validatorを Pure Perlとしてコーディングし, Pure Purlとして 動作する場合の依存モジュールを選び出しました.

性能

バリデータは不正な入力を検出するだけなので, 可能な限り高速で高速であるべきです. そうでなければ, no validationオプションのようなものが欲しくなってしまうことでしょう.

このモジュールは XSバックエンドを持つ Params::Validateよりも高速です.

INTERFACE¶

TRANHEADSTART

Data::Validator->new( $arg_name => $rule [, ...]) :ValidatorTRANHEADEND¶

Creates a validation rule. You should cache the rules for performance.

Attributes for $rule are as follows:

isa => $type : Str|Object

The type of the rule, which can be a Mouse type constraint name, a class name, or a type constraint object of either Mouse or Moose (i.e. it's duck-typed).

does => $role : Str|Object

The type of the rule, which can be a Mouse type constraint name, a role name, or a type constraint object of either Mouse or Moose (i.e. it's duck-typed).

Note that you cannot use it with the isa attribute.

coerce => $should_coercion : Bool

If false, the rule does not try to coerce when the validation fails. Default to true.

default=> $value : Any | CodeRef

The default value for the argument. If it is a CODE reference, it is called in scalar context as $default->($validator, $rule, $args) and its return value is used as a default value.

Because arguments are validated in the order of definitions, default callbacks can rely on the previously-filled values:

    my $v = Data::Validator->new(
        foo => { default => 99 },
        bar => { default => sub {
            my($validator, $this_rule, $args) = @_;
            return $args->{foo} + 1;
        } },
    );
    $v->validate();          # bar is 100
    $v->validate(foo => 42); # bar is 43

Unlike Moose/Mouse's default, any references are allowed, but note that they are statically allocated.

optional => $value : Bool

If true, users can omit the argument. Default to false.

xor => $exclusives : ArrayRef

Exclusive arguments, which users cannot pass together.

documentation => $doc : Str

Descriptions of the argument.

This is not yet used anywhere.

$validator->find_rule($name :Str)¶

Finds the rule named $name. Provided for error handling.

$validator->with(@extentions) :Validator¶

Applies @extentions to $validator and returns itself.

See "EXTENTIONS" for details.

$validator->validate(@args) :HashRef¶

Validates @args and returns a restricted HASH reference.

Restricted hashes are hashes which do not allow to access non-existing keys, so you must check a key exists in the hash before fetching its values.