code-ruby 0.3.1 → 0.5.0

data/lib/code/ruby.rb

@@ -0,0 +1,162 @@
+class Code
+  class Ruby
+    def initialize(raw = {})
+      @raw = raw
+    end
+
+    def self.to_code(raw)
+      new(raw).to_code
+    end
+
+    def self.from_code(raw)
+      new(raw).from_code
+    end
+
+    def to_code
+      if code?
+        raw
+      elsif true?
+        ::Code::Object::Boolean.new(raw)
+      elsif false?
+        ::Code::Object::Boolean.new(raw)
+      elsif string?
+        ::Code::Object::String.new(raw)
+      elsif symbol?
+        ::Code::Object::String.new(raw.to_s)
+      elsif integer?
+        ::Code::Object::Integer.new(raw)
+      elsif float?
+        ::Code::Object::Decimal.new(raw.to_s)
+      elsif big_decimal?
+        ::Code::Object::Decimal.new(raw)
+      elsif hash?
+        ::Code::Object::Dictionnary.new(
+          raw
+            .map do |key, value|
+              [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+            end
+            .to_h
+        )
+      elsif array?
+        ::Code::Object::List.new(
+          raw.map { |element| ::Code::Ruby.to_code(key) }
+        )
+      elsif proc?
+        ::Code::Object::RubyFunction.new(raw)
+      else
+        raise "Unsupported class #{raw.class} for Ruby to Code conversion"
+      end
+    end
+
+    def from_code
+      if code?
+        if code_boolean?
+          raw.raw
+        elsif code_decimal?
+          raw.raw
+        elsif code_integer?
+          raw.raw
+        elsif code_nothing?
+          raw.raw
+        elsif code_range?
+          raw.raw
+        elsif code_string?
+          raw.raw
+        elsif code_dictionnary?
+          raw
+            .raw
+            .map do |key, value|
+              [::Code::Ruby.to_code(key), ::Code::Ruby.to_code(value)]
+            end
+            .to_h
+        elsif code_list?
+          raw.raw.map { |element| ::Code::Ruby.to_code(element) }
+        else
+          raise "Unsupported class #{raw.class} for Code to Ruby conversion"
+        end
+      else
+        raw
+      end
+    end
+
+    private
+
+    attr_reader :raw
+
+    def code?
+      raw.is_a?(::Code::Object)
+    end
+
+    def true?
+      raw.is_a?(::TrueClass)
+    end
+
+    def false?
+      raw.is_a?(::FalseClass)
+    end
+
+    def hash?
+      raw.is_a?(::Hash)
+    end
+
+    def array?
+      raw.is_a?(::Array)
+    end
+
+    def string?
+      raw.is_a?(::String)
+    end
+
+    def symbol?
+      raw.is_a?(::Symbol)
+    end
+
+    def integer?
+      raw.is_a?(::Integer)
+    end
+
+    def float?
+      raw.is_a?(::Float)
+    end
+
+    def big_decimal?
+      raw.is_a?(::BigDecimal)
+    end
+
+    def proc?
+      raw.is_a?(::Proc)
+    end
+
+    def code_boolean?
+      raw.is_a?(::Code::Object::Boolean)
+    end
+
+    def code_decimal?
+      raw.is_a?(::Code::Object::Decimal)
+    end
+
+    def code_integer?
+      raw.is_a?(::Code::Object::Integer)
+    end
+
+    def code_nothing?
+      raw.is_a?(::Code::Object::Nothing)
+    end
+
+    def code_range?
+      raw.is_a?(::Code::Object::Range)
+    end
+
+    def code_string?
+      raw.is_a?(::Code::Object::String)
+    end
+
+    def code_dictionnary?
+      raw.is_a?(::Code::Object::Dictionnary)
+    end
+
+    def code_list?
+      raw.is_a?(::Code::Object::List)
+    end
+  end
+end

data/lib/code-ruby.rb

@@ -1,13 +1,10 @@
-require "parslet"
-require "zeitwerk"
 require "bigdecimal"
-require "active_support"
-require "active_support/core_ext/object/blank"
-require "active_support/core_ext/object/deep_dup"
 require "stringio"
 require "timeout"
+require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
 loader.ignore("#{__dir__}/template-ruby.rb")
 loader.ignore("#{__dir__}/code-ruby.rb")
+loader.ignore("#{__dir__}/language-ruby.rb")
 loader.setup

data/lib/code.rb

@@ -1,30 +1,47 @@
 class Code
+  EMPTY_STRING = ""
+  GLOBALS = %i[io context object]
   DEFAULT_TIMEOUT = Template::DEFAULT_TIMEOUT
 
-  def initialize(input, io: $stdout, timeout: DEFAULT_TIMEOUT)
+  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
     @input = input
-    @parsed = Timeout.timeout(timeout) { ::Code::Parser::Code.new.parse(@input) }
+    @parsed = Timeout.timeout(timeout) { ::Code::Parser.parse(@input).to_raw }
     @io = io
     @timeout = timeout || DEFAULT_TIMEOUT
+    @ruby = ::Code::Ruby.to_code(ruby || {})
   end
 
-  def self.evaluate(input, context = "", io: $stdout, timeout: DEFAULT_TIMEOUT)
-    new(input, io: io, timeout: timeout).evaluate(context)
+  def self.evaluate(
+    input,
+    context = "",
+    io: StringIO.new,
+    timeout: DEFAULT_TIMEOUT,
+    ruby: {}
+  )
+    new(input, io: io, timeout: timeout, ruby: ruby).evaluate(context)
   end
 
   def evaluate(context = "")
     Timeout.timeout(timeout) do
-      if context.present?
-        context = ::Code.evaluate(context, timeout: timeout)
+      if context != EMPTY_STRING
+        context = ::Code.evaluate(context, timeout: timeout, io: io, ruby: ruby)
       else
         context = ::Code::Object::Dictionnary.new
       end
 
+      if !context.is_a?(::Code::Object::Dictionnary)
+        raise ::Code::Error::IncompatibleContext.new(
+                "context must be a dictionnary"
+              )
+      end
+
+      context = context.merge(ruby)
+
       ::Code::Node::Code.new(parsed).evaluate(context: context, io: io)
     end
   end
 
   private
 
-  attr_reader :input, :parsed, :timeout, :io
+  attr_reader :input, :parsed, :timeout, :io, :ruby
 end

data/lib/language/atom.rb

@@ -0,0 +1,343 @@
+class Language
+  class Atom
+    class Rule < Atom
+      def initialize(name:)
+        @name = name
+      end
+
+      def parse(parser)
+        parser.find_rule!(@name).parse(parser)
+      end
+
+      def to_s
+        "rule(#{@name.inspect})"
+      end
+    end
+
+    class Any < Atom
+      def parse(parser)
+        parser.consume(1)
+      end
+
+      def to_s
+        "any"
+      end
+    end
+
+    class Then < Atom
+      def initialize(parent:, block:)
+        @parent = parent
+        @block = block
+      end
+
+      def parse(parser)
+        @parent.parse(parser)
+        parser.output = Output.from_raw(@block.call(parser.output.to_raw))
+      end
+
+      def to_s
+        "(#{@parent}).then {}"
+      end
+    end
+
+    class Repeat < Atom
+      def initialize(parent: nil, min: 0, max: nil)
+        @parent = parent
+        @min = min
+        @max = max
+      end
+
+      def parse(parser)
+        return unless @parent
+
+        if @max.nil?
+          @min.times { match(parser) }
+
+          begin
+            loop { match(parser) }
+          rescue Parser::Interuption
+          end
+        else
+          @min.times { match(parser) }
+
+          begin
+            (@max - @min).times { match(parser) }
+          rescue Parser::Interuption
+          end
+        end
+      end
+
+      def to_s
+        min = @min.zero? ? "" : @min.to_s
+        max = @max.nil? ? "" : ", #{@max}"
+        parenthesis = min.empty? && max.empty? ? "" : "(#{min}#{max})"
+
+        @parent ? "(#{@parent}).repeat#{parenthesis}" : "repeat#{parenthesis}"
+      end
+
+      private
+
+      def match(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        @parent.parse(clone)
+
+        parser.cursor = clone.cursor
+        parser.buffer = clone.buffer
+        parser.output << clone.output
+      end
+    end
+
+    class Str < Atom
+      def initialize(string:)
+        @string = string
+      end
+
+      def parse(parser)
+        if parser.next?(@string)
+          parser.consume(@string.size)
+        else
+          raise Parser::Str::NotFound.new(parser, @string)
+        end
+      end
+
+      def to_s
+        "str(#{@string.inspect})"
+      end
+    end
+
+    class Absent < Atom
+      def initialize(parent: nil)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @parent.parse(clone) if @parent
+      rescue Parser::Interuption
+      else
+        raise Parser::Interuption.new(parser, self)
+      end
+
+      def to_s
+        @parent ? "(#{@parent}).absent" : "absent"
+      end
+    end
+
+    class Ignore < Atom
+      def initialize(parent: nil)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @parent.parse(clone) if @parent
+        parser.cursor = clone.cursor
+      end
+
+      def to_s
+        @parent ? "#{@parent}.ignore" : "ignore"
+      end
+    end
+
+    class Maybe < Atom
+      def initialize(parent:)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        @parent.parse(clone)
+      rescue Parser::Interuption
+      else
+        parser.cursor = clone.cursor
+        parser.output = clone.output
+      end
+
+      def to_s
+        @parent ? "#{@parent}.maybe" : "maybe"
+      end
+    end
+
+    class Aka < Atom
+      def initialize(name:, parent:)
+        @name = name
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(root: self, input: parser.input, cursor: parser.cursor)
+
+        require "colorize"
+        @parent.parse(clone)
+
+        if clone.output?
+          parser.output = Output.new(@name => clone.output)
+        else
+          parser.output[@name] = Output.new(clone.buffer)
+          parser.buffer = ""
+        end
+
+        parser.cursor = clone.cursor
+      end
+
+      def to_s
+        @parent ? "#{@parent}.aka(#{@name.inspect})" : "aka(#{@name.inspect})"
+      end
+    end
+
+    class Or < Atom
+      def initialize(left:, right:)
+        @left = left
+        @right = right
+      end
+
+      def parse(parser)
+        left_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        right_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        begin
+          @left.parse(left_clone)
+          parser.cursor = left_clone.cursor
+          parser.buffer = left_clone.buffer
+          parser.output.merge(left_clone.output)
+        rescue Parser::Interuption
+          @right.parse(right_clone)
+          parser.cursor = right_clone.cursor
+          parser.buffer = right_clone.buffer
+          parser.output.merge(right_clone.output)
+        end
+      end
+
+      def to_s
+        "((#{@left}) | (#{@right}))"
+      end
+    end
+
+    class And < Atom
+      def initialize(left:, right:)
+        @left = left
+        @right = right
+      end
+
+      def parse(parser)
+        @left.parse(parser)
+        right_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @right.parse(right_clone)
+        parser.cursor = right_clone.cursor
+        parser.buffer = right_clone.buffer
+
+        parser.output.merge(right_clone.output)
+      end
+
+      def to_s
+        "#{@left} >> #{@right}".to_s
+      end
+    end
+
+    def any
+      Any.new
+    end
+
+    def str(string)
+      Str.new(string: string)
+    end
+
+    def absent
+      Absent.new(parent: self)
+    end
+
+    def ignore
+      Ignore.new(parent: self)
+    end
+
+    def maybe
+      Maybe.new(parent: self)
+    end
+
+    def repeat(min = 0, max = nil)
+      Repeat.new(parent: self, min: min, max: max)
+    end
+
+    def aka(name)
+      Aka.new(parent: self, name: name)
+    end
+
+    def |(other)
+      Or.new(left: self, right: other)
+    end
+
+    def >>(other)
+      And.new(left: self, right: other)
+    end
+
+    def <<(other)
+      And.new(left: self, right: other)
+    end
+
+    def then(&block)
+      Then.new(parent: self, block: block)
+    end
+
+    def rule(name)
+      Rule.new(name: name)
+    end
+
+    def parse(parser)
+      raise NotImplementedError.new("#{self.class}#parse")
+    end
+
+    def to_s
+      ""
+    end
+
+    def inspect
+      to_s
+    end
+  end
+end

data/lib/language/output.rb

@@ -0,0 +1,130 @@
+class Language
+  class Output
+    attr_reader :raw
+
+    def initialize(raw = nil)
+      @raw = raw
+    end
+
+    def self.from_raw(raw)
+      if raw.is_a?(Array)
+        new(raw.map { |element| from_raw(element) })
+      elsif raw.is_a?(Hash)
+        new(raw.map { |key, value| [key, from_raw(value)] }.to_h)
+      else
+        new(raw)
+      end
+    end
+
+    def to_raw
+      if raw.is_a?(Array)
+        raw.map(&:to_raw)
+      elsif raw.is_a?(Hash)
+        raw.map { |key, value| [key, value.to_raw] }.to_h
+      else
+        raw
+      end
+    end
+
+    def clone
+      Output.new(@raw.clone)
+    end
+
+    def present?
+      @raw != nil
+    end
+
+    def ==(other)
+      other.is_a?(Output) ? raw == other.raw : raw == other
+    end
+
+    def to_s
+      raw.to_s
+    end
+
+    def inspect
+      raw.inspect
+    end
+
+    def []=(key, value)
+      case @raw
+      when NilClass
+        @raw = { key => value }
+      when String
+        @raw = { key => value }
+      when Array
+        @raw << Output.new({ key => value })
+      when Hash
+        @raw[key] = value
+      end
+    end
+
+    def merge(other)
+      case @raw
+      when NilClass
+        @raw = other.raw
+      when String
+        case other.raw
+        when String
+          @raw = @raw + other.raw
+        when Array
+          @raw = other.raw
+        when Hash
+          @raw = other.raw
+        end
+      when Array
+        case other.raw
+        when String
+          return
+        when Array
+          @raw = @raw + other.raw
+        when Hash
+          @raw << other
+        end
+      when Hash
+        case other.raw
+        when String
+          return
+        when Array
+          return
+        when Hash
+          @raw.merge!(other.raw)
+        end
+      end
+    end
+
+    def <<(other)
+      case @raw
+      when NilClass
+        case other.raw
+        when String
+          @raw = [other]
+        when Array
+          @raw = [other]
+        when Hash
+          @raw = [other]
+        end
+      when String
+        case other.raw
+        when String
+          @raw = @raw + other.raw
+        when Array
+          @raw = [other]
+        when Hash
+          @raw = [other]
+        end
+      when Array
+        @raw << other
+      when Hash
+        case other.raw
+        when String
+          return
+        when Array
+          return
+        when Hash
+          @raw.merge!(other.raw)
+        end
+      end
+    end
+  end
+end

data/lib/language/parser/absent/present.rb

@@ -0,0 +1,8 @@
+class Language
+  class Parser
+    class Absent
+      class Present < Interuption
+      end
+    end
+  end
+end

data/lib/language/parser/absent.rb

@@ -0,0 +1,6 @@
+class Language
+  class Parser
+    class Absent
+    end
+  end
+end

data/lib/language/parser/end_of_input.rb

@@ -0,0 +1,6 @@
+class Language
+  class Parser
+    class EndOfInput < Interuption
+    end
+  end
+end