codify.rb 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e9506cfef26a10d61af066ebc60f754e826e2d84ba5650e7775299c59977bce4
-  data.tar.gz: 6be8bbfae264b901dcefb186a94c28ecfbe0329566195222544f17227922eece
+  metadata.gz: 4a2fc0cfdae5034fbbd99aff7da00a1b8d985c751c902a81c109fefdb1b60955
+  data.tar.gz: fc8b11f52952a04cb4c672656c881df181eb5d854990a627bfc50ee544f75f36
 SHA512:
-  metadata.gz: cd3f75887543dc439b40a3c40b3d839a742573bdde1ffeefc0b3714cd68baf75bfe77ee9702afb8bd80aae52eb0cecebbc5111b02aa9cd59b11f7c1db001253d
-  data.tar.gz: 439a9352e3dc039ab923cfa194ea68fc9c66695ae0edeb988353de2b2d9619c89825516537b78a52af91ab172c8b1d6d128db56468db298b68b8a406abf50d14
+  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.1.1 - 2025-05-13
+
 ## 0.1.0 - 2025-05-12

data/VERSION

@@ -1 +1 @@
-0.1.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

@@ -3,283 +3,11 @@
 module Codify; end
 module Codify::Rust; end
 
-module Codify::Rust::Type
-  def definition?
-    Codify::Rust::Definition === self
-  end
-
-  ##
-  # @return [Boolean]
-  def primitive?() true 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
-
-module Codify::Rust::Types
-  Named = ::Struct.new('Named', :t) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [] } # NB
-    type.define_method(:to_s) { t.to_s }
-  end
-
-  Val = ::Struct.new('Val', :t) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [] }
-    type.define_method(:to_s) { t.to_s }
-  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 |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [t] }
-    type.define_method(:to_s) { "&#{t}" }
-  end
-
-  Unit = ::Struct.new('Unit', :m) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [] }
-    type.define_method(:to_s) { m ? "(/*#{m}*/)" : "()" }
-  end
-
-  Vec = ::Struct.new('Vec', :t) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [t] }
-    type.define_method(:to_s) { "Vec<#{t}>" }
-  end
-
-  Option = ::Struct.new('Option', :t) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [t] }
-    type.define_method(:to_s) { "Option<#{t}>" }
-  end
-
-  Result = ::Struct.new('Result', :t, :e) do |type|
-    include Codify::Rust::Type
-    type.define_method(:types) { [t, e] }
-    type.define_method(:to_s) { "Result<#{t}, #{e}>" }
-  end
-end # Codify::Rust::Types
-
-module Codify::Rust
-  class Definition
-    include Codify::Rust::Type
-
-    attr_reader :name
-    attr_reader :derives
-    attr_accessor :comment
-
-    ##
-    # @param [String, #to_s] name
-    # @param [Array<Symbol, #to_sym>, #to_a] derives
-    # @param [String, #to_s] comment
-    def initialize(name, derives: nil, comment: nil)
-      @name = name.to_s
-      @derives = (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
-
-    ##
-    # @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?
-      out.puts "#[cfg_attr(feature = \"serde\", derive(serde::Serialize, serde::Deserialize))]"
-    end
-  end # Definition
-
-  class Newtype < 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, derives: %i(Clone Debug), comment: nil, &block)
-      super(name, derives:, comment:)
-      raise ArgumentError, "#{type.inspect}" unless type.is_a?(Rust::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 # Struct
-
-  class Struct < Definition
-    attr_reader :fields
-
-    ##
-    # @param [String, #to_s] name
-    # @param [Array<Field>, #to_a] fields
-    # @param [Array<Symbol, #to_sym>, #to_a] derives
-    # @param [String, #to_s] comment
-    # @param [Proc] block
-    def initialize(name, fields: nil, derives: nil, comment: nil, &block)
-      super(name, derives:, comment:)
-      @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 # Struct
-
-  class Enum < Definition
-    attr_reader :variants
-
-    ##
-    # @param [String, #to_s] name
-    # @param [Array<Variant>, #to_a] variants
-    # @param [Array<Symbol, #to_sym>, #to_a] derives
-    # @param [String, #to_s] comment
-    # @param [Proc] block
-    def initialize(name, variants: nil, derives: nil, comment: nil, &block)
-      super(name, derives:, comment:)
-      @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 # Enum
-
-  class Field
-    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?(Rust::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 # Field
-
-  class Variant
-    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?(Rust::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 # Variant
-end # Codify::Rust
+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.1.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: