codify.rb 0.0.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7682af0469ac965e6eaabdf5f7c5dfa364117ad1a2943a22784f81a58206cc7f
-  data.tar.gz: 62bb7c7af1a464fed837c0a2056c1c7a34118526d162d6a39997c6c9728f4ce6
+  metadata.gz: 4a2fc0cfdae5034fbbd99aff7da00a1b8d985c751c902a81c109fefdb1b60955
+  data.tar.gz: fc8b11f52952a04cb4c672656c881df181eb5d854990a627bfc50ee544f75f36
 SHA512:
-  metadata.gz: f3ef22cd1cef955b5c763d6b77fe310e00511462516680b5c90c17bd1fca53a42842a38843e68f7adaa4e7eef3806a2cfc1bd55c410a229fe5f34b6f7e09409b
-  data.tar.gz: 4a9d8c8f26d2adb822bac2346828e1101415911871677c3577518a0449da03f9e057e4d622716e954c844db4ea2dc3ed4b35c49602453c3682123e1a863fba06
+  metadata.gz: 5ccea702e716c28ebcda7051bcfdb296c9d16feb0f0b1b045f6472c2e5b7355b89e711d6683c58c927e9b15bee717053f0de1b902d75240b3e372116878fda88
+  data.tar.gz: cc5573697695713655bf15db4f8e65032b9f8ca912475734e3c8a3d864cc9c827c4b5d8b3bbeb2d658f8c22e474a63d3b4da573ccf2a3060d20d101f8d46d528

data/CHANGES.md

@@ -5,4 +5,6 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
-## 0.0.0 - 2025-05-12
+## 0.1.1 - 2025-05-13
+
+## 0.1.0 - 2025-05-12

data/VERSION

@@ -1 +1 @@
-0.0.0
+0.1.1

data/lib/codify/rust/definition.rb

@@ -0,0 +1,62 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'types'
+
+class Codify::Rust::Definition
+  include Codify::Rust
+  include Type
+
+  attr_reader :name
+  attr_reader :derives
+  attr_reader :cfg_derives
+  attr_accessor :comment
+
+  ##
+  # @param [String, #to_s] name
+  # @param [Array<Symbol, #to_sym>, #to_a] derives
+  # @param [Array<Symbol, #to_sym>, #to_a] cfg_derives
+  # @param [String, #to_s] comment
+  def initialize(name, derives: %i(Debug), cfg_derives: nil, comment: nil)
+    @name = name.to_s
+    @derives = (derives || []).to_a.dup.uniq.map!(&:to_sym).sort
+    @cfg_derives = (cfg_derives || []).to_a.dup.uniq.map!(&:to_sym).sort
+    @comment = comment ? comment.to_s.strip : nil
+  end
+
+  ##
+  # @return [Boolean]
+  def comment?
+    self.comment && !self.comment.empty?
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types() [] end
+
+  ##
+  # @return [Boolean]
+  def primitive?() false end
+
+  ##
+  # @return [String]
+  def to_s() @name end
+
+  ##
+  # @return [String]
+  def to_rust_code
+    out = StringIO.new
+    write(out)
+    out.string
+  end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    out.puts wrap_text(self.comment, 80-4).map { |s| s.prepend("/// ") }.join("\n") if self.comment?
+    out.puts "#[derive(#{@derives.sort.join(", ")})]" unless @derives.empty?
+    if @cfg_derives.include?(:serde)
+      out.puts "#[cfg_attr(feature = \"serde\", derive(serde::Serialize, serde::Deserialize))]"
+    end
+  end
+end # Codify::Rust::Definition

data/lib/codify/rust/enum.rb

