jylis-rb 0.0.1 → 0.1.0

data/doc/top-level-namespace.html

@@ -6,7 +6,7 @@
 <title>
   Top Level Namespace
   
-    &mdash; Documentation by YARD 0.9.13
+    &mdash; Documentation by YARD 0.9.14
   
 </title>
 
@@ -100,9 +100,9 @@
 </div>
 
       <div id="footer">
-  Generated on Sat Jun  2 13:02:48 2018 by
+  Generated on Sun Jun  3 21:46:59 2018 by
   <a href="http://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
-  0.9.13 (ruby-2.5.1).
+  0.9.14 (ruby-2.5.1).
 </div>
 
     </div>

data/lib/jylis-rb.rb

@@ -1,2 +1,11 @@
 require_relative "jylis-rb/version"
 require_relative "jylis-rb/jylis"
+require_relative "jylis-rb/connection"
+
+require_relative "jylis-rb/data_types/base"
+require_relative "jylis-rb/data_types/treg"
+require_relative "jylis-rb/data_types/tlog"
+require_relative "jylis-rb/data_types/gcount"
+require_relative "jylis-rb/data_types/pncount"
+require_relative "jylis-rb/data_types/mvreg"
+require_relative "jylis-rb/data_types/ujson"

data/lib/jylis-rb/connection.rb

@@ -0,0 +1,121 @@
+require "hiredis"
+
+class Jylis
+  # A connection to the database.
+  class Connection
+    # The server URI schema is not supported.
+    class UnsupportedSchemaError < StandardError; end
+    # The host is missing from the server URI.
+    class HostMissingError < StandardError; end
+
+    # @param server_uri [URI, String] uri of the server to connect to
+    #
+    # @raise [UnsupportedSchemaError] if the server URI schema is not supported
+    # @raise [HostMissingError] if the host is missing from the server URI
+    def initialize(server_uri)
+      server_uri = URI.parse(server_uri) unless server_uri.is_a?(URI)
+
+      unless server_uri.scheme.downcase == "jylis"
+        raise UnsupportedSchemaError.new(
+          "#{server_uri.scheme} is not a supported schema"
+        )
+      end
+
+      unless server_uri.host
+        raise HostMissingError.new("No host specified")
+      end
+
+      @server_host = server_uri.host
+      @server_port = server_uri.port || 6379
+      @connection  = Hiredis::Connection.new
+
+      connect
+    end
+
+    # @return [Boolean] true if a connection to the server is established
+    def connected?
+      @connection.connected?
+    end
+
+    # Reconnect to the server.
+    def reconnect
+      disconnect if connected?
+
+      connect
+    end
+
+    # Disconnect from the server.
+    def disconnect
+      @connection.disconnect
+    end
+
+    # Make a query to the database.
+    #
+    # @param args data type function args. Can be an args list or array.
+    #
+    # @return [Array] query response
+    #
+    # @see https://jemc.github.io/jylis/docs/types/
+    def query(*args)
+      if args.count == 1 && args.first.is_a?(Array)
+        args = *args.first
+      end
+
+      @connection.write(args)
+      @connection.read
+    end
+
+    # @!group Data Types
+
+    # TREG functions
+    #
+    # @return [Jylis::DataType::TREG]
+    def treg
+      @treg ||= Jylis::DataType::TREG.new(self)
+    end
+
+    # TLOG functions
+    #
+    # @return [Jylis::DataType::TLOG]
+    def tlog
+      @tlog ||= Jylis::DataType::TLOG.new(self)
+    end
+
+    # GCOUNT functions
+    #
+    # @return [Jylis::DataType::GCOUNT]
+    def gcount
+      @gcount ||= Jylis::DataType::GCOUNT.new(self)
+    end
+
+    # PNCOUNT functions
+    #
+    # @return [Jylis::DataType::PNCOUNT]
+    def pncount
+      @pncount ||= Jylis::DataType::PNCOUNT.new(self)
+    end
+
+    # MVREG functions
+    #
+    # @return [Jylis::DataType::MVREG]
+    def mvreg
+      @mvreg ||= Jylis::DataType::MVREG.new(self)
+    end
+
+    # UJSON functions
+    #
+    # @return [Jylis::DataType::UJSON]
+    def ujson
+      @ujson ||= Jylis::DataType::UJSON.new(self)
+    end
+
+    private
+
+    # Connect to the server.
+    def connect
+      @connection.connect(@server_host, @server_port)
+    end
+
+    # @!endgroup
+  end
+end

data/lib/jylis-rb/data_types/base.rb

