Add flake8 test and fix pep8 style in expansion scripts

Makefile

@@ -41,7 +41,7 @@ clean:
 	rm -rf bin
 
 .PHONY: test
-test: build test-style test-unit
+test: build test-style test-unit test-flake8
 
 ROOTFS := rootfs
 
@@ -64,6 +64,12 @@ test-style: lint vet
 		echo "gofmt check failed:"; gofmt -e -d -s $(GO_DIRS); exit 1; \
 	fi
 
+.PHONY: test-flake8
+test-flake8:
+	@echo Running flake8...
+	flake8 expansion
+	@echo ----------------
+
 .PHONY: lint
 lint:
 	@echo Running golint...

circle.yml

@@ -19,6 +19,7 @@ dependencies:
     - export PATH="$HOME/bin:$PATH" GLIDE_HOME="$HOME/.glide"
     - cd $GOPATH/src/$IMPORT_PATH
     - sudo pip install -r expansion/requirements.txt
+    - sudo pip install flake8
 
 test:
   override:

expansion/file_expander.py

@@ -4,7 +4,7 @@
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
+#           http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ -19,31 +19,31 @@ from expansion import Expand
 
 
 def main():
-  if len(sys.argv) < 2:
-    print >>sys.stderr, 'No template specified.'
-    sys.exit(1)
-  template = ''
-  imports = {}
-  try:
-    with open(sys.argv[1]) as f:
-      template = f.read()
-    for imp in sys.argv[2:]:
-      import_contents = ''
-      with open(imp) as f:
-        import_contents = f.read()
-        import_name = os.path.basename(imp)
-        imports[import_name] = import_contents
-  except IOError as e:
-    print 'IOException: ', str(e)
-    sys.exit(1)
+    if len(sys.argv) < 2:
+        print >>sys.stderr, 'No template specified.'
+        sys.exit(1)
+    template = ''
+    imports = {}
+    try:
+        with open(sys.argv[1]) as f:
+            template = f.read()
+        for imp in sys.argv[2:]:
+            import_contents = ''
+            with open(imp) as f:
+                import_contents = f.read()
+                import_name = os.path.basename(imp)
+                imports[import_name] = import_contents
+    except IOError as e:
+        print 'IOException: ', str(e)
+        sys.exit(1)
 
-  env = {}
-  env['deployment'] = os.environ['DEPLOYMENT_NAME']
-  env['project'] = os.environ['PROJECT']
-  validate_schema = 'VALIDATE_SCHEMA' in os.environ
+    env = {}
+    env['deployment'] = os.environ['DEPLOYMENT_NAME']
+    env['project'] = os.environ['PROJECT']
+    validate_schema = 'VALIDATE_SCHEMA' in os.environ
 
-  print  Expand(template, imports, env=env, validate_schema=validate_schema)
+    print Expand(template, imports, env=env, validate_schema=validate_schema)
 
 
 if __name__ == '__main__':
-  main()
+    main()

expansion/schema_validation_utils.py

@@ -4,7 +4,7 @@
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
-#     http://www.apache.org/licenses/LICENSE-2.0
+#           http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ -23,74 +23,77 @@ REQUIRED = 'required'
 
 
 def ExtendWithDefault(validator_class):
-  """Takes a validator and makes it set default values on properties.
+    """Takes a validator and makes it set default values on properties.
 
-  Args:
-    validator_class: A class to add our overridden validators to
+    Args:
+        validator_class: A class to add our overridden validators to
 
-  Returns:
-    A validator_class that will set default values and ignore required fields
-  """
-  validate_properties = validator_class.VALIDATORS['properties']
+    Returns:
+        A validator_class that will set default values
+        and ignore required fields
+    """
+    validate_properties = validator_class.VALIDATORS['properties']
 
-  def SetDefaultsInProperties(validator, user_schema, user_properties,
-                              parent_schema):
-    SetDefaults(validator, user_schema or {}, user_properties, parent_schema,
-                validate_properties)
+    def SetDefaultsInProperties(validator, user_schema, user_properties,
+                                parent_schema):
+        SetDefaults(validator, user_schema or {}, user_properties,
+                    parent_schema, validate_properties)
 
