dtr_core 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6c7633c61c5ed0d1268fb63d2b9245037292c352e850c819e5017fab420c8044
+  data.tar.gz: 7a0dcefa916e3daecefa505c8556e75fe5047e39836a31fe893affa043745f02
+SHA512:
+  metadata.gz: a2de4799a22ec515c6a23ee27e09735f6cd7043832dc3ab79b108ea68c802ddc0ae721ca78c72384712796302a2df55aee0b529c12439430b1ceaf948ee6ad79
+  data.tar.gz: 0b379f38905d1d28ea6d4dc8044622b7598383d1ee3bf627fa70f9c6d25d019506b8ab269bc99561c71bd6548afa969e3ec18621af19372bf4f441c2677b2fcd

data/lib/dtr_core/common.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module DTRCore
+  # Common methods used by the DTRCore module.
+  module Common
+    def strip_and_remove_quotes(str)
+      str.strip.gsub(/['"]/, '')
+    end
+
+    def split_strip_select(some_list)
+      some_list&.split("\n")&.map { |x| x&.strip }&.select { |x| x.length.positive? }
+    end
+
+    def first_match_for_content(patterm)
+      content.match(patterm)&.captures&.first
+    end
+  end
+end

data/lib/dtr_core/contract.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DTRCore
+  # Represents a contract in a DTR file.
+  class Contract
+    attr_reader :functions, :name, :state
+
+    def initialize(name, state, functions)
+      @name = name
+      @state = state
+      @functions = functions
+    end
+
+    def ==(other)
+      name == other.name &&
+        state == other.state &&
+        functions == other.functions
+    end
+  end
+end

data/lib/dtr_core/function.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module DTRCore
+  # Represents a state in a DTR file.
+  class Function
+    attr_reader :name, :inputs, :output, :instructions
+
+    def initialize(name, inputs, output, instructions)
+      @name = name
+      @inputs = inputs
+      @output = output
+      @instructions = instructions
+    end
+
+    def ==(other)
+      name == other.name &&
+        inputs == other.inputs &&
+        output == other.output &&
+        instructions == other.instructions
+    end
+  end
+end

data/lib/dtr_core/number.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module DTRCore
+  module Number
+    MIN_U32 = 0
+    MAX_U32 = (2**32) - 1
+
+    MIN_U64 = 0
+    MAX_U64 = (2**64) - 1
+
+    MIN_U256 = 0
+    MAX_U256 = (2**256) - 1
+
+    MIN_I32 = -2**31
+    MAX_I32 = (2**31) - 1
+
+    MIN_I64 = -2**63
+    MAX_I64 = (2**63) - 1
+
+    MIN_I256 = -2**255
+    MAX_I256 = (2**255) - 1
+  end
+end

data/lib/dtr_core/parser.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require 'dtr_core/common'
+
+module DTRCore
+  # Parses a DTR file and returns a Contract object.
+  class Parser
+    include ::DTRCore::Common
+
+    def initialize(file_path)
+      raise "Unable to find file: #{file_path}." unless File.exist?(file_path)
+
+      @content = File.read(file_path)
+    end
+
+    def self.parse(file_path)
+      new(file_path).parse
+    end
+
+    def parse
+      DTRCore::Contract.new(parse_contract_name_section, parse_state_section, parse_function_section)
+    end
+
+    private
+
+    attr_reader :content
+    attr_accessor :sections
+
+    def parse_contract_name_section
+      contract_name_section = first_match_for_content(/\[Contract\]:\s*(.+)/)
+
+      raise 'Missing contract name.' if contract_name_section.nil?
+
+      contract_name_section
+    end
+
+    def parse_state_section
+      state_section = first_match_for_content(/\[State\]:\s*((?:\s*\*\s*\[.+?\]\n(?:\s*  \* .+\n?)*)*)/)
+
+      return nil if state_section.nil?
+
+      state_definitions = state_section
+                          .split(/\n\s*\*\s*\[/).map { |x| "[#{x.strip}" }
+                          .map { |definition| state_definition_to_state_object(definition) }
+
+      raise 'Empty state section.' if state_definitions.empty?
+
+      state_definitions
+    end
+
+    def clean_state_definition_name(definition)
+      definition.gsub(/[\*\n\[]/, '').strip
+    end
+
+    def state_definition_to_state_object(definition)
+      name = clean_state_definition_name definition[/^\[([^\]]+)\]/, 1]
+
+      type = definition[/Type:\s*(\w+)/, 1]
+
+      initial_value = DTRCore::TypeValidator.new(type, definition[/Initial Value:\s*(.+)/, 1])
+                                            .validate_then_coerce_initial_value!
+
+      DTRCore::State.new(name, type, initial_value)
+    end
+
+    def parse_function_section
+      function_section = first_match_for_content(/\[Functions\]:(?<all>.*):\[Functions\]/m)
+
+      return nil if function_section.nil?
+
+      function_definitions = parse_parse_function_section(function_section)
+
+      raise 'Empty function section.' if function_definitions.empty?
+
+      function_definitions
+    end
+
+    def parse_parse_function_section(function_section)
+      function_section.split('-()')
+                      .map { |x| function_definition_to_function_object(x.strip.to_s) }
+                      .reject { |x| x.name.nil? }
+    end
+
+    def function_definition_to_function_object(definition)
+      name = definition[/\s*\[(?<all>[^\]]+)]/, 1]
+      inputs = format_function_inputs(definition[/Inputs\s*:\s*{\s*(?<inputs>[^}]+)\s*}/, 1])
+      # TODO: check output type
+      output = definition[/Output:\s*(.+)/, 1]
+      instructions = format_function_instruction(definition[/Instructions:\s*\$(?<inputs>[^\$]+)\$/, 1])
+
+      DTRCore::Function.new(name, inputs, output, instructions)
+    end
+
+    def format_function_inputs(inputs)
+      return [] if inputs.nil?
+
+      split_strip_select(inputs).map { |x| { name: x.split(':')[0].strip, type_name: x.split(':')[1].strip } }
+    end
+
+    def format_function_instruction(instructions)
+      split_strip_select(instructions)&.map { |instruction| parse_function_instruction(instruction) }
+    end
+
+    def parse_function_instruction(instruction)
+      {
+        instruction: instruction[/instruction:\s*(?<all>[^\s,]+)/, 1],
+        inputs: parse_function_instruction_input(instruction),
+        assign: instruction[/\s*assign:\s*(?<all>[^\s\,]+)/, 1]
+      }
+    end
+
+    def parse_function_instruction_input(definition)
+      definition[/\s*input:\s*\((?<all>[^\)]+)\)/, 1]
+        &.split(',')&.map(&:strip)
+    end
+  end
+end

