riak-client-noenc 1.0.0

data/lib/riak/crdt/map.rb

@@ -0,0 +1,121 @@
+module Riak
+  module Crdt
+
+    # A distributed map of multiple fields, such as counters, flags, registers,
+    # sets, and, recursively, other maps, using the Riak 2 Data Types feature.
+    #
+    # Maps are complex, and the implementation is spread across many classes.
+    # You're looking at the top-level {Map} class, but there are also others
+    # that are also responsible for how maps work:
+    #
+    # * {InnerMap}: used for maps that live inside other maps
+    # * {BatchMap}: proxies multiple operations into a single Riak update request
+    # * {TypedCollection}: a collection of members of a single map, similar
+    #   to a Ruby {Hash}
+    # * {InnerFlag}: a boolean value inside a map
+    # * {InnerRegister}: a {String} value inside a map
+    # * {InnerCounter}: a {Riak::Crdt::Counter}, but inside a map
+    # * {InnerSet}: a {Riak::Crdt::Set}, but inside a map
+    #
+    class Map < Base
+      attr_reader :counters, :flags, :maps, :registers, :sets
+
+      # Create a map 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[:map]` entry
+      #
+      # @param bucket [Bucket] the {Riak::Bucket} for this map
+      # @param [String, nil] key The name of the map. A nil key makes
+      #        Riak assign a key.
+      # @param [String] bucket_type The optional bucket type for this map.
+      #        The default is in `Crdt::Base::DEFAULT_BUCKET_TYPES[:map]`.
+      # @param options [Hash]
+      def initialize(bucket, key, bucket_type = nil, options = {})
+        super(bucket, key, bucket_type || :map, options)
+
+        if key
+          initialize_collections
+        else
+          initialize_blank_collections
+        end
+      end
+
+      # Maps are frequently updated in batches. Use this method to get a
+      # {BatchMap} to turn multiple operations into a single Riak update
+      # request.
+      #
+      # @yieldparam batch_map [BatchMap] collects updates and other operations
+      def batch(*args)
+        batch_map = BatchMap.new self
+
+        yield batch_map
+
+        write_operations batch_map.operations, *args
+      end
+
+      # This method *for internal use only* is used to collect oprations from
+      # disparate sources to provide a user-friendly API.
+      #
+      # @api private
+      def operate(operation, *args)
+        batch *args do |m|
+          m.operate operation
+        end
+      end
+
+      def pretty_print(pp)
+        super pp do
+          %w{counters flags maps registers sets}.each do |h|
+            pp.comma_breakable
+            pp.text "#{h}="
+            pp.pp send h
+          end
+        end
+      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
+
+      private
+      def vivify(data)
+        @counters = TypedCollection.new InnerCounter, self, data[:counters]
+        @flags = TypedCollection.new InnerFlag, self, data[:flags]
+        @maps = TypedCollection.new InnerMap, self, data[:maps]
+        @registers = TypedCollection.new InnerRegister, self, data[:registers]
+        @sets = TypedCollection.new InnerSet, self, data[:sets]
+      end
+
+      def initialize_collections(data = {})
+        reload if dirty?
+      end
+
+      def initialize_blank_collections
+        vivify counters: {}, flags: {}, maps: {}, registers: {}, sets: {}
+      end
+
+      def write_operations(operations, *args)
+        result = operator do |op|
+          op.operate(bucket.name,
+                     key,
+                     bucket_type,
+                     operations,
+                     *args
+                     )
+        end
+
+        @key ||= result.key
+
+        # collections break dirty tracking
+        reload
+      end
+    end
+  end
+end

data/lib/riak/crdt/operation.rb

@@ -0,0 +1,19 @@
+module Riak
+  module Crdt
+    # @api private
+    module Operation
+      class Update
+        attr_accessor :parent
+        attr_accessor :name
+        attr_accessor :type
+        attr_accessor :value
+      end
+
+      class Delete
+        attr_accessor :parent
+        attr_accessor :name
+        attr_accessor :type
+      end
+    end
+  end
+end

data/lib/riak/crdt/set.rb

