
- Lua Tutorial
- Lua - Home
- Lua Basics
- Lua - Overview
- Lua - Environment
- Lua - Basic Syntax
- Lua - Comments
- Lua - Print Hello World
- Lua - Variables
- Lua - Data Types
- Lua - Operators
- Lua - Loops
- Lua - Generic For
- Lua - Decision Making
- Lua - Date and Time
- Lua Functions
- Lua - Functions
- Lua - Multiple Results
- Lua - Named Arguments
- Lua - Default/Optional Arguments
- Lua - Closures
- Lua - Uses of Closures
- Lua - Local Functions
- Lua - Anonymous Functions
- Lua - Functions in Table
- Lua - Proper Tail Calls
- Lua Strings
- Lua - Strings
- Lua - String Concatenation
- Lua - Loop Through String
- Lua - String to Int
- Lua - Split String
- Lua - Check String is NULL
- Lua Arrays
- Lua - Arrays
- Lua - Multi-dimensional Arrays
- Lua - Array Length
- Lua - Iterating Over Arrays
- Lua - Slicing Arrays
- Lua - Sorting Arrays
- Lua - Merging Arrays
- Lua - Sparse Arrays
- Lua - Searching Arrays
- Lua - Resizing Arrays
- Lua - Array to String Conversion
- Lua - Array as Stack
- Lua - Array as Queue
- Lua - Array with Metatables
- Lua - Immutable Arrays
- Lua - Shuffling Arrays
- Lua Iterators
- Lua - Iterators
- Lua - Stateless Iterators
- Lua - Stateful Iterators
- Lua - Built-in Iterators
- Lua - Custom Iterators
- Lua - Iterator Closures
- Lua - Infinite Iterators
- Lua - File Iterators
- Lua - Table Iterators
- Lua - Numeric Iterators
- Lua - Reverse Iterators
- Lua - Filter Iterators
- Lua - Range Iterators
- Lua - Chaining Iterators
- Lua Tables
- Lua - Tables
- Lua - Tables as Arrays
- Lua - Tables as Dictionaries
- Lua - Tables as Sets
- Lua - Table Length
- Lua - Table Iteration
- Lua - Table Constructors
- Lua - Loop through Table
- Lua - Merge Tables
- Lua - Nested Tables
- Lua - Accessing Table Fields
- Lua - Copy Table by Value
- Lua - Get Entries from Table
- Lua - Table Metatables
- Lua - Tables as Objects
- Lua - Table Inheritance
- Lua - Table Cloning
- Lua - Table Sorting
- Lua - Table Searching
- Lua - Table Serialization
- Lua - Weak Tables
- Lua - Table Memory Management
- Lua - Tables as Stacks
- Lua - Tables as Queues
- Lua - Sparse Tables
- Lua Lists
- Lua - Lists
- Lua - Inserting Elements into Lists
- Lua - Removing Elements from Lists
- Lua - Iterating Over Lists
- Lua - Reverse Iterating Over Lists
- Lua - Accessing List Elements
- Lua - Modifying List Elements
- Lua - List Length
- Lua - Concatenate Lists
- Lua - Slicing Lists
- Lua - Sorting Lists
- Lua - Reversing Lists
- Lua - Searching in Lists
- Lua - Shuffling List
- Lua - Multi-dimensional Lists
- Lua - Sparse Lists
- Lua - Lists as Stacks
- Lua - Lists as Queues
- Lua - Functional Operations on Lists
- Lua - Immutable Lists
- Lua - List Serialization
- Lua - Metatables with Lists
- Lua Modules
- Lua - Modules
- Lua - Returning Functions from Modules
- Lua - Returning Functions Table from Modules
- Lua - Module Scope
- Lua - SubModule
- Lua - Module Caching
- Lua - Custom Module Loaders
- Lua - Namespaces
- Lua - Singleton Modules
- Lua - Sharing State Between Modules
- Lua - Module Versioning
- Lua Metatables
- Lua - Metatables
- Lua - Chaining Metatables
- Lua Coroutines
- Lua - Coroutines
- Lua File Handling
- Lua - File I/O
- Lua - Opening Files
- Lua - Modes for File Access
- Lua - Reading Files
- Lua - Writing Files
- Lua - Closing Files
- Lua - Renaming Files
- Lua - Deleting Files
- Lua - File Buffers and Flushing
- Lua - Reading Files Line by Line
- Lua - Binary File Handling
- Lua - File Positioning
- Lua - Appending to Files
- Lua - Error Handling in File Operations
- Lua - Checking if File exists
- Lua - Checking if File is Readable
- Lua - Checking if File is Writable
- Lua - Checking if File is ReadOnly
- Lua - File Descriptors
- Lua - Creating Temporary Files
- Lua - Working with Large Files
- Lua Advanced
- Lua - Error Handling
- Lua - Debugging
- Lua - Garbage Collection
- Lua - Object Oriented
- Lua - Web Programming
- Lua - Database Access
- Lua - Game Programing
- Lua Useful Resources
- Lua - Quick Guide
- Lua - Useful Resources
- Lua - Discussion
Lua - Module Versioning
Module versioning is crucial in dependency management especially in large lua projects. Using versions, we can maintain compatability checks and can handle updates easily. In this chapter, we're discussion various options as how to create and manage versions of modules.
Simple Approach - Store Version within Module
It is most easier and commonly used technique to maintain modules version. A version identified by _VERSION is stored in the module table returned. We can choose other name as well but generally _VERSION is preferred.
Create module with _VERSION string.
my_module.lua
local my_module = {} my_module._VERSION = "1.0.2" function my_module.some_function() print("Performing some function in version:",my_module._VERSION) end return my_module
Now using version, we can decide the function to be called or arguments to be passed.
main.lua
local my_module = require("my_module") print("Using my_module version:", my_module._VERSION) -- Execute code based on version if my_module._VERSION:match("^1%.") then -- execute code as per version 1.x.x my_module.some_function() else -- execute code for higher version print("Using a newer version with new function") end
Output
When we run the above program, we will get the following output−
Using my_module version: 1.0.2 Performing some function in version: 1.0.2
Simple Approach - Store Version within Module
It is most easier and commonly used technique to maintain modules version. A version identified by _VERSION is stored in the module table returned. We can choose other name as well but generally _VERSION is preferred.
Create module with _VERSION string.
my_module.lua
local my_module = {} my_module._VERSION = "1.0.2" function my_module.some_function() print("Performing some function in version:",my_module._VERSION) end return my_module
Now using version, we can decide the function to be called or arguments to be passed.
main.lua
local my_module = require("my_module") print("Using my_module version:", my_module._VERSION) -- Execute code based on version if my_module._VERSION:match("^1%.") then -- execute code as per version 1.x.x my_module.some_function() else -- execute code for higher version print("Using a newer version with new function") end
Output
When we run the above program, we will get the following output−
Using my_module version: 1.0.2 Performing some function in version: 1.0.2
This approch is simple and straight forward but it does not provide any automated dependency management or version resolution capability.
Separate Version File for Module
We can create a separate version file with a naming convension like my-module-1.0-2.lua and read it using custom loader when a module is loaded or create a file like module.version and ship with my-module.lua. as shown below −
Create module version file
my_module.version
1.0.2
Now read the version in my-module.lua module file.
my_module.lua
local my_module = {} local function get_version() local f = io.open("my_module.version", "r") print(f) if f then local version = f:read("*l") f:close() return version else return "unknown" end end my_module._VERSION = get_version() function my_module.some_function() print("Performing some function in version:",my_module._VERSION) end return my_module
Now using version, we can decide the function to be called or arguments to be passed.
main.lua
local my_module = require("my_module") print("Using my_module version:", my_module._VERSION) -- Execute code based on version if my_module._VERSION:match("^1%.") then -- execute code as per version 1.x.x my_module.some_function() else -- execute code for higher version print("Using a newer version with new function") end
Output
When we run the above program, we will get the following output−
Using my_module version: 1.0.2 Performing some function in version: 1.0.2
This approch separates version from module code and we can automate the versioning process.
External Dependency Management Tools
LuaRocks is an external dependency manager for Lua. It is used generally for large projects or while distributing libraries. LuaRocks provides a framework for −
To package the module with metadata like versions, release informations etc.
To install external dependencies and their management.
To handle versions like installing a specific version or a mininum version of a library.
Whenver we install any Lua library via LuaRocks, LuaRocks stores the version information in the metadata. LuaRocks is a robust dependency management and versioning tool. It provides a standardized way to handle multiple dependencies in a Lua project.