white_gold 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 2602400f722a11d0ea3f31366f29c3b31471fa0b001061e3c614518c0ae4f52e
+  data.tar.gz: d1c55ab3f33f03c59d389fe2739bd6ddcc10d13d9ecab594b826a365a9d41ec3
+SHA512:
+  metadata.gz: fe6e0e9ce7881149ed8d5912fda0dc7dcbcb3e4ae4ca8dcc242765a35f8066499eb89fed57d05a47906ab66e910e92a48ff6e60522473cff7604974498b1bdb3
+  data.tar.gz: 3ec8c60dcd97eacd677ddcd158c71db4e7947036f1f6313ec3805f9e7b18c4e1160fbfb996524143dc9bf3b4d30770e679f7666a4a5ddfeb234fe90a7ed2eb41

data/lib/white_gold/abi/alias.rb

@@ -0,0 +1,50 @@
+module Alias
+  def abi_def name, original_name = nil, **na
+    if original_name
+      if original_name.end_with? "_"
+        abi_name = "_abi_#{original_name}#{name}".delete_suffix("=").delete_suffix("?").to_sym
+      else
+        abi_name = "_abi_#{original_name}".to_sym
+      end
+    else
+      if name.end_with? "?"
+        abi_name = "_abi_is_#{name}".delete_suffix("?").to_sym
+      elsif name.end_with? "="
+        abi_name = "_abi_set_#{name}".delete_suffix("=").to_sym
+      else
+        abi_name = "_abi_#{name}".to_sym
+      end
+    end
+
+    interface = na.map{|k, v| Interface.from k, v }.first
+    self_abi_def name, abi_name, interface
+  end
+
+  def self_abi_def name, abi_name, abi_interface
+    define_method name do |*a|
+      abi_interface.call self, abi_name, *a
+    end
+  end
+
+  def abi_attr name, type = nil, original_name = nil
+    if original_name
+      if original_name.end_with? "_"
+        getter = "_abi_#{original_name}#{name}".delete_suffix("?").to_sym
+        setter = "_abi_set_#{name}".delete_suffix("?").to_sym
+      else
+        getter = "_abi_get_#{original_name}".to_sym
+        setter = "_abi_set_#{original_name}".to_sym
+      end
+    else
+      if name.end_with? "?"
+        getter = "_abi_is_#{name}".delete_suffix("?").to_sym
+      else 
+        getter = "_abi_get_#{name}".to_sym
+      end
+      setter = "_abi_set_#{name}".delete_suffix("?").to_sym
+    end
+    type ||= Boolean if name.end_with? "?"
+    abi_def "#{name.to_s.delete_suffix("?")}=".to_sym, setter, type => nil
+    abi_def name, getter, nil => type
+  end
+end

data/lib/white_gold/abi/enum.rb

@@ -0,0 +1,43 @@
+class Enum
+  def initialize *keywords, **indexed_keywords
+    @symbol_to_int = keywords.each_with_index.to_h
+    indexed_keywords.each do |k, i|
+        @symbol_to_int[k] = Integer === i ? i : @symbol_to_int[i]
+    end
+    @int_to_symbol = @symbol_to_int.invert
+  end
+
+  attr_accessor :name
+
+  def sym_to_i sym
+    @symbol_to_int[sym] || raise("No value at #{sym}")
+  end
+
+  def i_to_sym i
+    @int_to_symbol[i] || raise("No keyword at #{i}")
+  end
+
+  def [](k)
+    k.is_a?(Integer) ? i_to_sym(k) : sym_to_i(k)
+  end
+
+  def pack *k
+    k.map{ @symbol_to_int[_1] }.reduce(0, &:|)
+  end
+
+  def unpack m
+    @int_to_symbol.filter{|k, v| k != 0 and m & k == k }.map{ _1[1] }
+  end
+
+  def symbols
+    @symbol_to_int
+  end
+
+  def to_abi o
+    self[o]
+  end
+
+  def to_api o
+    self[o]
+  end
+end

data/lib/white_gold/abi/extern_object.rb

@@ -0,0 +1,180 @@
+require_relative '../convention/bang_def'
+require_relative 'packer'
+require_relative 'unpacker'
+
+class ExternObject
+  extend Packer
+  extend Unpacker
+  extend BangDef
+
+  def initialize pointer:, autofree: true
+    @pointer = pointer
+    
+    if autofree
+      cl = self.class
+      while !cl.respond_to?(:finalizer)
+        cl = cl.superclass
+      end
+      ObjectSpace.define_finalizer(self, cl.proc.finalizer(pointer))
+    end
+  end
+
+  def initialized
+  end
+
+  attr :pointer
+
+  @@callback_storage = {}
+  @@global_callback_storage = {}
+  @@data_storage = {}
+
+  def abi_pack type, *a
+    ExternObject.abi_pack self, type, *a
+  end
+
+  def abi_unpack type, object
+    ExternObject.abi_unpack self, type, object
+  end
+
+  class << self
+
+    def callback_storage=(callback_storage)
+      @@callback_storage = callback_storage
+    end
+
+    def callback_storage
+      @@callback_storage
+    end
+
+    def global_callback_storage=(global_callback_storage)
+      @@global_callback_storage = global_callback_storage
+    end
+
+    def global_callback_storage
+      @@global_callback_storage
+    end
+
+    def data_storage=(data_storage)
+      @@data_storage = data_storage
+    end
+
+    def abi_def name, original_name = nil, **na
+      if original_name
+        if original_name.end_with? "_"
+          abi_name = "_abi_#{original_name}#{name}".delete_suffix("=").delete_suffix("?").to_sym
+        else
+          abi_name = "_abi_#{original_name}".to_sym
+        end
+      else
+        if name.end_with? "?"
+          abi_name = "_abi_is_#{name}".delete_suffix("?").to_sym
+        elsif name.end_with? "="
+          abi_name = "_abi_set_#{name}".delete_suffix("=").to_sym
+        else
+          abi_name = "_abi_#{name}".to_sym
+        end
+      end
+
+      na = {nil => nil} if na.empty?
+      interface = na.map{|k, v| Interface.from k, v }.first
+      if name.to_s.end_with? "="
+        self_abi_def_setter name, abi_name, interface
+      else
+        self_abi_def name, abi_name, interface
+      end
+    end
+
+    def self_abi_def name, abi_name, abi_interface, *def_attr
+      define_method name do |*a|
+        abi_interface.call self, abi_name, *def_attr, *a
+      end
+    end
+
+    def self_abi_def_setter name, abi_name, abi_interface, *def_attr
+      define_method name do |a = VOID|
+        abi_interface.call self, abi_name, *def_attr, *a
+      end
+    end
+
+    def abi_attr name, type = nil, original_name = nil
+      if original_name
+        if original_name.end_with? "_"
+          getter = "#{original_name}#{name}".delete_suffix("?").to_sym
+          setter = "set_#{name}".delete_suffix("?").to_sym
+        else
+          getter = "get_#{original_name}".to_sym
+          setter = "set_#{original_name}".to_sym
+        end
+      else
+        if name.end_with? "?"
+          getter = "is_#{name}".delete_suffix("?").to_sym
+        else 
+          getter = "get_#{name}".to_sym
+        end
+        setter = "set_#{name}".delete_suffix("?").to_sym
+      end
+      type ||= Boolean if name.end_with? "?"
+      abi_def "#{name.to_s.delete_suffix("?")}=".to_sym, setter, type => nil
+      abi_def name, getter, nil => type
+    end
+
+    def abi_enum base, *keywords, **indexed_keywords
+      if base.is_a? Enum
+        enum = base
+      else
+        enum = Enum.new *keywords, **indexed_keywords
+        const_set base, enum
+        enum.name = base
+      end
+      abi_packer enum do |o|
+        enum.sym_to_i(o)
+      end
+      abi_unpacker enum do |o|
+        enum.i_to_sym(o)
+      end
+    end
+
+    def abi_bit_enum base, zero, *keywords, **indexed_keywords
+      if base.is_a? Enum
+        enum = base
+      else
+        enum = Enum.new zero, **(keywords.each_with_index.map{[_1, 1 << _2]}.to_h), **indexed_keywords
+        const_set base, enum
+        enum.name = base
+      end
+      abi_packer enum do |*o|
+        enum.pack(*o)
+      end
+      abi_unpacker enum do |o|
+        enum.unpack(o)
+      end
+    end
+
+    def abi_signal name, signal_class = Signal, original_name = nil
+      abi_getter = "_abi_#{original_name || name}".to_sym
+      define_method name do |*a, &b|
+        signal_pointer = send(abi_getter, *a)
+        signal = signal_class.new signal_pointer, self
+        b ? signal.connect(&b) : signal
+      end
+      define_method "#{name}=" do |a|
+        send(name, &a)
+      end
+    end
+
+    def abi_static name, original_name = nil
+      if original_name
+        if original_name.end_with? "_"
+          abi_name = "_abi_#{original_name}#{name}".delete_suffix("=").delete_suffix("?").to_sym
+        else
+          abi_name = "_abi_#{original_name}".delete_suffix("=").to_sym
+        end
+      else
+        abi_name = "_abi_#{name}".delete_suffix("=").delete_suffix("?").to_sym
+      end
+      define_singleton_method name do |*a|
+        send(abi_name, *a)
+      end
+    end
+  end
+end

