Merge pull request #14 from alerque/message-access

Add idomatic Lua access to Message from table properties

Author: alerque

README.md

@@ -49,21 +49,32 @@ Initialized project with some boiler plate Lua aparatus.
 Lua code `demo.lua`:
 
 ```lua
+-- Import and start a new instance
 local FluentBundle = require("fluent")
-local en = FluentBundle("en-US")
-en:add_messages({
-    "foo = bar",
-    "hello = Hello { $name }!"
-  })
-print(en:format("foo"))
-print(en:format("hello", { name = "World" }))
+local bundle = FluentBundle()
+
+-- Load some messages (can be a string or table of strings)
+bundle:add_messages([[
+foo = bar
+hello = Hello { $name }!
+]])
+
+-- Access methods like other Fluent implementations
+print(bundle:format("foo"))
+print(bundle:format("hello", { name = "World" }))
+
+-- Alternate idomatic Lua access methods
+print(bundle["foo"]) -- access property, implicit cast to string, cannot pass parammeters
+print(bundle.hello({ name = "World" })) -- access as property is callable, parameters passed to format()
 ```
 
 Output of `lua demo.lua`:
 
 ```txt
 bar
 Hello World!
+bar
+Hello World!
 ```
 
 ## Alternative(s)

fluent/init.lua

@@ -11,14 +11,25 @@ local FluentBundle = class({
     syntax = FluentSyntax(),
 
     _init = function (self, locale)
-      self.locale = locale
+      self.locale = locale or "und"
+      self.locales = {}
+      -- Penlight bug #307, should be — self:catch(self.get_message)
+      self:catch(function(_, k) return self:get_message(k) end)
     end,
 
-    add_messages = function (self, input)
+    get_message = function (self, identifier)
+      local locale = rawget(self, "locale")
+      local locales = rawget(self, "locales")
+      local default = rawget(locales, locale)
+      -- TODO iterate over fallback locales if not found in default
+      return default and default[identifier] or nil
+    end,
+
+    add_messages = function (self, input, locale)
       if type(input) == "string" then input = { input } end
       local resources = tablex.imap(function (v) return self.syntax:parsestring(v) end, input)
       local resource = tablex.reduce('+', resources)
-      self.locales[self.locale] = resource
+      self.locales[locale or self.locale] = resource
     end,
 
     format = function (self, identifier, parameters)

fluent/resource.lua

@@ -55,6 +55,18 @@ local FluentNode = class({
 
     attach = function (self, node)
       return node and type(node.__mul) == "function" and self * node
+    end,
+
+    __call = function (self, ...)
+      return self:format(...)
+    end,
+
+    __tostring = function (self)
+      return self:format({})
+    end,
+
+    __concat = function (a, b)
+      return tostring(a) .. tostring(b)
     end
 
   })
@@ -86,6 +98,11 @@ node_types.Message = class({
     _init = function (self, node)
       self.attributes = {}
       self:super(node)
+      -- Penlight bug #307, should be — self:catch(self.get_attribute)
+      self:catch(function(_, k) return self:get_attribute(k) end)
+    end,
+    get_attribute = function(self, attribute)
+      return self.index[attribute] and self.attributes[self.index[attribute]] or nil
     end,
     format = function (self, parameters)
       return self.value:format(parameters)
@@ -298,6 +315,9 @@ node_types.Attribute = class({
         self.value = node
         return self
       end
+    end,
+    format = function (self, parameters)
+      return self.value:format(parameters)
     end
   })
 
@@ -350,7 +370,8 @@ local FluentResource = class({
         end
       end
       flush()
-      -- self:catch(function (self, identifier) return self:get_message(identifier) end)
+      -- Penlight bug #307, should be — self:catch(self.get_message)
+      self:catch(function(_, k) return self:get_message(k) end)
     end,
 
     insert = function (self, node)
@@ -361,15 +382,12 @@ local FluentResource = class({
     end,
 
     get_message = function (self, identifier)
+      local key = rawget(self.index, string.match(identifier, "^(%a[-_%a%d]+)"))
+      if not key then return end
+      local entry = rawget(self, "body")[key]
+      if not entry then return end
       local attr = string.match(identifier, "%.([(%a[-_%a%d]+)$")
-      local id = string.match(identifier, "^(%a[-_%a%d]+)")
-      if not self.index[id] then error("No such entry") end
-      local entry = self.body[self.index[id]]
-      if attr then
-        return entry.attributes[entry.index[attr]].value
-      else
-        return entry.value
-      end
+      return attr and entry.attributes[entry.index[attr]] or entry
     end,
 
     dump_ast = function (self)

spec/fluent_spec.lua

@@ -46,6 +46,47 @@ describe('fluent.bundle', function ()
     assert.equals("qux", en:format("foo.baz"))
   end)
 
+  describe('messages', function ()
+    local en = FluentBundle("en-US")
+    en:add_messages("hi = Hello { $name }!\nfoo = bar\nbar = baz\n    .bax = qux")
+
+    it('can be accessed as properties', function ()
+      assert.same("bar", en.foo:format())
+      assert.same("bar", en["foo"]:format())
+      assert.same("baz", en.bar:format())
+      assert.same("baz", en["bar"]:format())
+    end)
+
+    it('attributes can be accessed as properties', function ()
+      assert.same("qux", en["bar.bax"]())
+      assert.same("qux", en.bar["bax"]())
+      assert.same("qux", en.bar.bax())
+    end)
+
+    it('can be called', function ()
+      assert.same("bar", en.foo())
+      assert.same("bar", en["foo"]())
+      assert.same("baz", en.bar())
+      assert.same("baz", en["bar"]())
+    end)
+
+    it('can be called with parameters', function ()
+      assert.same("Hello World!", en.hi({name = "World"}))
+      assert.same("Hello World!", en["hi"]({name = "World"}))
+      assert.same("Hello World!", en["hi"]:format({name = "World"}))
+    end)
+
+    it('can be cast to strings', function ()
+      assert.same("baz", tostring(en.bar))
+      assert.same("bar", tostring(en["foo"]))
+      assert.same("xbar", "x" .. en.foo)
+      assert.same("xbaz", "x" .. en["bar"])
+      assert.same("barx", en.foo .. "x")
+      assert.same("bazx", en["bar"] .. "x")
+    end)
+
+  end)
+
   it('should keep locale instances separate', function ()
     local en = FluentBundle("en-US")
     local tr = FluentBundle("tr-TR")