You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
{{ message }}
This repository has been archived by the owner on Jun 3, 2021. It is now read-only.
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
code format with danger-code_style_validation based on clang-format
clang-format support code format for program language like:java, c++, c, objective.
create a new file named Dangerfile and add a new line:
This check scans through your code and libraries and looks at the APIs being used, and checks this against the set of permissions required to access those APIs. If the code using those APIs is called at runtime, then the program will crash.
Furthermore, for permissions that are revocable (with targetSdkVersion 23), client code must also be prepared to handle the calls throwing an exception if the user rejects the request for permission at runtime. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "MissingPermission" as explained in the Suppressing Warnings and Errors section.
In a custom view's draw implementation, you should normally call getWidth and getHeight on the custom view itself, not on the canvas instance.
Canvas width and height are the width and height of the Canvas, which is not always the same as size of the view.
In the hardware accelerated path the width and height of the canvas typically always match that of the View because every view goes to its own recorded DisplayList. But in software rendering there's just one canvas that is clipped and transformed as it makes its way through the View tree, and otherwise remains the same Canvas object for every View's draw method.
You should only use Canvas state to adjust how much you draw, such as a quick-reject for early work avoidance if it's going to be clipped away, but not what you draw. To suppress this error, use the issue id "CanvasSize" as explained in the Suppressing Warnings and Errors section.
../../src/main/java/com/taobao/weex/WXEnvironment.java:61: Implicitly using the default locale is a common source of bugs: Use toUpperCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
../../src/main/java/com/taobao/weex/WXEnvironment.java:64: Implicitly using the default locale is a common source of bugs: Use toUpperCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
../../src/main/java/com/taobao/weex/http/WXStreamModule.java:79: Implicitly using the default locale is a common source of bugs: Use toUpperCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
76 String body = paramsObj.getString("body"); 77 int timeout = paramsObj.getIntValue("timeout"); 78 79 if (method != null) method = method.toUpperCase(); 80 Options.Builder builder = new Options.Builder() 81 .setMethod(!"GET".equals(method) 82 &&!"POST".equals(method)
../../src/main/java/com/taobao/weex/http/WXStreamModule.java:160: Implicitly using the default locale is a common source of bugs: Use toUpperCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
../../src/main/java/com/taobao/weex/http/WXStreamModule.java:237: Implicitly using the default locale is a common source of bugs: Use toLowerCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
../../src/main/java/com/taobao/weex/http/WXStreamModule.java:246: Implicitly using the default locale is a common source of bugs: Use toLowerCase(Locale) instead. For strings meant to be internal use Locale.ROOT, otherwise Locale.getDefault().
Calling String#toLowerCase() or #toUpperCase()without specifying an explicit locale is a common source of bugs. The reason for that is that those methods will use the current locale on the user's device, and even though the code appears to work correctly when you are developing the app, it will fail in some locales. For example, in the Turkish locale, the uppercase replacement for i is notI.
If you want the methods to just perform ASCII replacement, for example to convert an enum name, call String#toUpperCase(Locale.US) instead. If you really want to use the current locale, call String#toUpperCase(Locale.getDefault()) instead.
This check scans through all the Android API field references in the application and flags certain constants, such as static final integers and Strings, which were introduced in later versions. These will actually be copied into the class files rather than being referenced, which means that the value is available even when running on older devices. In some cases that's fine, and in other cases it can result in a runtime crash or incorrect behavior. It depends on the context, so consider the code carefully and decide whether it's safe and can be suppressed or whether the code needs to be guarded.
If you really want to use this API and don't need to support older devices just set the minSdkVersion in your build.gradle or AndroidManifest.xml files.
If your code is deliberately accessing newer APIs, and you have ensured (e.g. with conditional execution) that this code will only ever be called on a supported platform, then you can annotate your class or method with the @TargetApi annotation specifying the local minimum SDK to apply, such as @TargetApi(11), such that this check considers 11 rather than your manifest file's minimum SDK as the required API level. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "InlinedApi" as explained in the Suppressing Warnings and Errors section.
InlinedApiCorrectnessWarningPriority 6/10
Explain
Dismiss
Missing Default
../../src/main/res/values-ldltr/isrtl.xml:23: The bool "weex_is_right_to_left" in values-ldltr has no declaration in the base values folder; this can lead to crashes when the resource is queried in a configuration that does not match this qualifier
../../src/main/res/values-ldrtl/istrtl.xml:23: The bool "weex_is_right_to_left" in values-ldrtl has no declaration in the base values folder; this can lead to crashes when the resource is queried in a configuration that does not match this qualifier
If a resource is only defined in folders with qualifiers like -land or -en, and there is no default declaration in the base folder (layout or values etc), then the app will crash if that resource is accessed on a device where the device is in a configuration missing the given qualifier.
As a special case, drawables do not have to be specified in the base folder; if there is a match in a density folder (such as drawable-mdpi) that image will be used and scaled. Note however that if you only specify a drawable in a folder like drawable-en-hdpi, the app will crash in non-English locales.
There may be scenarios where you have a resource, such as a -fr drawable, which is only referenced from some other resource with the same qualifiers (such as a -fr style), which itself has safe fallbacks. However, this still makes it possible for somebody to accidentally reference the drawable and crash, so it is safer to create a default dummy fallback in the base folder. Alternatively, you can suppress the issue by adding tools:ignore="MissingDefaultResource" on the element.
(This scenario frequently happens with string translations, where you might delete code and the corresponding resources, but forget to delete a translation. There is a dedicated issue id for that scenario, with the id ExtraTranslation.) To suppress this error, use the issue id "MissingDefaultResource" as explained in the Suppressing Warnings and Errors section.
47 }
48 49 public WXAbstractRenderContainer(@NonNull Context context, @Nullable AttributeSet attrs, int defStyleAttr, int defStyleRes) {
50 super(context, attrs, defStyleAttr, defStyleRes); 51 }
52 53 publicvoid setSDKInstance(WXSDKInstance instance) {
This check scans through all the Android API calls in the application and warns about any calls that are not available on all versions targeted by this application (according to its minimum SDK attribute in the manifest).
If you really want to use this API and don't need to support older devices just set the minSdkVersion in your build.gradle or AndroidManifest.xml files.
If your code is deliberately accessing newer APIs, and you have ensured (e.g. with conditional execution) that this code will only ever be called on a supported platform, then you can annotate your class or method with the @TargetApi annotation specifying the local minimum SDK to apply, such as @TargetApi(11), such that this check considers 11 rather than your manifest file's minimum SDK as the required API level.
If you are deliberately setting android: attributes in style definitions, make sure you place this in a values-vNN folder in order to avoid running into runtime conflicts on certain devices where manufacturers have added custom attributes whose ids conflict with the new ones on later platforms.
Similarly, you can use tools:targetApi="11" in an XML file to indicate that the element will only be inflated in an adequate context. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "NewApi" as explained in the Suppressing Warnings and Errors section.
Toast.makeText() creates a Toast but does not show it. You must call show() on the resulting object to actually make the Toast appear. To suppress this error, use the issue id "ShowToast" as explained in the Suppressing Warnings and Errors section.
ShowToastCorrectnessWarningPriority 6/10
Explain
Dismiss
Implied locale in date format
../../src/main/java/com/taobao/weex/bridge/WXBridgeManager.java:949: To get local formatting use getDateInstance(), getDateTimeInstance(), or getTimeInstance(), or use new SimpleDateFormat(String template, Locale locale) with for example Locale.US for ASCII dates.
946 publicvoid callReportCrash(String crashFile, final String instanceId, final String url) {
947 // statistic weex core process crash 948 Date date = new Date();
949 DateFormat format = new SimpleDateFormat("yyyyMMddHHmmss"); 950 String time = format.format(date);
951 final String origin_filename = crashFile + "." + time;
952 File oldfile = new File(crashFile);
Almost all callers should use getDateInstance(), getDateTimeInstance(), or getTimeInstance() to get a ready-made instance of SimpleDateFormat suitable for the user's locale. The main reason you'd create an instance this class directly is because you need to format/parse a specific machine-readable format, in which case you almost certainly want to explicitly ask for US to ensure that you get ASCII digits (rather than, say, Arabic digits).
Therefore, you should either use the form of the SimpleDateFormat constructor where you pass in an explicit locale, such as Locale.US, or use one of the get instance methods, or suppress this error if really know what you are doing.
In order to support features such as tinting, the appcompat library will automatically load special appcompat replacements for the builtin widgets. However, this does not work for your own custom views.
Instead of extending the android.widget classes directly, you should instead extend one of the delegate classes in android.support.v7.widget.AppCompat. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "AppCompatCustomView" as explained in the Suppressing Warnings and Errors section.
AppCompatCustomViewCorrectnessErrorPriority 4/10
Explain
Dismiss
Value overridden by Gradle build script
../../src/main/AndroidManifest.xml:22: This versionCode value (1) is not used; it is always overridden by the value specified in the Gradle build script (1)
../../src/main/AndroidManifest.xml:23: This versionName value (1.0) is not used; it is always overridden by the value specified in the Gradle build script (0.26.0.1)
The value of (for example) minSdkVersion is only used if it is not specified in the build.gradle build scripts. When specified in the Gradle build scripts, the manifest value is ignored and can be misleading, so should be removed to avoid ambiguity. To suppress this error, use the issue id "GradleOverrides" as explained in the Suppressing Warnings and Errors section.
For applications built for API levels below 17, WebView#addJavascriptInterface presents a security hazard as JavaScript on the target web page has the ability to use reflection to access the injected object's public fields and thus manipulate the host application in unintended ways.
Using these device identifiers is not recommended other than for high value fraud prevention and advanced telephony use-cases. For advertising use-cases, use AdvertisingIdClient$Info#getId and for analytics, use InstanceId#getId.
Dynamically loading code from locations other than the application's library directory or the Android platform's built-in library directories is dangerous, as there is an increased risk that the code could have been tampered with. Applications should use loadLibrary when possible, which provides increased assurance that libraries are loaded from one of these safer locations. Application developers should use the features of their development environment to place application native libraries into the lib directory of their compiled APKs. To suppress this error, use the issue id "UnsafeDynamicallyLoadedCode" as explained in the Suppressing Warnings and Errors section.
You should avoid allocating objects during a drawing or layout operation. These are called frequently, so a smooth UI can be interrupted by garbage collection pauses caused by the object allocations.
The way this is generally handled is to allocate the needed objects up front and to reuse them for each drawing operation.
Some methods allocate memory on your behalf (such as Bitmap.create), and these should be handled in the same way. To suppress this error, use the issue id "DrawAllocation" as explained in the Suppressing Warnings and Errors section.
718 if (mTargetView == null) { 719 returnfalse; 720 } 721 if (Build.VERSION.SDK_INT < 14) { 722 if (mTargetView instanceof AbsListView) { 723 final AbsListView absListView = (AbsListView) mTargetView; 724 if (absListView.getChildCount() > 0) {
This check flags version checks that are not necessary, because the minSdkVersion (or surrounding known API level) is already at least as high as the version checked for.
Similarly, it also looks for resources in -vNN folders, such as values-v14 where the version qualifier is less than or equal to the minSdkVersion, where the contents should be merged into the best folder. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "ObsoleteSdkInt" as explained in the Suppressing Warnings and Errors section.
Non-static inner classes have an implicit reference to their outer class. If that outer class is for example a Fragment or Activity, then this reference means that the long-running handler/loader/task will hold a reference to the activity which prevents it from getting garbage collected.
Similarly, direct field references to activities and fragments from these longer running instances can cause leaks.
ViewModel classes should never point to Views or non-application Contexts. To suppress this error, use the issue id "StaticFieldLeak" as explained in the Suppressing Warnings and Errors section.
63 64 public WXTimerModule() {
65 handler = new Handler(WXBridgeManager.getInstance().getJSLooper(), this);
66 antiIntAutoBoxing = new SparseArray<>(); 67 }
68
For maps where the keys are of type integer, it's typically more efficient to use the Android SparseArray API. This check identifies scenarios where you might want to consider using SparseArray instead of HashMap for better performance.
This is particularly useful when the value types are primitives like ints, where you can use SparseIntArray and avoid auto-boxing the values from int to Integer.
If you need to construct a HashMap because you need to call an API outside of your control which requires a Map, you can suppress this warning using for example the @SuppressLint annotation. To suppress this error, use the issue id "UseSparseArrays" as explained in the Suppressing Warnings and Errors section.
You should not call the constructor for wrapper classes directly, such as`new Integer(42)`. Instead, call the valueOf factory method, such as Integer.valueOf(42). This will typically use less memory because common integers such as 0 and 1 will share a single instance. Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "UseValueOf" as explained in the Suppressing Warnings and Errors section.
UseValueOfPerformanceWarningPriority 4/10
Explain
Dismiss
Image defined in density-independent drawable folder
The res/drawable folder is intended for density-independent graphics such as shapes defined in XML. For bitmaps, move it to drawable-mdpi and consider providing higher and lower resolution versions in drawable-ldpi, drawable-hdpi and drawable-xhdpi. If the icon really is density independent (for example a solid color) you can place it in drawable-nodpi.
Some layout tools (such as the Android layout editor) need to find a constructor with one of the following signatures:
* View(Context context)
* View(Context context, AttributeSet attrs)
* View(Context context, AttributeSet attrs, int defStyle)
If your custom view needs to perform initialization which does not apply when used in a layout editor, you can surround the given code with a check to see if View#isInEditMode() is false, since that method will return false at runtime but true within a user interface editor. To suppress this error, use the issue id "ViewConstructor" as explained in the Suppressing Warnings and Errors section.
106 }
107 108 @Override 109 publicbooleanonTouchEvent(MotionEvent ev) { 110 if(!scrollable) {
111 returntrue; // when scrollable is set to false, then eat the touch event 112 }
183 } 184 185 @Override 186 publicbooleanonTouchEvent(MotionEvent ev) { 187 if(!scrollable) { 188 returntrue; // when scrollable is set to false, then eat the touch event 189 }
65 } 66 67 @Override 68 publicbooleanonTouchEvent(MotionEvent event) { 69 boolean result = super.onTouchEvent(event); 70 if (wxGesture != null) { 71 result |= wxGesture.onTouch(this, event);
If a View that overrides onTouchEvent or uses an OnTouchListener does not also implement performClick and call it when clicks are detected, the View may not handle accessibility actions properly. Logic handling the click actions should ideally be placed in View#performClick as some accessibility services invoke performClick when a click action should occur. To suppress this error, use the issue id "ClickableViewAccessibility" as explained in the Suppressing Warnings and Errors section.
Using Gravity#LEFT and Gravity#RIGHT can lead to problems when a layout is rendered in locales where text flows from right to left. Use Gravity#START and Gravity#END instead. Similarly, in XML gravity and layout_gravity attributes, use start rather than left.
For XML attributes such as paddingLeft and layout_marginLeft, use paddingStart and layout_marginStart. NOTE: If your minSdkVersion is less than 17, you should add both the older left/right attributes as well as the new start/right attributes. On older platforms, where RTL is not supported and the start/right attributes are unknown and therefore ignored, you need the older left/right attributes. There is a separate lint check which catches that type of error.
(Note: For Gravity#LEFT and Gravity#START, you can use these constants even when targeting older platforms, because the start bitmask is a superset of the left bitmask. Therefore, you can use gravity="start" rather than gravity="left|start".) Note: This issue has an associated quickfix operation in Android Studio and IntelliJ IDEA.
To suppress this error, use the issue id "RtlHardcoded" as explained in the Suppressing Warnings and Errors section.
The reason will be displayed to describe this comment to others. Learn more.
Correct me if I am wrong.
It seems like you are using the ruby version of danger for code_format, and the ruby version danger will some use Dangerfile as its source.
If this is the case, relying on https://github.com/wrmswindmill/danger-code_style_validation.git is not an option in my knowledge, as the source file could be changed in any minutes. At least, you should rely a publish version of https://github.com/wrmswindmill/danger-code_style_validation.git. I suggest you share your ideas in the mailing list.
PS:
I don't see the output of the code format in danger.
You should also provide a format script or file, within which developers could import the file into their IDE( XCode or Android Studio) and format code with one click.
Sign up for freeto subscribe to this conversation on GitHub.
Already have an account?
Sign in.
Labels
None yet
5 participants
Add this suggestion to a batch that can be applied as a single commit.This suggestion is invalid because no changes were made to the code.Suggestions cannot be applied while the pull request is closed.Suggestions cannot be applied while viewing a subset of changes.Only one suggestion per line can be applied in a batch.Add this suggestion to a batch that can be applied as a single commit.Applying suggestions on deleted lines is not supported.You must change the existing code in this line in order to create a valid suggestion.Outdated suggestions cannot be applied.This suggestion has been applied or marked resolved.Suggestions cannot be applied from pending reviews.Suggestions cannot be applied on multi-line comments.Suggestions cannot be applied while the pull request is queued to merge.Suggestion cannot be applied right now. Please check back later.
Brief Description of the PR
Add Static Check in Travis CI
Lint Tool Lists:
Check FileType
OCLint in .travis.yml
Android Lint in .travis.yml
Code Format
code format with danger-code_style_validation based on clang-format
clang-format support code format for program language like:java, c++, c, objective.
Update iOS
Todo
Links