riak-client-noenc 1.0.0

data/lib/riak/crdt/batch_counter.rb

@@ -0,0 +1,19 @@
+module Riak
+  module Crdt
+    class BatchCounter
+      attr_reader :accumulator
+
+      def initialize
+        @accumulator = 0
+      end
+
+      def increment(amount = 1)
+        @accumulator += amount
+      end
+
+      def decrement(amount = 1)
+        increment -amount
+      end
+    end
+  end
+end

data/lib/riak/crdt/batch_map.rb

@@ -0,0 +1,41 @@
+module Riak
+  module Crdt
+    # A map that queues up its operations for the parent {Map} to send to
+    # Riak all at once.
+    class BatchMap
+      attr_reader :counters, :flags, :maps, :registers, :sets
+
+      # @api private
+      def initialize(parent)
+        @parent = parent
+        @queue = []
+
+        initialize_collections
+      end
+
+      # @api private
+      def operate(operation)
+        @queue << operation
+      end
+
+      # @api private
+      def operations
+        @queue.map do |q|
+          Operation::Update.new.tap do |op|
+            op.type = :map
+            op.value = q
+          end
+        end
+      end
+
+      private
+      def initialize_collections
+        @counters = @parent.counters.reparent self
+        @flags = @parent.flags.reparent self
+        @maps = @parent.maps.reparent self
+        @registers = @parent.registers.reparent self
+        @sets = @parent.sets.reparent self
+      end
+    end
+  end
+end

data/lib/riak/crdt/counter.rb

@@ -0,0 +1,82 @@
+module Riak
+  module Crdt
+
+    # A distributed counter that supports incrementing and decrementing. This
+    # `Counter` uses the Riak 2 Data Types feature. If you're interested in
+    # Riak 1.4 Counters, see {Riak::Counter}.
+    class Counter < Base
+
+      # Create a counter instance. The bucket type is determined by the first of
+      # these sources:
+      #
+      # 1. The `bucket_type` String argument
+      # 2. A {BucketTyped::Bucket} as the `bucket` argument
+      # 3. The `Crdt::Base::DEFAULT_BUCKET_TYPES[:counter]` entry
+      #
+      # @param [Bucket] bucket the {Riak::Bucket} for this counter
+      # @param [String, nil] key The name of the counter. A nil key makes
+      #        Riak assign a key.
+      # @param [String] bucket_type The optional bucket type for this counter.
+      #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:counter]`.
+      # @param [Hash] options
+      def initialize(bucket, key, bucket_type = nil, options = {})
+        super(bucket, key, bucket_type || :counter, options)
+      end
+
+      # The current value of the counter; hits the server if the value has
+      # not been fetched or if the counter has been incremented.
+      def value
+        reload if dirty?
+        return @value
+      end
+
+      # Increment the counter.
+      #
+      # @param [Integer] amount
+      # @param [Hash] options
+      def increment(amount = 1, options = {})
+        operate operation(amount), options
+      end
+
+      # Yields a {BatchCounter} to turn multiple increments into a single
+      # Riak hit.
+      #
+      # @yieldparam [BatchCounter] batch_counter collects multiple increments
+      def batch
+        batcher = BatchCounter.new
+
+        yield batcher
+
+        increment batcher.accumulator
+      end
+
+      alias :to_i :value
+
+      # Decrement the counter.
+      #
+      # @param [Integer] amount
+      def decrement(amount = 1)
+        increment -amount
+      end
+
+      def pretty_print(pp)
+        super pp do
+          pp.comma_breakable
+          pp.text "value=#{value}"
+        end
+      end
+
+      private
+      def vivify(value)
+        @value = value
+      end
+
+      def operation(amount)
+        Operation::Update.new.tap do |op|
+          op.type = :counter
+          op.value = amount
+        end
+      end
+    end
+  end
+end

data/lib/riak/crdt/inner_counter.rb

@@ -0,0 +1,81 @@
+module Riak
+  module Crdt
+    # The {InnerCounter} lives inside a {Map}, or an {InnerMap} inside of a
+    # {Map}, and is accessed through a {TypedCollection}.
+    #
+    # Much like the {Riak::Crdt::Counter}, it provides an integer value that can
+    # be incremented and decremented.
+    class InnerCounter
+      # The name of this counter inside a map.
+      #
+      # @api private
+      attr_accessor :name
+
+      # The value of this counter.
+      #
+      # @return [Integer] counter value
+      attr_reader :value
+      alias :to_i :value
+
+      # The parent of this counter.
+      #
+      # @api private
+      attr_reader :parent
+
+      # @api private
+      def initialize(parent, value = 0)
+        @parent = parent
+        @value = value
+      end
+
+      # Increment the counter.
+      #
+      # @param [Integer] amount How much to increment the counter by.
+      def increment(amount = 1)
+        @parent.increment name, amount
+      end
+
+      # Decrement the counter. Opposite of increment.
+      #
+      # @param [Integer] amount How much to decrement from the counter.
+      def decrement(amount = 1)
+        increment -amount
+      end
+
+      # Perform multiple increments against this counter, and collapse
+      # them into a single operation.
+      #
+      # @yieldparam [BatchCounter] batch_counter actually collects the
+      #                            operations.
+      def batch
+        batcher = BatchCounter.new
+
+        yield batcher
+
+        increment batcher.accumulator
+      end
+
+      def pretty_print(pp)
+        pp.object_group self do
+          pp.breakable
+          pp.pp value
+        end
+      end
+
+      # @api private
+      def self.update(increment)
+        Operation::Update.new.tap do |op|
+          op.value = increment
+          op.type = :counter
+        end
+      end
+
+      # @api private
+      def self.delete
+        Operation::Delete.new.tap do |op|
+          op.type = :counter
+        end
+      end
+    end
+  end
+end

data/lib/riak/crdt/inner_flag.rb

@@ -0,0 +1,42 @@
+module Riak
+  module Crdt
+    # The {InnerFlag} is a boolean member of a {Map}. Since flag operations are
+    # extremely simple, this object simply provides internal API methods for
+    # {TypedCollection} to use.
+    #
+    # @api private
+    class InnerFlag
+      def self.new(parent, value = false)
+        ensure_boolean value
+
+        return value
+      end
+
+      def self.update(value)
+        ensure_boolean value
+
+        Operation::Update.new.tap do |op|
+          op.value = value
+          op.type = :flag
+        end
+      end
+
+      def self.delete
+        Operation::Delete.new.tap do |op|
+          op.type = :flag
+        end
+      end
+
+      private
+      def self.ensure_boolean(value)
+        return if value.is_a? TrueClass
+        return if value.is_a? FalseClass
+
+        raise FlagError, t('crdt.flag.not_boolean')
+      end
+
+      class FlagError < ArgumentError
+      end
+    end
+  end
+end

data/lib/riak/crdt/inner_map.rb

@@ -0,0 +1,75 @@
+module Riak
+  module Crdt
+    # A map that exists inside a {TypedCollection} inside another map.
+    class InnerMap
+      attr_reader :counters, :flags, :maps, :registers, :sets
+
+      attr_accessor :name
+
+      # The parent of this counter.
+      #
+      # @api private
+      attr_reader :parent
+
+      # @api private
+      def initialize(parent, value = {})
+        @parent = parent
+        @value = value.symbolize_keys
+
+        initialize_collections
+      end
+
+      # @api private
+      def operate(inner_operation)
+        wrapped_operation = Operation::Update.new.tap do |op|
+          op.value = inner_operation
+          op.type = :map
+        end
+
+        @parent.operate(name, wrapped_operation)
+      end
+
+      def pretty_print(pp)
+        pp.object_group self do
+          %w{counters flags maps registers sets}.each do |h|
+            pp.comma_breakable
+            pp.text "#{h}="
+            pp.pp send h
+          end
+        end
+      end
+
+      def pretty_print_cycle(pp)
+        pp.text "InnerMap"
+      end
+
+      def to_value_h
+        %w{counters flags maps registers sets}.map do |k|
+          [k, send(k).to_value_h]
+        end.to_h
+      end
+
+      alias :value :to_value_h
+
+      # @api private
+      def self.delete
+        Operation::Delete.new.tap do |op|
+          op.type = :map
+        end
+      end
+
+      def context?
+        @parent.context?
+      end
+
+      private
+      def initialize_collections
+        @counters = TypedCollection.new InnerCounter, self, @value[:counters]
+        @flags = TypedCollection.new InnerFlag, self, @value[:flags]
+        @maps = TypedCollection.new InnerMap, self, @value[:maps]
+        @registers = TypedCollection.new InnerRegister, self, @value[:registers]
+        @sets = TypedCollection.new InnerSet, self, @value[:sets]
+      end
+    end
+  end
+end

data/lib/riak/crdt/inner_register.rb

@@ -0,0 +1,26 @@
+module Riak
+  module Crdt
+    class InnerRegister < String
+      attr_reader :parent
+
+      def initialize(parent, *args, &block)
+        @parent = parent
+        super(*args, &block)
+        freeze
+      end
+
+      def self.update(value)
+        Operation::Update.new.tap do |op|
+          op.value = value
+          op.type = :register
+        end
+      end
+
+      def self.delete
+        Operation::Delete.new.tap do |op|
+          op.type = :register
+        end
+      end
+    end
+  end
+end

data/lib/riak/crdt/inner_set.rb

@@ -0,0 +1,102 @@
+module Riak
+  module Crdt
+    # The {InnerSet} is similar to a {Riak::Crdt::Set}, except it is part of
+    # a {Map} (or an {InnerMap} inside of a {Map}). It is usually accessed
+    # through a {TypedCollection}.
+    #
+    # Just like a {Riak::Crdt::Set}, it's a set of {String Strings} that can
+    # be added to or removed from.
+    class InnerSet
+      # The name of this set inside a map.
+      #
+      # @api private
+      attr_accessor :name
+
+      # The {::Set} value of this {InnerSet}.
+      #
+      # @return [::Set] set value
+      attr_reader :value
+      alias :members :value
+
+      # The parent of this counter.
+      #
+      # @api private
+      attr_reader :parent
+
+      # @api private
+      def initialize(parent, value = [])
+        @parent = parent
+        frozen_value = value.to_a.tap{ |v| v.each(&:freeze) }
+        @value = ::Set.new frozen_value
+        @value.freeze
+      end
+
+      # Casts this {InnerSet} to an {Array}.
+      #
+      # @return [Array] an array of all the members of this set
+      def to_a
+        value.to_a
+      end
+
+      # Check if this {InnerSet} is empty.
+      #
+      # @return [Boolean} whether this structure is empty or not
+      def empty?
+        value.empty?
+      end
+
+      # Check if a given string is in this structure.
+      #
+      # @param [String] element candidate string to check for inclusion
+      # @return [Boolean] whether the candidate is in this set or not
+      def include?(element)
+        value.include? element
+      end
+
+      # Add a {String} to the {InnerSet}
+      #
+      # @param [String] element the element to add
+      def add(element)
+        @parent.operate name, update(add: element)
+      end
+
+      # Remove a {String} from this set
+      #
+      # @param [String] element the element to remove
+      def remove(element)
+        raise CrdtError::SetRemovalWithoutContextError unless context?
+        @parent.operate name, update(remove: element)
+      end
+
+
+      # Does the map containing this set have the context necessary to remove elements?
+      #
+      # @return [Boolean] if the set has a defined context
+      def context?
+        @parent.context?
+      end
+
+      def pretty_print(pp)
+        pp.object_group self do
+          pp.breakable
+          pp.pp to_a
+        end
+      end
+
+      # @api private
+      def update(changes)
+        Operation::Update.new.tap do |op|
+          op.value = changes.symbolize_keys
+          op.type = :set
+        end
+      end
+
+      # @api private
+      def self.delete
+        Operation::Delete.new.tap do |op|
+          op.type = :set
+        end
+      end
+    end
+  end
+end