language-ruby 0.5.6 → 0.6.0

data/lib/code/parser/shift.rb

@@ -1,21 +0,0 @@
-class Code
-  class Parser
-    class Shift < Operation
-      def statement
-        ::Code::Parser::Addition
-      end
-
-      def greater
-        str(">")
-      end
-
-      def lesser
-        str("<")
-      end
-
-      def operator
-        (greater << greater) | (lesser << lesser)
-      end
-    end
-  end
-end

data/lib/code/parser/splat.rb

@@ -1,31 +0,0 @@
-class Code
-  class Parser
-    class Splat < Language
-      def statement
-        ::Code::Parser::Class
-      end
-
-      def splat
-        ::Code::Parser::Splat
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def ampersand
-        str("&")
-      end
-
-      def root
-        (ampersand.aka(:operator) << whitespace? << splat.aka(:right)).aka(
-          :splat
-        ) | statement
-      end
-    end
-  end
-end

data/lib/code/parser/statement.rb

@@ -1,9 +0,0 @@
-class Code
-  class Parser
-    class Statement < Language
-      def root
-        ::Code::Parser::Equality
-      end
-    end
-  end
-end

data/lib/code/parser/string.rb

@@ -1,78 +0,0 @@
-class Code
-  class Parser
-    class String < Language
-      def code
-        ::Code::Parser::Code
-      end
-
-      def name
-        ::Code::Parser::Name
-      end
-
-      def single_quote
-        str("'")
-      end
-
-      def double_quote
-        str('"')
-      end
-
-      def backslash
-        str("\\")
-      end
-
-      def opening_curly_bracket
-        str("{")
-      end
-
-      def closing_curly_bracket
-        str("}")
-      end
-
-      def colon
-        str(":")
-      end
-
-      def code_part
-        opening_curly_bracket << code << closing_curly_bracket.maybe
-      end
-
-      def single_quoted_text_part
-        (
-          backslash.ignore << opening_curly_bracket |
-            backslash.ignore << single_quote |
-            single_quote.absent << opening_curly_bracket.absent << any
-        ).repeat(1)
-      end
-
-      def double_quoted_text_part
-        (
-          backslash.ignore << opening_curly_bracket |
-            backslash.ignore << double_quote |
-            double_quote.absent << opening_curly_bracket.absent << any
-        ).repeat(1)
-      end
-
-      def single_quoted_string
-        single_quote.ignore <<
-          (code_part.aka(:code) | single_quoted_text_part.aka(:text)).repeat <<
-          single_quote.ignore.maybe
-      end
-
-      def double_quoted_string
-        double_quote.ignore <<
-          (code_part.aka(:code) | double_quoted_text_part.aka(:text)).repeat <<
-          double_quote.ignore.maybe
-      end
-
-      def symbol
-        (colon.ignore << name).aka(:text).repeat(1, 1)
-      end
-
-      def root
-        (single_quoted_string | double_quoted_string | symbol).aka(:string) |
-          ::Code::Parser::Number
-      end
-    end
-  end
-end

data/lib/code/parser/ternary.rb

@@ -1,46 +0,0 @@
-class Code
-  class Parser
-    class Ternary < Language
-      def statement
-        ::Code::Parser::Range
-      end
-
-      def ternary
-        ::Code::Parser::Ternary
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def question_mark
-        str("?")
-      end
-
-      def colon
-        str(":")
-      end
-
-      def root
-        (
-          statement.aka(:left) <<
-            (
-              whitespace? << question_mark << whitespace? <<
-                ternary.aka(:middle) <<
-                (
-                  whitespace? << colon << whitespace? << ternary.aka(:right)
-                ).maybe
-            ).maybe
-        )
-          .aka(:ternary)
-          .then do |output|
-            output[:ternary][:middle] ? output : output[:ternary][:left]
-          end
-      end
-    end
-  end
-end

data/lib/code/parser/unary_minus.rb

@@ -1,31 +0,0 @@
-class Code
-  class Parser
-    class UnaryMinus < Language
-      def unary_minus
-        ::Code::Parser::UnaryMinus
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def whitespace?
-        whitespace.maybe
-      end
-
-      def minus
-        str("-")
-      end
-
-      def operator
-        minus
-      end
-
-      def root
-        (operator.aka(:operator) << whitespace? << unary_minus.aka(:right)).aka(
-          :unary_minus
-        ) | ::Code::Parser::Power
-      end
-    end
-  end
-end

data/lib/code/parser/while.rb

