sometimes, it is better to temporarily use a deprecated method than to create several branches of a project to support several versions of Pharo. At least, that's what I sometimes do. However, calling a deprecated method makes my unit-tests fail in Pharo 3.0.
Is there anything I can do?
Shouldn't it be sufficient to switch off deprecation warnings? I think the reason is that opening the deprecation warning is based on an exception that the test case catches.
Related
I want to use some JsonPath library in browser, but they all relying on eval()/Function() that get caught with unsafe-eval by CSP. And any other workarounds/3rd party libraries like static-eval/safe-eval also all get caught with the same console error. Does anyone know of any other potential workarounds to resolve this unsafe-eval issue besides allowing the unsafe-eval csp directive?
The best thing I found was an old fork of JSONPath-Plus that attempted to create a non-eval version of the library. Here's the Pull Request, however, this was never merged (fully) because of some merge issues and performance issues.
I imagine performance would be a problem for other non-eval implementations as well, and that's why we have non, at least to my knowledge.
I have an API server built with loopback.io (NodeJS) version 3.0.0, however latest version is 3.17.1 and there obviously have been a lot of security and bug fixes over all this time, which makes me feel on potential danger and outdated.
How can I update the framework without affecting my own code? How do other frameworks deal with this kind of issue?
Your code should be completely separate from the loopback.io code. As such, you should be able to do npm update looback.io from the right directory and it should update the loopback.io code and not affect your code at all.
Now this assumes you were using loopback.io as a library that you loaded with require() and that you did not modify the actual loopback.io code yourself in any way.
Before upgrading, you will want to examine the release notes for the revisions of loopback.io since the version you originally installed and make sure there are only bug fixes and no compatibility issues with code written for prior versions (e.g. API changes, etc...). If there are any API changes or "breaking" fixes, then you may have to slightly modify your code in that one area to update to the new API.
Then, after upgrading, run your unit tests to see if everything is still working as you would expect.
We have a node.js project, and we want to start managing its dependencies using npm's package.json with specified versions for each dependency.
However, we are afraid that one of the packages our project depends on might get unpublished. Should I worry about unpublishing or is it a rare occurrence? What is the most effective way to handle this kind of problems?
It is very rare occurence. Never happened to me.
Unpublish is mostly used to remove a published version in which a major bug is reported. Thus, automatic semantic versioning upgrade will not fetch this version until a new one is published.
Are there any plans for the ServiceStack packages to start using the SemVer standard? We just had an unfortunate circumstance where we were broken by the interface breaking changes introduced in 4.0.44 from 4.0.43 around OrmLite.
We are a sizable commercial customer and have a custom implementation of a OrmLiteDialectProvider for one of our DBMSs, it all seemed good upon the initial upgrade in our web application, however as part of testing the changes around type converting broke our system. This wasn't initially evident as part of the upgrade because our custom implementation is in a NuGet package which overrides OrmLiteDialectProvider.ConvertDbValue on version 4.0.38 which is now gone. There were no binding issues because it is only a minor version difference.
NuGet adopted SemVer back in version 1.6.
Having the SemVer standard would make it a lot easier for us to know when interface breaking changes have been made, without having to dig through the Release Notes page.
NOTE: The release also didn't indicate that the old method had been removed and upgrading would break any custom implementations.
UPDATE FROM RESPONSE
Anyway, fair enough answer. I can appreciate it would be difficult to track each package individually. In our case we wrote a custom dialect provider as we have a legacy DBMS that wasn't supported and this appeared to be the way we were supposed to add the support. We wanted to use ORMLite because we use the rest of ServiceStack and it's a fantastic product.
The new way to support the types is a great improvement and actually made our implementation easier.
We actually ran into this issue because we do always keep our ServiceStack packages inline and were upgrading the ASP portion for some fixes to the WSDL generation and this came along as part of our upgrade.
ServiceStack adopts a single rolling version for all NuGet packages which all share the same Version number. Of all ServiceStack's 60 NuGet packages it's likely there's a breaking change to at least one of the packages so semver would be useless, you should also never mix and match different versions of ServiceStack together - when you upgrade, upgrade all packages to reference the same package versions. We do aim to keep user-facing breaking changes to a minimum, by looking to deprecate old API's first, maintain parallel API versions for a while then list the new API's release notes.
IOrmLiteDialectProvider is not a user-facing interface
However IOrmLiteDialectProvider is not considered a user-facing interface since it should be extremely rare that anyone implements their own custom provider. It's also the interface for specialization for all RDBMS's and often changes with every release to support new features, internal refactoring, optimizations, etc. E.g. implementing Type Converters was a major internal refactor that required changes to IOrmLiteDialectProvider but did not affect OrmLite's external user-facing API, later releases includes optimizations requiring further changes, again this doesn't affect OrmLite's external user-facing API.
SemVer won't help here, every ServiceStack version potentially has a breaking change in some of the packages and we have no intention to complicate each release by versioning each of the individual packages differently. The issue you're having is depending on an unstable Interface that's not intended for customization. It's not treated as a user-facing API so we don't try to maintain compatibility with existing versions or publish breaking changes which happens nearly every time we add features / optimizations to OrmLite. You should instead check the commit history of
IOrmLiteDialectProvider for any changes to this interface.
I just downloaded the 30-day trial of IntelliJ IDEA Ultimate Edition and I'm having an issue with the Node.js project I imported.
I am using Mongoose and am using the find and findById methods of my model classes fairly often. Since these methods are provided by mongoose and not actually defined explicitly in my model classes, IntelliJ does not seem to like them. Everywhere that I use the methods, I get an error saying "Unresolved function or method xxx".
I have read several other users stating they had similar issues with Node and WebStorm, but those all seemed to be with the code Node library and all of the answers said to use the Node.js Globals library. I have imported this library and tried downloading both mongodb-DefinitelyTyped and mongoose-DefinitelyTyped from the Libraries screen, and still cannot get the warnings to go away.
I decided it was probably faster to contact JetBrains support since I didn't seem to be getting any quick solutions here. I guess this issue is a bug with IntelliJ IDEA 14 because they had me try the IntelliJ IDEA 15 EAP and it worked fine.
So I guess the solution is to go EAP or just wait for 15 if anybody else has this issue.