rufus-lua-moon 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 64a42dafd47150d25613181b8f9898f7456e89ce
+  data.tar.gz: 22e9a59e022d27df880130803b6fa7a2aad8be10
+SHA512:
+  metadata.gz: 602ddba5e7e2abfca7c15ec506332e19ab5ddc7f81a3dc454488ced77b97e6559d9d9381cabbac08dde5cf6a86be575e68155ce7b3a7580a7187e714a0b66b32
+  data.tar.gz: ff8982b11792e45e2d21007527d0b0f84a8f1e58fa2e848caf05e9561255450822bc3868de0e36999b8d5e4662dc19b2b24862a0840a88ab35e8ffc86b044c78

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+.subversion

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rufus-lua-moon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Stas Ukolov
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,51 @@
+# Rufus::Lua::Moon
+
+[![Gem Version](https://badge.fury.io/rb/rufus-lua-moon.svg)](http://badge.fury.io/rb/rufus-lua-moon)
+
+Provides MoonScript for Rufus::Lua interpreter
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rufus-lua-moon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rufus-lua-moon
+
+## Usage
+
+After creating Rufus::Lua interpreter patch it to support MoonScript:
+
+```ruby
+s=Rufus::Lua::State.new
+s.moon!
+s.eval <<EOL
+  m=require "moonscript.base"
+  x=m.to_lua "->1"
+  print(x)
+EOL
+```
+You can set `package.moonpath` and require file(s) with moonscript code:
+```ruby
+s=Rufus::Lua::State.new.moon!
+s.eval <<EOL
+  package.moonpath='./?.moon'
+  require 'myfile'  -- load 'myfile.moon'
+EOL
+```
+
+## Credits
+
+  * [Lua](http://www.lua.org/)
+  * [MoonScript](http://moonscript.org/)
+  * [Rufus::Lua](https://github.com/jmettraux/rufus-lua)
+
+## See also
+
+  * [Rufus::Lua::Win](https://github.com/ukoloff/rufus-lua-win) if you run Rufus::Lua on Windows

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/rufus/lua/moon/version.rb

@@ -0,0 +1,12 @@
+module Rufus
+  module Lua
+    module Moon
+      root=File.expand_path '../../../../..', __FILE__
+      subV=File.read(File.expand_path '.subversion', root).strip rescue ''
+      subV="."+subV.gsub(/\W+/, '.') if subV.length>0
+      Path=File.expand_path 'vendor/lua', root
+      m=/(["'])(\d+(\.\d+){1,3}(-(?!0)[\da-z])*)\1/i.match File.read File.expand_path 'moonscript/version.lua', Path
+      VERSION = m ? m[2].gsub('-', '.')+subV : '0.0.?'
+    end
+  end
+end

data/lib/rufus/lua/moon.rb

@@ -0,0 +1,18 @@
+require "rufus/lua/moon/version"
+
+module Rufus
+  module Lua
+    module Moon
+      
+    end
+    class State
+      def moon!
+        self['package']['path']=
+          (['', '/init'].map{|x|File.expand_path "?#{x}.lua", Moon::Path}<<
+           self['package']['path'])*';'
+        eval 'require "moonscript"'
+        self
+      end
+    end
+  end
+end

data/rufus-lua-moon.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rufus/lua/moon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rufus-lua-moon"
+  spec.version       = Rufus::Lua::Moon::VERSION
+  spec.authors       = ["Stas Ukolov"]
+  spec.email         = ["ukoloff@gmail.com"]
+  spec.description   = 'Provides MoonScript for Rufus::Lua interpreter'
+  spec.summary       = ''
+  spec.homepage      = "https://github.com/ukoloff/rufus-lua-moon"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+
+  spec.add_dependency "rufus-lua"
+end

data/vendor/lua/moon/all.moon

@@ -0,0 +1,8 @@
+
+-- insert all moon library functions into requiring scope
+
+export moon
+moon = moon or {}
+moon.inject = true
+require "moon.init"
+

data/vendor/lua/moon/init.moon

@@ -0,0 +1,136 @@
+
+if not moon or not moon.inject
+  module "moon", package.seeall
+
+util = require "moonscript.util"
+
+lua = { :debug, :type }
+
+export *
+
+dump = util.dump
+
+p = (...) ->
+  print dump ...
+
+is_object =  (value) -> -- is a moonscript object
+  lua.type(value) == "table" and value.__class
+
+type = (value) -> -- class aware type
+  base_type = lua.type value
+  if base_type == "table"
+    cls = value.__class
+    return cls if cls
+  base_type
+
+debug = setmetatable {
+  upvalue: (fn, k, v) ->
+    upvalues = {}
+    i = 1
+    while true
+      name = lua.debug.getupvalue(fn, i)
+      break if name == nil
+      upvalues[name] = i
+      i += 1
+
+    if not upvalues[k]
+      error "Failed to find upvalue: " .. tostring k
+
+    if not v
+      _, value = lua.debug.getupvalue fn, upvalues[k]
+      value
+    else
+      lua.debug.setupvalue fn, upvalues[k], v
+}, __index: lua.debug
+
+-- run a function with scope injected before its function environment
+run_with_scope = (fn, scope, ...) ->
+  old_env = getfenv fn
+  env = setmetatable {}, {
+    __index: (name) =>
+      val = scope[name]
+      if val != nil
+        val
+      else
+        old_env[name]
+  }
+  setfenv fn, env
+  fn ...
+
+-- wrap obj such that calls to methods do not need a reference to self
+bind_methods = (obj) ->
+  setmetatable {}, {
+    __index: (name) =>
+      val = obj[name]
+      if val and lua.type(val) == "function"
+        bound = (...) -> val obj, ...
+        self[name] = bound
+        bound
+      else
+        val
+  }
+
+-- use a function to provide default values to table
+-- optionally specify a starting table
+-- fibanocci table:
+-- t = defaultbl {[0]: 0, [1]: 1}, (i) -> self[i - 1] + self[i - 2]
+defaultbl = (t, fn) ->
+  if not fn
+    fn = t
+    t = {}
+  setmetatable t, {
+    __index: (name) =>
+      val = fn self, name
+      rawset self, name, val
+      val
+  }
+
+-- chain together tables by __index metatables
+extend = (...) ->
+  tbls = {...}
+  return if #tbls < 2
+
+  for i = 1, #tbls - 1
+    a = tbls[i]
+    b = tbls[i + 1]
+
+    setmetatable a, __index: b
+
+  tbls[1]
+
+-- shallow copy
+copy = =>
+  {key,val for key,val in pairs self}
+
+-- mixin class properties into self, call new
+mixin = (cls, ...) =>
+  meta = getmetatable cls
+  for key, val in pairs meta.__index
+    self[key] = val if not key\match"^__"
+  cls.__init self, ...
+
+-- mixin methods from an object into self
+mixin_object = (object, methods) =>
+  for name in *methods
+    self[name] = (parent, ...) ->
+      object[name](object, ...)
+
+-- mixin table values into self
+mixin_table = (tbl, keys) =>
+  if keys
+    for key in *keys
+      self[key] = tbl[key]
+  else
+    for key, val in pairs tbl
+      self[key] = val
+
+fold = (items, fn)->
+  len = #items
+  if len > 1
+    accum = fn items[1], items[2]
+    for i=3,len
+      accum = fn acum, items[i]
+    accum
+  else
+    items[1]
+

data/vendor/lua/moonscript/compile/format.lua

@@ -0,0 +1,55 @@
+module("moonscript.compile", package.seeall)
+local util = require("moonscript.util")
+local data = require("moonscript.data")
+local Set
+do
+  local _table_0 = require("moonscript.data")
+  Set = _table_0.Set
+end
+local ntype
+do
+  local _table_0 = require("moonscript.types")
+  ntype = _table_0.ntype
+end
+local concat, insert = table.concat, table.insert
+indent_char = "  "
+user_error = function(...)
+  return error({
+    "user-error",
+    ...
+  })
+end
+moonlib = {
+  bind = function(tbl, name)
+    return concat({
+      "moon.bind(",
+      tbl,
+      ".",
+      name,
+      ", ",
+      tbl,
+      ")"
+    })
+  end
+}
+non_atomic = Set({
+  "update"
+})
+has_value = function(node)
+  if ntype(node) == "chain" then
+    local ctype = ntype(node[#node])
+    return ctype ~= "call" and ctype ~= "colon"
+  else
+    return true
+  end
+end
+is_non_atomic = function(node)
+  return non_atomic[ntype(node)]
+end
+count_lines = function(str)
+  local count = 1
+  for _ in str:gmatch("\n") do
+    count = count + 1
+  end
+  return count
+end

data/vendor/lua/moonscript/compile/statement.lua

@@ -0,0 +1,217 @@
+module("moonscript.compile", package.seeall)
+local util = require("moonscript.util")
+require("moonscript.compile.format")
+local dump = require("moonscript.dump")
+local reversed = util.reversed
+local ntype
+do
+  local _table_0 = require("moonscript.types")
+  ntype = _table_0.ntype
+end
+local concat, insert = table.concat, table.insert
+line_compile = {
+  raw = function(self, node)
+    local _, text = unpack(node)
+    return self:add(text)
+  end,
+  declare = function(self, node)
+    local _, names = unpack(node)
+    local undeclared = self:declare(names)
+    if #undeclared > 0 then
+      do
+        local _with_0 = self:line("local ")
+        _with_0:append_list((function()
+          local _accum_0 = { }
+          local _len_0 = 0
+          local _list_0 = names
+          for _index_0 = 1, #_list_0 do
+            local name = _list_0[_index_0]
+            _len_0 = _len_0 + 1
+            _accum_0[_len_0] = self:name(name)
+          end
+          return _accum_0
+        end)(), ", ")
+        return _with_0
+      end
+    end
+  end,
+  assign = function(self, node)
+    local _, names, values = unpack(node)
+    local undeclared = self:declare(names)
+    local declare = "local " .. concat(undeclared, ", ")
+    local has_fndef = false
+    local i = 1
+    while i <= #values do
+      if ntype(values[i]) == "fndef" then
+        has_fndef = true
+      end
+      i = i + 1
+    end
+    do
+      local _with_0 = self:line()
+      if #undeclared == #names and not has_fndef then
+        _with_0:append(declare)
+      else
+        if #undeclared > 0 then
+          self:add(declare)
+        end
+        _with_0:append_list((function()
+          local _accum_0 = { }
+          local _len_0 = 0
+          local _list_0 = names
+          for _index_0 = 1, #_list_0 do
+            local name = _list_0[_index_0]
+            _len_0 = _len_0 + 1
+            _accum_0[_len_0] = self:value(name)
+          end
+          return _accum_0
+        end)(), ", ")
+      end
+      _with_0:append(" = ")
+      _with_0:append_list((function()
+        local _accum_0 = { }
+        local _len_0 = 0
+        local _list_0 = values
+        for _index_0 = 1, #_list_0 do
+          local v = _list_0[_index_0]
+          _len_0 = _len_0 + 1
+          _accum_0[_len_0] = self:value(v)
+        end
+        return _accum_0
+      end)(), ", ")
+      return _with_0
+    end
+  end,
+  ["return"] = function(self, node)
+    return self:line("return ", (function()
+      if node[2] ~= "" then
+        return self:value(node[2])
+      end
+    end)())
+  end,
+  ["break"] = function(self, node)
+    return "break"
+  end,
+  ["if"] = function(self, node)
+    local cond, block = node[2], node[3]
+    local root
+    do
+      local _with_0 = self:block(self:line("if ", self:value(cond), " then"))
+      _with_0:stms(block)
+      root = _with_0
+    end
+    local current = root
+    local add_clause
+    add_clause = function(clause)
+      local type = clause[1]
+      local i = 2
+      local next
+      if type == "else" then
+        next = self:block("else")
+      else
+        i = i + 1
+        next = self:block(self:line("elseif ", self:value(clause[2]), " then"))
+      end
+      next:stms(clause[i])
+      current.next = next
+      current = next
+    end
+    local _list_0 = node
+    for _index_0 = 4, #_list_0 do
+      cond = _list_0[_index_0]
+      add_clause(cond)
+    end
+    return root
+  end,
+  ["while"] = function(self, node)
+    local _, cond, block = unpack(node)
+    local out
+    if is_non_atomic(cond) then
+      do
+        local _with_0 = self:block("while true do")
+        _with_0:stm({
+          "if",
+          {
+            "not",
+            cond
+          },
+          {
+            {
+              "break"
+            }
+          }
+        })
+        out = _with_0
+      end
+    else
+      out = self:block(self:line("while ", self:value(cond), " do"))
+    end
+    out:stms(block)
+    return out
+  end,
+  ["for"] = function(self, node)
+    local _, name, bounds, block = unpack(node)
+    local loop = self:line("for ", self:name(name), " = ", self:value({
+      "explist",
+      unpack(bounds)
+    }), " do")
+    do
+      local _with_0 = self:block(loop)
+      _with_0:stms(block)
+      return _with_0
+    end
+  end,
+  foreach = function(self, node)
+    local _, names, exp, block = unpack(node)
+    local loop
+    do
+      local _with_0 = self:line()
+      _with_0:append("for ")
+      _with_0:append_list((function()
+        local _accum_0 = { }
+        local _len_0 = 0
+        local _list_0 = names
+        for _index_0 = 1, #_list_0 do
+          local name = _list_0[_index_0]
+          _len_0 = _len_0 + 1
+          _accum_0[_len_0] = self:name(name)
+        end
+        return _accum_0
+      end)(), ", ")
+      _with_0:append(" in ", self:value(exp), " do")
+      loop = _with_0
+    end
+    do
+      local _with_0 = self:block(loop)
+      _with_0:stms(block)
+      return _with_0
+    end
+  end,
+  export = function(self, node)
+    local _, names = unpack(node)
+    if type(names) == "string" then
+      if names == "*" then
+        self.export_all = true
+      elseif names == "^" then
+        self.export_proper = true
+      end
+    else
+      self:declare(names)
+    end
+    return nil
+  end,
+  run = function(self, code)
+    code:call(self)
+    return nil
+  end,
+  group = function(self, node)
+    return self:stms(node[2])
+  end,
+  ["do"] = function(self, node)
+    do
+      local _with_0 = self:block()
+      _with_0:stms(node[2])
+      return _with_0
+    end
+  end
+}