@@ -0,0 +1,41 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'definition'
+
+class Codify::Rust::Enum < Codify::Rust::Definition
+  attr_reader :variants
+
+  ##
+  # @param [String, #to_s] name
+  # @param [Array<EnumVariant>, #to_a] variants
+  # @param [Array<Symbol, #to_sym>, #to_a] derives
+  # @param [String, #to_s] comment
+  # @param [Proc] block
+  def initialize(name, variants: nil, **kwargs, &block)
+    super(name, **kwargs)
+    @variants = (variants || []).to_a.dup
+    block.call(self) if block_given?
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types() @variants.map(&:type).compact.uniq.to_a end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    super(out)
+    if self.variants.empty?
+      out.puts "pub struct #{@name};"
+    else
+      out.puts "pub enum #{@name} {"
+      @variants.each_with_index do |variant, i|
+        out.puts if i > 0
+        out.puts wrap_text(variant.comment, 80-8).map { |s| s.prepend("    /// ") }.join("\n") if variant.comment?
+        variant.write(out)
+      end
+      out.puts "}"
+    end
+  end
+end # Codify::Rust::Enum

data/lib/codify/rust/enum_variant.rb

@@ -0,0 +1,38 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'definition'
+
+class Codify::Rust::EnumVariant
+  include Codify::Rust
+
+  attr_reader :name, :type, :summary
+  attr_accessor :comment
+
+  def initialize(name, type = nil, &block)
+    @name = name.to_sym
+    @type = type
+    raise ArgumentError, "#{type.inspect}" unless type.nil? || type.is_a?(Type)
+    block.call(self) if block_given?
+  end
+
+  ##
+  # @return [Boolean]
+  def comment?
+    self.comment && !self.comment.empty?
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types() [@type].compact end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    if !@type
+      out.puts "    #{@name},"
+    else
+      out.puts "    #{@name}(#{@type}),"
+    end
+  end
+end # Codify::Rust::EnumVariant

data/lib/codify/rust/newtype.rb

@@ -0,0 +1,30 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'definition'
+
+class Codify::Rust::Newtype < Codify::Rust::Definition
+  ##
+  # @param [String, #to_s] name
+  # @param [Type] type
+  # @param [Array<Symbol, #to_sym>, #to_a] derives
+  # @param [String, #to_s] comment
+  # @param [Proc] block
+  def initialize(name, type, **kwargs, &block)
+    super(name, **kwargs)
+    raise ArgumentError, "#{type.inspect}" unless type.is_a?(Type)
+    @type = type
+    block.call(self) if block_given?
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types() [@type] end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    super(out)
+    out.puts "pub struct #{@name}(pub #{@type});"
+  end
+end # Codify::Rust::Newtype

data/lib/codify/rust/struct.rb

@@ -0,0 +1,42 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'definition'
+
+class Codify::Rust::Struct < Codify::Rust::Definition
+  attr_reader :fields
+
+  ##
+  # @param [String, #to_s] name
+  # @param [Array<StructField>, #to_a] fields
+  # @param [Array<Symbol, #to_sym>, #to_a] derives
+  # @param [String, #to_s] comment
+  # @param [Proc] block
+  def initialize(name, fields: nil, **kwargs, &block)
+    super(name, **kwargs)
+    @fields = (fields || []).to_a.dup
+    block.call(self) if block_given?
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types() @fields.map(&:type).uniq.to_a end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    super(out)
+    if self.fields.empty?
+      out.puts "pub struct #{@name};"
+    else
+      out.puts "pub struct #{@name} {"
+      @fields.each_with_index do |field, i|
+        out.puts if i > 0
+        out.puts wrap_text(field.comment, 80-8).map { |s| s.prepend("    /// ") }.join("\n") if field.comment?
+        out.puts "    #[cfg_attr(feature = \"serde\", serde(rename = \"#{k.id}\"))]" if false
+        field.write(out)
+      end
+      out.puts "}"
+    end
+  end
+end # Codify::Rust::Struct

data/lib/codify/rust/struct_field.rb

@@ -0,0 +1,33 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'definition'
+
+class Codify::Rust::StructField
+  include Codify::Rust
+
+  attr_reader :name, :type, :summary
+  attr_accessor :comment, :rename
+
+  def initialize(name, type, &block)
+    @name = name.to_s.gsub('[]', '').gsub('.', '_')
+    @type = type
+    raise ArgumentError, "#{type.inspect}" unless type.is_a?(Type)
+    block.call(self) if block_given?
+  end
+
+  ##
+  # @return [Boolean]
+  def comment?() self.comment && !self.comment.empty? end
+
+  ##
+  # @return [Array<Type>]
+  def types() [@type] end
+
+  ##
+  # @param [IO] out
+  # @return [void]
+  def write(out)
+    out.puts "    #[cfg_attr(feature = \"serde\", serde(rename = \"#{self.rename}\"))]" if self.rename
+    out.puts "    pub r##{@name}: #{@type},"
+  end
+end # Codify::Rust::StructField

