crystalruby 0.2.2 → 0.3.0

data/lib/crystalruby/types/primitive.rb

@@ -0,0 +1,117 @@
+module CrystalRuby
+  module Types
+    class Primitive < Type
+      # Primitives just store the Ruby value directly
+      # (Or read it from memory if passed a pointer)
+      def initialize(rbval)
+        super(rbval)
+        self.value = rbval.is_a?(FFI::Pointer) ? rbval.send("read_#{ffi_type}") : rbval
+      end
+
+      # Read a value from a pointer at a given index
+      # (Type can be a byte-array, pointer or numeric type)
+      def self.fetch_single(pointer, native: false)
+        # Nothing to fetch for Nils
+        return if memsize.zero?
+
+        if numeric?
+          pointer.send("read_#{ffi_type}")
+        elsif primitive?
+          single = new(pointer.send("read_#{ffi_type}"))
+          if native
+            single.value
+          else
+            single
+          end
+        end
+      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, value)
+        # Dont need to write nils
+        return if memsize.zero?
+
+        pointer.send("write_#{ffi_type}", to_ffi_repr(value))
+      end
+
+      # Fetch an array of a given data type from a list pointer
+      # (Type can be a byte-array, pointer or numeric type)
+      def self.fetch_multi(pointer, size, native: false)
+        if numeric?
+          pointer.send("get_array_of_#{ffi_type}", 0, size)
+        elsif primitive?
+          pointer.send("get_array_of_#{ffi_type}", 0, size).map(&method(:from_ffi_array_repr))
+        end
+      end
+
+      def self.decrement_ref_count!(pointer)
+        # Do nothing
+      end
+
+      # Define a new primitive type
+      # Primitive types are stored by value
+      # and efficiently copied using native FFI types
+      # They are written directly into the memory of a container type
+      #  (No indirection)
+      def self.build(
+        typename = nil,
+        ffi_type: :uint8,
+        memsize: FFI.type_size(ffi_type),
+        convert_if: [],
+        error: nil,
+        superclass: Primitive,
+        &block
+      )
+        Class.new(superclass) do
+          %w[typename ffi_type memsize convert_if error].each do |name|
+            define_singleton_method(name) { binding.local_variable_get("#{name}") }
+            define_method(name) { binding.local_variable_get("#{name}") }
+          end
+
+          class_eval(&block) if block_given?
+
+          # Primitives are stored directly in memory as a raw numeric value
+          def self.to_ffi_repr(value)
+            new(value).inner_value
+          end
+
+          def self.refsize
+            memsize
+          end
+
+          # Primiives are anonymous (Shouldn't be subclassed)
+          def self.anonymous?
+            true
+          end
+
+          def self.copy_to!(rbval, memory:)
+            memory.send("write_#{self.ffi_type}", to_ffi_repr(rbval))
+          end
+
+          def self.primitive?
+            true
+          end
+
+          def self.inspect
+            inspect_name
+          end
+
+          def memory
+            @value
+          end
+
+          def self.crystal_supertype
+            "CrystalRuby::Types::Primitive"
+          end
+        end
+      end
+    end
+  end
+end
+
+require_relative "primitive_types/time"
+require_relative "primitive_types/symbol"
+require_relative "primitive_types/numbers"
+require_relative "primitive_types/nil"
+require_relative "primitive_types/bool"

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

@@ -0,0 +1,34 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  def initialize(value : ::Bool)
+    @value = value ? 1_u8 : 0_u8
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+    @value = ptr[0]
+  end
+
+  def initialize(value : UInt8)
+    @value = value
+  end
+
+  def value=(value : ::Bool)
+    @value = value ? 1_u8 : 0_u8
+  end
+
+  def value : <%= native_type_expr %>
+    @value == 1_u8
+  end
+
+  def ==(other : ::Bool)
+    value == other
+  end
+
+  def self.memsize
+    <%= memsize %>
+  end
+
+  def self.write_single(pointer : Pointer(::UInt8), value)
+    pointer.as(Pointer(::UInt8)).value = value ? 1_u8 : 0_u8
+  end
+end

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

@@ -0,0 +1,11 @@
+module CrystalRuby::Types
+  Bool = Primitive.build(:Bool, convert_if: [::TrueClass, ::FalseClass], ffi_type: :uint8, memsize: 1) do
+    def value(native: false)
+      super == 1
+    end
+
+    def value=(val)
+      !!val && val != 0 ? super(1) : super(0)
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+class <%= base_crystal_class_name %> < CrystalRuby::Types::Primitive
+
+  property value : ::Nil = nil
+
+  def initialize(nilval : ::Nil)
+  end
+
+  def initialize(ptr : Pointer(::UInt8))
+  end
+
+  def initialize(raw : UInt8)
+  end
+
+  def value : ::Nil
+    nil
+  end
+
+  def ==(other : ::Nil)
+    value.nil?
+  end
+
+  def value=(val : ::Nil)
+  end
+
+  def self.memsize
+    0
+  end
+
+  def return_value
+    0_u8
+  end
+
+  def self.write_single(pointer : Pointer(::UInt8), value)
+  end
+end

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

@@ -0,0 +1,16 @@
+module CrystalRuby::Types
+  Nil = Primitive.build(:Nil, convert_if: [::NilClass], memsize: 0) do
+    def initialize(val = nil)
+      super
+      @value = 0
+    end
+
+    def nil?
+      true
+    end
+
+    def value(native: false)
+      nil
+    end
+  end
+end

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