data/lib/white_gold/abi/interface/interface.rb

@@ -0,0 +1,114 @@
+require_relative '../reducer'
+
+module Interface
+
+  def self.abi_const_string_method_suffix str
+    return str.gsub(/([A-Z])/, '_\1').gsub(/::/, '__').downcase
+  end
+
+  def self.parse_packer packer
+    case packer
+    when Proc, Reducer
+      packer
+    when Array
+      packers = packer.map{ parse_packer _1 }
+      proc do |host, *a|
+        ai = a.each
+        packers.map do |packer|
+          case packer
+          when Proc then packer.call host, *ai.next
+          when nil then ai.next
+          when Reducer then packer.call host, *(0..packer.reduction).map{ ai.next }
+          else packer
+          end
+        end.flatten
+      end
+    when Symbol
+      if packer.to_s.start_with? "_"
+        parse_packer "abi_pack#{packer}".to_sym
+      else
+        proc do |host, *a|
+          host.send packer, *a
+        end
+      end
+    when Class, Module, Enum
+      parse_packer "abi_pack#{abi_const_string_method_suffix packer.name}".to_sym
+    when String
+      parse_packer "abi_pack#{abi_const_string_method_suffix packer}".to_sym
+    when Range
+      subpacker = parse_packer packer.min
+      fiddle_type = packer_fiddle_type packer.min
+      if packer.exclude_end?
+        proc do |host, *a|
+          it = a.each
+          block_caller = Fiddle::Closure::BlockCaller.new(fiddle_type, [0]) do
+            subpacker.call host, it.next
+          rescue StopIteration
+            subpacker.call host, nil
+          end
+          block_caller
+        end
+      else
+        proc do |host, *a|
+          it = a.each
+          block_caller = Fiddle::Closure::BlockCaller.new(fiddle_type, [0]) do
+            subpacker.call host, it.next
+          end
+          [a.size, block_caller]
+        end
+      end
+    when nil
+      proc{}
+    else raise "Unknown packer type #{packer.class}"
+    end
+  end
+
+  def self.packer_fiddle_type type
+    if type == Integer || type == Boolean then Fiddle::TYPE_INT
+    elsif type == Float then Fiddle::TYPE_FLOAT
+    elsif type == String then Fiddle::TYPE_CONST_STRING
+    else Fiddle::TYPE_VOIDP
+    end
+  end
+
+  def self.parse_unpacker unpacker
+    case unpacker
+    when Proc
+      unpacker
+    when Symbol
+      if unpacker.to_s.start_with? "_"
+        parse_unpacker "abi_unpack#{unpacker}".to_sym
+      else
+        proc do |host, *a|
+          host.send unpacker, *a
+        end
+      end
+    when Class, Module, Enum
+      parse_unpacker "abi_unpack#{abi_const_string_method_suffix unpacker.name}".to_sym
+    when String
+      parse_unpacker "abi_unpack#{abi_const_string_method_suffix unpacker}".to_sym
+    when nil
+      nil
+    else raise "Unknown unpacker type #{unpacker.class}"
+    end
+  end
+
+  def self.fiddle_type type
+    if type == Integer || type == Boolean then Fiddle::TYPE_INT
+    elsif type == Float then Fiddle::TYPE_FLOAT
+    else Fiddle::TYPE_VOIDP
+    end
+  end
+
+  require_relative 'interface_collection_out'
+  require_relative 'interface_composed_out'
+  require_relative 'interface_single_out'
+
+  def self.from packer, unpacker
+    case unpacker
+    when Array then InterfaceComposedOut
+    when Range then InterfaceCollectionOut
+    else InterfaceSingleOut
+    end.from packer, unpacker
+  end
+end