@@ -0,0 +1,24 @@
+class Jylis
+  # Namespace for Jylis data types.
+  #
+  # @see https://jemc.github.io/jylis/docs/types/
+  module DataType
+    # A base data type for others to inherit shared logic from.
+    # This class can't be instantiated directly.
+    class Base
+      # The Jylis::Connection to use for queries.
+      attr_reader :connection
+
+      # @param connection [Jylis::Connection] connection to use for queries
+      def initialize(connection)
+        if self.class == Base
+          raise "Base is an abstract class and must be inherited"
+        end
+
+        raise ArgumentError.new("Connection can't be nil") unless connection
+
+        @connection = connection
+      end
+    end
+  end
+end

data/lib/jylis-rb/data_types/gcount.rb

@@ -0,0 +1,24 @@
+class Jylis
+  module DataType
+    # A grow-only counter.
+    #
+    # @see https://jemc.github.io/jylis/docs/types/gcount/
+    class GCOUNT < Base
+      # Get the resulting `value` for the counter at `key`.
+      #
+      # @return [Integer]
+      def get(key)
+        connection.query("GCOUNT", "GET", key)
+      end
+
+      # Increase the counter at `key` by the amount of `value`.
+      def inc(key, value)
+        result = connection.query("GCOUNT", "INC", key, value)
+
+        unless result == "OK"
+          raise "Failed: GCOUNT INC #{key} #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/jylis-rb/data_types/mvreg.rb

@@ -0,0 +1,23 @@
+class Jylis
+  module DataType
+    # A multi-value register.
+    #
+    # @see https://jemc.github.io/jylis/docs/types/mvreg/
+    class MVREG < Base
+
+      # Get the latest value(s) for the register at `key`.
+      def get(key)
+        connection.query("MVREG", "GET", key)
+      end
+
+      # Set the latest `value` for the register at `key`.
+      def set(key, value)
+        result = connection.query("MVREG", "SET", key, value)
+
+        unless result == "OK"
+          raise "Failed: MVREG SET #{key} #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/jylis-rb/data_types/pncount.rb

@@ -0,0 +1,33 @@
+class Jylis
+  module DataType
+    # A positive/negative counter.
+    #
+    # @see https://jemc.github.io/jylis/docs/types/pncount/
+    class PNCOUNT < Base
+      # Get the resulting `value` for the counter at `key`.
+      #
+      # @return [Integer]
+      def get(key)
+        connection.query("PNCOUNT", "GET", key)
+      end
+
+      # Increase the counter at `key` by the amount of `value`.
+      def inc(key, value)
+        result = connection.query("PNCOUNT", "INC", key, value)
+
+        unless result == "OK"
+          raise "Failed: PNCOUNT INC #{key} #{value}"
+        end
+      end
+
+      # Decrease the counter at `key` by the amount of `value`.
+      def dec(key, value)
+        result = connection.query("PNCOUNT", "DEC", key, value)
+
+        unless result == "OK"
+          raise "Failed: PNCOUNT DEC #{key} #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/jylis-rb/data_types/tlog.rb