@@ -0,0 +1,166 @@
+module Riak
+  module Crdt
+
+    # A distributed set containing strings, using the Riak 2 Data Types feature.
+    #
+    # Uses the Ruby standard library `::Set` frequently, so the full class names will
+    # be used frequently.
+    class Set < Base
+
+      # Create a set 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[:set]` entry
+      #
+      # @param bucket [Bucket] the {Riak::Bucket} for this set
+      # @param [String, nil] key The name of the set. A nil key makes
+      #        Riak assign a key.
+      # @param [String] bucket_type The optional bucket type for this set.
+      # @param options [Hash]
+      def initialize(bucket, key, bucket_type = nil, options = {})
+        super(bucket, key, bucket_type || :set, options)
+      end
+
+      # Yields a `BatchSet` to proxy multiple set operations into a single
+      # Riak update. The `BatchSet` has the same methods as this
+      # {Riak::Crdt::Set}.
+      #
+      # @yieldparam batch_set [BatchSet] collects set operations
+      def vivify(value)
+        value.each(&:freeze)
+        @members = ::Set.new(value)
+        @members.freeze
+      end
+
+      def batch
+        batcher = BatchSet.new self
+
+        yield batcher
+
+        operate batcher.operations
+      end
+
+      # Gets the current set members from Riak if necessary, and return the
+      # stdlib `::Set` of them.
+      #
+      # @return [::Set] a Ruby standard library {::Set} of the members
+      #                 of this {Riak::Crdt::Set}
+      def members
+        reload if dirty?
+        @members
+      end
+
+      alias :value :members
+
+      # Cast this {Riak::Crdt::Set} to a Ruby {Array}.
+      #
+      # @return [Array] array of set members
+      def to_a
+        members.to_a
+      end
+
+      # Check to see if this structure has any members.
+      #
+      # @return [Boolean] if the structure is empty
+      def empty?
+        members.empty?
+      end
+
+      # Check to see if a given string is present in this data structure.
+      #
+      # @param [String] candidate string to check for inclusion in this structure
+      # @return [Boolean] if the structure includes
+      def include?(candidate)
+        members.include?(candidate)
+      end
+
+      # Add a {String} to the {Riak::Crdt::Set}
+      #
+      # @param [String] element the element to add to the set
+      # @param [Hash] options
+      def add(element, options = {})
+        operate operation(:add, element), options
+      end
+
+      # Remove a {String} from the {Riak::Crdt::Set}
+      #
+      # @param [String] element to remove from the set
+      # @param [Hash] options
+      def remove(element, options = {})
+        raise CrdtError::SetRemovalWithoutContextError unless context?
+        operate operation(:remove, element), options
+      end
+
+      alias :delete :remove
+
+      def pretty_print(pp)
+        super pp do
+          pp.comma_breakable
+          pp.pp to_a
+        end
+      end
+
+      private
+      def vivify(value)
+        @members = value
+      end
+
+      def operation(direction, element)
+        Operation::Update.new.tap do |op|
+          op.type = :set
+          op.value = { direction => element }
+        end
+      end
+
+      class BatchSet
+        def initialize(base)
+          @base = base
+          @adds = ::Set.new
+          @removes = ::Set.new
+        end
+
+        def add(element)
+          @adds.add element
+        end
+
+        def remove(element)
+          raise CrdtError::SetRemovalWithoutContextError.new unless context?
+          @removes.add element
+        end
+
+        alias :delete :remove
+
+        def include?(element)
+          members.include? element
+        end
+
+        def empty?
+          members.empty?
+        end
+
+        def context?
+          @base.context?
+        end
+
+        def to_a
+          members.to_a
+        end
+
+        def members
+          (@base + @adds).subtract @removes
+        end
+
+        alias :value :members
+
+        def operations
+          Operation::Update.new.tap do |op|
+            op.type = :set
+            op.value = {add: @adds.to_a, remove: @removes.to_a}
+          end
+        end
+      end
+    end
+  end
+end

data/lib/riak/crdt/typed_collection.rb

