crystalruby 0.2.3 → 0.3.1

data/lib/crystalruby/types/primitive_types/numbers.cr

@@ -0,0 +1,37 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  def initialize(value : <%= native_type_expr %>)
+    @value = value
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+    @value = ptr.as(Pointer( <%= native_type_expr %>))[0]
+  end
+
+  def value
+    @value
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    value == other
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def value=(value : <%= native_type_expr %>)
+    @value = value
+  end
+
+  def self.copy_to!(value : <%= native_type_expr %>, ptr : Pointer(::UInt8))
+    ptr.as(Pointer( <%= native_type_expr %>))[0] = value
+  end
+
+  # Write a data type into a pointer at a given index
+  # (Type can be a byte-array, pointer or numeric type)
+  def self.write_single(pointer : Pointer(::UInt8), value)
+    pointer.as(Pointer( <%= native_type_expr %>)).value = value
+  end
+
+end

data/lib/crystalruby/types/primitive_types/numbers.rb

@@ -0,0 +1,28 @@
+module CrystalRuby::Types
+  %i[UInt8 UInt16 UInt32 UInt64 Int8 Int16 Int32 Int64 Float32 Float64].each do |type_name|
+    ffi_type = CrystalRuby::Typemaps::FFI_TYPE_MAP.fetch(type_name.to_s)
+    const_set(type_name, Primitive.build(type_name, convert_if: [::Numeric], ffi_type: ffi_type) do
+      def value=(val)
+        raise "Expected a numeric value, got #{val}" unless val.is_a?(::Numeric)
+
+        super(typename.to_s.start_with?("Float") ? val.to_f : val.to_i)
+      end
+
+      def value(native: false)
+        @value
+      end
+
+      def self.from_ffi_array_repr(value)
+        value
+      end
+
+      def self.numeric?
+        true
+      end
+
+      def self.template_name
+        "Numbers"
+      end
+    end)
+  end
+end

data/lib/crystalruby/types/primitive_types/symbol.cr

@@ -0,0 +1,55 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  def initialize(value : ::Symbol)
+    @value = 0.to_u32
+    self.value = value
+  end
+
+  def initialize(value : UInt32)
+    @value = value
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+    initialize(ptr.as(Pointer(::UInt32))[0])
+  end
+
+  def ==(other : ::Symbol)
+    value == other
+  end
+
+  def value=(value : ::Symbol)
+    case value
+    <% allowed_values.each_with_index do |v, i| %>
+    when :<%= v %> then @value = <%= i %>.to_u32
+    <% end %>
+    else raise "Symbol must be one of <%= allowed_values %>. Got #{value}"
+    end
+  end
+
+  def value : ::Symbol
+    case @value
+    <% allowed_values.each_with_index do |v, i| %>
+    when <%= i %> then :<%= v %>
+    <% end %>
+    else raise "Symbol must be one of <%= allowed_values %>. Got #{value}"
+    end
+  end
+
+  def self.copy_to!(value : ::Symbol, ptr : Pointer(::UInt8))
+    ptr.as(Pointer(::UInt32))[0] = new(value).return_value
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def self.write_single(pointer : Pointer(::UInt8), value)
+    as_uint32 = case value
+    <% allowed_values.each_with_index do |v, i| %>
+    when :<%= v %> then <%= i %>.to_u32
+    <% end %>
+    else raise "Symbol must be one of <%= allowed_values %>. Got #{value}"
+    end
+    pointer.as(Pointer(::UInt32)).value = as_uint32
+  end
+end

data/lib/crystalruby/types/primitive_types/symbol.rb

