rufus-lua-moon 0.3.2 → 0.4.0

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

@@ -0,0 +1,54 @@
+local is_value
+is_value = require("moonscript.types").is_value
+local construct_comprehension
+construct_comprehension = function(inner, clauses)
+  local current_stms = inner
+  for i = #clauses, 1, -1 do
+    local clause = clauses[i]
+    local t = clause[1]
+    local _exp_0 = t
+    if "for" == _exp_0 then
+      local _, name, bounds
+      _, name, bounds = clause[1], clause[2], clause[3]
+      current_stms = {
+        "for",
+        name,
+        bounds,
+        current_stms
+      }
+    elseif "foreach" == _exp_0 then
+      local _, names, iter
+      _, names, iter = clause[1], clause[2], clause[3]
+      current_stms = {
+        "foreach",
+        names,
+        {
+          iter
+        },
+        current_stms
+      }
+    elseif "when" == _exp_0 then
+      local _, cond
+      _, cond = clause[1], clause[2]
+      current_stms = {
+        "if",
+        cond,
+        current_stms
+      }
+    else
+      current_stms = error("Unknown comprehension clause: " .. t)
+    end
+    current_stms = {
+      current_stms
+    }
+  end
+  return current_stms[1]
+end
+local comprehension_has_value
+comprehension_has_value = function(comp)
+  return is_value(comp[2])
+end
+return {
+  construct_comprehension = construct_comprehension,
+  comprehension_has_value = comprehension_has_value
+}

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

@@ -68,7 +68,7 @@ extract_assign_names = function(name, accum, prefix)
       local s
       if ntype(key) == "key_literal" then
         local key_name = key[2]
