View Javadoc

1   package com.lexicalscope.jewel.cli;
2   
3   import java.util.List;
4   
5   import com.lexicalscope.jewel.JewelRuntimeException;
6   import com.lexicalscope.jewel.cli.specification.OptionSpecification;
7   import com.lexicalscope.jewel.cli.specification.SpecificationMultiplicity;
8   
9   
10  /*
11   * Copyright 2011 Tim Wood
12   *
13   * Licensed under the Apache License, Version 2.0 (the "License");
14   * you may not use this file except in compliance with the License.
15   * You may obtain a copy of the License at
16   *
17   * http://www.apache.org/licenses/LICENSE-2.0
18   *
19   * Unless required by applicable law or agreed to in writing, software
20   * distributed under the License is distributed on an "AS IS" BASIS,
21   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
22   * See the License for the specific language governing permissions and
23   * limitations under the License.
24   */
25  
26  class ValidationFailureWrongNumberOfValues extends ValidationFailureImpl
27  {
28      private static final long serialVersionUID = -7899339429456035393L;
29      private final OptionSpecification specification;
30      private final List<String> values;
31  
32      public ValidationFailureWrongNumberOfValues(final OptionSpecification specification, final List<String> values) {
33          super(specification, formatMessage(specification, values));
34          this.specification = specification;
35          this.values = values;
36      }
37  
38      private static String formatMessage(final OptionSpecification specification, final List<String> values) {
39          return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<String>(){
40              @Override public String expectedNoneGotSome() {
41                  if(values.size() == 1)
42                  {
43                      return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValue"), values.get(0));
44                  }
45                  return String.format(ArgumentValidationException.m_messages.getString("validationError.UnexpectedValues"), values);
46              }
47  
48              @Override public String expectedOneGotNone() {
49                  return String.format(ArgumentValidationException.m_messages.getString("validationError.MissingValue"));
50              }
51  
52              @Override public String expectedOneGotSome() {
53                  return String.format(ArgumentValidationException.m_messages.getString("validationError.AdditionalValue"), values.subList(1, values.size()));
54              }
55  
56              @Override public String expectedExactGotTooFew(final int exactly, final int valueCount) {
57                  if(exactly == 1)
58                  {
59                      return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanExactly"), exactly, values);
60                  }
61                  return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanExactly"), exactly, values);
62              }
63  
64              @Override public String expectedExactGotTooMany(final int exactly, final int valueCount) {
65                  final List<String> subList = values.subList(exactly, values.size());
66                  if(exactly == 1) {
67                      return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanExactly"), exactly, subList);
68                  }
69                  return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanExactly"), exactly, subList);
70              }
71  
72              @Override public String expectedMinimumGotTooFew(final int minimum, final int valueCount) {
73                  if(minimum == 1) {
74                      return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValueThanMinimum"), minimum, values);
75                  }
76                  return String.format(ArgumentValidationException.m_messages.getString("validationError.LessValuesThanMinimum"), minimum, values);
77              }
78  
79              @Override public String expectedMaximumGotTooMany(final int maximum, final int valueCount) {
80                  final List<String> subList = values.subList(maximum, values.size());
81                  if(maximum == 1) {
82                      return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValueThanMaximum"), maximum, subList);
83                  }
84                  return String.format(ArgumentValidationException.m_messages.getString("validationError.MoreValuesThanMaximum"), maximum, subList);
85              }
86  
87              @Override public String allowed() {
88                  throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
89              }});
90      }
91  
92      @Override public ValidationFailureType getFailureType() {
93          return specification.compareCountToSpecification(values.size(), new SpecificationMultiplicity<ValidationFailureType>(){
94              @Override public ValidationFailureType expectedNoneGotSome() {
95                  return ValidationFailureType.UnexpectedValue;
96              }
97  
98              @Override public ValidationFailureType expectedOneGotNone() {
99                  return ValidationFailureType.MissingValue;
100             }
101 
102             @Override public ValidationFailureType expectedOneGotSome() {
103                 return ValidationFailureType.UnexpectedAdditionalValue;
104             }
105 
106             @Override public ValidationFailureType expectedExactGotTooFew(final int exactly, final int valueCount) {
107                 return ValidationFailureType.TooFewValues;
108             }
109 
110             @Override public ValidationFailureType expectedExactGotTooMany(final int exactly, final int valueCount) {
111                 return ValidationFailureType.TooManyValues;
112             }
113 
114             @Override public ValidationFailureType expectedMinimumGotTooFew(final int minimum, final int valueCount) {
115                 return ValidationFailureType.TooFewValues;
116             }
117 
118             @Override public ValidationFailureType expectedMaximumGotTooMany(final int maximum, final int valueCount) {
119                 return ValidationFailureType.TooManyValues;
120             }
121 
122             @Override public ValidationFailureType allowed() {
123                 throw new JewelRuntimeException("unable to determine why the number of values is wrong " + specification + " with values (" + values.size() + ")");
124             }});
125     }
126 }