template-ruby 0.5.6 → 0.6.0

data/lib/code/ruby.rb

@@ -1,174 +0,0 @@
-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 nil?
-        ::Code::Object::Nothing.new
-      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(element) }
-        )
-      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_nothing?
-          raw.raw
-        elsif 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.from_code(key), ::Code::Ruby.from_code(value)]
-            end
-            .to_h
-        elsif code_list?
-          raw.raw.map { |element| ::Code::Ruby.from_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 nil?
-      raw.is_a?(::NilClass)
-    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_nothing?
-      raw.is_a?(::Code::Object::Nothing)
-    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,10 +0,0 @@
-require "bigdecimal"
-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,47 +0,0 @@
-class Code
-  EMPTY_STRING = ""
-  GLOBALS = %i[io context object]
-  DEFAULT_TIMEOUT = Template::DEFAULT_TIMEOUT
-
-  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
-    @input = 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: 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 != 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, :ruby
-end

data/lib/language/atom.rb

@@ -1,342 +0,0 @@
-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)
-
-        @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

@@ -1,130 +0,0 @@
-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

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

data/lib/language/parser/absent.rb

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

data/lib/language/parser/end_of_input.rb

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