rufus-lua-moon 0.3.2 → 0.4.0

data/vendor/leafo/moonscript/transform/statements.lua

@@ -0,0 +1,115 @@
+local types = require("moonscript.types")
+local ntype, mtype, is_value, NOOP
+ntype, mtype, is_value, NOOP = types.ntype, types.mtype, types.is_value, types.NOOP
+local comprehension_has_value
+comprehension_has_value = require("moonscript.transform.comprehension").comprehension_has_value
+local Run
+do
+  local _class_0
+  local _base_0 = {
+    call = function(self, state)
+      return self.fn(state)
+    end
+  }
+  _base_0.__index = _base_0
+  _class_0 = setmetatable({
+    __init = function(self, fn)
+      self.fn = fn
+      self[1] = "run"
+    end,
+    __base = _base_0,
+    __name = "Run"
+  }, {
+    __index = _base_0,
+    __call = function(cls, ...)
+      local _self_0 = setmetatable({}, _base_0)
+      cls.__init(_self_0, ...)
+      return _self_0
+    end
+  })
+  _base_0.__class = _class_0
+  Run = _class_0
+end
+local last_stm
+last_stm = function(stms)
+  local last_exp_id = 0
+  for i = #stms, 1, -1 do
+    local stm = stms[i]
+    if stm and mtype(stm) ~= Run then
+      if ntype(stm) == "group" then
+        return last_stm(stm[2])
+      end
+      last_exp_id = i
+      break
+    end
+  end
+  return stms[last_exp_id], last_exp_id, stms
+end
+local transform_last_stm
+transform_last_stm = function(stms, fn)
+  local _, last_idx, _stms = last_stm(stms)
+  if _stms ~= stms then
+    error("cannot transform last node in group")
+  end
+  return (function()
+    local _accum_0 = { }
+    local _len_0 = 1
+    for i, stm in ipairs(stms) do
+      if i == last_idx then
+        _accum_0[_len_0] = {
+          "transform",
+          stm,
+          fn
+        }
+      else
+        _accum_0[_len_0] = stm
+      end
+      _len_0 = _len_0 + 1
+    end
+    return _accum_0
+  end)()
+end
+local chain_is_stub
+chain_is_stub = function(chain)
+  local stub = chain[#chain]
+  return stub and ntype(stub) == "colon"
+end
+local implicitly_return
+implicitly_return = function(scope)
+  local is_top = true
+  local fn
+  fn = function(stm)
+    local t = ntype(stm)
+    if t == "decorated" then
+      stm = scope.transform.statement(stm)
+      t = ntype(stm)
+    end
+    if types.cascading[t] then
+      is_top = false
+      return scope.transform.statement(stm, fn)
+    elseif types.manual_return[t] or not is_value(stm) then
+      if is_top and t == "return" and stm[2] == "" then
+        return NOOP
+      else
+        return stm
+      end
+    else
+      if t == "comprehension" and not comprehension_has_value(stm) then
+        return stm
+      else
+        return {
+          "return",
+          stm
+        }
+      end
+    end
+  end
+  return fn
+end
+return {
+  Run = Run,
+  last_stm = last_stm,
+  transform_last_stm = transform_last_stm,
+  chain_is_stub = chain_is_stub,
+  implicitly_return = implicitly_return
+}

data/vendor/leafo/moonscript/transform/transformer.lua

@@ -0,0 +1,74 @@
+local ntype
+ntype = require("moonscript.types").ntype
+local Transformer
+do
+  local _class_0
+  local _base_0 = {
+    transform_once = function(self, scope, node, ...)
+      if self.seen_nodes[node] then
+        return node
+      end
+      self.seen_nodes[node] = true
+      local transformer = self.transformers[ntype(node)]
+      if transformer then
+        return transformer(scope, node, ...) or node
+      else
+        return node
+      end
+    end,
+    transform = function(self, scope, node, ...)
+      if self.seen_nodes[node] then
+        return node
+      end
+      self.seen_nodes[node] = true
+      while true do
+        local transformer = self.transformers[ntype(node)]
+        local res
+        if transformer then
+          res = transformer(scope, node, ...) or node
+        else
+          res = node
+        end
+        if res == node then
+          return node
+        end
+        node = res
+      end
+      return node
+    end,
+    bind = function(self, scope)
+      return function(...)
+        return self:transform(scope, ...)
+      end
+    end,
+    __call = function(self, ...)
+      return self:transform(...)
+    end,
+    can_transform = function(self, node)
+      return self.transformers[ntype(node)] ~= nil
+    end
+  }
+  _base_0.__index = _base_0
+  _class_0 = setmetatable({
+    __init = function(self, transformers)
+      self.transformers = transformers
+      self.seen_nodes = setmetatable({ }, {
+        __mode = "k"
+      })
+    end,
+    __base = _base_0,
+    __name = "Transformer"
+  }, {
+    __index = _base_0,
+    __call = function(cls, ...)
+      local _self_0 = setmetatable({}, _base_0)
+      cls.__init(_self_0, ...)
+      return _self_0
+    end
+  })
+  _base_0.__class = _class_0
+  Transformer = _class_0
+end
+return {
+  Transformer = Transformer
+}

data/vendor/leafo/moonscript/transform/value.lua

@@ -0,0 +1,265 @@
+local Transformer
+Transformer = require("moonscript.transform.transformer").Transformer
+local build, ntype, smart_node
+do
+  local _obj_0 = require("moonscript.types")
+  build, ntype, smart_node = _obj_0.build, _obj_0.ntype, _obj_0.smart_node
+end
+local NameProxy
+NameProxy = require("moonscript.transform.names").NameProxy
+local Accumulator, default_accumulator
+do
+  local _obj_0 = require("moonscript.transform.accumulator")
+  Accumulator, default_accumulator = _obj_0.Accumulator, _obj_0.default_accumulator
+end
+local lua_keywords
+lua_keywords = require("moonscript.data").lua_keywords
+local Run, transform_last_stm, implicitly_return, chain_is_stub
+do
+  local _obj_0 = require("moonscript.transform.statements")
+  Run, transform_last_stm, implicitly_return, chain_is_stub = _obj_0.Run, _obj_0.transform_last_stm, _obj_0.implicitly_return, _obj_0.chain_is_stub
+end
+local construct_comprehension
+construct_comprehension = require("moonscript.transform.comprehension").construct_comprehension
+local insert
+insert = table.insert
+local unpack
+unpack = require("moonscript.util").unpack
+return Transformer({
+  ["for"] = default_accumulator,
+  ["while"] = default_accumulator,
+  foreach = default_accumulator,
+  ["do"] = function(self, node)
+    return build.block_exp(node[2])
+  end,
+  decorated = function(self, node)
+    return self.transform.statement(node)
+  end,
+  class = function(self, node)
+    return build.block_exp({
+      node
+    })
+  end,
+  string = function(self, node)
+    local delim = node[2]
+    local convert_part
+    convert_part = function(part)
+      if type(part) == "string" or part == nil then
+        return {
+          "string",
+          delim,
+          part or ""
+        }
+      else
+        return build.chain({
+          base = "tostring",
+          {
+            "call",
+            {
+              part[2]
+            }
+          }
+        })
+      end
+    end
+    if #node <= 3 then
+      if type(node[3]) == "string" then
+        return node
+      else
+        return convert_part(node[3])
+      end
+    end
+    local e = {
+      "exp",
+      convert_part(node[3])
+    }
+    for i = 4, #node do
+      insert(e, "..")
+      insert(e, convert_part(node[i]))
+    end
+    return e
+  end,
+  comprehension = function(self, node)
+    local a = Accumulator()
+    node = self.transform.statement(node, function(exp)
+      return a:mutate_body({
+        exp
+      })
+    end)
+    return a:wrap(node)
+  end,
+  tblcomprehension = function(self, node)
+    local _, explist, clauses = unpack(node)
+    local key_exp, value_exp = unpack(explist)
+    local accum = NameProxy("tbl")
+    local inner
+    if value_exp then
+      local dest = build.chain({
+        base = accum,
+        {
+          "index",
+          key_exp
+        }
+      })
+      inner = {
+        build.assign_one(dest, value_exp)
+      }
+    else
+      local key_name, val_name = NameProxy("key"), NameProxy("val")
+      local dest = build.chain({
+        base = accum,
+        {
+          "index",
+          key_name
+        }
+      })
+      inner = {
+        build.assign({
+          names = {
+            key_name,
+            val_name
+          },
+          values = {
+            key_exp
+          }
+        }),
+        build.assign_one(dest, val_name)
+      }
+    end
+    return build.block_exp({
+      build.assign_one(accum, build.table()),
+      construct_comprehension(inner, clauses),
+      accum
+    })
+  end,
+  fndef = function(self, node)
+    smart_node(node)
+    node.body = transform_last_stm(node.body, implicitly_return(self))
+    node.body = {
+      Run(function(self)
+        return self:listen("varargs", function() end)
+      end),
+      unpack(node.body)
+    }
+    return node
+  end,
+  ["if"] = function(self, node)
+    return build.block_exp({
+      node
+    })
+  end,
+  unless = function(self, node)
+    return build.block_exp({
+      node
+    })
+  end,
+  with = function(self, node)
+    return build.block_exp({
+      node
+    })
+  end,
+  switch = function(self, node)
+    return build.block_exp({
+      node
+    })
+  end,
+  chain = function(self, node)
+    for i = 2, #node do
+      local part = node[i]
+      if ntype(part) == "dot" and lua_keywords[part[2]] then
+        node[i] = {
+          "index",
+          {
+            "string",
+            '"',
+            part[2]
+          }
+        }
+      end
+    end
+    if ntype(node[2]) == "string" then
+      node[2] = {
+        "parens",
+        node[2]
+      }
+    end
+    if chain_is_stub(node) then
+      local base_name = NameProxy("base")
+      local fn_name = NameProxy("fn")
+      local colon = table.remove(node)
+      local is_super = ntype(node[2]) == "ref" and node[2][2] == "super"
+      return build.block_exp({
+        build.assign({
+          names = {
+            base_name
+          },
+          values = {
+            node
+          }
+        }),
+        build.assign({
+          names = {
+            fn_name
+          },
+          values = {
+            build.chain({
+              base = base_name,
+              {
+                "dot",
+                colon[2]
+              }
+            })
+          }
+        }),
+        build.fndef({
+          args = {
+            {
+              "..."
+            }
+          },
+          body = {
+            build.chain({
+              base = fn_name,
+              {
+                "call",
+                {
+                  is_super and "self" or base_name,
+                  "..."
+                }
+              }
+            })
+          }
+        })
+      })
+    end
+  end,
+  block_exp = function(self, node)
+    local _, body = unpack(node)
+    local fn = nil
+    local arg_list = { }
+    fn = smart_node(build.fndef({
+      body = {
+        Run(function(self)
+          return self:listen("varargs", function()
+            insert(arg_list, "...")
+            insert(fn.args, {
+              "..."
+            })
+            return self:unlisten("varargs")
+          end)
+        end),
+        unpack(body)
+      }
+    }))
+    return build.chain({
+      base = {
+        "parens",
+        fn
+      },
+      {
+        "call",
+        arg_list
+      }
+    })
+  end
+})