foobara 0.0.1

data/projects/value/src/transformer.rb

@@ -0,0 +1,84 @@
+require "securerandom"
+
+Foobara.require_project_file("value", "processor/runner")
+
+module Foobara
+  module Value
+    class Transformer < Processor
+      class Runner < Processor::Runner
+        runner_methods :transform
+      end
+
+      class << self
+        def foobara_manifest(to_include:)
+          super.merge(processor_type: :transformer)
+        end
+
+        def error_classes
+          []
+        end
+
+        def create(options)
+          subclass(**options).instance
+        end
+
+        # TODO: make transform the first argument for convenience
+        def subclass(name: nil, **options)
+          arity_zero = %i[always_applicable? priority]
+          arity_one = %i[applicable? transform]
+          allowed = arity_zero + arity_one
+
+          invalid_options = options.keys - allowed
+
+          unless invalid_options.empty?
+            # :nocov:
+            raise ArgumentError, "Invalid options #{invalid_options} expected only #{allowed}"
+            # :nocov:
+          end
+
+          name ||= "#{self.name}::Anon#{SecureRandom.hex}"
+
+          unless name.include?(":")
+            name = "#{self.name}::#{name}"
+          end
+
+          Util.make_class(name, self) do
+            arity_one.each do |method_name|
+              if options.key?(method_name)
+                method = options[method_name]
+
+                define_method method_name do |value|
+                  method.call(value)
+                end
+              end
+            end
+
+            arity_zero.each do |method_name|
+              if options.key?(method_name)
+                value = options[method_name]
+
+                define_method method_name do
+                  value
+                end
+              end
+            end
+          end
+        end
+      end
+
+      def transform(_value)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def process_value(value)
+        if applicable?(value)
+          value = transform(value)
+        end
+
+        Outcome.success(value)
+      end
+    end
+  end
+end

data/projects/value/src/validator.rb

@@ -0,0 +1,53 @@
+module Foobara
+  module Value
+    class Validator < Processor
+      class Runner < Processor::Runner
+        runner_methods :validation_errors
+      end
+
+      class << self
+        def foobara_manifest(to_include:)
+          super.merge(processor_type: :transformer)
+        end
+      end
+
+      # Should a Validator only return one type of error?
+      def validation_errors(_value)
+        # :nocov:
+        raise "subclass responsibility"
+        # :nocov:
+      end
+
+      def process_value(value)
+        return Outcome.success(value) unless applicable?(value)
+
+        errors = Util.array(validation_errors(value))
+
+        if errors.empty?
+          Outcome.success(value)
+        else
+          Outcome.new(errors:, result: value)
+        end
+      end
+
+      def build_error(
+        value = nil,
+        message: error_message(value),
+        context: error_context(value),
+        path: error_path,
+        **
+      )
+        error_class.new(
+          path:,
+          message:,
+          context:,
+          **
+        )
+      end
+
+      def possible_errors
+        [PossibleError.new(error_class, processor: self)]
+      end
+    end
+  end
+end

data/projects/version/lib/foobara/version.rb

@@ -0,0 +1,4 @@
+module Foobara
+  module Version
+  end
+end

data/projects/version/src/version.rb

@@ -0,0 +1,5 @@
+module Foobara
+  module Version
+    VERSION = "0.0.1".freeze
+  end
+end

data/projects/weak_object_set/lib/foobara/weak_object_set.rb

@@ -0,0 +1,3 @@
+require "weakref"
+
+class Foobara::WeakObjectSet; end

data/projects/weak_object_set/src/weak_object_set.rb

@@ -0,0 +1,163 @@
+module Foobara
+  class WeakObjectSet
+    class GarbageCleaner
+      def initialize(objects, key_to_object_id = nil, object_id_to_key = nil)
+        @objects = objects
+        @key_to_object_id = key_to_object_id
+        @object_id_to_key = object_id_to_key
+      end
+
+      def cleanup_proc
+        @cleanup_proc ||= ->(object_id) {
+          unless @deactivated
+            @objects.delete(object_id)
+
+            key = @object_id_to_key&.delete(object_id)
+
+            if key
+              @key_to_object_id.delete(key)
+            end
+          end
+        }
+      end
+
+      def track(object)
+        if @deactivated
+          # :nocov:
+          raise "Cannot track anymore objects since we have been deactivated"
+          # :nocov:
+        end
+
+        ObjectSpace.define_finalizer(object, cleanup_proc)
+      end
+
+      def deactivate
+        @deactivated = true
+      end
+    end
+
+    include Enumerable
+
+    def initialize(key_method = nil)
+      @key_method = key_method
+    end
+
+    def [](object_or_object_id)
+      ref = ref_for(object_or_object_id)
+
+      if ref&.weakref_alive?
+        ref.__getobj__
+      end
+    end
+
+    def ref_for(object_or_object_id)
+      object_id = if object_or_object_id.is_a?(::Integer)
+                    object_or_object_id
+                  else
+                    object_or_object_id.object_id
+                  end
+
+      objects[object_id]
+    end
+
+    def each
+      objects.each_value do |ref|
+        if ref.weakref_alive?
+          yield ref.__getobj__
+        end
+      end
+    end
+
+    def objects
+      @objects ||= {}
+    end
+
+    def size
+      count
+    end
+
+    def empty?
+      objects.empty? || objects.values.none?(&:weakref_alive?)
+    end
+
+    def key_to_object_id
+      @key_to_object_id ||= {}
+    end
+
+    def object_id_to_key
+      @object_id_to_key ||= {}
+    end
+
+    def garbage_cleaner
+      @garbage_cleaner ||= if @key_method
+                             GarbageCleaner.new(objects, key_to_object_id, object_id_to_key)
+                           else
+                             GarbageCleaner.new(objects)
+                           end
+    end
+
+    def <<(object)
+      garbage_cleaner.track(object)
+
+      object_id = object.object_id
+
+      objects[object_id] = WeakRef.new(object)
+
+      if @key_method
+        key = object.send(@key_method)
+
+        if key
+          key_to_object_id[key] = object_id
+          object_id_to_key[object_id] = key
+        end
+      end
+
+      object
+    end
+
+    def include?(object_or_object_id)
+      ref_for(object_or_object_id)&.weakref_alive?
+    end
+
+    def delete(object)
+      if @key_method
+        key = @object_id_to_key&.delete(object.object_id)
+
+        if key
+          @key_to_object_id.delete(key)
+        end
+      end
+
+      objects.delete(object)
+    end
+
+    def include_key?(key)
+      unless @key_method
+        # :nocov:
+        raise "Cannot check by key if there was no key_method given."
+        # :nocov:
+      end
+
+      objects[key_to_object_id[key]]&.weakref_alive?
+    end
+
+    def find_by_key(key)
+      unless @key_method
+        # :nocov:
+        raise "Cannot find by key if there was no key_method given."
+        # :nocov:
+      end
+
+      object = objects[key_to_object_id[key]]
+
+      if object&.weakref_alive?
+        object.__getobj__
+      end
+    end
+
+    def clear
+      @garbage_cleaner&.deactivate
+      @key_to_object_id = @object_id_to_key = @objects = @garbage_cleaner = nil
+    end
+  end
+end