-        if ntype(key_name) == "colon_stub" then
+        if ntype(key_name) == "colon" then
           s = key_name
         else
           s = {
@@ -228,5 +228,6 @@ end
 return {
   has_destructure = has_destructure,
   split_assign = split_assign,
-  build_assign = build_assign
+  build_assign = build_assign,
+  extract_assign_names = extract_assign_names
 }

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

@@ -4,13 +4,14 @@ local unpack
 unpack = require("moonscript.util").unpack
 local LocalName
 do
+  local _class_0
   local _base_0 = {
     get_name = function(self)
       return self.name
     end
   }
   _base_0.__index = _base_0
-  local _class_0 = setmetatable({
+  _class_0 = setmetatable({
     __init = function(self, name)
       self.name = name
       self[1] = "temp_name"
@@ -30,6 +31,7 @@ do
 end
 local NameProxy
 do
+  local _class_0
   local _base_0 = {
     get_name = function(self, scope, dont_put)
       if dont_put == nil then
@@ -81,7 +83,7 @@ do
     end
   }
   _base_0.__index = _base_0
-  local _class_0 = setmetatable({
+  _class_0 = setmetatable({
     __init = function(self, prefix)
       self.prefix = prefix
       self[1] = "temp_name"

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

@@ -0,0 +1,741 @@
+local Transformer
+Transformer = require("moonscript.transform.transformer").Transformer
+local NameProxy
+NameProxy = require("moonscript.transform.names").NameProxy
+local Run, transform_last_stm, implicitly_return, last_stm
+do
+  local _obj_0 = require("moonscript.transform.statements")
+  Run, transform_last_stm, implicitly_return, last_stm = _obj_0.Run, _obj_0.transform_last_stm, _obj_0.implicitly_return, _obj_0.last_stm
+end
+local types = require("moonscript.types")
+local build, ntype, is_value, smart_node, value_is_singular, is_slice, NOOP
+build, ntype, is_value, smart_node, value_is_singular, is_slice, NOOP = types.build, types.ntype, types.is_value, types.smart_node, types.value_is_singular, types.is_slice, types.NOOP
+local insert
+insert = table.insert
+local destructure = require("moonscript.transform.destructure")
+local construct_comprehension
+construct_comprehension = require("moonscript.transform.comprehension").construct_comprehension
+local unpack
+unpack = require("moonscript.util").unpack
+local with_continue_listener
+with_continue_listener = function(body)
+  local continue_name = nil
+  return {
+    Run(function(self)
+      return self:listen("continue", function()
+        if not (continue_name) then
+          continue_name = NameProxy("continue")
+          self:put_name(continue_name)
+        end
+        return continue_name
+      end)
+    end),
+    build.group(body),
+    Run(function(self)
+      if not (continue_name) then
+        return 
+      end
+      local last = last_stm(body)
+      local enclose_lines = types.terminating[last and ntype(last)]
+      self:put_name(continue_name, nil)
+      return self:splice(function(lines)
+        if enclose_lines then
+          lines = {
+            "do",
+            {
+              lines
+            }
+          }
+        end
+        return {
+          {
+            "assign",
+            {
+              continue_name
+            },
+            {
+              "false"
+            }
+          },
+          {
+            "repeat",
+            "true",
+            {
+              lines,
+              {
+                "assign",
+                {
+                  continue_name
+                },
+                {
+                  "true"
+                }
+              }
+            }
+          },
+          {
+            "if",
+            {
+              "not",
+              continue_name
+            },
+            {
+              {
+                "break"
+              }
+            }
+          }
+        }
+      end)
+    end)
+  }
+end
+local extract_declarations
+extract_declarations = function(self, body, start, out)
+  if body == nil then
+    body = self.current_stms
+  end
+  if start == nil then
+    start = self.current_stm_i + 1
+  end
+  if out == nil then
+    out = { }
+  end
+  for i = start, #body do
+    local _continue_0 = false
+    repeat
+      local stm = body[i]
+      if stm == nil then
+        _continue_0 = true
+        break
+      end
+      stm = self.transform.statement(stm)
+      body[i] = stm
+      local _exp_0 = stm[1]
+      if "assign" == _exp_0 or "declare" == _exp_0 then
+        local _list_0 = stm[2]
+        for _index_0 = 1, #_list_0 do
+          local name = _list_0[_index_0]
+          if ntype(name) == "ref" then
+            insert(out, name)
+          elseif type(name) == "string" then
+            insert(out, name)
+          end
+        end
+      elseif "group" == _exp_0 then
+        extract_declarations(self, stm[2], 1, out)
+      end
+      _continue_0 = true
+    until true
+    if not _continue_0 then
+      break
+    end
+  end
+  return out
+end
+local expand_elseif_assign
+expand_elseif_assign = function(ifstm)
+  for i = 4, #ifstm do
+    local case = ifstm[i]
+    if ntype(case) == "elseif" and ntype(case[2]) == "assign" then
+      local split = {
+        unpack(ifstm, 1, i - 1)
+      }
+      insert(split, {
+        "else",
+        {
+          {
+            "if",
+            case[2],
+            case[3],
+            unpack(ifstm, i + 1)
+          }
+        }
+      })
+      return split
+    end
+  end
+  return ifstm
+end
+return Transformer({
+  transform = function(self, tuple)
+    local _, node, fn
+    _, node, fn = tuple[1], tuple[2], tuple[3]
+    return fn(node)
+  end,
+  root_stms = function(self, body)
+    return transform_last_stm(body, implicitly_return(self))
+  end,
+  ["return"] = function(self, node)
+    local ret_val = node[2]
+    local ret_val_type = ntype(ret_val)
+    if ret_val_type == "explist" and #ret_val == 2 then
+      ret_val = ret_val[2]
+      ret_val_type = ntype(ret_val)
+    end
+    if types.cascading[ret_val_type] then
+      return implicitly_return(self)(ret_val)
+    end
+    if ret_val_type == "chain" or ret_val_type == "comprehension" or ret_val_type == "tblcomprehension" then
+      local Value = require("moonscript.transform.value")
+      ret_val = Value:transform_once(self, ret_val)
+      if ntype(ret_val) == "block_exp" then
+        return build.group(transform_last_stm(ret_val[2], function(stm)
+          return {
+            "return",
+            stm
+          }
+        end))
+      end
+    end
+    node[2] = ret_val
+    return node
+  end,
+  declare_glob = function(self, node)
+    local names = extract_declarations(self)
+    if node[2] == "^" then
+      do
+        local _accum_0 = { }
+        local _len_0 = 1
+        for _index_0 = 1, #names do
+          local _continue_0 = false
+          repeat
+            local name = names[_index_0]
+            if not (name[2]:match("^%u")) then
+              _continue_0 = true
+              break
+            end
+            local _value_0 = name
+            _accum_0[_len_0] = _value_0
+            _len_0 = _len_0 + 1
+            _continue_0 = true
+          until true
+          if not _continue_0 then
+            break
+          end
+        end
+        names = _accum_0
+      end
+    end
+    return {
+      "declare",
+      names
+    }
+  end,
+  assign = function(self, node)
+    local names, values = unpack(node, 2)
+    local num_values = #values
+    local num_names = #values
+    if num_names == 1 and num_values == 1 then
+      local first_value = values[1]
+      local first_name = names[1]
+      local first_type = ntype(first_value)
+      if first_type == "chain" then
+        local Value = require("moonscript.transform.value")
+        first_value = Value:transform_once(self, first_value)
+        first_type = ntype(first_value)
+      end
+      local _exp_0 = ntype(first_value)
+      if "block_exp" == _exp_0 then
+        local block_body = first_value[2]
+        local idx = #block_body
+        block_body[idx] = build.assign_one(first_name, block_body[idx])
+        return build.group({
+          {
+            "declare",
+            {
+              first_name
+            }
+          },
+          {
+            "do",
+            block_body
+          }
+        })
+      elseif "comprehension" == _exp_0 or "tblcomprehension" == _exp_0 or "foreach" == _exp_0 or "for" == _exp_0 or "while" == _exp_0 then
+        local Value = require("moonscript.transform.value")
+        return build.assign_one(first_name, Value:transform_once(self, first_value))
+      else
+        values[1] = first_value
+      end
+    end
+    local transformed
+    if num_values == 1 then
+      local value = values[1]
+      local t = ntype(value)
+      if t == "decorated" then
+        value = self.transform.statement(value)
+        t = ntype(value)
+      end
+      if types.cascading[t] then
+        local ret
+        ret = function(stm)
+          if is_value(stm) then
+            return {
+              "assign",
+              names,
+              {
+                stm
+              }
+            }
+          else
+            return stm
+          end
+        end
+        transformed = build.group({
+          {
+            "declare",
+            names
+          },
+          self.transform.statement(value, ret, node)
+        })
+      end
+    end
+    node = transformed or node
+    if destructure.has_destructure(names) then
+      return destructure.split_assign(self, node)
+    end
+    return node
+  end,
+  continue = function(self, node)
+    local continue_name = self:send("continue")
+    if not (continue_name) then
+      error("continue must be inside of a loop")
+    end
+    return build.group({
+      build.assign_one(continue_name, "true"),
+      {
+        "break"
+      }
+    })
+  end,
+  export = function(self, node)
+    if #node > 2 then
+      if node[2] == "class" then
+        local cls = smart_node(node[3])
+        return build.group({
+          {
+            "export",
+            {
+              cls.name
+            }
+          },
+          cls
+        })
+      else
+        return build.group({
+          {
+            "export",
+            node[2]
+          },
+          build.assign({
+            names = node[2],
+            values = node[3]
+          })
+        })
+      end
+    else
+      return nil
+    end
+  end,
+  update = function(self, node)
+    local _, name, op, exp = unpack(node)
+    local op_final = op:match("^(.+)=$")
+    if not op_final then
+      error("Unknown op: " .. op)
+    end
+    if not (value_is_singular(exp)) then
+      exp = {
+        "parens",
+        exp
+      }
+    end
+    return build.assign_one(name, {
+      "exp",
+      name,
+      op_final,
+      exp
+    })
+  end,
+  import = function(self, node)
+    local _, names, source = unpack(node)
+    local table_values
+    do
+      local _accum_0 = { }
+      local _len_0 = 1
+      for _index_0 = 1, #names do
+        local name = names[_index_0]
+        local dest_name
+        if ntype(name) == "colon" then
+          dest_name = name[2]
+        else
+          dest_name = name
+        end
+        local _value_0 = {
+          {
+            "key_literal",
+            name
+          },
+          dest_name
+        }
+        _accum_0[_len_0] = _value_0
+        _len_0 = _len_0 + 1
+      end
+      table_values = _accum_0
+    end
+    local dest = {
+      "table",
+      table_values
+    }
+    return {
+      "assign",
+      {
+        dest
+      },
+      {
+        source
+      },
+      [-1] = node[-1]
+    }
+  end,
+  comprehension = function(self, node, action)
+    local _, exp, clauses = unpack(node)
+    action = action or function(exp)
+      return {
+        exp
+      }
+    end
+    return construct_comprehension(action(exp), clauses)
+  end,
+  ["do"] = function(self, node, ret)
+    if ret then
+      node[2] = transform_last_stm(node[2], ret)
+    end
+    return node
+  end,
+  decorated = function(self, node)
+    local stm, dec = unpack(node, 2)
+    local wrapped
+    local _exp_0 = dec[1]
+    if "if" == _exp_0 then
+      local cond, fail = unpack(dec, 2)
+      if fail then
+        fail = {
+          "else",
+          {
+            fail
+          }
+        }
+      end
+      wrapped = {
+        "if",
+        cond,
+        {
+          stm
+        },
+        fail
+      }
+    elseif "unless" == _exp_0 then
+      wrapped = {
+        "unless",
+        dec[2],
+        {
+          stm
+        }
+      }
+    elseif "comprehension" == _exp_0 then
+      wrapped = {
+        "comprehension",
+        stm,
+        dec[2]
+      }
+    else
+      wrapped = error("Unknown decorator " .. dec[1])
+    end
+    if ntype(stm) == "assign" then
+      wrapped = build.group({
+        build.declare({
+          names = (function()
+            local _accum_0 = { }
+            local _len_0 = 1
+            local _list_0 = stm[2]
+            for _index_0 = 1, #_list_0 do
+              local name = _list_0[_index_0]
+              if ntype(name) == "ref" then
+                _accum_0[_len_0] = name
+                _len_0 = _len_0 + 1
+              end
+            end
+            return _accum_0
+          end)()
+        }),
+        wrapped
+      })
+    end
+    return wrapped
+  end,
+  unless = function(self, node)
+    return {
+      "if",
+      {
+        "not",
+        {
+          "parens",
+          node[2]
+        }
+      },
+      unpack(node, 3)
+    }
+  end,
+  ["if"] = function(self, node, ret)
+    if ntype(node[2]) == "assign" then
+      local _, assign, body = unpack(node)
+      if destructure.has_destructure(assign[2]) then
+        local name = NameProxy("des")
+        body = {
+          destructure.build_assign(self, assign[2][1], name),
+          build.group(node[3])
+        }
+        return build["do"]({
+          build.assign_one(name, assign[3][1]),
+          {
+            "if",
+            name,
+            body,
+            unpack(node, 4)
+          }
+        })
+      else
+        local name = assign[2][1]
+        return build["do"]({
+          assign,
+          {
+            "if",
+            name,
+            unpack(node, 3)
+          }
+        })
+      end
+    end
+    node = expand_elseif_assign(node)
+    if ret then
+      smart_node(node)
+      node['then'] = transform_last_stm(node['then'], ret)
+      for i = 4, #node do
+        local case = node[i]
+        local body_idx = #node[i]
+        case[body_idx] = transform_last_stm(case[body_idx], ret)
+      end
+    end
+    return node
+  end,
+  with = function(self, node, ret)
+    local exp, block = unpack(node, 2)
+    local copy_scope = true
+    local scope_name, named_assign
+    do
+      local last = last_stm(block)
+      if last then
+        if types.terminating[ntype(last)] then
+          ret = false
+        end
+      end
+    end
+    if ntype(exp) == "assign" then
+      local names, values = unpack(exp, 2)
+      local first_name = names[1]
+      if ntype(first_name) == "ref" then
+        scope_name = first_name
+        named_assign = exp
+        exp = values[1]
+        copy_scope = false
+      else
+        scope_name = NameProxy("with")
+        exp = values[1]
+        values[1] = scope_name
+        named_assign = {
+          "assign",
+          names,
+          values
+        }
+      end
+    elseif self:is_local(exp) then
+      scope_name = exp
+      copy_scope = false
+    end
+    scope_name = scope_name or NameProxy("with")
+    local out = build["do"]({
+      copy_scope and build.assign_one(scope_name, exp) or NOOP,
+      named_assign or NOOP,
+      Run(function(self)
+        return self:set("scope_var", scope_name)
+      end),
+      unpack(block)
+    })
+    if ret then
+      table.insert(out[2], ret(scope_name))
+    end
+    return out
+  end,
+  foreach = function(self, node, _)
+    smart_node(node)
+    local source = unpack(node.iter)
+    local destructures = { }
+    do
+      local _accum_0 = { }
+      local _len_0 = 1
+      for i, name in ipairs(node.names) do
+        if ntype(name) == "table" then
+          do
+            local proxy = NameProxy("des")
+            insert(destructures, destructure.build_assign(self, name, proxy))
+            _accum_0[_len_0] = proxy
+          end
+        else
+          _accum_0[_len_0] = name
+        end
+        _len_0 = _len_0 + 1
+      end
+      node.names = _accum_0
+    end
+    if next(destructures) then
+      insert(destructures, build.group(node.body))
+      node.body = destructures
+    end
+    if ntype(source) == "unpack" then
+      local list = source[2]
+      local index_name = NameProxy("index")
+      local list_name = self:is_local(list) and list or NameProxy("list")
+      local slice_var = nil
+      local bounds
+      if is_slice(list) then
+        local slice = list[#list]
+        table.remove(list)
+        table.remove(slice, 1)
+        if self:is_local(list) then
+          list_name = list
+        end
+        if slice[2] and slice[2] ~= "" then
+          local max_tmp_name = NameProxy("max")
+          slice_var = build.assign_one(max_tmp_name, slice[2])
+          slice[2] = {
+            "exp",
+            max_tmp_name,
+            "<",
+            0,
+            "and",
+            {
+              "length",
+              list_name
+            },
+            "+",
+            max_tmp_name,
+            "or",
+            max_tmp_name
+          }
+        else
+          slice[2] = {
+            "length",
+            list_name
+          }
+        end
+        bounds = slice
+      else
+        bounds = {
+          1,
+          {
+            "length",
+            list_name
+          }
+        }
+      end
+      return build.group({
+        list_name ~= list and build.assign_one(list_name, list) or NOOP,
+        slice_var or NOOP,
+        build["for"]({
+          name = index_name,
+          bounds = bounds,
+          body = {
+            {
+              "assign",
+              node.names,
+              {
+                NameProxy.index(list_name, index_name)
+              }
+            },
+            build.group(node.body)
+          }
+        })
+      })
+    end
+    node.body = with_continue_listener(node.body)
+  end,
+  ["while"] = function(self, node)
+    smart_node(node)
+    node.body = with_continue_listener(node.body)
+  end,
+  ["for"] = function(self, node)
+    smart_node(node)
+    node.body = with_continue_listener(node.body)
+  end,
+  switch = function(self, node, ret)
+    local _, exp, conds = unpack(node)
+    local exp_name = NameProxy("exp")
+    local convert_cond
+    convert_cond = function(cond)
+      local t, case_exps, body = unpack(cond)
+      local out = { }
+      insert(out, t == "case" and "elseif" or "else")
+      if t ~= "else" then
+        local cond_exp = { }
+        for i, case in ipairs(case_exps) do
+          if i == 1 then
+            insert(cond_exp, "exp")
+          else
+            insert(cond_exp, "or")
+          end
+          if not (value_is_singular(case)) then
+            case = {
+              "parens",
+              case
+            }
+          end
+          insert(cond_exp, {
+            "exp",
+            case,
+            "==",
+            exp_name
+          })
+        end
+        insert(out, cond_exp)
+      else
+        body = case_exps
+      end
+      if ret then
+        body = transform_last_stm(body, ret)
+      end
+      insert(out, body)
+      return out
+    end
+    local first = true
+    local if_stm = {
+      "if"
+    }
+    for _index_0 = 1, #conds do
+      local cond = conds[_index_0]
+      local if_cond = convert_cond(cond)
+      if first then
+        first = false
+        insert(if_stm, if_cond[2])
+        insert(if_stm, if_cond[3])
+      else
+        insert(if_stm, if_cond)
+      end
+    end
+    return build.group({
+      build.assign_one(exp_name, exp),
+      if_stm
+    })
+  end,
+  class = require("moonscript.transform.class")
+})