crystalruby 0.2.3 → 0.3.1

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module CrystalRuby::Types
+  Array = VariableWidth.build(error: "Array type must have a type parameter. E.g. Array(Float64)")
+
+  # An array-like, reference counted manually managed memory type.
+  # Shareable between Crystal and Crystal.
+  def self.Array(type)
+    VariableWidth.build(:Array, inner_types: [type], convert_if: [Array, Root::Array], superclass: Array) do
+      include Enumerable
+
+      # Implement the Enumerable interface
+      # Helps this object to act like an Array
+      def each
+        size.times { |i| yield self[i] }
+      end
+
+      # We only accept Array-like values, from which all elements
+      # can successfully be cast to our inner type
+      def self.cast!(value)
+        unless value.is_a?(Array) || value.is_a?(Root::Array) && value.all?(&inner_type.method(:valid_cast?))
+          raise CrystalRuby::InvalidCastError, "Cannot cast #{value} to #{inspect}"
+        end
+
+        if inner_type.primitive?
+          value.map(&inner_type.method(:to_ffi_repr))
+        else
+          value
+        end
+      end
+
+      def self.copy_to!(rbval, memory:)
+        data_pointer = malloc(rbval.size * inner_type.refsize)
+
+        memory[size_offset].write_uint32(rbval.size)
+        memory[data_offset].write_pointer(data_pointer)
+
+        if inner_type.primitive?
+          data_pointer.send("put_array_of_#{inner_type.ffi_type}", 0, rbval)
+        else
+          rbval.each_with_index do |val, i|
+            inner_type.write_single(data_pointer[i * refsize], val)
+          end
+        end
+      end
+
+      def self.each_child_address(pointer)
+        size = pointer[size_offset].get_int32(0)
+        pointer = pointer[data_offset].read_pointer
+        size.times do |i|
+          yield inner_type, pointer[i * inner_type.refsize]
+        end
+      end
+
+      def checked_offset!(index, size)
+        raise "Index out of bounds: #{index} >= #{size}" if index >= size
+
+        if index < 0
+          raise "Index out of bounds: #{index} < -#{size}" if index < -size
+
+          index += size
+        end
+        index
+      end
+
+      # Return the element at the given index.
+      # This will automatically increment
+      # the reference count if not a primitive type.
+      def [](index)
+        inner_type.fetch_single(data_pointer[checked_offset!(index, size) * inner_type.refsize])
+      end
+
+      # Overwrite the element at the given index
+      # The replaced element will have
+      # its reference count decremented.
+      def []=(index, value)
+        inner_type.write_single(data_pointer[checked_offset!(index, size) * inner_type.refsize], value)
+      end
+
+      # Load values stored inside array type.
+      # If it's a primitive type, we can quickly bulk load the values.
+      # Otherwise we need toinstantiate new ref-checked instances.
+      def value(native: false)
+        inner_type.fetch_multi(data_pointer, size, native: native)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,146 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::VariableWidth
+
+  def initialize(hash : Hash(<%= key_type.native_type_expr %>, <%= value_type.native_type_expr %>))
+    @memory = malloc(data_offset + 8)
+    self.value = hash
+    increment_ref_count!
+  end
+
+  def value=(hash : Hash(<%= key_type.native_type_expr %>, <%= value_type.native_type_expr %>))
+    if self.ref_count > 0
+      self.class.decr_inner_ref_counts!(memory)
+    end
+    self.class.copy_to!(hash, self.memory)
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def self.copy_to!(hash : Hash(<%= key_type.native_type_expr %>, <%= value_type.native_type_expr %>), memory : Pointer(::UInt8))
+    data_pointer = malloc(hash.size * (keysize +  valsize)).as(Pointer(::UInt8))
+
+    hash.keys.each_with_index do |key, i|
+      <%= key_type.crystal_class_name %>.write_single(data_pointer + i * keysize, key)
+    end
+
+    hash.values.each_with_index do |value, i|
+      <%= value_type.crystal_class_name %>.write_single(data_pointer + hash.size * keysize + i * valsize, value)
+    end
+
+    (memory+size_offset).as(Pointer(::UInt32)).value = hash.size.to_u32
+    (memory+data_offset).as(Pointer(::UInt64)).value = data_pointer.address
+  end
+
+  def value
+    ::Hash.zip(keys, values)
+  end
+
+  def native : ::Hash(<%= key_type.native_type_expr %>, <%= value_type.native_type_expr %>)
+    ::Hash.zip(keys_native, values_native)
+  end
+
+  include Enumerable(::Tuple(<%= key_type.native_type_expr %>, <%= value_type.native_type_expr %>))
+
+  def each
+    size.times do |i|
+      yield({keys_native[i], values_native[i]})
+    end
+  end
+
+  def size
+    (memory+size_offset).as(Pointer(::UInt32)).value.to_i
+  end
+
+  def self.keysize
+    <%= key_type.refsize %>
+  end
+
+  def keysize
+    <%= key_type.refsize %>
+  end
+
+  def self.valsize
+    <%= value_type.refsize %>
+  end
+
+  def valsize
+    <%= value_type.refsize %>
+  end
+
+  def []=(key : <%= key_type.native_type_expr %>, value : <%= value_type.native_type_expr %>)
+    index = index_of(key)
+    if index
+      <%= value_type.crystal_class_name %>.write_single(data_pointer + size * keysize + index * valsize, value)
+    else
+      self.value = self.native.merge({key => value})
+    end
+  end
+
+  def key_ptr : Pointer(<%= !key_type.numeric? ? "UInt64" : key_type.native_type_expr %>)
+    data_pointer.as(Pointer(<%= !key_type.numeric? ? "UInt8" : key_type.native_type_expr %>))
+  end
+
+  def value_ptr : Pointer(<%= !value_type.numeric? ? "UInt64" : value_type.native_type_expr %>)
+    (data_pointer + size * keysize).as(Pointer(<%= !value_type.numeric? ? "UInt8" : value_type.native_type_expr %>))
+  end
+
+  def []?(key : <%= key_type.native_type_expr %>)
+    index = index_of(key)
+    if index
+      values[index]
+    else
+      nil
+    end
+  end
+
+  def [](key : <%= key_type.native_type_expr %>)
+    index = index_of(key)
+    if index
+      values[index]
+    else
+      raise "Key not found"
+    end
+  end
+
+
+  def data_pointer
+    Pointer(::UInt8).new((@memory + data_offset).as(::Pointer(UInt64)).value)
+  end
+
+  def keys
+    keys = [] of <%=  key_type.numeric? ? key_type.native_type_expr : key_type.crystal_class_name %>
+    size.times do |i|
+      keys << <%= !key_type.numeric? ? "#{key_type.crystal_class_name}.fetch_single(data_pointer + i * keysize)" : "key_ptr[i]" %>
+    end
+    keys
+  end
+
+  def values
+    values = [] of <%= value_type.numeric? ? value_type.native_type_expr : value_type.crystal_class_name %>
+    size.times do |i|
+      values << <%= !value_type.numeric? ? "#{value_type.crystal_class_name}.fetch_single(data_pointer + size * keysize + i * valsize)" : "value_ptr[i]" %>
+    end
+    values
+  end
+
+  def keys_native
+    keys = [] of <%= key_type.native_type_expr %>
+    size.times do |i|
+      keys << <%= !key_type.numeric? ? "#{key_type.crystal_class_name}.fetch_single(data_pointer + i * keysize).native" : "key_ptr[i]" %>.as(<%= key_type.native_type_expr %>)
+    end
+    keys
+  end
+
+  def values_native
+    values = [] of <%= value_type.native_type_expr %>
+    size.times do |i|
+      values << <%= !value_type.numeric? ? "#{value_type.crystal_class_name}.fetch_single(data_pointer + size * keysize + i * valsize).native" : "value_ptr[i]" %>.as(<%= value_type.native_type_expr %>)
+    end
+    values
+  end
+
+  def index_of(key : <%= key_type.native_type_expr %>)
+    keys.index(key)
+  end
+end

data/lib/crystalruby/types/variable_width/hash.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module CrystalRuby::Types
+  Hash = VariableWidth.build(error: "Hash type must have 2 type parameters. E.g. Hash(Float64, String)")
+
+  def self.Hash(key_type, value_type)
+    VariableWidth.build(:Hash, inner_types: [key_type, value_type], convert_if: [Root::Hash], superclass: Hash) do
+      include Enumerable
+
+      def_delegators :@class, :value_type, :key_type
+
+      # Implement the Enumerable interface
+      # Helps this object to act like a true Hash
+      def each
+        if block_given?
+          size.times { |i| yield key_for_index(i), value_for_index(i) }
+        else
+          to_enum(:each)
+        end
+      end
+
+      def keys
+        each.map { |k, _| k }
+      end
+
+      def values
+        each.map { |_, v| v }
+      end
+
+      def self.key_type
+        inner_types.first
+      end
+
+      def self.value_type
+        inner_types.last
+      end
+
+      # We only accept Hash-like values, from which all elements
+      # can successfully be cast to our inner types
+      def self.cast!(value)
+        unless (value.is_a?(Hash) || value.is_a?(Root::Hash)) && value.keys.all?(&key_type.method(:valid_cast?)) && value.values.all?(&value_type.method(:valid_cast?))
+          raise CrystalRuby::InvalidCastError, "Cannot cast #{value} to #{inspect}"
+        end
+
+        [[key_type, value.keys], [value_type, value.values]].map do |type, values|
+          if type.primitive?
+            values.map(&type.method(:to_ffi_repr))
+          else
+            values
+          end
+        end
+      end
+
+      def self.copy_to!((keys, values), memory:)
+        data_pointer = malloc(values.size * (key_type.refsize + value_type.refsize))
+
+        memory[size_offset].write_uint32(values.size)
+        memory[data_offset].write_pointer(data_pointer)
+
+        [
+          [key_type, data_pointer, keys],
+          [value_type, data_pointer[values.length * key_type.refsize], values]
+        ].each do |type, pointer, list|
+          if type.primitive?
+            pointer.send("put_array_of_#{type.ffi_type}", 0, list)
+          else
+            list.each_with_index do |val, i|
+              type.write_single(pointer[i * type.refsize], val)
+            end
+          end
+        end
+      end
+
+      def index_for_key(key)
+        size.times { |i| return i if key_for_index(i) == key }
+        nil
+      end
+
+      def key_for_index(index)
+        key_type.fetch_single(data_pointer[index * key_type.refsize])
+      end
+
+      def value_for_index(index)
+        value_type.fetch_single(data_pointer[key_type.refsize * size + index * value_type.refsize])
+      end
+
+      def self.each_child_address(pointer)
+        size = pointer[size_offset].read_int32
+        pointer = pointer[data_offset].read_pointer
+        size.times do |i|
+          yield key_type, pointer[i * key_type.refsize]
+          yield value_type, pointer[size * key_type.refsize + i * value_type.refsize]
+        end
+      end
+
+      def [](key)
+        return nil unless index = index_for_key(key)
+
+        value_for_index(index)
+      end
+
+      def []=(key, value)
+        if index = index_for_key(key)
+          value_type.write_single(data_pointer[key_type.refsize * size + index * value_type.refsize], value)
+        else
+          method_missing(:[]=, key, value)
+        end
+      end
+
+      def value(native: false)
+        keys = key_type.fetch_multi(data_pointer, size, native: native)
+        values = value_type.fetch_multi(data_pointer[key_type.refsize * size], size, native: native)
+        keys.zip(values).to_h
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::VariableWidth
+
+  def initialize(string : ::String)
+    @memory = malloc(data_offset + 8)
+    self.value = string
+    increment_ref_count!
+  end
+
+  def self.copy_to!(value : ::String, memory : Pointer(::UInt8))
+    data_pointer = malloc(value.bytesize.to_u32).as(Pointer(::UInt8))
+    data_pointer.copy_from(value.to_unsafe, value.bytesize)
+    (memory+size_offset).as(Pointer(::UInt32)).value = value.bytesize.to_u32
+    (memory+data_offset).as(Pointer(::UInt64)).value = data_pointer.address
+  end
+
+  def value=(string : ::String)
+    if self.ref_count > 0
+      self.class.decr_inner_ref_counts!(memory)
+    end
+    self.class.copy_to!(string, self.memory)
+  end
+
+  def ==(other : <%= native_type_expr %>)
+    native == other
+  end
+
+  def value : ::String
+    char_ptr = (memory + data_offset).as(Pointer(Pointer(::UInt8)))
+    size = (memory + size_offset).as(Pointer(::UInt32))
+    ::String.new(char_ptr[0], size[0])
+  end
+
+  def native : ::String
+    value
+  end
+end

data/lib/crystalruby/types/variable_width/string.rb

@@ -0,0 +1,18 @@
+module CrystalRuby::Types
+  String = VariableWidth.build(:String, convert_if: [String, Root::String]) do
+    def self.cast!(rbval)
+      rbval.to_s
+    end
+
+    def self.copy_to!(rbval, memory:)
+      data_pointer = malloc(rbval.bytesize)
+      data_pointer.write_string(rbval)
+      memory[size_offset].write_uint32(rbval.size)
+      memory[data_offset].write_pointer(data_pointer)
+    end
+
+    def value(native: false)
+      data_pointer.read_string(size)
+    end
+  end
+end

data/lib/crystalruby/types/variable_width.cr

@@ -0,0 +1,23 @@
+module CrystalRuby
+  module Types
+    class VariableWidth < FixedWidth
+
+      def self.size_offset
+        4
+      end
+
+      def self.data_offset
+        8
+      end
+
+      def self.memsize
+        8
+      end
+
+      def variable_width?
+        true
+      end
+
+    end
+  end
+end

data/lib/crystalruby/types/variable_width.rb

@@ -0,0 +1,46 @@
+module CrystalRuby
+  module Types
+    # A variable with type operates much like a fixed width type, but
+    # it writes a size and a pointer to the type memory instead of the data itself.
+    # When we decrement our internal ref count we need to resolve the pointer.
+    # The layout is a tiny bit different (data begins at byte 8 to allow room for size uint32 at byte 4)
+    class VariableWidth < FixedWidth
+      def self.variable_width?
+        true
+      end
+
+      def self.crystal_supertype
+        "CrystalRuby::Types::VariableWidth"
+      end
+
+      def self.build(
+        typename = nil,
+        error: nil,
+        inner_types: nil,
+        inner_keys: nil,
+        ffi_type: :pointer,
+        size_offset: 4,
+        data_offset: 8,
+        memsize: FFI.type_size(ffi_type),
+        refsize: 8,
+        convert_if: [],
+        superclass: VariableWidth,
+        &block
+      )
+        inner_types&.each(&Type.method(:validate!))
+
+        Class.new(superclass) do
+          bind_local_vars!(
+            %i[typename error inner_types inner_keys ffi_type memsize convert_if data_offset size_offset
+               refsize], binding
+          )
+          class_eval(&block) if block_given?
+        end
+      end
+    end
+  end
+end
+
+require_relative "variable_width/string"
+require_relative "variable_width/array"
+require_relative "variable_width/hash"

data/lib/crystalruby/types.rb

@@ -1,18 +1,37 @@
-require_relative "types/type"
-require_relative "types/union_type"
-require_relative "types/typedef"
-require_relative "types/string"
-require_relative "types/time"
-require_relative "types/symbol"
-require_relative "types/array"
-require_relative "types/hash"
-require_relative "types/nil"
-require_relative "types/bool"
-require_relative "types/named_tuple"
-require_relative "types/tuple"
-require_relative "types/numbers"
 
 module CrystalRuby
   module Types
+    # Store references to root types so that we can reference these in places where
+    # we load the CrystalRuby equivalents into the global namespace
+    module Root
+      Symbol = ::Symbol
+      String = ::String
+      Array = ::Array
+      Hash = ::Hash
+      Time = ::Time
+    end
+
+    def self.const_missing(const_name)
+      return @fallback.const_get(const_name) if @fallback&.const_defined?(const_name)
+      super
+    end
+
+    def self.method_missing(method_name, *args)
+      return @fallback.send(method_name, *args) if @fallback&.method_defined?(method_name)
+      super
+    end
+
+    def self.with_binding_fallback(fallback)
+      @fallback, previous_fallback = fallback, @fallback
+      @fallback = @fallback.class unless @fallback.kind_of?(Module)
+      yield binding
+    ensure
+      @fallback = previous_fallback
+    end
   end
 end
+require_relative "types/concerns/allocator"
+require_relative "types/type"
+require_relative "types/primitive"
+require_relative "types/fixed_width"
+require_relative "types/variable_width"

data/lib/crystalruby/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-module Crystalruby
-  VERSION = "0.2.3"
+module CrystalRuby
+  VERSION = "0.3.1"
 end

data/lib/crystalruby.rb

@@ -3,11 +3,12 @@
 require "ffi"
 require "digest"
 require "fileutils"
-require "method_source"
+require "prism"
 require "pathname"
 
 require_relative "crystalruby/config"
 require_relative "crystalruby/version"
+require_relative "crystalruby/arc_mutex"
 require_relative "crystalruby/typemaps"
 require_relative "crystalruby/types"
 require_relative "crystalruby/typebuilder"
@@ -17,7 +18,7 @@ require_relative "crystalruby/adapter"
 require_relative "crystalruby/reactor"
 require_relative "crystalruby/library"
 require_relative "crystalruby/function"
-require_relative "module"
+require_relative "crystalruby/source_reader"
 
 module CrystalRuby
   module_function
@@ -37,19 +38,25 @@ module CrystalRuby
   def check_crystal_ruby!
     return if system("which crystal > /dev/null 2>&1")
 
-    raise "Crystal executable not found. Please ensure Crystal is installed and in your PATH." \
-      "See https://crystal-lang.org/install/"
+    msg = "Crystal executable not found. Please ensure Crystal is installed and in your PATH. " \
+      "See https://crystal-lang.org/install/."
+
+    if config.crystal_missing_ignore
+      config.logger.error msg
+    else
+      raise msg
+    end
   end
 
   def check_config!
     return if config.crystal_src_dir
 
-    raise "Missing config option `crystal_src_dir`. \nProvide this inside crystalruby.yaml "\
+    raise "Missing config option `crystal_src_dir`. \nProvide this inside crystalruby.yaml " \
       "(run `bundle exec crystalruby init` to generate this file with detaults)"
   end
 
   %w[debug info warn error].each do |level|
-    define_method("log_#{level}") do |*msg|
+    define_method(:"log_#{level}") do |*msg|
       prefix = config.colorize_log_output ? "\e[33mcrystalruby\e[0m\e[90m [#{Thread.current.object_id}]\e[0m" : "[crystalruby] #{Thread.current.object_id}"
 
       config.logger.send(level, "#{prefix} #{msg.join(", ")}")