-  return jsonschema.validators.extend(
-      validator_class, {PROPERTIES: SetDefaultsInProperties,
-                        REQUIRED: IgnoreKeyword})
+    return jsonschema.validators.extend(
+            validator_class, {PROPERTIES: SetDefaultsInProperties,
+                              REQUIRED: IgnoreKeyword})
 
 
 def SetDefaults(validator, user_schema, user_properties, parent_schema,
                 validate_properties):
-  """Populate the default values of properties.
-
-  Args:
-    validator: A generator that validates the "properties" keyword of the schema
-    user_schema: Schema which might define defaults, might be a nested part of
-      the entire schema file.
-    user_properties: User provided values which we are setting defaults on
-    parent_schema: Schema object that contains the schema being evaluated on
-      this pass, user_schema.
-    validate_properties: Validator function, called recursively.
-  """
-
-  for schema_property, subschema in user_schema.iteritems():
-    # The ordering of these conditions assumes that '$ref' blocks override
-    # all other schema info, which is what the jsonschema library assumes.
-
-    # If the subschema has a reference,
-    # see if that reference defines a 'default' value
-    if REF in subschema:
-      out = ResolveReferencedDefault(validator, subschema[REF])
-      user_properties.setdefault(schema_property, out)
-    # Otherwise, see if the subschema has a 'default' value
-    elif DEFAULT in subschema:
-      user_properties.setdefault(schema_property, subschema[DEFAULT])
-
-  # Recursively apply defaults. This is a generator, so we must wrap with list()
-  list(validate_properties(validator, user_schema,
-                           user_properties, parent_schema))
+    """Populate the default values of properties.
+
+    Args:
+        validator: A generator that validates the "properties" keyword
+                   of the schema
+        user_schema: Schema which might define defaults, might be a nested
+                     part of the entire schema file.
+        user_properties: User provided values which we are setting defaults on
+        parent_schema: Schema object that contains the schema being
+                       evaluated on this pass, user_schema.
+        validate_properties: Validator function, called recursively.
+    """
+
+    for schema_property, subschema in user_schema.iteritems():
+        # The ordering of these conditions assumes that '$ref' blocks override
+        # all other schema info, which is what the jsonschema library assumes.
+
+        # If the subschema has a reference,
+        # see if that reference defines a 'default' value
+        if REF in subschema:
+            out = ResolveReferencedDefault(validator, subschema[REF])
+            user_properties.setdefault(schema_property, out)
+        # Otherwise, see if the subschema has a 'default' value
+        elif DEFAULT in subschema:
+            user_properties.setdefault(schema_property, subschema[DEFAULT])
+
+    # Recursively apply defaults. This is a generator, we must wrap with list()
+    list(validate_properties(validator, user_schema,
+                             user_properties, parent_schema))
 
 
 def ResolveReferencedDefault(validator, ref):
-  """Resolves a reference, and returns any default value it defines.
+    """Resolves a reference, and returns any default value it defines.
 
-  Args:
-    validator: A generator that validates the "$ref" keyword
-    ref: The target of the "$ref" keyword
+    Args:
+        validator: A generator that validates the "$ref" keyword
+        ref: The target of the "$ref" keyword
 
-  Returns:
-    The value of the 'default' field found in the referenced schema, or None
-  """
-  with validator.resolver.resolving(ref) as resolved:
-    if DEFAULT in resolved:
-      return resolved[DEFAULT]
+    Returns:
+        The value of the 'default' field found in the referenced schema,
+        or None
+    """
+    with validator.resolver.resolving(ref) as resolved:
+        if DEFAULT in resolved:
+            return resolved[DEFAULT]
 
 
 def IgnoreKeyword(
-    unused_validator, unused_required, unused_instance, unused_schema):
-  """Validator for JsonSchema that does nothing."""
-  pass
+        unused_validator, unused_required, unused_instance, unused_schema):
+    """Validator for JsonSchema that does nothing."""
+    pass