brpoplpush-redis_script 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 37ccff484d1570a0306da629f9dd37f2da81dc0c33ad44725b2ec0a1e417a48a
+  data.tar.gz: 7e2dfe274df20f602aadca5035cbd15eb82dc823e539e7ec18fbd2e6f9755520
+SHA512:
+  metadata.gz: 1231b92745e69ed64ffc0e24c93650f5ea92f33fbc0c8b72c6218ed2402d524ab3b00b05d53138f605b9c787b03a1fb3075c4c580288dcd9faef46500bb1ead3
+  data.tar.gz: c3938006e1cc0c922a6464125868ca9c5945a538a4d82c83d210e929972535efe32c961b81687c09bc667e027a386d7f2196979a5f98d1ed108ccd8dd34f8c62

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 brpoplpush
+
+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,84 @@
+# brpoplpush-redis_script
+
+Bring your own LUA scripts into redis
+
+[![Build Status](https://travis-ci.com/brpoplpush/brpoplpush-redis_script.svg?branch=master)](https://travis-ci.com/brpoplpush/brpoplpush-redis_script) [![Maintainability](https://api.codeclimate.com/v1/badges/3770a079b380d50c3d50/maintainability)](https://codeclimate.com/github/brpoplpush/brpoplpush-redis_script/maintainability) [![Test Coverage](https://api.codeclimate.com/v1/badges/3770a079b380d50c3d50/test_coverage)](https://codeclimate.com/github/brpoplpush/brpoplpush-redis_script/test_coverage)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'brpoplpush-redis_script'
+```
+
+And then execute:
+
+`bundle`
+
+Or install it yourself as:
+
+`gem install brpoplpush-redis_script`
+
+## Usage
+
+If you want to avoid global state in your project/gem the recommended way to use `RedisScript` is the following way.
+
+Include the DSL module from the gem and configure with a path. We don't believe it is a good idea to put all your lua files in a single directory. We rather believe that these scripts should be placed and organized by feature.
+
+Let's take sidekiq-unique-jobs for example. It uses `brpoplpush-redis_script` like follows:
+
+```ruby
+# lib/my_redis_scripts.rb
+require "brpoplpush-redis_script"
+
+module SidekiqUniqueJobs::Scripts
+  include Brpoplpush::RedisScript::DSL
+
+  configure do |config|
+    config.scripts_path = Rails.root.join("app", "lua")
+  end
+end
+
+SidekiqUniqueJobs::Scripts.execute(:lock, Redis.new, keys: ["key1", "key2"] argv: ["bogus"])
+# => 1
+
+SidekiqUniqueJobs::Scripts.execute(:lock, Redis.new, keys: ["key1", "key1"] argv: ["bogus"])
+# => -1
+```
+
+```lua
+-- app/lua/lock.lua
+
+local key_one = KEYS[1]
+local key_two = KEYS[2]
+
+local locked_val = ARGV[1]
+
+if not key_one == key_two then
+  redis.call("SET", key_two, )
+  return 1
+end
+
+return -1
+```
+
+This is a very simplified version of course.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at [https://github.com/bropoplpush/brpoplpush-redis_script](https://github.com/bropoplpush/brpoplpush-redis_script). This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the Brpoplpush::RedisScript project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/brpoplpush-redis_script/blob/master/CODE_OF_CONDUCT.md).

data/lib/brpoplpush/redis_script.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require "concurrent/map"
+require "concurrent/mutable_struct"
+require "digest/sha1"
+require "logger"
+require "pathname"
+require "redis"
+
+require "brpoplpush/redis_script/version"
+require "brpoplpush/redis_script/template"
+require "brpoplpush/redis_script/lua_error"
+require "brpoplpush/redis_script/script"
+require "brpoplpush/redis_script/scripts"
+require "brpoplpush/redis_script/config"
+require "brpoplpush/redis_script/timing"
+require "brpoplpush/redis_script/logging"
+require "brpoplpush/redis_script/dsl"
+require "brpoplpush/redis_script/client"
+
+module Brpoplpush
+  # Interface to dealing with .lua files
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  module RedisScript
+    module_function
+
+    include Brpoplpush::RedisScript::DSL
+
+    #
+    # The current gem version
+    #
+    #
+    # @return [String] the current gem version
+    #
+    def version
+      VERSION
+    end
+
+    #
+    # The current logger
+    #
+    #
+    # @return [Logger] the configured logger
+    #
+    def logger
+      config.logger
+    end
+
+    #
+    # Set a new logger
+    #
+    # @param [Logger] other another logger
+    #
+    # @return [Logger] the new logger
+    #
+    def logger=(other)
+      config.logger = other
+    end
+
+    #
+    # Execute the given script_name
+    #
+    #
+    # @param [Symbol] script_name the name of the lua script
+    # @param [Array<String>] keys script keys
+    # @param [Array<Object>] argv script arguments
+    # @param [Redis] conn the redis connection to use
+    #
+    # @return value from script
+    #
+    def execute(script_name, conn, keys: [], argv: [])
+      Client.execute(script_name, conn, keys: keys, argv: argv)
+    end
+  end
+end

data/lib/brpoplpush/redis_script/client.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Client
+      include Brpoplpush::RedisScript::Timing
+
+      #
+      # @!attribute [r] logger
+      #   @return [Logger] an instance of a logger
+      attr_reader :logger
+      #
+      # @!attribute [r] file_name
+      #   @return [String] The name of the file to execute
+      attr_reader :config
+      #
+      # @!attribute [r] scripts
+      #   @return [Scripts] the collection with loaded scripts
+      attr_reader :scripts
+
+      def initialize(config)
+        @config  = config
+        @logger  = config.logger
+        @scripts = Scripts.fetch(config.scripts_path)
+      end
+
+      #
+      # Execute a lua script with the provided script_name
+      #
+      # @note this method is recursive if we need to load a lua script
+      #   that wasn't previously loaded.
+      #
+      # @param [Symbol] script_name the name of the script to execute
+      # @param [Redis] conn the redis connection to use for execution
+      # @param [Array<String>] keys script keys
+      # @param [Array<Object>] argv script arguments
+      #
+      # @return value from script
+      #
+      def execute(script_name, conn, keys: [], argv: [])
+        result, elapsed = timed do
+          scripts.execute(script_name, conn, keys: keys, argv: argv)
+        end
+
+        logger.debug("Executed #{script_name}.lua in #{elapsed}ms")
+        result
+      rescue ::Redis::CommandError => ex
+        handle_error(script_name, conn, ex) do
+          execute(script_name, conn, keys: keys, argv: argv)
+        end
+      end
+
+      private
+
+      #
+      # Handle errors to allow retrying errors that need retrying
+      #
+      # @param [Redis::CommandError] ex exception to handle
+      #
+      # @return [void]
+      #
+      # @yieldreturn [void] yields back to the caller when NOSCRIPT is raised
+      def handle_error(script_name, conn, ex)
+        case ex.message
+        when /NOSCRIPT/
+          handle_noscript(script_name) { return yield }
+        when /BUSY/
+          handle_busy(conn) { return yield }
+        end
+
+        raise unless LuaError.intercepts?(ex)
+
+        script = scripts.fetch(script_name, conn)
+        raise LuaError.new(ex, script)
+      end
+
+      def handle_noscript(script_name)
+        scripts.delete(script_name)
+        yield
+      end
+
+      def handle_busy(conn)
+        scripts.kill(conn)
+      rescue ::Redis::CommandError => ex
+        logger.warn(ex)
+      ensure
+        yield
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/config.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    #
+    # Class holding gem configuration
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Config
+      #
+      # @!attribute [r] logger
+      #   @return [Logger] a logger to use for debugging
+      attr_reader :logger
+      #
+      # @!attribute [r] scripts_path
+      #   @return [Pathname] a directory with lua scripts
+      attr_reader :scripts_path
+
+      #
+      # Initialize a new instance of {Config}
+      #
+      #
+      def initialize
+        @conn         = Redis.new
+        @logger       = Logger.new(STDOUT)
+        @scripts_path = nil
+      end
+
+      #
+      # Sets a value for scripts_path
+      #
+      # @param [String, Pathname] obj <description>
+      #
+      # @raise [ArgumentError] when directory does not exist
+      # @raise [ArgumentError] when argument isn't supported
+      #
+      # @return [Pathname]
+      #
+      def scripts_path=(obj)
+        raise ArgumentError "#{obj} does not exist" unless Dir.exist?(obj.to_s)
+
+        @scripts_path =
+          case obj
+          when String
+            Pathname.new(obj)
+          when Pathname
+            obj
+          else
+            raise ArgumentError, "#{obj} should be a Pathname or String"
+          end
+      end
+
+      #
+      # Sets a value for logger
+      #
+      # @param [Logger] obj a logger to use
+      #
+      # @raise [ArgumentError] when given argument isn't a Logger
+      #
+      # @return [Logger]
+      #
+      def logger=(obj)
+        raise ArgumentError, "#{obj} should be a Logger" unless obj.is_a?(Logger)
+
+        @logger = obj
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/dsl.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "digest/sha1"
+require "concurrent/map"
+
+module Brpoplpush
+  module RedisScript
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    module DSL
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+        end
+      end
+
+      #
+      # Module ClassMethods extends the base class with necessary methods
+      #
+      # @author Mikael Henriksson <mikael@zoolutions.se>
+      #
+      module ClassMethods
+        def execute(file_name, conn, keys: [], argv: [])
+          Brpoplpush::RedisScript::Client
+            .new(config)
+            .execute(file_name, conn, keys: keys, argv: argv)
+        end
+
+        # Configure the gem
+        #
+        # This is usually called once at startup of an application
+        # @param [Hash] options global gem options
+        # @option options [String, Pathname] :path
+        # @option options [Logger] :logger (default is Logger.new(STDOUT))
+        # @yield control to the caller when given block
+        def configure(options = {})
+          if block_given?
+            yield config
+          else
+            options.each do |key, val|
+              config.send("#{key}=", val)
+            end
+          end
+        end
+
+        #
+        # The current configuration (See: {.configure} on how to configure)
+        #
+        #
+        # @return [RedisScript::Config] the gem configuration
+        #
+        def config
+          @config ||= Config.new
+        end
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/logging.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    # Utility module for reducing the number of uses of logger.
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    module Logging
+      def self.included(base)
+        base.send(:extend, self)
+      end
+
+      #
+      # A convenience method for using the configured gem logger
+      #
+      # @see RedisScript#.logger
+      #
+      # @return [Logger]
+      #
+      def logger
+        Brpoplpush::RedisScript.logger
+      end
+
+      #
+      # Logs a message at debug level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_debug(message_or_exception = nil, &block)
+        logger.debug(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at info level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_info(message_or_exception = nil, &block)
+        logger.info(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at warn level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_warn(message_or_exception = nil, &block)
+        logger.warn(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at error level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_error(message_or_exception = nil, &block)
+        logger.error(message_or_exception, &block)
+        nil
+      end
+
+      #
+      # Logs a message at fatal level
+      #
+      # @param [String, Exception] message_or_exception the message or exception to log
+      #
+      # @return [void]
+      #
+      # @yield [String, Exception] the message or exception to use for log message
+      #
+      def log_fatal(message_or_exception = nil, &block)
+        logger.fatal(message_or_exception, &block)
+        nil
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/lua_error.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    #
+    # Misconfiguration is raised when gem is misconfigured
+    #
+    # @author Mikael Henriksson <mikael@zoolutions.se>
+    #
+    class Misconfiguration < RuntimeError
+    end
+    # LuaError raised on errors in Lua scripts
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class LuaError < RuntimeError
+      # Reformats errors raised by redis representing failures while executing
+      # a lua script. The default errors have confusing messages and backtraces,
+      # and a type of +RuntimeError+. This class improves the message and
+      # modifies the backtrace to include the lua script itself in a reasonable
+      # way.
+
+      PATTERN  = /ERR Error (compiling|running) script \(.*?\): .*?:(\d+): (.*)/.freeze
+      LIB_PATH = File.expand_path("..", __dir__).freeze
+      CONTEXT_LINE_NUMBER = 2
+
+      attr_reader :error, :file, :content
+
+      # Is this error one that should be reformatted?
+      #
+      # @param error [StandardError] the original error raised by redis
+      # @return [Boolean] is this an error that should be reformatted?
+      def self.intercepts?(error)
+        PATTERN.match?(error.message)
+      end
+
+      # Initialize a new {LuaError} from an existing redis error, adjusting
+      # the message and backtrace in the process.
+      #
+      # @param error [StandardError] the original error raised by redis
+      # @param script [Script] a DTO with information about the script
+      #
+      def initialize(error, script)
+        @error        = error
+        @file         = script.path
+        @content      = script.source
+        @backtrace    = @error.backtrace
+
+        @error.message.match(PATTERN) do |regexp_match|
+          line_number   = regexp_match[2].to_i
+          message       = regexp_match[3]
+          error_context = generate_error_context(content, line_number)
+
+          super("#{message}\n\n#{error_context}\n\n")
+          set_backtrace(generate_backtrace(file, line_number))
+        end
+      end
+
+      private
+
+      # :nocov:
+      def generate_error_context(content, line_number)
+        lines                 = content.lines.to_a
+        beginning_line_number = [1, line_number - CONTEXT_LINE_NUMBER].max
+        ending_line_number    = [lines.count, line_number + CONTEXT_LINE_NUMBER].min
+        line_number_width     = ending_line_number.to_s.length
+
+        (beginning_line_number..ending_line_number).map do |number|
+          indicator = (number == line_number) ? "=>" : "  "
+          formatted_number = format("%#{line_number_width}d", number)
+          " #{indicator} #{formatted_number}: #{lines[number - 1]}"
+        end.join.chomp
+      end
+
+      # :nocov:
+      def generate_backtrace(file, line_number)
+        pre_gem                 = backtrace_before_entering_gem(@backtrace)
+        index_of_first_gem_line = (@backtrace.size - pre_gem.size - 1)
+
+        pre_gem.unshift(@backtrace[index_of_first_gem_line])
+        pre_gem.unshift("#{file}:#{line_number}")
+        pre_gem
+      end
+
+      # :nocov:
+      def backtrace_before_entering_gem(backtrace)
+        backtrace.reverse.take_while { |line| !line_from_gem(line) }.reverse
+      end
+
+      # :nocov:
+      def line_from_gem(line)
+        line.split(":").first.include?(LIB_PATH)
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/script.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Script
+      def self.load(name, root_path, conn)
+        script = new(name: name, root_path: root_path)
+        script.load(conn)
+      end
+
+      #
+      # @!attribute [r] script_name
+      #   @return [Symbol, String] the name of the script without extension
+      attr_reader :name
+      #
+      # @!attribute [r] script_path
+      #   @return [String] the path to the script on disk
+      attr_reader :path
+      #
+      # @!attribute [r] root_path
+      #   @return [Pathname]
+      attr_reader :root_path
+      #
+      # @!attribute [r] source
+      #   @return [String] the source code of the lua script
+      attr_reader :source
+      #
+      # @!attribute [rw] sha
+      #   @return [String] the sha of the script
+      attr_reader :sha
+      #
+      # @!attribute [rw] call_count
+      #   @return [Integer] the number of times the script was called/executed
+      attr_reader :call_count
+
+      def initialize(name:, root_path:)
+        @name      = name
+        @root_path = root_path
+        @path      = root_path.join("#{name}.lua").to_s
+        @source    = render_file
+        @sha       = compiled_sha
+        @call_count = 0
+      end
+
+      def ==(other)
+        sha == compiled_sha && compiled_sha == other.sha
+      end
+
+      def increment_call_count
+        @call_count += 1
+      end
+
+      def changed?
+        compiled_sha != sha
+      end
+
+      def render_file
+        Template.new(root_path).render(path)
+      end
+
+      def compiled_sha
+        Digest::SHA1.hexdigest(source)
+      end
+
+      def load(conn)
+        @sha = conn.script(:load, source)
+
+        self
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/scripts.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    # Interface to dealing with .lua files
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    class Scripts
+      #
+      # @return [Concurrent::Map] a map with configured script paths
+      SCRIPT_PATHS = Concurrent::Map.new
+
+      #
+      # Fetch a scripts configuration for path
+      #
+      # @param [Pathname] root_path the path to scripts
+      #
+      # @return [Scripts] a collection of scripts
+      #
+      def self.fetch(root_path)
+        if (scripts = SCRIPT_PATHS.get(root_path))
+          return scripts
+        end
+
+        create(root_path)
+      end
+
+      #
+      # Create a new scripts collection based on path
+      #
+      # @param [Pathname] root_path the path to scripts
+      #
+      # @return [Scripts] a collection of scripts
+      #
+      def self.create(root_path)
+        scripts = new(root_path)
+        store(scripts)
+      end
+
+      #
+      # Store the scripts collection in memory
+      #
+      # @param [Scripts] scripts the path to scripts
+      #
+      # @return [Scripts] the scripts instance that was stored
+      #
+      def self.store(scripts)
+        SCRIPT_PATHS.put(scripts.root_path, scripts)
+        scripts
+      end
+
+      #
+      # @!attribute [r] scripts
+      #   @return [Concurrent::Map] a collection of loaded scripts
+      attr_reader :scripts
+
+      #
+      # @!attribute [r] root_path
+      #   @return [Pathname] the path to the directory with lua scripts
+      attr_reader :root_path
+
+      def initialize(path)
+        raise ArgumentError, "path needs to be a Pathname" unless path.is_a?(Pathname)
+
+        @scripts   = Concurrent::Map.new
+        @root_path = path
+      end
+
+      def fetch(name, conn)
+        if (script = scripts.get(name.to_sym))
+          return script
+        end
+
+        load(name, conn)
+      end
+
+      def load(name, conn)
+        script = Script.load(name, root_path, conn)
+        scripts.put(name.to_sym, script)
+
+        script
+      end
+
+      def delete(script)
+        if script.is_a?(Script)
+          scripts.delete(script.name)
+        else
+          scripts.delete(script.to_sym)
+        end
+      end
+
+      def kill(conn)
+        conn.script(:kill)
+      end
+
+      #
+      # Execute a lua script with given name
+      #
+      # @note this method is recursive if we need to load a lua script
+      #   that wasn't previously loaded.
+      #
+      # @param [Symbol] name the name of the script to execute
+      # @param [Redis] conn the redis connection to use for execution
+      # @param [Array<String>] keys script keys
+      # @param [Array<Object>] argv script arguments
+      #
+      # @return value from script
+      #
+      def execute(name, conn, keys: [], argv: [])
+        script = fetch(name, conn)
+        conn.evalsha(script.sha, keys: keys, argv: argv)
+      end
+
+      def count
+        scripts.keys.size
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/template.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  # Interface to dealing with .lua files
+  #
+  # @author Mikael Henriksson <mikael@mhenrixon.com>
+  module RedisScript
+    #
+    # Class Template provides LUA script partial template rendering
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    #
+    class Template
+      def initialize(script_path)
+        @script_path = script_path
+      end
+
+      #
+      # Renders a Lua script and includes any partials in that file
+      #  all `<%= include_partial '' %>` replaced with the actual contents of the partial
+      #
+      # @param [Pathname] pathname the path to the
+      #
+      # @return [String] the rendered Luascript
+      #
+      def render(pathname)
+        @partial_templates ||= {}
+        ERB.new(File.read(pathname)).result(binding)
+      end
+
+      # helper method to include a lua partial within another lua script
+      #
+      def include_partial(relative_path)
+        return if @partial_templates.key?(relative_path)
+
+        @partial_templates[relative_path] = nil
+        render(Pathname.new("#{@script_path}/#{relative_path}"))
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/timing.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    # Handles timing> of things
+    #
+    # @author Mikael Henriksson <mikael@mhenrixon.com>
+    module Timing
+      module_function
+
+      #
+      # Used for timing method calls
+      #
+      #
+      # @return [yield return, Float]
+      #
+      def timed
+        start_time = now
+
+        [yield, now - start_time]
+      end
+
+      #
+      # Returns a float representation of the current time.
+      #   Either from Process or Time
+      #
+      #
+      # @return [Float]
+      #
+      def now
+        (Process.clock_gettime(Process::CLOCK_MONOTONIC) * 1000).to_i
+      end
+    end
+  end
+end

data/lib/brpoplpush/redis_script/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Brpoplpush
+  module RedisScript
+    VERSION = "0.1.0"
+  end
+end

data/lib/tasks/changelog.rake

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+desc "Generate a Changelog"
+task :changelog do
+  # rubocop:disable Style/MutableConstant
+  CHANGELOG_CMD ||= %w[
+    github_changelog_generator
+    -u
+    brpoplpush
+    -p
+    brpoplpush-redis_script
+    --no-verbose
+    --token
+  ]
+  ADD_CHANGELOG_CMD      ||= "git add --all"
+  COMMIT_CHANGELOG_CMD   ||= "git commit -a -m 'Update changelog'"
+  # rubocop:enable Style/MutableConstant
+
+  sh("git checkout master")
+  sh(*CHANGELOG_CMD.push(ENV["CHANGELOG_GITHUB_TOKEN"]))
+  sh(ADD_CHANGELOG_CMD)
+  sh(COMMIT_CHANGELOG_CMD)
+end

metadata

@@ -0,0 +1,202 @@
+--- !ruby/object:Gem::Specification
+name: brpoplpush-redis_script
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mikael Henriksson
+- Mauro Berlanda
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-10-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - "<="
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.7'
+- !ruby/object:Gem::Dependency
+  name: github-markup
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: github_changelog_generator
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.18
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.18
+- !ruby/object:Gem::Dependency
+  name: gem-release
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+description: Bring your own LUA scripts into redis.
+email:
+- mikael@mhenrixon.com
+- mauro.berlanda@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/brpoplpush/redis_script.rb
+- lib/brpoplpush/redis_script/client.rb
+- lib/brpoplpush/redis_script/config.rb
+- lib/brpoplpush/redis_script/dsl.rb
+- lib/brpoplpush/redis_script/logging.rb
+- lib/brpoplpush/redis_script/lua_error.rb
+- lib/brpoplpush/redis_script/script.rb
+- lib/brpoplpush/redis_script/scripts.rb
+- lib/brpoplpush/redis_script/template.rb
+- lib/brpoplpush/redis_script/timing.rb
+- lib/brpoplpush/redis_script/version.rb
+- lib/tasks/changelog.rake
+homepage: https://github.com/brpoplpush/brpoplpush-redis_script
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+  homepage_uri: https://github.com/brpoplpush/brpoplpush-redis_script
+  source_code_uri: https://github.com/brpoplpush/brpoplpush-redis_script
+  changelog_uri: https://github.com/brpoplpush/brpoplpush-redis_script/CHANGELOG.md
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.5.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Bring your own LUA scripts into redis.
+test_files: []