@@ -0,0 +1,157 @@
+class Jylis
+  module DataType
+    # A timestamped log.
+    #
+    # @see https://jemc.github.io/jylis/docs/types/tlog/
+    class TLOG < Base
+      # The result of a TLOG query.
+      class Result
+        include Enumerable
+
+        # Construct a Result from a raw query result.
+        #
+        # @param query_result [Array]
+        #
+        # @return [Jylis::DataType::TLOG::Result]
+        def self.parse(query_result)
+          rows = query_result.reduce([]) do |memo, row|
+            memo << Row.parse(row)
+            memo
+          end
+
+          new(rows)
+        end
+
+        def initialize(rows)
+          @rows = rows
+        end
+
+        # @return [Jylis::DataType::TLOG::Row] the row at the given index
+        def [](index)
+          @rows[index]
+        end
+
+        # :no doc:
+        def each(&block)
+          @rows.each(&block)
+        end
+
+        # @return [Integer] number of rows
+        def count
+          @rows.count
+        end
+
+        # Reconstruct the raw result returned by the database.
+        def to_a
+          @rows.map(&:to_a)
+        end
+      end
+
+      # A row (data point) in a TLOG::Result.
+      class Row
+        attr_reader :value
+        attr_reader :timestamp
+
+        # Construct a Row from a raw query row.
+        #
+        # @param query_row [Array]
+        #
+        # @return [Jylis::DataType::TLOG::Row]
+        def self.parse(query_row)
+          new(query_row[0], query_row[1])
+        end
+
+        def initialize(value, timestamp)
+          @value     = value
+          @timestamp = timestamp
+        end
+
+        # :nodoc:
+        def ==(other)
+          other.value == self.value &&
+          other.timestamp == self.timestamp
+        end
+
+        # Reconstruct the raw result returned by the database.
+        def to_a
+          [value, timestamp]
+        end
+      end
+
+      # Get the latest `value` and `timestamp` for the register at `key`.
+      #
+      # @return [Jylis::DataType::TLOG::Result]
+      def get(key, count = nil)
+        params = ["TLOG", "GET", key]
+
+        params.push(count) if count
+
+        result = connection.query(*params)
+
+        Result.parse(result)
+      end
+
+      # # Set a `value` and `timestamp` for the register at `key`.
+      # def set(key, value, timestamp)
+        # result = connection.query("TLOG", "SET", key, value, timestamp)
+
+        # unless result == "OK"
+        #   raise "Failed: TLOG SET #{key} #{value} #{timestamp}"
+        # end
+      # end
+
+      # Insert a `value`/`timestamp` entry into the log at `key`.
+      def ins(key, value, timestamp)
+        result = connection.query("TLOG", "INS", key, value, timestamp)
+
+        unless result == "OK"
+          raise "Failed: TLOG INS #{key} #{value} #{timestamp}"
+        end
+      end
+
+      # @return [Integer] the number of entries in the log at `key`
+      def size(key)
+        connection.query("TLOG", "SIZE", key)
+      end
+
+      # @return [Integer] the current cutoff timestamp of the log at `key`
+      def cutoff(key)
+        connection.query("TLOG", "CUTOFF", key)
+      end
+
+      # Raise the cutoff timestamp of the log, causing any entries to be
+      # discarded whose timestamp is earlier than the newly given `timestamp`.
+      def trimat(key, timestamp)
+        result = connection.query("TLOG", "TRIMAT", key, timestamp)
+
+        unless result == "OK"
+          raise "Failed: TLOG TRIMAT #{key} #{timestamp}"
+        end
+      end
+
+      # Raise the cutoff timestamp of the log to retain at least `count`
+      # entries, by setting the cutoff timestamp to the timestamp of the entry
+      # at index `count - 1` in the log. Any entries with an earlier timestamp
+      # than the entry at that index will be discarded. If `count` is zero,
+      # this is the same as calling #clr.
+      def trim(key, count)
+        result = connection.query("TLOG", "TRIM", key, count)
+
+        unless result == "OK"
+          raise "Failed: TLOG TRIM #{key} #{count}"
+        end
+      end
+
+      # Raise the cutoff timestamp to be the timestamp of the latest entry plus
+      # one, such that all local entries in the log will be discarded due to
+      # having timestamps earlier than the cutoff timestamp.
+      def clr(key)
+        result = connection.query("TLOG", "CLR", key)
+
+        unless result == "OK"
+          raise "Failed: TLOG CLR #{key}"
+        end
+      end
+    end
+  end
+end

data/lib/jylis-rb/data_types/treg.rb

@@ -0,0 +1,57 @@
+class Jylis
+  module DataType
+    # A timestamped register.
+    #
+    # @see https://jemc.github.io/jylis/docs/types/treg/
+    class TREG < Base
+      # The result of a TREG query.
+      class Result
+        attr_reader :value
+        attr_reader :timestamp
+
+        # Construct a Result from a raw query result.
+        #
+        # @param query_result [Array]
+        #
+        # @return [Jylis::DataType::TREG::Result]
+        def self.parse(query_result)
+          new(query_result[0], query_result[1])
+        end
+
+        def initialize(value, timestamp)
+          @value     = value
+          @timestamp = timestamp
+        end
+
+        # :nodoc:
+        def ==(other)
+          other.value == self.value &&
+          other.timestamp == self.timestamp
+        end
+
+        # Reconstruct the raw result returned by the database.
+        def to_a
+          [value, timestamp]
+        end
+      end
+
+      # Get the latest `value` and `timestamp` for the register at `key`.
+      #
+      # @return [Jylis::DataType::TREG::Result]
+      def get(key)
+        result = connection.query("TREG", "GET", key)
+
+        Result.parse(result)
+      end
+
+      # Set a `value` and `timestamp` for the register at `key`.
+      def set(key, value, timestamp)
+        result = connection.query("TREG", "SET", key, value, timestamp)
+
+        unless result == "OK"
+          raise "Failed: TREG SET #{key} #{value} #{timestamp}"
+        end
+      end
+    end
+  end
+end