@@ -0,0 +1,181 @@
+module Riak
+  module Crdt
+    # A collection of elements of a given type inside a {Map}.
+    class TypedCollection
+      ALREADY_WRAPPED = ::Set.new [InnerCounter, InnerFlag, InnerMap]
+      NEEDS_NAME = ::Set.new [InnerCounter, InnerSet, InnerMap]
+      INITIALIZE_NIL = ::Set.new [InnerRegister]
+
+      # @api private
+      def initialize(type, parent, contents = {})
+        @type = type
+        @parent = parent
+        contents = {} if contents.nil?
+        stringified_contents = contents.stringify_keys
+        @contents = materialize_contents stringified_contents
+      end
+
+      def pretty_print(pp)
+        pp.object_group self do
+          pp.breakable
+          pp.text inspect_name
+          pp.comma_breakable
+          pp.text 'parent='
+          @parent.pretty_print_cycle(pp)
+          pp.comma_breakable
+          pp.text 'contents='
+          pp.pp @contents
+        end
+        # buf = []
+        # buf << inspect_name
+        # buf <<
+        # buf << "contents={#{inspect_contents}}"
+        # "#<#{self.class.name} #{buf.join ' '}>"
+      end
+
+      def pretty_print_cycle(pp)
+        pp.object_group self do
+          pp.breakable
+          @parent.pretty_print_cycle(pp)
+        end
+      end
+
+      def inspect_name
+        "contains=#{content_name}"
+      end
+
+      def pretty_print_contents(_pp)
+        @contents.map do |k, v|
+          "#{k}=>#{v.inspect}"
+        end.join ', '
+      end
+
+      def content_name
+        @type.name
+      end
+
+      # @api private
+      def reparent(new_parent)
+        self.class.new(@type,
+                       new_parent,
+                       @contents)
+      end
+
+      # Check if a value for a given key exists in this map.
+      #
+      # @param [String] key the key to check for
+      # @return [Boolean] if the key is inside this collection
+      def include?(key)
+        @contents.include? normalize_key(key)
+      end
+
+      # Get the value for a given key
+      #
+      # @param [String] key the key to get the value for
+      # @return the value for the given key
+      def [](key)
+        key = normalize_key key
+        if include? key
+          candidate = @contents[key]
+          return candidate unless candidate.respond_to? :parent
+          return candidate if candidate.parent == self
+        end
+
+        return nil if initialize_nil?
+
+        new_instance = @type.new self
+        new_instance.name = key if needs_name?
+
+        new_instance
+      end
+
+      # Set the value for a given key. Operation of this method
+      # is only defined for {InnerCounter}, {InnerRegister}, and
+      # {InnerFlag} types.
+      #
+      # @param [String] key the key to set a new value for
+      # @param [Boolean, String, Integer] value the value to set at the key,
+      #        or in the case of counters, the amount to increment
+      def []=(key, value)
+        key = normalize_key key
+
+        operation = @type.update value
+        operation.name = key
+
+        result = @parent.operate operation
+
+        @contents[key] = @type.new self, value
+        @contents[key].name = key if needs_name?
+
+        result
+      end
+
+      alias_method :increment, :[]=
+
+      # Remove the entry from the map.
+      #
+      # @param [String] key the key to remove from the map
+      def delete(key)
+        key = normalize_key key
+        operation = @type.delete
+        operation.name = key
+
+        @parent.operate operation
+
+        @contents.delete key
+      end
+
+      # @api private
+      def operate(key, inner_operation)
+        key = normalize_key key
+
+        inner_operation.name = key
+
+        @parent.operate inner_operation
+      end
+
+      # Does this set have the context necessary to remove elements?
+      #
+      # @return [Boolean] if the set has a defined context
+      def context?
+        !!@parent.context?
+      end
+
+      def to_value_h
+        return @contents unless NEEDS_NAME.include? @type
+
+        @contents.map do |k, v|
+          [k, v.value]
+        end.to_h
+      end
+
+      private
+
+      def normalize_key(unnormalized_key)
+        unnormalized_key.to_s
+      end
+
+      def initialize_nil?
+        INITIALIZE_NIL.include? @type
+      end
+
+      def needs_name?
+        NEEDS_NAME.include? @type
+      end
+
+      def materialize_contents(stringified_contents)
+        stringified_contents.keys.inject(Hash.new) do |new_contents, key|
+          new_contents.tap do |c|
+            content = stringified_contents[key]
+            if ALREADY_WRAPPED.include? content.class
+              c[key] = content
+            else
+              c[key] = @type.new self, content
+            end
+            c[key].name = key if needs_name?
+          end
+        end
+      end
+    end
+  end
+end