data/lib/codify/rust/type.rb

@@ -0,0 +1,36 @@
+# This is free and unencumbered software released into the public domain.
+
+module Codify; end
+module Codify::Rust; end
+
+module Codify::Rust::Type
+  def to_rust
+    self
+  end
+
+  ##
+  # @return [Boolean]
+  def primitive?()
+    true
+  end
+
+  def definition?
+    Codify::Rust::Definition === self
+  end
+
+  ##
+  # @return [Array<Type>]
+  def types()
+    []
+  end
+
+  ##
+  # @return [void]
+  def each_subtype(&block)
+    self.types.each do |subtype|
+      raise RuntimeError, subtype.inspect unless subtype.is_a?(Codify::Rust::Type)
+      block.call(subtype) if block_given?
+      subtype.each_subtype(&block)
+    end
+  end
+end # Codify::Rust::Type

data/lib/codify/rust/types.rb

@@ -0,0 +1,76 @@
+# This is free and unencumbered software released into the public domain.
+
+require_relative 'type'
+
+module Codify::Rust::Types
+  Named = ::Struct.new('Named', :t) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Named' end
+
+    def types() [] end # NB
+    def to_s() t.to_s end
+  end
+
+  Val = ::Struct.new('Val', :t) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Val' end
+
+    def types() [] end
+    def to_s() t.to_s end
+    def inspect() t.to_s end
+  end
+
+  Bool = Val.new(:bool).freeze
+  I64 = Val.new(:i64).freeze
+  F64 = Val.new(:f64).freeze
+  String = Val.new(:String).freeze
+
+  Ref = ::Struct.new('Ref', :t) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Ref' end
+
+    def types() [t] end
+    def to_s() "&#{t}" end
+  end
+
+  Tuple0 = ::Struct.new('Unit', :m) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Unit' end
+
+    def types() [] end
+    def to_s() m ? "(/*#{m}*/)" : '()' end
+  end
+
+  Unit = Tuple0.new.freeze
+
+  Vec = ::Struct.new('Vec', :t) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Vec' end
+
+    def types() [t] end
+    def to_s() "Vec<#{t || '_'}>" end
+  end
+
+  Option = ::Struct.new('Option', :t) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Option' end
+
+    def types() [t] end
+    def to_s() "Option<#{t}>" end
+  end
+
+  Result = ::Struct.new('Result', :t, :e) do
+    include Codify::Rust::Type
+
+    def self.to_s() 'Codify::Rust::Types::Result' end
+
+    def types() [t, e] end
+    def to_s() "Result<#{t}, #{e}>" end
+  end
+end # Codify::Rust::Types

data/lib/codify/rust.rb

@@ -1 +1,13 @@
 # This is free and unencumbered software released into the public domain.
+
+module Codify; end
+module Codify::Rust; end
+
+require_relative 'rust/definition'
+require_relative 'rust/enum'
+require_relative 'rust/enum_variant'
+require_relative 'rust/newtype'
+require_relative 'rust/struct'
+require_relative 'rust/struct_field'
+require_relative 'rust/type'
+require_relative 'rust/types'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: codify.rb
 version: !ruby/object:Gem::Version
-  version: 0.0.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Arto Bendiken
 bindir: bin
 cert_chain: []
-date: 2025-05-12 00:00:00.000000000 Z
+date: 2025-05-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -50,6 +50,14 @@ files:
 - VERSION
 - lib/codify.rb
 - lib/codify/rust.rb
+- lib/codify/rust/definition.rb
+- lib/codify/rust/enum.rb
+- lib/codify/rust/enum_variant.rb
+- lib/codify/rust/newtype.rb
+- lib/codify/rust/struct.rb
+- lib/codify/rust/struct_field.rb
+- lib/codify/rust/type.rb
+- lib/codify/rust/types.rb
 - lib/codify/version.rb
 homepage: https://github.com/dryruby/codify.rb
 licenses: