code-ruby 0.5.6 → 0.6.1

data/lib/language.rb

@@ -1,80 +0,0 @@
-class Language
-  def self.parse(input)
-    new.parse(input)
-  end
-
-  def self.absent
-    Atom::Absent.new(parent: new)
-  end
-
-  def self.ignore
-    Atom::Ignore.new(parent: new)
-  end
-
-  def self.maybe
-    Atom::Maybe.new(parent: new)
-  end
-
-  def self.repeat(min = 0, max = nil)
-    Atom::Repeat.new(parent: new, min: min, max: max)
-  end
-
-  def self.aka(name)
-    Atom::Aka.new(parent: new, name: name)
-  end
-
-  def self.|(other)
-    Atom::Or.new(left: new, right: other)
-  end
-
-  def self.>>(other)
-    Atom::And.new(left: new, right: other)
-  end
-
-  def self.<<(other)
-    Atom::And.new(left: new, right: other)
-  end
-
-  def self.then(&block)
-    Atom::Then.new(parent: new, block: block)
-  end
-
-  def parse(input_or_parser)
-    if input_or_parser.is_a?(Parser)
-      parser = input_or_parser
-      clone =
-        Parser.new(
-          root: root,
-          input: parser.input,
-          cursor: parser.cursor,
-          buffer: parser.buffer,
-          output: parser.output
-        )
-
-      clone.parse(check_end_of_input: false)
-
-      parser.cursor = clone.cursor
-      parser.buffer = clone.buffer
-      parser.output = clone.output
-    else
-      input = input_or_parser
-      Parser.new(root: root, input: input).parse
-    end
-  end
-
-  def str(string)
-    Atom::Str.new(string: string)
-  end
-
-  def any
-    Atom::Any.new
-  end
-
-  def to_s
-    "<#{self.class.name}>"
-  end
-
-  def inspect
-    to_s
-  end
-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")

data/lib/template-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/template.rb

@@ -1,50 +0,0 @@
-class Template
-  DEFAULT_TIMEOUT = 10
-
-  def initialize(input, io: StringIO.new, timeout: DEFAULT_TIMEOUT, ruby: {})
-    @input = input
-    @parsed =
-      Timeout.timeout(timeout) { ::Template::Parser.parse(@input).to_raw }
-    @io = io
-    @timeout = timeout || DEFAULT_TIMEOUT
-    @ruby = ::Code::Ruby.to_code(ruby || {})
-  end
-
-  def self.render(
-    input,
-    context = "",
-    io: StringIO.new,
-    timeout: DEFAULT_TIMEOUT,
-    ruby: {}
-  )
-    new(input, io: io, timeout: timeout, ruby: ruby).render(context)
-  end
-
-  def render(context = "")
-    Timeout.timeout(timeout) do
-      if context != ""
-        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::Template::IncompatibleContext.new(
-                "context must be a dictionnary"
-              )
-      end
-
-      context = context.merge(ruby)
-
-      ::Template::Node::Template.new(parsed).evaluate(context: context, io: io)
-
-      io.is_a?(StringIO) ? io.string : nil
-    end
-  end
-
-  private
-
-  attr_reader :parsed, :io, :timeout, :ruby
-end
-
-require_relative "template/version"

