operaton-bpm-client 0.1.0

data/lib/operaton/bpm/engine/variable/typed_value.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require_relative "value_type"
+
+module Operaton
+  module Bpm
+    module Engine
+      module Variable
+        # Mirrors org.operaton.bpm.engine.variable.value.TypedValue
+        class TypedValue
+          attr_reader :value, :type
+
+          def initialize(value, type, is_transient = false)
+            @value = value
+            @type = type
+            @is_transient = is_transient
+          end
+
+          def transient?
+            @is_transient
+          end
+
+          attr_writer :is_transient
+
+          def to_s
+            "Value '#{value}' of type '#{type}', isTransient=#{transient?}"
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.PrimitiveValue
+        class PrimitiveTypeValue < TypedValue
+        end
+
+        class BooleanValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::BOOLEAN, is_transient)
+          end
+        end
+
+        class StringValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::STRING, is_transient)
+          end
+        end
+
+        class DateValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::DATE, is_transient)
+          end
+        end
+
+        class BytesValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::BYTES, is_transient)
+          end
+        end
+
+        class IntegerValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::INTEGER, is_transient)
+          end
+        end
+
+        class LongValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::LONG, is_transient)
+          end
+        end
+
+        class ShortValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::SHORT, is_transient)
+          end
+        end
+
+        class DoubleValue < PrimitiveTypeValue
+          def initialize(value, is_transient = false)
+            super(value, ValueType::DOUBLE, is_transient)
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.impl.value.UntypedValueImpl
+        class UntypedValue < TypedValue
+          def initialize(value, is_transient = false)
+            super(value, nil, is_transient)
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.impl.value.NullValueImpl
+        class NullValue < TypedValue
+          def initialize(is_transient = false)
+            super(nil, ValueType::NULL, is_transient)
+          end
+
+          INSTANCE = new
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.ObjectValue /
+        # SerializableValue semantics.
+        class ObjectValue < TypedValue
+          attr_accessor :object_type_name, :serialization_data_format, :serialized_value
+
+          def initialize(value, serialized_value = nil, serialization_data_format = nil,
+                         object_type_name = nil, deserialized = true, is_transient = false)
+            super(value, ValueType::OBJECT, is_transient)
+            @serialized_value = serialized_value
+            @serialization_data_format = serialization_data_format
+            @object_type_name = object_type_name
+            @deserialized = deserialized
+          end
+
+          def deserialized?
+            @deserialized
+          end
+
+          def value_serialized
+            @serialized_value
+          end
+
+          def value
+            unless deserialized?
+              raise Client::ValueMapperException,
+                    "Object is not deserialized: call value_serialized instead"
+            end
+            @value
+          end
+
+          def set_value(value) # rubocop:disable Naming/AccessorMethodName
+            @value = value
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.FileValue (FileValueImpl)
+        class FileValue < TypedValue
+          attr_accessor :filename, :mime_type, :encoding
+
+          def initialize(filename, byte_array = nil, is_transient = false)
+            super(byte_array, ValueType::FILE, is_transient)
+            @filename = filename
+          end
+
+          def byte_array
+            @value
+          end
+
+          def set_value(bytes) # rubocop:disable Naming/AccessorMethodName
+            @value = bytes
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/engine/variable/value_type.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Operaton
+  module Bpm
+    module Engine
+      module Variable
+        # Mirrors org.operaton.bpm.engine.variable.type.ValueType and its
+        # implementations, reduced to what the external task client needs.
+        class ValueType
+          attr_reader :name
+
+          def initialize(name)
+            @name = name
+          end
+
+          def primitive_value_type?
+            false
+          end
+
+          def abstract?
+            false
+          end
+
+          # Mirrors ValueType#getValueInfo(TypedValue)
+          def value_info(typed_value)
+            info = {}
+            info[VALUE_INFO_TRANSIENT] = true if typed_value.transient?
+            info
+          end
+
+          def to_s
+            name
+          end
+
+          VALUE_INFO_TRANSIENT = "transient"
+        end
+
+        class PrimitiveValueType < ValueType
+          def initialize(name, &assignable)
+            super(name)
+            @assignable = assignable
+          end
+
+          def primitive_value_type?
+            true
+          end
+
+          # Mirrors PrimitiveValueType#getJavaType assignability checks.
+          def assignable?(value)
+            @assignable ? @assignable.call(value) : false
+          end
+        end
+
+        class NumberValueType < PrimitiveValueType
+          def abstract?
+            true
+          end
+        end
+
+        class ObjectValueType < ValueType
+          VALUE_INFO_OBJECT_TYPE_NAME = "objectTypeName"
+          VALUE_INFO_SERIALIZATION_DATA_FORMAT = "serializationDataFormat"
+
+          def initialize
+            super("object")
+          end
+
+          def value_info(typed_value)
+            info = {}
+            if typed_value.object_type_name
+              info[VALUE_INFO_OBJECT_TYPE_NAME] = typed_value.object_type_name
+            end
+            if typed_value.serialization_data_format
+              info[VALUE_INFO_SERIALIZATION_DATA_FORMAT] = typed_value.serialization_data_format
+            end
+            info[VALUE_INFO_TRANSIENT] = true if typed_value.transient?
+            info
+          end
+        end
+
+        class FileValueType < ValueType
+          VALUE_INFO_FILE_NAME = "filename"
+          VALUE_INFO_FILE_MIME_TYPE = "mimetype"
+          VALUE_INFO_FILE_ENCODING = "encoding"
+
+          def initialize
+            super("file")
+          end
+
+          def value_info(typed_value)
+            info = {}
+            info[VALUE_INFO_FILE_NAME] = typed_value.filename
+            info[VALUE_INFO_FILE_MIME_TYPE] = typed_value.mime_type if typed_value.mime_type
+            info[VALUE_INFO_FILE_ENCODING] = typed_value.encoding if typed_value.encoding
+            info[VALUE_INFO_TRANSIENT] = true if typed_value.transient?
+            info
+          end
+        end
+
+        class ValueType
+          INTEGER_MIN = -2**31
+          INTEGER_MAX = 2**31 - 1
+          LONG_MIN = -2**63
+          LONG_MAX = 2**63 - 1
+          SHORT_MIN = -2**15
+          SHORT_MAX = 2**15 - 1
+
+          NULL = PrimitiveValueType.new("null") { |v| v.nil? }
+          BOOLEAN = PrimitiveValueType.new("boolean") { |v| v == true || v == false }
+          STRING = PrimitiveValueType.new("string") { |v| v.is_a?(String) }
+          DATE = PrimitiveValueType.new("date") do |v|
+            v.is_a?(Time) || (defined?(DateTime) && v.is_a?(DateTime)) || (defined?(::Date) && v.is_a?(::Date))
+          end
+          BYTES = PrimitiveValueType.new("bytes") { |v| v.is_a?(String) }
+          INTEGER = PrimitiveValueType.new("integer") { |v| v.is_a?(Integer) && v.between?(INTEGER_MIN, INTEGER_MAX) }
+          LONG = PrimitiveValueType.new("long") { |v| v.is_a?(Integer) && v.between?(LONG_MIN, LONG_MAX) }
+          SHORT = PrimitiveValueType.new("short") { |v| v.is_a?(Integer) && v.between?(SHORT_MIN, SHORT_MAX) }
+          DOUBLE = PrimitiveValueType.new("double") { |v| v.is_a?(Float) }
+          NUMBER = NumberValueType.new("number") { |v| v.is_a?(Numeric) }
+          OBJECT = ObjectValueType.new
+          FILE = FileValueType.new
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/engine/variable/variable_map.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "typed_value"
+
+module Operaton
+  module Bpm
+    module Engine
+      module Variable
+        # Mirrors org.operaton.bpm.engine.variable.VariableMap: a map of
+        # variable names to typed values, with untyped access convenience.
+        class VariableMap
+          include Enumerable
+
+          def initialize
+            @map = {}
+          end
+
+          # Mirrors VariableMap#putValue
+          def put_value(name, value)
+            put_value_typed(name, Variables.untyped_value(value))
+          end
+          alias []= put_value
+
+          # Mirrors VariableMap#putValueTyped
+          def put_value_typed(name, typed_value)
+            @map[name] = typed_value
+            self
+          end
+
+          # Mirrors VariableMap#getValue (raw value access)
+          def get_value(name)
+            typed = @map[name]
+            typed&.value
+          end
+          alias [] get_value
+
+          # Mirrors VariableMap#getValueTyped
+          def get_value_typed(name)
+            @map[name]
+          end
+
+          def keys
+            @map.keys
+          end
+
+          def key?(name)
+            @map.key?(name)
+          end
+
+          def size
+            @map.size
+          end
+          alias length size
+
+          def empty?
+            @map.empty?
+          end
+
+          def each
+            return enum_for(:each) unless block_given?
+
+            @map.each_key { |name| yield name, get_value(name) }
+          end
+
+          def to_h
+            @map.keys.to_h { |name| [name, get_value(name)] }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton/bpm/engine/variable/variables.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require_relative "typed_value"
+require_relative "variable_map"
+
+module Operaton
+  module Bpm
+    module Engine
+      module Variable
+        # Factory methods mirroring org.operaton.bpm.engine.variable.Variables.
+        # Defined as a mixin so that Operaton::Bpm::Client::Variable::ClientValues
+        # can "extend" Variables like the Java class does.
+        module VariablesFactory
+          def create_variables
+            VariableMap.new
+          end
+
+          def untyped_value(value, is_transient = false)
+            return value if value.is_a?(TypedValue)
+
+            UntypedValue.new(value, is_transient)
+          end
+
+          def untyped_null_value(is_transient = false)
+            UntypedValue.new(nil, is_transient)
+          end
+
+          def boolean_value(value, is_transient = false)
+            BooleanValue.new(value, is_transient)
+          end
+
+          def string_value(value, is_transient = false)
+            StringValue.new(value, is_transient)
+          end
+
+          def date_value(value, is_transient = false)
+            DateValue.new(value, is_transient)
+          end
+
+          def byte_array_value(value, is_transient = false)
+            BytesValue.new(value, is_transient)
+          end
+
+          def integer_value(value, is_transient = false)
+            IntegerValue.new(value, is_transient)
+          end
+
+          def long_value(value, is_transient = false)
+            LongValue.new(value, is_transient)
+          end
+
+          def short_value(value, is_transient = false)
+            ShortValue.new(value, is_transient)
+          end
+
+          def double_value(value, is_transient = false)
+            DoubleValue.new(value, is_transient)
+          end
+
+          # Mirrors Variables.objectValue(value) which returns an ObjectValueBuilder
+          def object_value(value, is_transient = false)
+            ObjectValueBuilder.new(value, is_transient)
+          end
+
+          # Mirrors Variables.serializedObjectValue(...)
+          def serialized_object_value(serialized_value = nil)
+            SerializedObjectValueBuilder.new(serialized_value)
+          end
+
+          # Mirrors Variables.fileValue(filename) which returns a FileValueBuilder
+          def file_value(filename)
+            FileValueBuilder.new(filename)
+          end
+        end
+
+        module Variables
+          extend VariablesFactory
+
+          # Mirrors Variables.SerializationDataFormats
+          module SerializationDataFormats
+            JAVA = "application/x-java-serialized-object"
+            JSON = "application/json"
+            XML = "application/xml"
+
+            def self.json
+              JSON
+            end
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.builder.ObjectValueBuilder
+        class ObjectValueBuilder
+          def initialize(value, is_transient = false)
+            @value = value
+            @is_transient = is_transient
+            @serialization_data_format = nil
+          end
+
+          def serialization_data_format(format)
+            @serialization_data_format = format
+            self
+          end
+
+          def set_transient(is_transient) # rubocop:disable Naming/AccessorMethodName
+            @is_transient = is_transient
+            self
+          end
+
+          def create
+            ObjectValue.new(@value, nil, @serialization_data_format, nil, true, @is_transient)
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.builder.SerializedObjectValueBuilder
+        class SerializedObjectValueBuilder
+          def initialize(serialized_value = nil)
+            @serialized_value = serialized_value
+            @serialization_data_format = nil
+            @object_type_name = nil
+            @is_transient = false
+          end
+
+          def serialized_value(value)
+            @serialized_value = value
+            self
+          end
+
+          def serialization_data_format(format)
+            @serialization_data_format = format
+            self
+          end
+
+          def object_type_name(name)
+            @object_type_name = name
+            self
+          end
+
+          def set_transient(is_transient) # rubocop:disable Naming/AccessorMethodName
+            @is_transient = is_transient
+            self
+          end
+
+          def create
+            ObjectValue.new(nil, @serialized_value, @serialization_data_format,
+                            @object_type_name, false, @is_transient)
+          end
+        end
+
+        # Mirrors org.operaton.bpm.engine.variable.value.builder.FileValueBuilder
+        class FileValueBuilder
+          def initialize(filename)
+            @filename = filename
+            @bytes = nil
+            @mime_type = nil
+            @encoding = nil
+            @is_transient = false
+          end
+
+          # Accepts a byte string, an IO, or a file path.
+          def file(file)
+            @bytes =
+              if file.respond_to?(:read)
+                file.read
+              elsif file.is_a?(String) && !file.include?("\0") && ::File.file?(file)
+                ::File.binread(file)
+              else
+                file
+              end
+            self
+          end
+
+          def mime_type(mime_type)
+            @mime_type = mime_type
+            self
+          end
+
+          def encoding(encoding)
+            @encoding = encoding
+            self
+          end
+
+          def set_transient(is_transient) # rubocop:disable Naming/AccessorMethodName
+            @is_transient = is_transient
+            self
+          end
+
+          def create
+            value = FileValue.new(@filename, @bytes, @is_transient)
+            value.mime_type = @mime_type
+            value.encoding = @encoding
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/operaton-bpm-client.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require_relative "operaton/bpm/client"