rufus-lua-win 5.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8ed9195d631c653242a1a4b5f8247af3d569ad52
+  data.tar.gz: 75ab729a6b7ee3482afb45b426d2e212e5f7e81f
+SHA512:
+  metadata.gz: a78148645ffd4c6a20598a374ea0b2a08d22a928dc3c0e25b2080a253ea9104af51f35906182c6cff3d8a6a2f0bb01c31da0a902d173466523a1230e83fbfd02
+  data.tar.gz: 031ed845cd2a4893ddc0ba5a54dfa228b61b8fea76752341dc9fa3a01abcd0cb48efc05c50b85f00c6b08ed356f7435eee0bce8563ab0659fd8164662b71c16f

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in rufus-lua-win.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,69 @@
+# Rufus::Lua::Win
+
+[![Gem Version](https://badge.fury.io/rb/rufus-lua-win.svg)](http://badge.fury.io/rb/rufus-lua-win)
+
+Provides Lua binary on Windows.
+
+Embedding Lua into Ruby on Windows has two issues:
+
+  1. There is no standard binary distributive for Lua
+  2. Lua way of searching for libraries (rocks) fails
+
+So, this gem embeds binary Lua (from LuaDist)
+and patches package.path and package.cpath.
+
+## Installation
+
+You don't need to download, install or compile any Lua distribution.
+Just add this line to your application's Gemfile:
+
+    gem 'rufus-lua-win'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rufus-lua-win
+
+## Usage
+
+Add two lines to Gemfile (in *that* order):
+
+    gem 'rufus-lua-win' if Gem.win_platform?
+    gem 'rufus-lua'
+
+Rufus::Lua::Win will setup environment variables, so Rufus::Lua could load.
+
+If not using bundler, just:
+
+```ruby
+require 'rufus/lua/win' if Gem.win_platform?
+require 'rufus/lua'
+
+s=Rufus::Lua::State.new
+s.eval "require 'lpeg'"
+...
+```
+
+## Lua Path
+
+Rufus::Lua::Win overrides standard Lua search paths to point to its own
+Lua libraries.
+
+Paths like `./?.lua` or `./?.dll` are excluded, since they are not very useful
+in embedded environment.
+
+If you like to `require` your own files inside Rufus::Lua - put them in
+separate folder and add it to package.path (or package.cpath).
+
+## Credits
+
+  * [Lua](http://www.lua.org/)
+  * [LuaDist](http://luadist.org/)
+  * [Rufus::Lua](https://github.com/jmettraux/rufus-lua)
+
+## See also
+
+  * [Rufus::Lua::Moon](https://github.com/ukoloff/rufus-lua-moon) to use MoonScript

data/Rakefile

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

data/lib/rufus/lua/win.rb

@@ -0,0 +1,18 @@
+require "rufus/lua/win/version"
+
+module Rufus
+  module Lua
+    module Win
+      def self.inject
+        dll = File.expand_path '../../../../vendor/lua/bin/liblua.dll', __FILE__
+        rocks = File.expand_path '../../lib/lua', dll
+
+        ENV['LUA_LIB']=dll
+        ENV['LUA_PATH']=['', '/init'].map{|x| File.expand_path "?#{x}.lua", rocks}*';'
+        ENV['LUA_CPATH']=File.expand_path "?.dll", rocks
+      end
+
+      inject if Gem.win_platform?
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+module Rufus
+  module Lua
+    module Win
+      VERSION = "5.1.5"
+    end
+  end
+end

data/rufus-lua-win.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rufus/lua/win/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rufus-lua-win"
+  spec.version       = Rufus::Lua::Win::VERSION
+  spec.authors       = ["Stas Ukolov"]
+  spec.email         = ["ukoloff@gmail.com"]
+  spec.description   = 'Provides Lua binary on Windows'
+  spec.summary       = ''
+  spec.homepage      = "https://github.com/ukoloff/rufus-lua-win"
+  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"
+end

data/vendor/lua/lib/lua/LuaXml.lua

@@ -0,0 +1,119 @@
+require("LuaXML_lib")
+
+local base = _G
+local xml = xml
+module("xml")
+
+-- symbolic name for tag index, this allows accessing the tag by var[xml.TAG]
+TAG = 0
+
+-- sets or returns tag of a LuaXML object
+function tag(var,tag)
+  if base.type(var)~="table" then return end
+  if base.type(tag)=="nil" then 
+    return var[TAG]
+  end
+  var[TAG] = tag
+end
+
+-- creates a new LuaXML object either by setting the metatable of an existing Lua table or by setting its tag
+function new(arg)
+  if base.type(arg)=="table" then 
+    base.setmetatable(arg,{__index=xml, __tostring=xml.str})
+	return arg
+  end
+  local var={}
+  base.setmetatable(var,{__index=xml, __tostring=xml.str})
+  if base.type(arg)=="string" then var[TAG]=arg end
+  return var
+end
+
+-- appends a new subordinate LuaXML object to an existing one, optionally sets tag
+function append(var,tag)
+  if base.type(var)~="table" then return end
+  local newVar = new(tag)
+  var[#var+1] = newVar
+  return newVar
+end
+
+-- converts any Lua var into an XML string
+function str(var,indent,tagValue)
+  if base.type(var)=="nil" then return end
+  local indent = indent or 0
+  local indentStr=""
+  for i = 1,indent do indentStr=indentStr.."  " end
+  local tableStr=""
+  
+  if base.type(var)=="table" then
+    local tag = var[0] or tagValue or base.type(var)
+    local s = indentStr.."<"..tag
+    for k,v in base.pairs(var) do -- attributes 
+      if base.type(k)=="string" then
+        if base.type(v)=="table" and k~="_M" then --  otherwise recursiveness imminent
+          tableStr = tableStr..str(v,indent+1,k)
+        else
+          s = s.." "..k.."=\""..encode(base.tostring(v)).."\""
+        end
+      end
+    end
+    if #var==0 and #tableStr==0 then
+      s = s.." />\n"
+    elseif #var==1 and base.type(var[1])~="table" and #tableStr==0 then -- single element
+      s = s..">"..encode(base.tostring(var[1])).."</"..tag..">\n"
+    else
+      s = s..">\n"
+      for k,v in base.ipairs(var) do -- elements
+        if base.type(v)=="string" then
+          s = s..indentStr.."  "..encode(v).." \n"
+        else
+          s = s..str(v,indent+1)
+        end
+      end
+      s=s..tableStr..indentStr.."</"..tag..">\n"
+    end
+    return s
+  else
+    local tag = base.type(var)
+    return indentStr.."<"..tag.."> "..encode(base.tostring(var)).." </"..tag..">\n"
+  end
+end
+
+
+-- saves a Lua var as xml file
+function save(var,filename)
+  if not var then return end
+  if not filename or #filename==0 then return end
+  local file = base.io.open(filename,"w")
+  file:write("<?xml version=\"1.0\"?>\n<!-- file \"",filename, "\", generated by LuaXML -->\n\n")
+  file:write(str(var))
+  base.io.close(file)
+end
+
+
+-- recursively parses a Lua table for a substatement fitting to the provided tag and attribute
+function find(var, tag, attributeKey,attributeValue)
+  -- check input:
+  if base.type(var)~="table" then return end
+  if base.type(tag)=="string" and #tag==0 then tag=nil end
+  if base.type(attributeKey)~="string" or #attributeKey==0 then attributeKey=nil end
+  if base.type(attributeValue)=="string" and #attributeValue==0 then attributeValue=nil end
+  -- compare this table:
+  if tag~=nil then
+    if var[0]==tag and ( attributeValue == nil or var[attributeKey]==attributeValue ) then
+      base.setmetatable(var,{__index=xml, __tostring=xml.str})
+      return var
+    end
+  else
+    if attributeValue == nil or var[attributeKey]==attributeValue then
+      base.setmetatable(var,{__index=xml, __tostring=xml.str})
+      return var
+    end
+  end
+  -- recursively parse subtags:
+  for k,v in base.ipairs(var) do
+    if base.type(v)=="table" then
+      local ret = find(v, tag, attributeKey,attributeValue)
+      if ret ~= nil then return ret end
+    end
+  end
+end

data/vendor/lua/lib/lua/alien.lua

@@ -0,0 +1,250 @@
+
+
+local core = require "alien.core"
+local io = require "io"
+
+local pairs, ipairs = pairs, ipairs
+local setmetatable = setmetatable
+local error = error
+local pcall = pcall
+local type = type
+local rawset = rawset
+local unpack = unpack
+local math = math
+local print = print
+
+local _M = alien
+
+_M.loaded = {}
+
+local load_library, find_library = {}, {}
+
+local function find_library_helper(libname, opt)
+  local expr = '/[^() ]*lib' .. libname .. '\.so[^() ]*'
+  local cmd = '/sbin/ldconfig ' .. opt ..
+    ' 2>/dev/null | egrep -o "' .. expr .. '"'
+  local pipe = io.popen(cmd)
+  if pipe then
+    local res = pipe:read()
+    pipe:close()
+    return res and res:match("([^%s]*)")
+  end
+  return nil
+end
+
+function find_library.linux(libname)
+  return find_library_helper(libname, "-p")
+end
+
+function find_library.bsd(libname)
+  return find_library_helper(libname, "-r")
+end
+
+function find_library.darwin(libname)
+  local ok, lib = pcall(core.load, libname .. ".dylib")
+  if ok then return lib end
+  ok, lib = pcall(core.load, libname .. ".framework/" .. libname)
+  if ok then return lib end
+  return nil
+end
+
+local function load_library_helper(libname, libext)
+  if libname:match("/") or libname:match("%" .. libext) then
+    return core.load(libname)
+  else
+    local ok, lib = pcall(core.load, "lib" .. libname .. libext)
+    if not ok then
+      ok, lib = pcall(core.load, "./lib" .. libname .. libext)
+      if not ok then
+        local name = find_library[core.platform](libname)
+        if name then
+          lib = core.load(name)
+        else
+          error("library " .. libname .. " not found")
+        end
+      end
+    end
+    return lib
+  end
+end
+
+function load_library.linux(libname)
+  return load_library_helper(libname, ".so")
+end
+
+load_library.bsd = load_library.linux
+
+function load_library.darwin(libname)
+  return load_library_helper(libname, ".dylib")
+end
+
+setmetatable(load_library, { __index = function (t, plat)
+                                         return core.load
+                                       end } )
+
+function load_library.windows(libname)
+  return core.load(libname)
+end
+
+setmetatable(_M.loaded, { __index = function (t, libname)
+                                   local lib =
+                                     load_library[core.platform](libname)
+                                   t[libname] = lib
+                                   return lib
+                                 end, __mode = "kv" })
+
+setmetatable(_M, { __index = _M.loaded })
+
+for name, f in pairs(core) do
+  _M[name] = f
+end
+
+function _M.load(libname)
+  return _M.loaded[libname]
+end
+
+function _M.callback(f, ...)
+  local cb = core.callback(f)
+  cb.types(cb, ...)
+  return cb
+end
+
+local array_methods = {}
+
+local function array_next(arr, i)
+   if i < arr.length then
+      return i + 1, arr[i + 1]
+   else
+      return nil
+   end
+end
+
+function array_methods:ipairs()
+   return array_next, self, 0
+end
+
+local function array_get(arr, key)
+  if type(key) == "number" then
+    if key < 1 or key > arr.length then
+      error("array access out of bounds")
+    end
+    local offset = (key - 1) * arr.size + 1
+    return arr.buffer:get(offset, arr.type)
+  else
+    return array_methods[key]
+  end
+end
+
+local function array_set(arr, key, val)
+  if type(key) == "number" then
+    if key < 1 or key > arr.length then
+      error("array access out of bounds")
+    end
+    local offset = (key - 1) * arr.size + 1
+    arr.buffer:set(offset, val, arr.type)
+    if arr.type == "pointer" then
+      arr.pinned[key] = val
+    end
+  else
+    rawset(arr, key, val)
+  end
+end
+
+function _M.array(t, length, init)
+  local ok, size = pcall(core.sizeof, t)
+  if not ok then
+    error("type " .. t .. " does not exist")
+  end
+  if type(length) == "table" then
+    init = length
+    length = #length
+  end
+  local arr = { type = t, length = length, size = size, pinned = {} }
+  setmetatable(arr, { __index = array_get, __newindex = array_set })
+  if type(init) == "userdata" then
+    arr.buffer = init
+  else
+    arr.buffer = core.buffer(size * length)
+    if type(init) == "table" then
+      for i = 1, length do
+        if type(init[i]) == "string" then
+	      local offset = (i - 1) * size + 1
+	      arr.pinned[i] = alien.buffer(#init[i] + 1)
+          arr.buffer:set(offset, arr.pinned[i], "pointer")
+        end
+        arr[i] = init[i]
+      end
+    end
+  end
+  return arr
+end
+
+local function struct_new(s_proto, ptr)
+  local buf = core.buffer(ptr or s_proto.size)
+  local function struct_get(_, key)
+    if s_proto.offsets[key] then
+      return buf:get(s_proto.offsets[key] + 1, s_proto.types[key])
+    else
+      error("field " .. key .. " does not exist")
+    end
+  end
+  local function struct_set(_, key, val)
+    if s_proto.offsets[key] then
+      buf:set(s_proto.offsets[key] + 1, val, s_proto.types[key])
+    else
+      error("field " .. key .. " does not exist")
+    end
+  end
+  return setmetatable({}, { __index = struct_get, __newindex = struct_set,
+                            __call = function () return buf end })
+end
+
+local function struct_byval(s_proto)
+  local types = {}
+  local size = s_proto.size
+  for i = 0, size - 1, 4 do
+    if size - i == 1 then
+      types[#types + 1] = "char"
+    elseif size - i == 2 then
+      types[#types + 1] = "short"
+    else
+      types[#types + 1] = "int"
+    end
+  end
+  return unpack(types)
+end
+
+function _M.defstruct(t)
+  local off = 0
+  local names, offsets, types = {}, {}, {}
+  for _, field in ipairs(t) do
+    local name, type = field[1], field[2]
+    names[#names + 1] = name
+    off = math.ceil(off / core.align(type)) * core.align(type)
+    offsets[name] = off
+    types[name] = type
+    off = off + core.sizeof(type)
+  end
+  return { names = names, offsets = offsets, types = types, size = off, new = struct_new,
+            byval = struct_byval }
+end
+
+function _M.byval(buf)
+  if buf.size then
+    local size = buf.size
+    local types = { "char", "short"}
+    local vals = {}
+    for i = 1, size, 4 do
+      if size - i == 0 then
+        vals[#vals + 1] = buf:get(i, "char")
+      elseif size - i == 1 then
+        vals[#vals + 1] = buf:get(i, "short")
+      else
+        vals[#vals + 1] = buf:get(i, "int")
+      end
+    end
+    return unpack(vals)
+  else
+    error("this type of buffer can't be passed by value")
+  end
+end