data/spec/code/addition_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "function" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["1 + 2", "3"], ["2 - 1", "1"], ["a = 2 - 1 a", "1"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/and_operator_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "and operator" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["true && false", "false"], ["true && true", "true"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/bitwise_and_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "bitwise and" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["1 & 1", "1"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/bitwise_or_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "bitwise or" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["1 | 2", "3"], ["1 ^ 2", "3"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/boolean_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "boolean" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [%w[true true], %w[false false]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/call_spec.rb

@@ -1,21 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "call" do
-  let(:timeout) { 0 }
-
-  context "inspecting the io" do
-    let(:io) { StringIO.new }
-
-    subject do
-      Code.evaluate(input, io: io, timeout: timeout)
-      io.string
-    end
-
-    [["puts(true)", "true\n"], %w[print(false) false]].each do |input, output|
-      context input do
-        let(:input) { input }
-        it { expect(subject).to eq(output) }
-      end
-    end
-  end
-end

data/spec/code/chained_call_spec.rb

@@ -1,16 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "chained call" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["[1, 2, 3].select { |n| n.even? }", "[2]"],
-    ["[1, 2, 3].select { |n| n.even? }.select { |n| n.odd? }", "[]"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/code_spec.rb

@@ -1,29 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "function" do
-  it "converts nil" do
-    expect(Code::Ruby.from_code(Code.evaluate("a", ruby: { a: nil }))).to eq(nil)
-  end
-
-  it "works with downcase" do
-    expect(Code.evaluate("downcase", "{ downcase: 1 }")).to eq(1)
-  end
-
-  it "works with nested objects" do
-    expect(
-      Code.evaluate(
-        "items.first.title",
-        ruby: { items: [{ title: "Hello" }] }
-      )
-    ).to eq("Hello")
-  end
-
-  it "works with arrays" do
-    expect(
-      Code.evaluate(
-        "items.map { |item| item.title }",
-        ruby: { items: [{ title: "Hello" }] }
-      )
-    ).to eq(["Hello"])
-  end
-end

data/spec/code/dictionnary_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "dictionnary" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    %w[{} {}],
-    ["{ a: 1, b: 2, c: 3 }", '{"a" => 1, "b" => 2, "c" => 3}'],
-    ['{ "first_name": "Dorian" }', '{"first_name" => "Dorian"}']
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/equal_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "function" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["a = 1 a", "1"],
-    ["a = 1 a += 1 a", "2"],
-    ["a = 1 a -= 1 a", "0"],
-    ["a = 1 a *= 2 a", "2"],
-    ["a = 1 a /= 2 a", "0.5"],
-    ["a = 10 a %= 2 a", "0"],
-    ["a = 1 a >>= 1 a", "0"],
-    ["a = 1 a <<= 1 a", "2"],
-    ["a = 1 a |= 2 a", "3"],
-    ["a = 1 a ^= 2 a", "3"],
-    ["a = false a ||= true a", "true"],
-    ["a = false a &&= true a", "false"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/equality_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "while" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["1 == 1", "true"], ["1 == 1 and 2 == 2", "true"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/function_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "function" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["even? = (i) => { i.even? } even?(2)", "true"],
-    ["even? = (i:) => { i.even? } even?(i: 2)", "true"],
-    ["add = (a, b) => { a + b } add(1, 2)", "3"],
-    ["minus = (a:, b:) => { a - b } minus(b: 1, a: 2)", "1"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/greater_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "greater" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["1 > 2", "false"],
-    ["1 < 2", "true"],
-    ["1 <= 1", "true"],
-    ["1 >= 1", "true"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/group_spec.rb

@@ -1,12 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "group" do
-  subject { Code.evaluate(input).to_s }
-
-  [["(true false)", "false"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/if_modifier_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "if modifier" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["1 if true", "1"],
-    ["1 if false", ""],
-    ["1 unless true", ""],
-    ["1 unless false", "1"],
-    ["a = 0 a += 1 while a < 10 a", "10"],
-    ["a = 0 a += 1 until a > 10 a", "11"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/if_spec.rb

@@ -1,25 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "if" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["if true 1", "1"],
-    ["unless false 1", "1"],
-    ["if false 1", ""],
-    ["unless true 1", ""],
-    ["if false 1 else 2", "2"],
-    ["if false 1 elsif true 2", "2"],
-    ["if false 1 elsif false 2", ""],
-    ["if false 1 else if true 2", "2"],
-    ["if false 1 else if false 2", ""],
-    ["if false 1 else unless false 2", "2"],
-    ["if false 1 else unless true 2", ""]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/list_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "list" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["[]", "[]"],
-    ["[1, 2, 3]", "[1, 2, 3]"],
-    ["[1, 2, 3].include?(2)", "true"],
-    ["[1, 2, 3].include?(4)", "false"],
-    ["[[true]]", "[[true]]"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/multiplication_spec.rb

@@ -1,18 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "multiplication" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    ["2 * 3", "6"],
-    ["2 * 3 + 2", "8"],
-    ["2 / 4", "0.5"],
-    ["4 % 3", "1"]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/negation_spec.rb

@@ -1,20 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "function" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [
-    %w[!false true],
-    %w[!!true true],
-    %w[!!1 true],
-    %w[+1 1],
-    %w[+1.0 1.0],
-    %w[+true true]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/not_keyword_spec.rb

@@ -1,13 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "not keyword" do
-  let(:timeout) { 0 }
-  subject { Code.evaluate(input, timeout: timeout).to_s }
-
-  [["not true", "false"], ["not not false", "false"]].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end

data/spec/code/nothing_spec.rb

@@ -1,17 +0,0 @@
-require "spec_helper"
-
-RSpec.describe "nothing" do
-  subject { Code.evaluate(input).to_s }
-
-  [
-    ["nothing", ""],
-    ["null", ""],
-    ["nil", ""],
-    ["nothing null", ""]
-  ].each do |input, output|
-    context input do
-      let(:input) { input }
-      it { expect(subject).to eq(output) }
-    end
-  end
-end