dtr_core 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c7633c61c5ed0d1268fb63d2b9245037292c352e850c819e5017fab420c8044
-  data.tar.gz: 7a0dcefa916e3daecefa505c8556e75fe5047e39836a31fe893affa043745f02
+  metadata.gz: 9594c7bac85d086ec888836ba17242023cadaccc4f6d4dc268520035324e682b
+  data.tar.gz: a9cb05cd8ac136ebaf433b7f7f6c6d2fc64f60e807588b59f435a056311a2374
 SHA512:
-  metadata.gz: a2de4799a22ec515c6a23ee27e09735f6cd7043832dc3ab79b108ea68c802ddc0ae721ca78c72384712796302a2df55aee0b529c12439430b1ceaf948ee6ad79
-  data.tar.gz: 0b379f38905d1d28ea6d4dc8044622b7598383d1ee3bf627fa70f9c6d25d019506b8ab269bc99561c71bd6548afa969e3ec18621af19372bf4f441c2677b2fcd
+  metadata.gz: 189ffb27f3065aaa6d09bb5da75b693abe88236e073792aea4b0f33a609fa9383d187cbb12bf246e5bb470476bb767b4c74f60067f7cfa3e51a24383f742ff46
+  data.tar.gz: a261d658929cd4c9208f47ccebafc3d5b9b065fb328a184637fad60c843d6a000ec4cbbf736b57e9a4152be1e2433dd2bfb13b86319a653c7cec25a3d71b122a

data/lib/dtr_core/common.rb

@@ -8,11 +8,15 @@ module DTRCore
     end
 
     def split_strip_select(some_list)
-      some_list&.split("\n")&.map { |x| x&.strip }&.select { |x| x.length.positive? }
+      some_list&.split("\n")&.map(&:strip)&.select { |x| x.length.positive? }
     end
 
     def first_match_for_content(patterm)
       content.match(patterm)&.captures&.first
     end
+
+    def clean_name(definition)
+      definition.gsub(/[\*\n\[]/, '').strip
+    end
   end
 end

data/lib/dtr_core/contract.rb

@@ -11,6 +11,18 @@ module DTRCore
       @functions = functions
     end
 
+    def self.from_dtr(filepath)
+      parser = DTRCore::Parser.new(filepath)
+
+      new(parser.name_section, parser.state_section, parser.function_section)
+    end
+
+    def self.from_dtr_raw(content)
+      parser = DTRCore::Parser.new('', content:)
+
+      new(parser.name_section, parser.state_section, parser.function_section)
+    end
+
     def ==(other)
       name == other.name &&
         state == other.state &&

data/lib/dtr_core/function.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'dtr_core/common'
+
 module DTRCore
   # Represents a state in a DTR file.
   class Function
+    include ::DTRCore::Common
+
     attr_reader :name, :inputs, :output, :instructions
 
     def initialize(name, inputs, output, instructions)
@@ -12,11 +16,55 @@ module DTRCore
       @instructions = instructions
     end
 
+    def sanitize
+      @inputs = format_function_inputs(@inputs)
+      @instructions = format_function_instruction(@instructions)
+    end
+
+    def self.from_definition(definition)
+      name = definition[/\s*\[(?<all>[^\]]+)]/, 1]
+      inputs = (definition[/Inputs\s*:\s*{\s*(?<inputs>[^}]+)\s*}/, 1])
+      # TODO: check output type
+      output = definition[/Output:\s*(.+)/, 1]
+      instructions = definition[/Instructions:\s*\$(?<inputs>[^\$]+)\$/, 1]
+
+      function_object = new(name, inputs, output, instructions)
+
+      function_object.sanitize
+
+      function_object
+    end
+
     def ==(other)
       name == other.name &&
         inputs == other.inputs &&
         output == other.output &&
         instructions == other.instructions
     end
+
+    private
+
+    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/parser.rb

@@ -7,111 +7,61 @@ module DTRCore
   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)
+    def initialize(file_path, content: nil)
+      if content
+        @content = content
+      else
+        raise "Unable to find file: #{file_path}." unless File.exist?(file_path)
+
+        @content = File.read(file_path)
+      end
     end
 
-    private
-
     attr_reader :content
     attr_accessor :sections
 
-    def parse_contract_name_section
-      contract_name_section = first_match_for_content(/\[Contract\]:\s*(.+)/)
+    def name_section
+      return @name_section if @name_section
 
-      raise 'Missing contract name.' if contract_name_section.nil?
+      name_section = first_match_for_content(/\[Contract\]:\s*(.+)/)
 
-      contract_name_section
+      raise 'Missing contract name.' if name_section.nil?
+
+      @name_section ||= name_section
     end
 
-    def parse_state_section
+    def state_section
+      return @state_definitions if @state_definitions
+
       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) }
+                          .map { |definition| DTRCore::State.from_definition(definition) }
 
       raise 'Empty state section.' if state_definitions.empty?
 
-      state_definitions
+      @state_section ||= 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!
+    def function_section
+      return @function_definitions if @function_definitions
 
-      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)
+      function_definitions = function_section.split('-()').map do |x|
+        DTRCore::Function.from_definition(x.strip.to_s)
+      end
 
-      raise 'Empty function section.' if function_definitions.empty?
+      function_definitions.reject! { |x| x.name.nil? }
 
-      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
+      raise 'Empty function section.' if function_definitions.empty?
 
-    def parse_function_instruction_input(definition)
-      definition[/\s*input:\s*\((?<all>[^\)]+)\)/, 1]
-        &.split(',')&.map(&:strip)
+      @function_section ||= function_definitions
     end
   end
 end

data/lib/dtr_core/state.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require 'dtr_core/common'
+
 module DTRCore
   # Represents a state in a DTR file.
   class State
+    include ::DTRCore::Common
+
     attr_reader :name, :type, :initial_value
 
     def initialize(name, type, initial_value)
@@ -11,6 +15,25 @@ module DTRCore
       @initial_value = initial_value
     end
 
+    def sanitize
+      @name = clean_name @name
+    end
+
+    def self.from_definition(definition)
+      not_yet_cleaned_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!
+
+      state_object = new(not_yet_cleaned_name, type, initial_value)
+
+      state_object.sanitize
+
+      state_object
+    end
+
     def ==(other)
       name == other.name &&
         type == other.type &&

metadata

@@ -1,16 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: dtr_core
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - Rob Durst
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-22 00:00:00.000000000 Z
+date: 2024-05-12 00:00:00.000000000 Z
 dependencies: []
-description: A longer description of my_gem
+description: Core smart contract intermediate language (Digicus Textual Representation)
+  parser.
 email:
 - me@robdurst.com
 executables: []
@@ -25,7 +26,7 @@ files:
 - lib/dtr_core/parser.rb
 - lib/dtr_core/state.rb
 - lib/dtr_core/type_validator.rb
-homepage:
+homepage: https://spaced-out-thoughts-dev-foundation.github.io/digicus/
 licenses:
 - MIT
 metadata:
@@ -48,5 +49,6 @@ requirements: []
 rubygems_version: 3.4.10
 signing_key:
 specification_version: 4
-summary: A short summary of my_gem
+summary: Core smart contract intermediate language (Digicus Textual Representation)
+  parser.
 test_files: []