data/lib/white_gold/abi/interface/interface_collection_out.rb

@@ -0,0 +1,29 @@
+class InterfaceCollectionOut
+  include Interface
+
+  def self.from packer, unpacker
+    self.new Interface.parse_packer(packer), Interface.parse_unpacker(unpacker.min), Interface.fiddle_type(unpacker.min)
+  end
+    
+
+  def initialize packer, unpacker, fiddle_type
+    @packer = packer
+    @unpacker = unpacker
+    # unpacking in block caller allows abi side to free memory on return eg. for strings passed by value
+    @block_caller = Fiddle::Closure::BlockCaller.new(0, [fiddle_type]) do |a|
+      @unpacked << @unpacker.call(@host, a)
+    end
+  end
+
+  # Works propertly only for single thread (like whole TGUI btw.)
+  def call host, name, *a
+    a = @packer.call host, *a if @packer
+    @host = host
+    @unpacked = []
+    host.send name, *a, @block_caller
+    unpacked = @unpacked
+    @unpacked = nil
+    @host = nil
+    unpacked
+  end
+end

data/lib/white_gold/abi/interface/interface_composed_out.rb

@@ -0,0 +1,28 @@
+class InterfaceComposedOut
+  include Interface
+
+  def self.from packer, unpacker
+    self.new Interface.parse_packer(packer), unpacker.map{ Interface.parse_unpacker _1 }, unpacker.map{ Interface.fiddle_type _1 }
+  end
+    
+
+  def initialize packer, unpacker, fiddle_types
+    @packer = packer
+    @unpacker = unpacker
+    # unpacking in block caller allows abi side to free memory on return eg. for strings passed by value
+    @block_caller = Fiddle::Closure::BlockCaller.new(0, fiddle_types) do |*a|
+      @unpacked = @unpacker.zip(a).map{ _1.call @host, _2 }
+    end
+  end
+
+  # Works propertly only for single thread (like whole TGUI btw.)
+  def call host, name, *a
+    a = @packer.call host, *a if @packer
+    @host = host
+    host.send name, *a, @block_caller
+    unpacked = @unpacked
+    @unpacked = nil
+    @host = nil
+    unpacked
+  end
+end

data/lib/white_gold/abi/interface/interface_single_out.rb

@@ -0,0 +1,19 @@
+class InterfaceSingleOut
+  include Interface
+
+  def self.from packer, unpacker
+    self.new Interface.parse_packer(packer), Interface.parse_unpacker(unpacker)
+  end
+
+  def initialize packer, unpacker
+    @packer = packer
+    @unpacker = unpacker
+  end
+
+  def call host, name, *a
+    a = @packer.call host, *a if @packer
+    received = host.send name, *a
+    @unpacker&.call host, received
+  end
+
+end

data/lib/white_gold/abi/packer.rb

@@ -0,0 +1,28 @@
+require_relative 'interface/interface'
+
+module Packer
+  def abi_packer base, &body
+    if block_given?
+      define_method abi_packer_method_name(base), &body
+    elsif base.is_a? Module
+      define_method abi_packer_method_name(base) do |*o|
+        base.from *o
+      end
+    else
+      raise "..."
+    end
+  end
+
+  def abi_packer_method_name base
+    case base
+    when String then "abi_pack#{Interface.abi_const_string_method_suffix base}".to_sym
+    when Symbol then base.to_s.start_with?("_") ? "abi_pack#{base}".to_sym : base
+    else "abi_pack#{Interface.abi_const_string_method_suffix base.name}".to_sym
+    end
+  end
+
+  def abi_pack host, type, *a
+    Interface.parse_packer(type).call host, *a
+  end
+end
+    

data/lib/white_gold/abi/reducer.rb

@@ -0,0 +1,12 @@
+class Reducer
+  def initialize reduction, &block
+    @reduction = reduction
+    @block = block
+  end
+
+  def call *a
+    block.call *a
+  end
+
+  attr :reduction
+end

data/lib/white_gold/abi/unpacker.rb

