Merge pull request #3452 from shockey/v/3.0.21

v3.0.21 (hotfix release)

README.md

@@ -22,7 +22,7 @@ The OpenAPI Specification has undergone 4 revisions since initial creation in 20
 
 Swagger UI Version | Release Date | OpenAPI Spec compatibility | Notes | Status
 ------------------ | ------------ | -------------------------- | ----- | ------
-3.0.20              | 2017-07-21   | 2.0                        | [tag v3.0.20](https://github.com/swagger-api/swagger-ui/tree/v3.0.20) |
+3.0.21              | 2017-07-24   | 2.0                        | [tag v3.0.21](https://github.com/swagger-api/swagger-ui/tree/v3.0.21) |
 2.2.10             | 2017-01-04   | 1.1, 1.2, 2.0              | [tag v2.2.10](https://github.com/swagger-api/swagger-ui/tree/v2.2.10) |
 2.1.5              | 2016-07-20   | 1.1, 1.2, 2.0              | [tag v2.1.5](https://github.com/swagger-api/swagger-ui/tree/v2.1.5) |
 2.0.24             | 2014-09-12   | 1.1, 1.2 | [tag v2.0.24](https://github.com/swagger-api/swagger-ui/tree/v2.0.24) |

dist/swagger-ui-bundle.js.map

@@ -1 +1 @@
-{"version":3,"file":"swagger-ui-bundle.js","sources":["webpack:///swagger-ui-bundle.js"],"mappings":"AAAA;;;;;AAsyKA;;;;;;AA4uEA;;;;;;;;;;;;;;;;;;;;;;;;;;AAkqTA;;;;;;;;;;;;;;AA+5JA;;;;;;;;;AAmwnBA;;;;;AA+kQA;;;;;;AA+gXA","sourceRoot":""}
+{"version":3,"file":"swagger-ui-bundle.js","sources":["webpack:///swagger-ui-bundle.js"],"mappings":"AAAA;;;;;AAsyKA;;;;;;AAmtEA;;;;;;;;;;;;;;;;;;;;;;;;;;AAkqTA;;;;;;;;;;;;;;AA+5JA;;;;;;;;;AAkwnBA;;;;;AA6kQA;;;;;;AA+gXA","sourceRoot":""}

dist/swagger-ui.js.map

@@ -1 +1 @@
-{"version":3,"file":"swagger-ui.js","sources":["webpack:///swagger-ui.js"],"mappings":"AAAA;;;;;;AAw8aA","sourceRoot":""}
+{"version":3,"file":"swagger-ui.js","sources":["webpack:///swagger-ui.js"],"mappings":"AAAA;;;;;;AA46aA","sourceRoot":""}

package.json

@@ -1,6 +1,6 @@
 {
   "name": "swagger-ui",
-  "version": "3.0.20",
+  "version": "3.0.21",
   "main": "dist/swagger-ui.js",
   "repository": "git@github.com:swagger-api/swagger-ui.git",
   "contributors": [

src/core/components/layout-utils.jsx

@@ -129,8 +129,7 @@ export class Select extends React.Component {
     value: PropTypes.any,
     onChange: PropTypes.func,
     multiple: PropTypes.bool,
-    allowEmptyValue: PropTypes.bool,
-    className: PropTypes.string
+    allowEmptyValue: PropTypes.bool
   }
 
   static defaultProps = {
@@ -143,7 +142,7 @@ export class Select extends React.Component {
 
     let value
 
-    if (props.value) {
+    if (props.value !== undefined) {
       value = props.value
     } else {
       value = props.multiple ? [""] : ""
@@ -179,7 +178,7 @@ export class Select extends React.Component {
     let value = this.state.value.toJS ? this.state.value.toJS() : this.state.value
 
     return (
-      <select className={this.props.className} multiple={ multiple } value={ value } onChange={ this.onChange } >
+      <select multiple={ multiple } value={ value } onChange={ this.onChange } >
         { allowEmptyValue ? <option value="">--</option> : null }
         {
           allowedValues.map(function (item, key) {

src/core/json-schema-components.js

@@ -57,8 +57,7 @@ export class JsonSchema_string extends Component {
 
     if ( enumValue ) {
       const Select = getComponent("Select")
-      return (<Select className={ errors.length ? "invalid" : ""}
-                      allowedValues={ enumValue }
+      return (<Select allowedValues={ enumValue }
                       value={ value }
                       allowEmptyValue={ !required }
                       onChange={ this.onEnumChange }/>)
@@ -122,7 +121,6 @@ export class JsonSchema_array extends PureComponent {
   render() {
     let { getComponent, required, schema, fn } = this.props
 
-    let errors = schema.errors || []
     let itemSchema = fn.inferSchema(schema.items)
 
     const JsonSchemaForm = getComponent("JsonSchemaForm")
@@ -133,17 +131,19 @@ export class JsonSchema_array extends PureComponent {
 
     if ( enumValue ) {
       const Select = getComponent("Select")
-      return (<Select className={ errors.length ? "invalid" : ""}
-                     multiple={ true }
+      return (<Select multiple={ true }
                      value={ value }
                      allowedValues={ enumValue }
                      allowEmptyValue={ !required }
                      onChange={ this.onEnumChange }/>)
     }
 
+    let errors = schema.errors || []
+
     return (
       <div>
-        { !value || value.count() < 1 ? null : 
+        { !value || value.count() < 1 ?
+          (errors.length ? <span style={{ color: "red", fortWeight: "bold" }}>{ errors[0] }</span> : null) :
           value.map( (item,i) => {
             let schema = Object.assign({}, itemSchema)
             if ( errors.length ) {
@@ -153,12 +153,12 @@ export class JsonSchema_array extends PureComponent {
           return (
             <div key={i} className="json-schema-form-item">
               <JsonSchemaForm fn={fn} getComponent={getComponent} value={item} onChange={(val) => this.onItemChange(val, i)} schema={schema} />
-              <Button className="btn btn-sm json-schema-form-item-remove" onClick={()=> this.removeItem(i)} > - </Button>
+              <Button className="json-schema-form-item-remove" onClick={()=> this.removeItem(i)} > - </Button>
             </div>
             )
           }).toArray()
         }
-        <Button className={`btn btn-sm json-schema-form-item-add ${errors.length ? "invalid" : null}`} onClick={this.addItem}> Add item </Button>
+        <Button className="json-schema-form-item-add" onClick={this.addItem}> Add item </Button>
       </div>
     )
   }
@@ -170,14 +170,12 @@ export class JsonSchema_boolean extends Component {
 
   onEnumChange = (val) => this.props.onChange(val)
   render() {
-    let { getComponent, value, schema } = this.props
-    let errors = schema.errors || []
+    let { getComponent, required, value } = this.props
     const Select = getComponent("Select")
 
-    return (<Select className={ errors.length ? "invalid" : ""}
-                    value={ String(value) }
+    return (<Select value={ String(value) }
                     allowedValues={ fromJS(["true", "false"]) }
-                    allowEmptyValue={true}
+                    allowEmptyValue={ !required }
                     onChange={ this.onEnumChange }/>)
   }
 }

src/core/utils.js

@@ -468,18 +468,6 @@ export const validateFile = ( val ) => {
   }
 }
 
-export const validateBoolean = ( val ) => {
-  if ( !(val === "true" || val === "false" || val === true || val === false) ) {
-    return "Value must be a boolean"
-  }
-}
-
-export const validateString = ( val ) => {
-  if ( val && typeof val !== "string" ) {
-    return "Value must be a string"
-  }
-}
-
 // validation of parameters before execute
 export const validateParam = (param, isXml) => {
   let errors = []
@@ -487,66 +475,53 @@ export const validateParam = (param, isXml) => {
   let required = param.get("required")
   let type = param.get("type")
 
-  // If the parameter is required OR the parameter has a value (meaning optional, but filled in)
-  // then we should do our validation routine
-  if ( required || value ) {
-    // These checks should evaluate to true if the parameter's value is valid
-    let stringCheck = type === "string" && value && !validateString(value)
-    let arrayCheck = type === "array" && Array.isArray(value) && value.length
-    let listCheck = type === "array" && Im.List.isList(value) && value.count()
-    let fileCheck = type === "file" && value instanceof win.File
-    let booleanCheck = type === "boolean" && !validateBoolean(value)
-    let numberCheck = type === "number" && !validateNumber(value) // validateNumber returns undefined if the value is a number
-    let integerCheck = type === "integer" && !validateInteger(value) // validateInteger returns undefined if the value is an integer
+  let stringCheck = type === "string" && !value
+  let arrayCheck = type === "array" && Array.isArray(value) && !value.length
+  let listCheck = type === "array" && Im.List.isList(value) && !value.count()
+  let fileCheck = type === "file" && !(value instanceof win.File)
+  let nullUndefinedCheck = value === null || value === undefined
 
-    if ( required && !(stringCheck || arrayCheck || listCheck || fileCheck || booleanCheck || numberCheck || integerCheck) ) {
-      errors.push("Required field is not provided")
-      return errors
-    }
+  if ( required && (stringCheck || arrayCheck || listCheck || fileCheck || nullUndefinedCheck) ) {
+    errors.push("Required field is not provided")
+    return errors
+  }
 
-    if ( type === "string" ) {
-      let err = validateString(value)
-      if (!err) return errors
-      errors.push(err)
-    } else if ( type === "boolean" ) {
-      let err = validateBoolean(value)
-      if (!err) return errors
-      errors.push(err)
-    } else if ( type === "number" ) {
-      let err = validateNumber(value)
-      if (!err) return errors
-      errors.push(err)
-    } else if ( type === "integer" ) {
-      let err = validateInteger(value)
-      if (!err) return errors
-      errors.push(err)
-    } else if ( type === "array" ) {
-      let itemType
+  if ( value === null || value === undefined ) {
+    return errors
+  }
 
-      if ( !value.count() ) { return errors }
+  if ( type === "number" ) {
+    let err = validateNumber(value)
+    if (!err) return errors
+    errors.push(err)
+  } else if ( type === "integer" ) {
+    let err = validateInteger(value)
+    if (!err) return errors
+    errors.push(err)
+  } else if ( type === "array" ) {
+    let itemType
 
-      itemType = param.getIn(["items", "type"])
+    if ( !value.count() ) { return errors }
 
-      value.forEach((item, index) => {
-        let err
+    itemType = param.getIn(["items", "type"])
 
-        if (itemType === "number") {
-          err = validateNumber(item)
-        } else if (itemType === "integer") {
-          err = validateInteger(item)
-        } else if (itemType === "string") {
-          err = validateString(item)
-        }
+    value.forEach((item, index) => {
+      let err
 
-        if ( err ) {
-          errors.push({ index: index, error: err})
-        }
-      })
-    } else if ( type === "file" ) {
-      let err = validateFile(value)
-      if (!err) return errors
-      errors.push(err)
-    }
+      if (itemType === "number") {
+        err = validateNumber(item)
+      } else if (itemType === "integer") {
+        err = validateInteger(item)
+      }
+
+      if ( err ) {
+        errors.push({ index: index, error: err})
+      }
+    })
+  } else if ( type === "file" ) {
+    let err = validateFile(value)
+    if (!err) return errors
+    errors.push(err)
   }
 
   return errors

src/style/_buttons.scss

@@ -14,11 +14,6 @@
 
     @include text_headline();
 
-    &.btn-sm {
-        font-size: 12px;
-        padding: 4px 23px;
-    }
-
     &[disabled]
     {
         cursor: not-allowed;
@@ -170,9 +165,6 @@
 button
 {
     cursor: pointer;
-    outline: none;
 
-    &.invalid {
-        @include invalidFormElement();
-    }
+    outline: none;
 }

src/style/_form.scss

@@ -21,10 +21,6 @@ select
 
         background: #f7f7f7;
     }
-
-    &.invalid {
-        @include invalidFormElement();
-    }
 }
 
 .opblock-body select
@@ -57,8 +53,12 @@ input[type=file]
     border-radius: 4px;
     background: #fff;
 
-    &.invalid {
-        @include invalidFormElement();
+    &.invalid
+    {
+        animation: shake .4s 1;
+
+        border-color: $_color-delete;
+        background: lighten($_color-delete, 35%);
     }
 }
 

src/style/_mixins.scss

@@ -166,9 +166,3 @@ $browser-context: 16;
         @warn 'Breakpoint mixin supports: tablet, mobile, desktop';
     }
 }
-
-@mixin invalidFormElement() {
-    animation: shake .4s 1;
-    border-color: $_color-delete;
-    background: lighten($_color-delete, 35%);
-}

src/style/_table.scss

@@ -97,10 +97,6 @@ table
         width: 100%;
         max-width: 340px;
     }
-
-    select {
-        border-width: 1px;
-    }
 }
 
 .parameter__name

test/core/utils.js

@@ -176,7 +176,6 @@ describe("utils", function() {
     let result = null
 
     it("validates required strings", function() {
-      // invalid string
       param = fromJS({
         required: true,
         type: "string",
@@ -184,39 +183,9 @@ describe("utils", function() {
       })
       result = validateParam( param, false )
       expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid string
-      param = fromJS({
-        required: true,
-        type: "string",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional strings", function() {
-      // valid (empty) string
-      param = fromJS({
-        required: false,
-        type: "string",
-        value: ""
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid string
-      param = fromJS({
-        required: false,
-        type: "string",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
     })
 
     it("validates required files", function() {
-      // invalid file
       param = fromJS({
         required: true,
         type: "file",
@@ -224,48 +193,9 @@ describe("utils", function() {
       })
       result = validateParam( param, false )
       expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid file
-      param = fromJS({
-        required: true,
-        type: "file",
-        value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional files", function() {
-      // invalid file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: "not a file"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a file"] )
-
-      // valid (empty) file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid file
-      param = fromJS({
-        required: false,
-        type: "file",
-        value: new win.File()
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
     })
 
     it("validates required arrays", function() {
-      // invalid (empty) array
       param = fromJS({
         required: true,
         type: "array",
@@ -274,51 +204,75 @@ describe("utils", function() {
       result = validateParam( param, false )
       expect( result ).toEqual( ["Required field is not provided"] )
 
-      // invalid (not an array)
       param = fromJS({
         required: true,
         type: "array",
-        value: undefined
+        value: []
       })
       result = validateParam( param, false )
       expect( result ).toEqual( ["Required field is not provided"] )
+    })
 
-      // invalid array, items do not match correct type
+    it("validates numbers", function() {
+      // string instead of a number
       param = fromJS({
-        required: true,
-        type: "array",
-        value: [1],
-        items: {
-          type: "string"
-        }
+        required: false,
+        type: "number",
+        value: "test"
       })
       result = validateParam( param, false )
-      expect( result ).toEqual( [{index: 0, error: "Value must be a string"}] )
+      expect( result ).toEqual( ["Value must be a number"] )
 
-      // valid array, with no 'type' for items
+      // undefined value
       param = fromJS({
-        required: true,
-        type: "array",
-        value: ["1"]
+        required: false,
+        type: "number",
+        value: undefined
       })
       result = validateParam( param, false )
       expect( result ).toEqual( [] )
 
-      // valid array, items match type
+      // null value
       param = fromJS({
-        required: true,
-        type: "array",
-        value: ["1"],
-        items: {
-          type: "string"
-        }
+        required: false,
+        type: "number",
+        value: null
       })
       result = validateParam( param, false )
       expect( result ).toEqual( [] )
     })
 
-    it("validates optional arrays", function() {
-      // valid, empty array
+    it("validates integers", function() {
+      // string instead of integer
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: "test"
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( ["Value must be an integer"] )
+
+      // undefined value
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: undefined
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+
+      // null value
+      param = fromJS({
+        required: false,
+        type: "integer",
+        value: null
+      })
+      result = validateParam( param, false )
+      expect( result ).toEqual( [] )
+    })
+
+    it("validates arrays", function() {
+      // empty array
       param = fromJS({
         required: false,
         type: "array",
@@ -327,7 +281,7 @@ describe("utils", function() {
       result = validateParam( param, false )
       expect( result ).toEqual( [] )
 
-      // invalid, items do not match correct type
+      // numbers
       param = fromJS({
         required: false,
         type: "array",
@@ -339,209 +293,17 @@ describe("utils", function() {
       result = validateParam( param, false )
       expect( result ).toEqual( [{index: 0, error: "Value must be a number"}] )
 
-      // valid
+      // integers
       param = fromJS({
         required: false,
         type: "array",
-        value: ["test"],
+        value: ["not", "numbers"],
         items: {
-          type: "string"
+          type: "integer"
         }
       })
       result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required booleans", function() {
-      // invalid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid boolean value (not a boolean)
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid boolean value
-      param = fromJS({
-        required: true,
-        type: "boolean",
-        value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional booleans", function() {
-      // valid (empty) boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // invalid boolean value (not a boolean)
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: "test string"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a boolean"] )
-
-      // valid boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: "true"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid boolean value
-      param = fromJS({
-        required: false,
-        type: "boolean",
-        value: false
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required numbers", function() {
-      // invalid number, string instead of a number
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid number, undefined value
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid number
-      param = fromJS({
-        required: true,
-        type: "number",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional numbers", function() {
-      // invalid number, string instead of a number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be a number"] )
-
-      // valid (empty) number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid number
-      param = fromJS({
-        required: false,
-        type: "number",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates required integers", function() {
-      // invalid integer, string instead of an integer
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // invalid integer, undefined value
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Required field is not provided"] )
-
-      // valid integer
-      param = fromJS({
-        required: true,
-        type: "integer",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-    })
-
-    it("validates optional integers", function() {
-      // invalid integer, string instead of an integer
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: "test"
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( ["Value must be an integer"] )
-
-      // valid (empty) integer
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: undefined
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
-
-      // valid number
-      param = fromJS({
-        required: false,
-        type: "integer",
-        value: 10
-      })
-      result = validateParam( param, false )
-      expect( result ).toEqual( [] )
+      expect( result ).toEqual( [{index: 0, error: "Value must be an integer"}, {index: 1, error: "Value must be an integer"}] )
     })
   })