data/lib/dtr_core/state.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module DTRCore
+  # Represents a state in a DTR file.
+  class State
+    attr_reader :name, :type, :initial_value
+
+    def initialize(name, type, initial_value)
+      @name = name
+      @type = type
+      @initial_value = initial_value
+    end
+
+    def ==(other)
+      name == other.name &&
+        type == other.type &&
+        initial_value == other.initial_value
+    end
+  end
+end

data/lib/dtr_core/type_validator.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+require 'dtr_core/common'
+
+module DTRCore
+  # Type validator for DTR types.
+  class TypeValidator
+    include ::DTRCore::Common
+
+    def initialize(type_name, initial_value)
+      @type_name = type_name
+      @initial_value = initial_value
+    end
+
+    def validate_then_coerce_initial_value!
+      raise 'Missing Type Name.' if @type_name.nil?
+      raise 'Missing Initial Value.' if @initial_value.nil?
+
+      case @type_name
+      when 'I32', 'I64', 'I256', 'U32', 'U64', 'U256'
+        validate_numeric!
+
+      # TODO: check type
+      when 'Symbol'
+        strip_and_remove_quotes(@initial_value)
+      else
+        raise 'Missing Invalid Type Name.'
+      end
+    end
+
+    private
+
+    def validate_numeric!
+      raise 'Invalid initial value for type. Wrong type.' unless @initial_value =~ (/^[\-\.\d]\d*(\.?\d*)*/)
+
+      raise "Invalid initial value for type #{@type_name}. Out of range." unless @initial_value.to_i.between?(
+        DTRCore::Number.const_get(:"MIN_#{@type_name}"), DTRCore::Number.const_get(:"MAX_#{@type_name}")
+      )
+
+      @initial_value.to_i
+    end
+  end
+end

data/lib/dtr_core.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Core logic for consuming Digicus Textual Representation (DTR) files.
+module DTRCore
+  autoload :Contract, 'dtr_core/contract'
+  autoload :Function, 'dtr_core/function'
+  autoload :Number, 'dtr_core/number'
+  autoload :Parser, 'dtr_core/parser'
+  autoload :State, 'dtr_core/state'
+  autoload :TypeValidator, 'dtr_core/type_validator'
+
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,52 @@
+--- !ruby/object:Gem::Specification
+name: dtr_core
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Rob Durst
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-04-22 00:00:00.000000000 Z
+dependencies: []
+description: A longer description of my_gem
+email:
+- me@robdurst.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dtr_core.rb
+- lib/dtr_core/common.rb
+- lib/dtr_core/contract.rb
+- lib/dtr_core/function.rb
+- lib/dtr_core/number.rb
+- lib/dtr_core/parser.rb
+- lib/dtr_core/state.rb
+- lib/dtr_core/type_validator.rb
+homepage:
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.2.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.10
+signing_key:
+specification_version: 4
+summary: A short summary of my_gem
+test_files: []