crystalruby 0.2.3 → 0.3.0

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.0"
 end

data/lib/crystalruby.rb

@@ -3,11 +3,12 @@
 require "ffi"
 require "digest"
 require "fileutils"
-require "method_source"
+require "syntax_tree"
 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(", ")}")

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: crystalruby
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.3.0
 platform: ruby
 authors:
 - Wouter Coppieters
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-05-09 00:00:00.000000000 Z
+date: 2024-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: digest
@@ -53,7 +53,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: method_source
+  name: syntax_tree
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -87,35 +87,57 @@ files:
 - exe/crystalruby
 - lib/crystalruby.rb
 - lib/crystalruby/adapter.rb
+- lib/crystalruby/arc_mutex.rb
 - lib/crystalruby/compilation.rb
 - lib/crystalruby/config.rb
 - lib/crystalruby/function.rb
 - lib/crystalruby/library.rb
 - lib/crystalruby/reactor.rb
+- lib/crystalruby/source_reader.rb
 - lib/crystalruby/template.rb
 - lib/crystalruby/templates/function.cr
 - lib/crystalruby/templates/index.cr
 - lib/crystalruby/templates/inline_chunk.cr
+- lib/crystalruby/templates/ruby_interface.cr
+- lib/crystalruby/templates/top_level_function.cr
+- lib/crystalruby/templates/top_level_ruby_interface.cr
 - lib/crystalruby/typebuilder.rb
 - lib/crystalruby/typemaps.rb
 - lib/crystalruby/types.rb
-- lib/crystalruby/types/array.rb
-- lib/crystalruby/types/bool.rb
-- lib/crystalruby/types/hash.rb
-- lib/crystalruby/types/named_tuple.rb
-- lib/crystalruby/types/nil.rb
-- lib/crystalruby/types/numbers.rb
-- lib/crystalruby/types/string.rb
-- lib/crystalruby/types/symbol.rb
-- lib/crystalruby/types/time.rb
-- lib/crystalruby/types/tuple.rb
+- lib/crystalruby/types/concerns/allocator.rb
+- lib/crystalruby/types/fixed_width.cr
+- lib/crystalruby/types/fixed_width.rb
+- lib/crystalruby/types/fixed_width/named_tuple.cr
+- lib/crystalruby/types/fixed_width/named_tuple.rb
+- lib/crystalruby/types/fixed_width/proc.cr
+- lib/crystalruby/types/fixed_width/proc.rb
+- lib/crystalruby/types/fixed_width/tagged_union.cr
+- lib/crystalruby/types/fixed_width/tagged_union.rb
+- lib/crystalruby/types/fixed_width/tuple.cr
+- lib/crystalruby/types/fixed_width/tuple.rb
+- lib/crystalruby/types/primitive.cr
+- lib/crystalruby/types/primitive.rb
+- lib/crystalruby/types/primitive_types/bool.cr
+- lib/crystalruby/types/primitive_types/bool.rb
+- lib/crystalruby/types/primitive_types/nil.cr
+- lib/crystalruby/types/primitive_types/nil.rb
+- lib/crystalruby/types/primitive_types/numbers.cr
+- lib/crystalruby/types/primitive_types/numbers.rb
+- lib/crystalruby/types/primitive_types/symbol.cr
+- lib/crystalruby/types/primitive_types/symbol.rb
+- lib/crystalruby/types/primitive_types/time.cr
+- lib/crystalruby/types/primitive_types/time.rb
+- lib/crystalruby/types/type.cr
 - lib/crystalruby/types/type.rb
-- lib/crystalruby/types/type_serializer.rb
-- lib/crystalruby/types/type_serializer/json.rb
-- lib/crystalruby/types/typedef.rb
-- lib/crystalruby/types/union_type.rb
+- lib/crystalruby/types/variable_width.cr
+- lib/crystalruby/types/variable_width.rb
+- lib/crystalruby/types/variable_width/array.cr
+- lib/crystalruby/types/variable_width/array.rb
+- lib/crystalruby/types/variable_width/hash.cr
+- lib/crystalruby/types/variable_width/hash.rb
+- lib/crystalruby/types/variable_width/string.cr
+- lib/crystalruby/types/variable_width/string.rb
 - lib/crystalruby/version.rb
-- lib/module.rb
 - logo.png
 - sig/crystalruby.rbs
 homepage: https://github.com/wouterken/crystalruby
@@ -140,7 +162,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.19
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: Embed Crystal code directly in Ruby.

data/lib/crystalruby/types/array.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-module CrystalRuby::Types
-  Array = Type.new(
-    :Array,
-    error: "Array type must have a type parameter. E.g. Array(Float64)"
-  )
-
-  def self.Array(type)
-    Type.validate!(type)
-    Type.new("Array", inner_types: [type], accept_if: [::Array]) do |a|
-      a.map! { |v| type.interpret!(v) }
-    end
-  end
-end

data/lib/crystalruby/types/bool.rb

@@ -1,3 +0,0 @@
-module CrystalRuby::Types
-  Bool = Type.new(:Bool, accept_if: [::TrueClass, ::FalseClass])
-end

data/lib/crystalruby/types/hash.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module CrystalRuby::Types
-  Hash = Type.new(
-    :Hash,
-    error: "Hash type must have 2 type parameters. E.g. Hash(Float64, String)"
-  )
-
-  def self.Hash(key_type, value_type)
-    Type.validate!(key_type)
-    Type.validate!(value_type)
-    Type.new("Hash", inner_types: [key_type, value_type], accept_if: [::Hash]) do |h|
-      h.transform_keys! { |k| key_type.interpret!(k) }
-      h.transform_values! { |v| value_type.interpret!(v) }
-    end
-  end
-end

data/lib/crystalruby/types/named_tuple.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module CrystalRuby::Types
-  NamedTuple = Type.new(
-    :NamedTuple,
-    error: "NamedTuple type must contain one or more symbol -> type pairs. E.g. NamedTuple(hello: Int32, world: String)"
-  )
-
-  def self.NamedTuple(types_hash)
-    types_hash.keys.each do |key|
-      raise "NamedTuple keys must be symbols" unless key.is_a?(::Symbol) || key.respond_to?(:to_sym)
-    end
-    types_hash.values.each do |value_type|
-      Type.validate!(value_type)
-    end
-    keys = types_hash.keys.map(&:to_sym)
-    values = types_hash.values
-    Type.new("NamedTuple", inner_types: values, inner_keys: keys, accept_if: [::Hash]) do |h|
-      h.transform_keys! { |k| k.to_sym }
-      raise "Invalid keys for named tuple" unless h.keys.length == keys.length
-      raise "Invalid keys for named tuple" unless h.keys.all? { |k| keys.include?(k) }
-
-      h.each do |key, value|
-        h[key] = values[keys.index(key)].interpret!(value)
-      end
-    end
-  end
-end

data/lib/crystalruby/types/nil.rb

@@ -1,3 +0,0 @@
-module CrystalRuby::Types
-  Nil = Type.new(:Nil, accept_if: [::NilClass])
-end

data/lib/crystalruby/types/numbers.rb

@@ -1,5 +0,0 @@
-module CrystalRuby::Types
-  %i[Uint8 Uint16 Uint32 Uint64 Int8 Int16 Int32 Int64 Float32 Float64].each do |type_name|
-    const_set type_name, Type.new(type_name, accept_if: [::Numeric])
-  end
-end

data/lib/crystalruby/types/string.rb

@@ -1,3 +0,0 @@
-module CrystalRuby::Types
-  String = Type.new(:String, accept_if: [::String])
-end

data/lib/crystalruby/types/symbol.rb

@@ -1,3 +0,0 @@
-module CrystalRuby::Types
-  Symbol = Type.new(:Symbol, accept_if: [::String, ::Symbol])
-end

data/lib/crystalruby/types/time.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-module CrystalRuby::Types
-  require "date"
-  Time = Type.new(:Time, accept_if: [::Time, ::String]) do |v|
-    DateTime.parse(v)
-  end
-end

data/lib/crystalruby/types/tuple.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module CrystalRuby::Types
-  Tuple = Type.new(
-    :Tuple,
-    error: "Tuple type must contain one or more types E.g. Tuple(Int32, String)"
-  )
-
-  def self.Tuple(*types)
-    types.each do |value_type|
-      Type.validate!(value_type)
-    end
-    Type.new("Tuple", inner_types: types, accept_if: [::Array]) do |a|
-      a.map!.with_index { |v, i| inner_types[i].interpret!(v) }
-    end
-  end
-end

data/lib/crystalruby/types/type_serializer/json.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module CrystalRuby::Types
-  class TypeSerializer
-    class JSON < TypeSerializer
-      def lib_type
-        "UInt8*"
-      end
-
-      def crystal_type
-        type_expr
-      end
-
-      def error_value
-        '"{}".to_unsafe'
-      end
-
-      def ffi_type
-        :string
-      end
-
-      def prepare_argument(arg)
-        arg.to_json
-      end
-
-      def prepare_retval(retval)
-        @typedef.interpret!(::JSON.parse(retval))
-      end
-
-      def lib_to_crystal_type_expr(expr)
-        "(#{type_expr}).from_json(String.new(%s))" % expr
-      end
-
-      def crystal_to_lib_type_expr(expr)
-        "%s.to_json.to_unsafe" % expr
-      end
-    end
-  end
-end

data/lib/crystalruby/types/type_serializer.rb

@@ -1,37 +0,0 @@
-module CrystalRuby::Types
-  class TypeSerializer
-    include FFI::DataConverter
-    def self.for(format)
-      case format
-      when :json then JSON
-      else raise "Unknown type format: #{format}"
-      end
-    end
-
-    def error_value
-      0
-    end
-
-    def initialize(typedef)
-      @typedef = typedef
-    end
-
-    def type_expr
-      @typedef.type_expr
-    end
-
-    def type_defn
-      @typedef.type_defn
-    end
-
-    def anonymous?
-      @typedef.anonymous?
-    end
-
-    def name
-      @typedef.name
-    end
-  end
-end
-
-require_relative "type_serializer/json"