When I add this line to a plugin I am writing I get an error from Lightroom

MyPluginApi:28 cannot open JSON:lua: No such file or directory

The thing that makes no sense to me is that the JSON.lua file is located in the same directory as MyPluginApi.lua

Do you have an example plugin that might show the usage of this JSON library working?

Thanks

It looks as if you have a colon before ‘lua’ rather than a dot. —Jeffrey

Hi,

thanks for this. I’ve just checked out the file, but I didn’t find any info regarding the license type, just your copyright notice.

From a legal perspective, if the code comes without a license everyone can have a look but no one can use it, for any type of project. So are there any strings attached?

Cheers,

Michael

Feel free to use it as you like. —Jeffrey

Err… something seems to be up with the comments in the file:
Lines 14 and 123 have -- JSON = (loadfile "JSON.lua")() -- one-time load of the routines
While lines 24 and 111 have -- JSON = (loadfile "JSON:lua")() -- one-time load of the routines

That JSON.lua / JSON:lua is a bit inconsistent… Is that intentional? (Considering that Lightroom just gave me the error “attempt to call a nil value” when I tried loading JSON:lua, I doubt it…)

Also, THANK YOU for publishing this. It’s making my first foray into Lightroom plugin development (and Lua) so much easier!

(While I’m at it, any pointers on using relative paths in loadfile(), or, alternatively, finding out with directory is Lightroom’s working directory so I can build a relative path from that? Doing loadfile(JSON.lua) falls over with File not found, but putting the absolute path in works fine, but… won’t work for anyone but me, which is not an optimal solution.

And Lightroom’s file access is too fast to show up in Process Explorer, so I can’t get anything from there.)

Oops, thanks, I thought I fixed that once, but apparently not in my master source, so it reared its ugly head again. It should be dot-“lua” in all situations, so I’ve fixed it (again), thanks. As for the path stuff, try loadfile(LrPathUtils.child(_PLUGIN.path, “JSON.lua”)) or the like. —Jeffrey

I just included your JSON.lua file in my project: https://github.com/etu/i3luastatus. I hope it’s fine.

Sure, it’s fine, you’re not the only one these days. I realize, though, that there was no link back to this page, so it’s harder for folks to check for updates, so I’ve added a link in the code directly back to this page. —Jeffrey

Jeffrey,

Thanks – great module.

Would you mind putting the ‘Feel free to use this any way you like” comment in the code (or just say you are placing in the public domain) rather than just in the blog. That would make your intentions clear to anyone auditing code later, which sadly gets done.

Alex

I’ve updated the code and the web page to reflect a Creative Commons “CC-BY” license, which is what I really should have done from the beginning. —Jeffrey

Hey there from Spain!

I just wanted to thank you for releasing this, it literally saved my life, as I am using Lua in a closed environment for a project, and the functions they provided me to work with JSON were pretty lame.

And I must also say thanks for your pure lua sha1 implementation! ; )

Regards.

Hello Jeffrey,

Thank you very much for making your code available.
When trying to decode a malformed JSON:

{"sleepCycle": 15,a"enabled": 1}

your code gets to line 550:

      -- should never get here... JSON parse errors should have been caught earlier
      assert(false, value)

and fails. Although it says it should not get there, it’s there.
Anyway I think the right code should be:

      -- should never get here... JSON parse errors should have been caught earlier
      -- assert(false, value)
	   if self.assert then
		  self.assert(false, message)
	   else
		  assert(false, message)
	   end

To be able to catch the exception. Do you agree?
Best regards.

Good catch… the “should never get here” comment is true only if the user’s JSON.assert actually breaks out of the pcall, as it does when I use it in Adobe Lightroom, so it’s not an appropriate comment for the general package, so I’ve updated it, and the code as you suggest (with s/message/value/). Thanks for the heads up. —Jeffrey

Nice job: thank you!

Forked this repo for LuaRocks. Do you have GitHub account for this?
https://github.com/jiyinyiyong/json-lua

No, sorry, no GitHub. —Jeffrey

Hi Jeffrey,
Thanks a lot for this code ! Excellent work ! We are using this serilizer together with Zabbix JSON-RPC API in a large distributed monitoring network. This code provided us with an excellent jumpstart at first when we made a prototype of the gateway from Zabbix to internal ESB. After a while we have decided not to touch anything as it works perfectly and performance is sufficient for this project.

Thanks a lot again,
Greetings from Kazakhstan,
Pavel.

During encode(), numbers larger than 1e14 were being changed to scientific notation.

Here is some lua code to show how tostring() handles large numbers
> x=100000000000001
> print(tonumber(x));
1e+14
> print(string.format(“%.0f”,x))
100000000000001

I changes the encoding to use the “%.0f” format -> works great

Here is the GIT DIFF
@@ -837,7 +837,10 @@ function encode_value(self, value, parents, etc, options, indent)
—
return “-1e+9999”
else
– return tostring(value)
+ return string.format(“%.0f”, value);
end

Any thoughts or ways around having decode properly handling nil values from a table?

For instance:
{
“somevalue”: null
}

will create a empty output since lua doesn’t support nil values as a key in a table element.

I’ve locally (and horribly) solved this by patching if nil to return a function that returns nil — but looking at the table I have to account for that too — then on the encode I just say if it’s a function then it is nil — good enough for me, but not for a general stance.
local function grok_object(self, text, start, etc)
[…]
VALUE[key] = new_val or function() return nil end

function encode_value(self, value, parents, etc, options, indent)
if type(value) == ‘function’ then value = nil end
if value == nil then
return ‘null’

Other than this small hiccup, I really love how the rest works… Efficient and stable!

As of version 20160526.15 I’ve added a “null” field to the encoding-options table. If your Lua table has a string value with the same value as the “null” option, it gets encoded into JSON as a raw null. Using null="\0" might be appropriate, for example. —Jeffrey

I have found a bug when decoding an empty object, it is interpreted as an empty array, at least that is what shows on encode().
look at the field: ‘attributes’, it is an object in the string and then an array on decode()

lua
> JSON = (loadfile “./JSON.lua”)();– one-time load routines
> x='{“id”:”UserInfo_BILL”,”actions”:[],”attributes”:{}}’
> y=JSON:decode(x)
> print(JSON:encode(y));
{“actions”:[],”attributes”:[],”id”:”UserInfo_BILL”}

As mentioned in the docs, it’s handled correctly if you “JSON.strictTypes = true“. It’s not the default because supporting it requires adding metatables to the data, which can break some systems into which Lua is embedded. —Jeffrey

Hi!
This is an awesome module, thanks a lot!

Wanted to know, sadly in the project I’m testing, ‘the order’ of some keys in the json file needs to be preserved, my question is, is it possible when reading a json to keep the original order in which they were read?
decoding/encoding the same file changes the order of key-value pairs.

It’s not currently possible, sorry. Lua tables have no order for non-numeric keys, so to preserve the order you’d have to use metatables somehow, which just opens up a can of worms for handling that metadata (e.g. what to do when new keys are added in Lua). —Jeffrey

Hey, do you have the old versions 1-20 somewhere online?
It would be cool to have a look at them (push them to git for proper version history/changes etc).

Cheers

You can append the version string to the download link to get old ones, e.g. http://regex.info/code/JSON.lua-20140920.13 —Jeffrey

local stock= ‘{“open”:332.44,”close”:329.87,”high”:332.5,”low”:328.15,”volume”:11038600.0,”actual_close”:331.29}’
local s = JSON:decode(stock)
return s[“high”]

This gives me a result of 332
or if I add JSON.decodeNumbersAsObjects = true I get: (empty list or set)

What do I need to get the right answer, 332.5?

Are you sure you’re not using it in some kind of integer context once you get the value back from whatever function this is? I changed your ‘return’ line to a ‘print’ line, and I got the proper 332.5. —Jeffrey

hi, Jeffrey

I add a ‘array_newline’ option, which show array

[11,22,[33,44]]


as

[
| 11,
| 22,
| [
| | 33,
| | 44
| ]
]


https://github.com/yurenchen000/json-lua/commit/e870c6e702deacd3b9c5c2b1135893791fc51e16

thank you~

Seems like a good idea… I’ve added it, thanks! —Jeffrey

Thanks man, this is exactly what I needed. I was just messing around with modding a game that I am playing at the moment. I was looking to export some data as JSON, so that I persist state between gaming sessions. This did the trick perfectly. You’ve saved me a bunch of time, and I really appreciate that you make this free to use.

Thank you!

Using VERSION = ‘20170416.23’

At line 1325:

local encode_value – – must predeclare because it calls itself
function encode_value

Actually, you don’t need to predeclare a recursive function in Lua. The interpreter includes the function in its own _ENV before calling the function. You only need to predeclare pairs of recursive functions, like this:

local a
local function b()
  a()
end
function a()
  b()
end

I know about that property of Lua and use it elsewhere in the file, so I suppose there was something esoteric happening at one point during development that made me feel the need to do it explicitly. The Lua docs are pretty clear that the two expressions are identical, so I’m at a loss to guess what it might have been, but in any case, you’re right and I’ve tidied it up. Thanks. —Jeffrey

Hi Jeffrey,

Great package! We’ve been using it for a while now and it works pretty well. This seems to have been mentioned before but as of Version 20170823.25 (version 25: August 23, 2017) we haven’t been able to pass a null option for *decoding* JSON strings. This is useful to us because we need to retain keys in the lua table (since there is no distinction between keys that don’t exist and keys assigned as nil values). Having null configurable when encoding a JSON string is not sufficient because we decode, modify, and then subsequently encode it again. The patch we made was as follows:


1086: - return nil, start + 4
1086: + return options.null, start + 4


Is there any chance that this patch could be surfaced for the next release?

Cheers,
Max

Oops, yeah, that was mentioned four years ago… I completely missed it, sorry. Thanks for the bump. I’ve just pushed the update. —Jeffrey

The encode/decode process is causing loss of precision for floating point numbers. I changed the tostring() call in encode _value to string.format(‘%20.16g’,value) to fix the problem.

Could you give an example where the original code was losing precision? —Jeffrey

It is amazing work. Thank you for the sharing!

Hi Jeffrey,

Great library, thanks for sharing. I’m curious is there a way to make encoding happen in the order I create a table in Lua so keys are not sorted in alphabetic order? Let say I have a table t = {z = “some value for z”, a = “some value for a”} if I’ll encode it I’m going to get {“a”:”some value for a”, “z”: “some value for z”}

Thank you.

No, I don’t think that’s possible. As far as I know, there is no temporal information available in Lua tables to indicate any kind of added/modified order. —Jeffrey