wca 0.46.0

The tool to make CLI ( commands user interface ). It is able to aggregate external binary applications, as well as functions, which are written in your language. 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use super :: *;
use the_module ::
{
  parser ::Parser,
  VerifiedCommand,
  executor ::Context,
  Type,
  grammar ::Dictionary,
  verifier ::Verifier,

  Executor,
  // wtools
};

//

tests_impls! {
  fn basic()
  {
  // init parser
  let parser = Parser;

  // init converter
  let dictionary = &Dictionary ::former()
  .command
  (
   wca ::grammar ::Command ::former()
   .hint( "hint" )
   .long_hint( "long_hint" )
   .phrase( "command" )
   .routine( || println!( "hello" ) )
   .form()
 )
  .form();
  let verifier = Verifier;

  // init executor
  let executor = Executor ::former().form();

  // existed command | unknown command will fail on converter
  let raw_program = parser.parse( [ ".command" ] ).unwrap();
  let grammar_program = verifier.to_program( dictionary, raw_program ).unwrap();

  // execute the command
  a_true!( executor.program( dictionary, grammar_program ).is_ok() );
 }

  fn with_context()
  {
  use std ::sync :: { Arc, Mutex };
  use ::error_tools ::untyped ::Error;

  // init parser
  let parser = Parser;

  // init converter
  let dictionary = &Dictionary ::former()
  .command
  (
   wca ::grammar ::Command ::former()
   .hint( "hint" )
   .long_hint( "long_hint" )
   .phrase( "inc" )
   .routine
   (
  | ctx: Context |
  ctx
  .get()
  .ok_or_else( || "Have no value" )
  .and_then( | x: Arc< Mutex< i32 > > | { *x.lock().unwrap() += 1; Ok( () ) } )
 )
   .form()
 )
  .command
  (
   wca ::grammar ::Command ::former()
   .hint( "hint" )
   .long_hint( "long_hint" )
   .phrase( "eq" )
   .subject().hint( "number" ).kind( Type ::Number ).optional( true ).end()
   .routine
   (
  | ctx: Context, o: VerifiedCommand |
  ctx
  .get()
  .ok_or_else( || "Have no value".to_string() )
  .and_then
  (
   | x: Arc< Mutex< i32 > > |
   {
  let x = x.lock().unwrap();
  let y: i32 = o.args.get( 0 ).ok_or_else( || "Missing subject".to_string() ).unwrap().to_owned().into();

  if dbg!( *x ) != y 
  { Err( format!( "{} not eq {}", x, y ) ) } else { Ok( () ) }
 }
 )
 )
   .form()
 )
  .form();
  let verifier = Verifier;

  // starts with 0
  let ctx = wca ::executor ::Context ::new( Mutex ::new( 0 ) );
  // init simple executor
  let executor = Executor ::former()
  .context( ctx )
  .form();

  // value in context = 0
  let raw_program = parser.parse( [ ".eq", "1" ] ).unwrap();
  let grammar_program = verifier.to_program( dictionary, raw_program ).unwrap();

  a_true!( executor.program( dictionary, grammar_program ).is_err() );

  // value in context = 1 + 1 + 1 = 3
  let raw_program = parser.parse( [ ".eq", "0", ".inc", ".inc", ".eq", "2" ] ).unwrap();
  let grammar_program = verifier.to_program( dictionary, raw_program ).unwrap();

  a_true!( executor.program( dictionary, grammar_program ).is_ok() );
 }
}

//

tests_index! {
  basic,
  with_context,
}