Shoulda context and syntax, ruby 2.1 - minitest

The following code doesn't compile in ruby 2.1 on OS X. The error message is quite strange:
/Library/Ruby/Gems/2.0.0/gems/rake-10.3.2/lib/rake/rake_test_loader.rb:10:in `require':
/Users/jayunit100/Development/leitmotif/test/test_leitmotif.rb:21:
syntax error, unexpected keyword_end, expecting end-of-input (SyntaxError)
That is, it is requesting that i remove the final "end" statement from the class, and when i do so, it indeed compiles ! So my first question is , how or why it is that the rake_test_loader wants a class declaration without a closing end block.
require 'helper'
require 'minitest/autorun'
class TestLeitmotif < MiniTest::Test
### A simple test
context "Leitmotif core tests" do
setup do
#lm = Leitmotif.new
end
should "run should return 1 if arguments are invalid"
#lm=Leitmotif.new
print("\nASDF\n")
print(#lz.inspect);
print(#lm.inspect)
print("\nASDF\n")
x=#lm.run("","")
#assert_equal 1, x
end
end
end
My second problem here is that the variable
#lm = Leimotif.new
Which is declared in the setup block, seems to be inaccessible in the should method.
My suspicion here is that somehow the syntax of the should framework is not parsed correctly in the current version of ruby, but am quite new to ruby so any insight would be appreciated.
Thanks!

This error is because you are missing the do at the beginning of the block passed to should.
should "run should return 1 if arguments are invalid" do
#lm=Leitmotif.new
print("\nASDF\n")
print(#lz.inspect);
print(#lm.inspect)
print("\nASDF\n")
x=#lm.run("","")
#assert_equal 1, x
end
Most implementations of shoulda on Minitest simply alias the Minitest Spec DSL's it to should, so those docs should help.

Related

Call groovy script dynamically in Apache Camel using doTry-doCatch

I'm building a route which calls a groovy script whose path is dynamically computed and, if the script can't be found, defaults to a generic, static script:
.doTry()
.toD("language://groovy:resource:classpath:scripts/${exchangeProperty.consumerType}ResponseHandler.groovy")
.doCatch(FileNotFoundException.class)
.script().groovy("resource:classpath:scripts/defaultResponseHandler.groovy")
.end()
The problem is that the exchange property consumerType is not resolved since the uri string parameter of toD is evaluated using groovy and not simple.
MultipleCompilationErrorsException -> startup failed:
Script_09b4150584d9e2c979353feee06897b5.groovy: 1: Unexpected input: 'scripts/${exchangeProperty.consumerType}' # line 1, column 20.
resource:classpath:scripts/${exchangeProperty.consumerType}ResponseHandler.groovy
^
1 error
How can I obtain the desired behavior?
According to the error shown there, it seems Camel is not able to resolve the string you provided in the toD().
By default, the expression you pass to a dynamic to is evaluated as Simple language but, as described in To Dynamic Camel documentation, you can specify other languages for the dynamic evaluation.
In your case, you are trying to evaluate the endpoint with groovy language but then you're using Simple language to substitute a piece of the name of the script.
One solution I've found (yet not the best) would be to specify the language for the interpretation of the string as simple and then use language:groovy to specify the endpoint that will need to be called.
You could write something like this:
.doTry()
.toD("language:simple:language://groovy:resource:classpath:scripts/${exchangeProperty.consumerType}ResponseHandler.groovy")
.doCatch(FileNotFoundException.class)
.script().groovy("resource:classpath:scripts/defaultResponseHandler.groovy")
.end()
It seems to work, but I hope someone else comes up with a better solution.

"Expected an assignment or function call and instead saw an expression no-unused-expressions" "while using Optional Chaining"

useEffect(()=>{
scrollRef.current?.scrollIntoView({behavior:"smooth"})
},[messages])
This use hook shows an error while compiling as "Expected an assignment or function call and instead saw an expression no-unused-expressions", the "?" used is -i think- is the cause which is called "Optional chaining" ..Right? im not sure.
I couldnt understand what makes this statement doesnt work for me , please help me. every info you pass would be be really greatfull.
is it beacuse i miss any npm module?..

What to do when a code review tool declares unmatched types?

I am working on developing a large-scale Python (backend) project. I was working with a firm that does extensive testing, and they built the frontend and test tools. Before every deploy, all the tools (like linters) are run regularly.
I had put down the code for a while, and now it fails many tests. Some of these are deprecation warnings for features or syntax soon to be deprecated, and they note they started classifying those as warnings (to later become errors) starting January 1, 2020, so I know they make dynamic changes in the tools themselves.
My problem is a bunch of code that used to pass no longer does. And the error is always the same: if I have a line that looks like so, I get an error that says something along the lines of "error: may not use operator '-' with incompatible types; a and b are of types numpy.array and NoneType":
x = a - b
This gets fixed by making the code super-messy with this sort of fix:
x = a.astype(float) - b.astype(float)
It's even worse because in the actual code there are 3 variables, all doing addition and subtraction with a 'c' that is an integer array kicking around along with the two numpy arrays. But then the code goes from:
x = a - b - c
to:
x = a.astype(float) - b.astype(float) - c.astype(float)
And this won't work since int's don't have an astype method. The error looks like this now:
File "/home/engine.py", line 165, in Foo
lower_array[t].astype(float)) / num_values.astype(float)
AttributeError: 'NoneType' object has no attribute 'astype'
Thus, I end up with:
x = a.astype(float) - b.astype(float) - float(c)
This is all extraordinarily cumbersome and nasty casting that is required, and makes the code impossible to read.
The odd thing to me is that all three arrays were instantiated as numpy arrays, i.e.,:
a=numpy.array(_a)
b=numpy.array(_b)
c=numpy.array(_c)
When I ask the code to put output to stdout the type of all three vars, they all say . Yet, the next line of code blows up and dumps, saying "Attribute error: 'NoneType' object has no attribute 'astype'"
I can't fathom how a static code analyzer determines the types - other than as numpy.ndarray type - since Python uses duck-typing. Thus, the type could change dynamically. But that's not the case here; all three vars are identified as numpy.ndarray type, but "z = a - b - c" fails.
Anyone understand what's going on here?
After much work, the answer is to ignore the linter. Readable code is the object, not code that satisfies a linter.

Error on printIN function for groovy

I am fairly new to java programming and I am trying to learn groovy right now.
I am getting this weird error when I am entering a simple line of code of hello world.
I am buffered. I believe I have set the environment variables correctly
You have the method name wrong
It's println not printIn
If you look at the exception, it tells you what's wrong, and a list of possible solutions
I think that you are using the wrong letter:
println "hello"
with "L" lowercase

Groovy method naming convention or magic?

I try to create a small DSL, but i'm struggling with even simple stuff.
The following script gives me an error.
def DEMON(String input) {
['a': input]
}
DEMON 'Hello thingy' a
For some reasons, the parentheses around the parameters are not optional and i get an error.
This script runs fine:
def dEMON(String input) {
['a': input]
}
dEMON 'Hello thingy' a
Note: the only difference is the lowercase first char.
So what is going on here? Why are the scripts interpreted (compiled?) different? Is there some kind of method/class naming schemes i have to follow?
Update: The error message. I guess a Syntax error:
unexpected token: Hello thingy # line 4, column 7.
The groovy syntax is sometime complex, and the compiler use some rules to choose what it must do. One of this rule is simple : If a word starts with an uppercase, it's probably a class.
for example, f String is a syntax valid in groovy, and the compiler converts it to f(String.class).
you can use parenthesis to help groovy understand your DEMON is not a class but a method, DEMON('Hello thingy', a)

Resources