@@ -1,36 +0,0 @@
-class Code
-  class Parser
-    class While < Language
-      def statement
-        ::Code::Parser::If
-      end
-
-      def whitespace
-        ::Code::Parser::Whitespace
-      end
-
-      def code
-        ::Code::Parser::Code
-      end
-
-      def while_keyword
-        str("while")
-      end
-
-      def until_keyword
-        str("until")
-      end
-
-      def end_keyword
-        str("end")
-      end
-
-      def root
-        (
-          (while_keyword | until_keyword).aka(:operator) << whitespace <<
-            statement.aka(:statement) << code.aka(:body) << end_keyword.maybe
-        ).aka(:while) | statement
-      end
-    end
-  end
-end

data/lib/code/parser/whitespace.rb

@@ -1,49 +0,0 @@
-class Code
-  class Parser
-    class Whitespace < Language
-      def space
-        str(" ")
-      end
-
-      def newline
-        str("\n")
-      end
-
-      def hashtag
-        str("#")
-      end
-
-      def slash
-        str("/")
-      end
-
-      def asterisk
-        str("*")
-      end
-
-      def hash_comment
-        hashtag << (newline.absent << any).repeat << newline.maybe
-      end
-
-      def double_slash_comment
-        slash << slash << (newline.absent << any).repeat << newline.maybe
-      end
-
-      def multi_line_comment
-        slash << asterisk << ((asterisk << slash).absent << any).repeat <<
-          asterisk.maybe << slash.maybe
-      end
-
-      def without_newline
-        (space | multi_line_comment).repeat(1)
-      end
-
-      def root
-        (
-          space | newline | hash_comment | double_slash_comment |
-            multi_line_comment
-        ).repeat(1)
-      end
-    end
-  end
-end

data/lib/code/parser.rb

@@ -1,19 +0,0 @@
-class Code
-  class Parser
-    def initialize(input)
-      @input = input
-    end
-
-    def self.parse(input)
-      new(input).parse
-    end
-
-    def parse
-      ::Code::Parser::Code.parse(input)
-    end
-
-    private
-
-    attr_reader :input
-  end
-end

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/template/node/code_part.rb

@@ -1,13 +0,0 @@
-class Template
-  class Node
-    class CodePart < Node
-      def initialize(code)
-        @code = ::Code::Node::Code.new(code)
-      end
-
-      def evaluate(**args)
-        @code.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/template/node/part.rb

@@ -1,19 +0,0 @@
-class Template
-  class Node
-    class Part < Node
-      def initialize(part)
-        if part.key?(:text)
-          @part = ::Template::Node::TextPart.new(part[:text])
-        elsif part.key?(:code)
-          @part = ::Template::Node::CodePart.new(part[:code])
-        else
-          raise NotImplementedError.new(part.inspect)
-        end
-      end
-
-      def evaluate(**args)
-        @part.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/template/node/template.rb

@@ -1,15 +0,0 @@
-class Template
-  class Node
-    class Template < Node
-      def initialize(parts)
-        @parts = parts.map { |part| ::Template::Node::Part.new(part) }
-      end
-
-      def evaluate(**args)
-        io = args.fetch(:io)
-
-        @parts.each { |part| io.print(part.evaluate(**args)) }
-      end
-    end
-  end
-end

data/lib/template/node/text_part.rb

@@ -1,13 +0,0 @@
-class Template
-  class Node
-    class TextPart < Node
-      def initialize(text)
-        @text = text
-      end
-
-      def evaluate(**args)
-        ::Code::Object::String.new(@text.to_s)
-      end
-    end
-  end
-end

data/lib/template/node.rb

@@ -1,4 +0,0 @@
-class Template
-  class Node < ::Code::Node
-  end
-end

data/lib/template/parser/template.rb

@@ -1,39 +0,0 @@
-class Template
-  class Parser
-    class Template < Language
-      def code
-        ::Code::Parser::Code
-      end
-
-      def opening_curly_bracket
-        str("{")
-      end
-
-      def closing_curly_bracket
-        str("}")
-      end
-
-      def backslash
-        str("\\")
-      end
-
-      def code_part
-        opening_curly_bracket << code << (closing_curly_bracket | any.absent)
-      end
-
-      def text_character
-        (backslash.ignore << opening_curly_bracket) |
-          (opening_curly_bracket.absent << any)
-      end
-
-      def text_part
-        text_character.repeat(1)
-      end
-
-      def root
-        (code_part.aka(:code) | text_part.aka(:text)).repeat |
-          str("").aka(:text).repeat(1, 1)
-      end
-    end
-  end
-end

data/lib/template/parser.rb

@@ -1,19 +0,0 @@
-class Template
-  class Parser
-    def initialize(input)
-      @input = input
-    end
-
-    def self.parse(input)
-      new(input).parse
-    end
-
-    def parse
-      ::Template::Parser::Template.parse(input)
-    end
-
-    private
-
-    attr_reader :input
-  end
-end

data/lib/template/version.rb

@@ -1,3 +0,0 @@
-require_relative "../template"
-
-Template::Version = Gem::Version.new("0.5.6")