@@ -0,0 +1,35 @@
+module CrystalRuby::Types
+  Symbol = Primitive.build(
+    error: "Symbol CrystalRuby types should indicate a list of possible values shared between Crystal and Ruby. "\
+    "E.g. Symbol(:green, :blue, :orange). If this list is not known at compile time, you should use a String instead."
+  )
+
+  def self.Symbol(*allowed_values)
+    raise "Symbol must have at least one value" if allowed_values.empty?
+
+    allowed_values.flatten!
+    raise "Symbol allowed values must all be symbols" unless allowed_values.all? { |v| v.is_a?(::Symbol) }
+
+    Primitive.build(:Symbol, ffi_type: :uint32, convert_if: [Root::String, Root::Symbol], memsize: 4) do
+      bind_local_vars!(%i[allowed_values], binding)
+      define_method(:value=) do |val|
+        val = allowed_values[val] if val.is_a?(::Integer) && val >= 0 && val < allowed_values.size
+        raise "Symbol must be one of #{allowed_values}" unless allowed_values.include?(val)
+
+        super(allowed_values.index(val))
+      end
+
+      define_singleton_method(:valid_cast?) do |raw|
+        super(raw) && allowed_values.include?(raw)
+      end
+
+      define_method(:value) do |native: false|
+        allowed_values[super()]
+      end
+
+      define_singleton_method(:type_digest) do
+        Digest::MD5.hexdigest(native_type_expr.to_s + allowed_values.map(&:to_s).join(","))
+      end
+    end
+  end
+end

data/lib/crystalruby/types/primitive_types/time.cr

@@ -0,0 +1,35 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  def initialize(time : ::Time)
+    @value = time.to_unix_ns / 1000_000_000.0
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+    @value = ptr.as(Pointer(::Float64)).value
+  end
+
+  def initialize(@value : ::Float64)
+  end
+
+  def ==(other : ::Time)
+    value == other
+  end
+
+  def value=(time : ::Time)
+    @value = time.to_unix_ns / 1000_000_000.0
+  end
+
+  def value : ::Time
+    ::Time.unix_ns((@value * 1000_000_000).to_i128)
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+
+  def self.write_single(pointer : Pointer(::UInt8), time)
+    pointer.as(Pointer(::Float64)).value = time.to_unix_ns / 1000_000_000.0
+  end
+
+end

data/lib/crystalruby/types/primitive_types/time.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require "date"
+
+module CrystalRuby::Types
+  Time = Primitive.build(:Time, convert_if: [Root::Time, Root::String, DateTime], ffi_type: :double) do
+    def initialize(val = Root::Time.now)
+      super
+    end
+
+    def value=(val)
+      super(
+        if val.respond_to?(:to_time)
+          val.to_time.to_f
+        else
+          val.respond_to?(:to_f) ? val.to_f : 0
+        end
+      )
+    end
+
+    def value(native: false)
+      ::Time.at(super)
+    end
+  end
+end

data/lib/crystalruby/types/type.cr

@@ -0,0 +1,64 @@
+module CrystalRuby
+  module Types
+    class Type
+      property memory : Pointer(::UInt8) = Pointer(::UInt8).null
+
+      macro method_missing(call)
+        current_value = self.native
+        current_hash = current_value.hash
+        return_value = current_value.{{ call }}
+
+        if current_hash != current_value.hash
+          self.value = current_value
+        end
+        return_value
+      end
+
+      def to_s
+        native.to_s
+      end
+
+      def synchronize
+        CrystalRuby.synchronize do
+          yield
+        end
+      end
+
+      def self.synchronize
+        yield
+      end
+
+      def variable_width?
+        false
+      end
+
+      def return_value
+        memory
+      end
+
+      def self.free(memory : Pointer(::UInt8))
+        LibC.free(memory)
+      end
+
+      def self.malloc(size : Int) : Pointer(::UInt8)
+        LibC.calloc(size, 1).as(Pointer(::UInt8))
+      end
+
+      def malloc(memsize)
+        self.class.malloc(memsize)
+      end
+
+      def self.each_child_address(pointer : Pointer(::UInt8), &block : Pointer(::UInt8) -> Nil)
+        # Do nothing
+      end
+
+      def self.fetch_multi!(pointer : Pointer(::UInt8), size)
+        size.times.map { |i| fetch_single(pointer + i * refsize) }.to_a
+      end
+
+      def self.fetch_multi_native!(pointer : Pointer(::UInt8), size)
+        size.times.map { |i| fetch_single(pointer + i * refsize).native }.to_a
+      end
+    end
+  end
+end

data/lib/crystalruby/types/type.rb

@@ -1,66 +1,285 @@
+# frozen_string_literal: true
+
+# Can create complex structs in Ruby
+# E.g.
+# Types::MyType.new({a: 1, b: [2,3, {four: "five"}})
+#
+# Can read complex structs in Crystal.
+# Expose Ruby setters to Crystal.
+#   - These accepts pointers and *copy* the values from them (so that they are governed by Ruby GC)
+#   - Safe to GC on Crystal side after call to setter
+#
+# All Structs are memory managed in Ruby.
+# Parameters are temporarily stored in memory *before* being passed, then nilled (might be GC'd if we don't hold on to it elsewhere)
+# Internal pointers are stored in complex types.
+# Cannot create new structs in Crystal.
+# All information passed from Crystal back to Ruby is either:
+# - Direct memory access (for primitives)
+# - Using setters + copy
+#
+# What if:
+#   - We ask Crystal to implement allocation og memory, and implement all of the setters
+#   - It stores the pointers to the memory in an address indexed hash
+#   - Ruby will reference count using AutoPointer
+#   - If reference count is 0, clear out hash in Crystal (Trigger GC)
+#   - Don't like this because, types can't stand alone in Ruby AND crosses FFI bridge many times to allocate complex struct.
+
+require "forwardable"
+
 module CrystalRuby
+  InvalidCastError = Class.new(StandardError)
+
   module Types
     class Type
-      attr_accessor :name, :error, :inner_types, :inner_keys, :accept_if, :convert
+      # TODO: Replace with pthread primitives and share
+      # with Crystal
+      ARC_MUTEX = CrystalRuby::ArcMutex.new
+
+      include Allocator
+      extend Typemaps
 
-      def initialize(name, error: nil, inner_types: nil, inner_keys: nil, accept_if: [], &convert)
-        self.name = name
-        self.error = error
-        self.inner_types = inner_types
-        self.inner_keys = inner_keys
-        self.accept_if = accept_if
-        self.convert = convert
+      class << self
+        attr_accessor :typename, :ffi_type, :memsize, :convert_if, :inner_types
       end
 
-      def union_types
-        [self]
+      def_delegators :@class, :primitive?, :cast!, :type, :typename, :memsize, :refsize,
+                     :ffi_type, :error, :inner_type, :inner_keys, :inner_types,
+                     :write_mixed_byte_slices_to_uint8_array, :data_offset, :size_offset,
+                     :union_types
+
+      attr_accessor :value, :memory
+
+      def initialize(_rbval)
+        @class = self.class
+        raise error if error
       end
 
-      def valid?
-        !error
+      def self.finalize(_memory)
+        ->(_) {}
       end
 
-      def |(other)
-        raise "Cannot union non-crystal type #{other}" unless other.is_a?(Type) || (
-          other.is_a?(Class) && other.ancestors.include?(Typedef)
-        )
+      def self.inspect_name
+        (name || "#{typename}").to_s.gsub(/^CrystalRuby::Types::[^::]+::/, "")
+      end
 
-        UnionType.new(*union_types, *other.union_types)
+      def self.union_types
+        [self]
       end
 
-      def type_expr
-        inspect
+      def self.valid?
+        true
       end
 
-      def inspect
+      def self.native_type_expr
         if !inner_types
-          name
+          "::#{typename}"
         elsif !inner_keys
-          "#{name}(#{inner_types.map(&:inspect).join(", ")})"
+          "::#{typename}(#{inner_types.map(&:native_type_expr).join(", ")})"
         else
-          "#{name}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})"
+          "::#{typename}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.native_type_expr}" }.join(", ")})"
         end
       end
 
-      def interprets?(raw)
-        accept_if.any? { |type| raw.is_a?(type) }
+      def self.named_type_expr
+        if !inner_types
+          "::#{name || typename}"
+        elsif !inner_keys
+          "::#{name || typename}(#{inner_types.map(&:named_type_expr).join(", ")})"
+        else
+          "::#{name || typename}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.named_type_expr}" }.join(", ")})"
+        end
+      end
+
+      def self.valid_cast?(raw)
+        raw.is_a?(self) || convert_if.any? { |type| raw.is_a?(type) }
+      end
+
+      def self.[](*value)
+        is_list_type = ancestors.any? { |a| a < CrystalRuby::Types::Array || a < CrystalRuby::Types::Tuple }
+        new(is_list_type ? value : value.first)
+      end
+
+      def self.anonymous?
+        name.nil? || name.start_with?("CrystalRuby::Types::")
+      end
+
+      def self.crystal_class_name
+        name || named_type_expr.split(",").join("_and_")
+                               .split("|").join("_or_")
+                               .split("(").join("_of_")
+                               .gsub(/[^a-zA-Z0-9_]/, "")
+                               .split("_")
+                               .map(&:capitalize).join << "_#{type_digest[0..6]}"
       end
 
-      def interpret!(raw)
-        if interprets?(raw)
-          convert ? convert.call(raw) : raw
+      def self.base_crystal_class_name
+        crystal_class_name.split("::").last
+      end
+
+      def value(native: false)
+        @value
+      end
+
+      def native
+        value(native: true)
+      end
+
+      def self.type_digest
+        Digest::MD5.hexdigest(native_type_expr.to_s)
+      end
+
+      def self.nested_types
+        [self, *(inner_types || []).map(&:nested_types)].flatten.uniq
+      end
+
+      def self.pointer_to_crystal_type_conversion(expr)
+        anonymous? ? "#{crystal_class_name}.new(#{expr}).native" : "#{crystal_class_name}.new(#{expr})"
+      end
+
+      def self.crystal_type_to_pointer_type_conversion(expr)
+        anonymous? ? "#{crystal_class_name}.new(#{expr}).return_value" : "#{expr}.return_value"
+      end
+
+      def self.template_name
+        typename || superclass.template_name
+      end
+
+      def self.type_defn
+        unless Template.const_defined?(template_name) && Template.const_get(template_name).is_a?(Template::Renderer)
+          raise "Template not found for #{template_name}"
+        end
+
+        Template.const_get(template_name).render(binding)
+      end
+
+      def self.numeric?
+        false
+      end
+
+      def self.primitive?
+        false
+      end
+
+      def self.variable_width?
+        false
+      end
+
+      def self.fixed_width?
+        false
+      end
+
+      def self.cast!(value)
+        value.is_a?(Type) ? value.value : value
+      end
+
+      def ==(other)
+        value(native: true) == (other.is_a?(Type) ? other.value(native: true) : other)
+      end
+
+      def nil?
+        value.nil?
+      end
+
+      def coerce(other)
+        [other, value]
+      end
+
+      def inspect
+        value.inspect
+      end
+
+      def self.from_ffi_array_repr(value)
+        anonymous? ? new(value).value : new(value)
+      end
+
+      def inner_value
+        @value
+      end
+
+      # Create a brand new copy of this object
+      def deep_dup
+        self.class.new(native)
+      end
+
+      # Create a new reference to this object.
+      def dup
+        self.class.new(@memory)
+      end
+
+      def method_missing(method, *args, &block)
+        v = begin
+          native
+        rescue StandardError
+          super
+        end
+        if v.respond_to?(method)
+          hash_before = v.hash
+          result = v.send(method, *args, &block)
+          if v.hash != hash_before
+            self.value = v
+            v.equal?(result) ? self : result
+          else
+            result
+          end
         else
-          raise "Invalid deserialized value #{raw} for type #{inspect}"
+          super
+        end
+      end
+
+      def self.bind_local_vars!(variable_names, binding)
+        variable_names.each do |name|
+          define_singleton_method(name) do
+            binding.local_variable_get("#{name}")
+          end
+          define_method(name) do
+            binding.local_variable_get("#{name}")
+          end
         end
       end
 
+      def self.each_child_address(pointer); end
+
+      def item_size
+        inner_types.map(&:memsize).sum
+      end
+
+      def self.crystal_type
+        lib_type(ffi_type)
+      end
+
+      def self.|(other)
+        raise "Cannot union non-crystal type #{other}" unless other.is_a?(Class) && other.ancestors.include?(Type)
+
+        CrystalRuby::Types::TaggedUnion(*union_types, *other.union_types)
+      end
+
       def self.validate!(type)
-        unless type.is_a?(Types::Type) || (type.is_a?(Class) && type.ancestors.include?(Types::Typedef))
+        unless type.is_a?(Class) && type.ancestors.include?(Types::Type)
           raise "Result #{type} is not a valid CrystalRuby type"
         end
 
         raise "Invalid type: #{type.error}" unless type.valid?
       end
+
+      def self.inner_type
+        inner_types.first
+      end
+
+      def self.type_expr
+        if !inner_types
+          inspect_name
+        elsif !anonymous?
+          name
+        elsif inner_keys
+          "#{inspect_name}(#{inner_keys.zip(inner_types).map { |k, v| "#{k}: #{v.inspect}" }.join(", ")})"
+        else
+          "#{inspect_name}(#{inner_types.map(&:inspect).join(", ")})"
+        end
+      end
+
+      def self.inspect
+        type_expr
+      end
     end
   end
 end

data/lib/crystalruby/types/variable_width/array.cr

@@ -0,0 +1,74 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::VariableWidth
+
+  include Enumerable(<%= inner_type.native_type_expr %>)
+
+  def initialize(array : Array(<%= inner_type.native_type_expr %>))
+    @memory = malloc(data_offset + 8)
+    self.value = array
+    increment_ref_count!
+  end
+
+  def each
+    size.times do |i|
+      yield self[i].native
+    end
+  end
+
+  def ==(other : Array(<%= inner_type.native_type_expr %>))
+    native == other
+  end
+
+  def data_pointer
+    Pointer(::UInt8).new((@memory + data_offset).as(Pointer(::UInt64)).value)
+  end
+
+  def value=(array : Array(<%= inner_type.native_type_expr %>))
+    if self.ref_count > 0
+      self.class.decr_inner_ref_counts!(memory)
+    end
+    self.class.copy_to!(array, self.memory)
+  end
+
+  def <<(value : <%= inner_type.native_type_expr %>)
+    self.value = self.native + [value]
+  end
+
+  def []=(index : Int, value : <%= inner_type.native_type_expr %>)
+    index += size if index < 0
+    <%= inner_type.crystal_class_name %>.write_single(data_pointer + index * <%= inner_type.refsize %>, value)
+  end
+
+  def [](index : Int)
+    index += size if index < 0
+    <%= inner_type.crystal_class_name %>.fetch_single(data_pointer + index * <%= inner_type.refsize %>)
+  end
+
+  def self.copy_to!(array : Array(<%= inner_type.native_type_expr %>), memory : Pointer(::UInt8))
+    data_pointer = malloc(array.size * <%= inner_type.refsize %>)
+    array.size.times do |i|
+      <%= inner_type.crystal_class_name %>.write_single(data_pointer + i * <%= inner_type.refsize %>, array[i])
+    end
+    (memory+size_offset).as(Pointer(::UInt32)).value = array.size.to_u32
+    (memory+data_offset).as(Pointer(::UInt64)).value = data_pointer.address
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def value
+    <%= inner_type.crystal_class_name %>.fetch_multi!(data_pointer, size)
+  end
+
+  def native : ::Array(<%= inner_type.native_type_expr %>)
+    <%= inner_type.crystal_class_name %>.fetch_multi_native!(data_pointer, size)
+  end
+
+  def size
+    (@memory + self.class.size_offset).as(Pointer(::UInt32))[0]
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+end