@@ -0,0 +1,27 @@
+require_relative 'interface/interface'
+
+module Unpacker
+  def abi_unpacker base, &body
+    if block_given?
+      define_method abi_unpacker_method_name(base), &body
+    elsif base.is_a? Module
+      define_method abi_unpacker_method_name(base) do |o|
+        base.new pointer: o
+      end
+    else
+      raise "..."
+    end
+  end
+
+  def abi_unpacker_method_name base
+    case base
+    when String then "abi_unpack#{Interface.abi_const_string_method_suffix base}".to_sym
+    when Symbol then base.to_s.start_with?("_") ? "abi_unpack#{base}".to_sym : base
+    else "abi_unpack#{Interface.abi_const_string_method_suffix base.name}".to_sym
+    end
+  end
+
+  def abi_unpack host, type, object
+    Interface.parse_unpacker(type).call host, object
+  end
+end

data/lib/white_gold/convention/api_child.rb

@@ -0,0 +1,30 @@
+module Tgui
+  module ApiChild
+    API_CHILD_PREFIX = "api_child_".freeze
+
+    def api_child name, original_name = nil, &b
+      if block_given?
+        define_method "#{API_CHILD_PREFIX}#{name}", &b
+      else
+        if original_name
+          if original_name.end_with? "_"
+            abi_name = "_abi_#{original_name}#{name}".delete_suffix("=").delete_suffix("?").to_sym
+          else
+            abi_name = "_abi_#{original_name}".to_sym
+          end
+        else
+          if name.end_with? "?"
+            abi_name = "_abi_is_#{name}".delete_suffix("?").to_sym
+          elsif name.end_with? "="
+            abi_name = "_abi_set_#{name}".delete_suffix("=").to_sym
+          else
+            abi_name = "_abi_#{name}".to_sym
+          end
+        end
+        define_method "#{API_CHILD_PREFIX}#{name}" do |*a|
+          send(abi_name, *a)
+        end
+      end
+    end
+  end
+end

data/lib/white_gold/convention/bang_def.rb

@@ -0,0 +1,5 @@
+module BangDef
+  def def! name, &b
+    define_method "api_bang_#{name}", &b
+  end
+end

data/lib/white_gold/convention/bang_nest.rb

@@ -0,0 +1,16 @@
+require_relative 'bang_nested_caller'
+
+module BangNest
+  include BangNestedCaller
+
+  def respond_to? name
+    super || bang_respond_to?(name)
+  end
+
+  def method_missing name, *a, **na, &b
+    if name.end_with? "!"
+      bang_method_missing name, *a, **na, &b
+    else super
+    end
+  end
+end

data/lib/white_gold/convention/bang_nested_caller.rb

@@ -0,0 +1,48 @@
+module BangNestedCaller
+  def bang_respond_to? name
+    name.end_with?("!") && (respond_to?("#{name[...-1]}=") || respond_to?("api_bang_#{name[...-1]}") || (@bang_target && @bang_target.respond_to?(name)))
+  end
+
+  def bang_method_missing name, *a, **na, &b
+    return @bang_target.send(name, *a, **na, &b) if @bang_target && @bang_target.respond_to?(name)
+
+    api_name = "api_bang_#{name[...-1]}".to_sym
+    return send(api_name, *a, **na, &b) if respond_to? api_name
+
+    setter = "#{name[...-1]}=".to_sym
+    if respond_to? setter
+      return send(setter, a) if !a.empty?
+      return send(setter, na) if !na.empty?
+      return send(setter, b) if block_given?
+      return send(setter)
+    end
+
+    no_method_error = NoMethodError.new("undefined bang nested method `#{name}` for #{bang_object_stack.map(&:class).join("/")}")
+    raise no_method_error
+  end
+
+  def self!
+    @bang_target&.respond_to?(:self!) ? @bang_target.self! : self
+  end
+
+  def bang_object_stack root = true
+    stack = []
+    stack << self if root
+    stack << @bang_target if @bang_target
+    stack += @bang_target.bang_object_stack(false) if @bang_target&.respond_to? :bang_object_stack
+    return stack
+  end
+
+
+  def upon! item, **na, &b
+    na.each do |k, v|
+      item.send("#{k}=", v)
+    end
+    if b
+      @bang_target, original_bang_target = item, @bang_target
+      b.call item
+      @bang_target = original_bang_target
+    end
+    item
+  end
+end