binary encode 7 ([7].pack("C")) as "\007" instead of "\a"

[Woody Peterson]

I have a problem that's on the borders of ruby and erlang, but I'm
beginning to think the solution won't be from the erlang side of things.
(and forgive me for my haziness with the terminology here...)

The basic problem is that ruby encodes the integer 7 as "\a", while
erlang only decodes it as "\007". Ruby *will* decode both "\007" and
"\a" into 7, which makes me think there's more than one opinion about
how it can be encoded, and that ruby might be able to encode it as
"\007" if I knew how to ask it.

The bigger problem is I'm trying to send data from ruby to erlang via
BERT, and turns out it can't handle data (broadly defined) of length 7
(!).

Here's some code examples:

ruby:

[7].pack("C") # => "\a"
"\a".unpack("C") # => 7
"\007".unpack("C") # => 7

erlang:

<<"\a">>. % => <<a>>
<<"\007">>. % => <<7>>

Not sure exactly what to google here, "erlang OR
ruby binary 007" doesn't really get me anywhere (suprise!), plus I'm
not sure what exactly this encoding/decoding specification is called.
I'd really like to understand why the design discrepancy between the
languages, but I'd settle for a quick fix on the ruby side

Any help is appreciated,

-Woody

(PS, more details are at
http://github.com/mojombo/bert.erl/issues#issue/3, although examples are
bert-specific)

 

[Woody Peterson]

The basic problem is that ruby encodes the integer 7 as "\a", while

erlang only decodes it as "\007"

Correction, this is actually a non-issue. The basic problem is that I
was encoding binary data to its C escape sequences in my test (via
to_s), and erlang will automatically decode this back to binary, except
for the number 7. Thus it *appeared* like it was almost working, when in
fact I was just doing it wrong. Sending the binary, not the escape
sequences, is what I should have been doing. Apologies for the extra
email, maybe this will save some poor confused soul someday...

 

[Ryan Davis]

Correction, this is actually a non-issue.

Well, I think it was a non-issue regardless of what erlang is doing:

"\a" == "\007" => true
"\007"[0] => 7
"\a"[0]

=> 7

I'd guess you should be writing tests to verify instead of eyeballing it.

 

[Woody Peterson]

"\a" == "\007"

I'd guess you should be writing tests to verify instead of eyeballing
it.

In Ruby "\a" == "\007", but when my integration test (incorrectly)
converted the binary into escape sequences before sending it to erlang,
*then*, in erlang, <<"\a">> =/= <<"\007">> (not-equal, and I have
learned this is because Erlang uses the basic C set of character
encodings, while Ruby uses the ANSI C encodings, which differ in at
least this respect). So in my tests erlang -> ruby would work, but ruby
-> erlang wouldn't work, and tests confirmed this to be due to character
encoding differences (how I knew to ask the question). Those differences
are verifiable, although the whole point is moot (and I feel stupid for
asking because I should have been testing via binary in the first place
:/