code-ruby 0.4.0 → 0.5.1

data/lib/code/node/not_keyword.rb

@@ -1,13 +0,0 @@
-class Code
-  class Node
-    class NotKeyword < Node
-      def initialize(not_keyword)
-        @statement = ::Code::Node::Statement.new(not_keyword)
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Boolean.new(!@statement.evaluate(**args).truthy?)
-      end
-    end
-  end
-end

data/lib/code/node/or_keyword.rb

@@ -1,34 +0,0 @@
-class Code
-  class Node
-    class OrKeyword < Node
-      OR_KEYWORD = "or"
-      AND_KEYWORD = "and"
-
-      def initialize(or_keyword)
-        @first = ::Code::Node::Statement.new(or_keyword.fetch(:first))
-        @rest = or_keyword.fetch(:rest)
-        @rest.map! do |operation|
-          ::Code::Node::Operation::Operation.new(operation)
-        end
-      end
-
-      def evaluate(**args)
-        object = @first.evaluate(**args)
-
-        @rest.each do |operation|
-          if operation.operator == OR_KEYWORD
-            return object if object.truthy?
-          elsif operation.operator == AND_KEYWORD
-            return object unless object.truthy?
-          else
-            raise NotImplementedError.new(operation.operator.inspect)
-          end
-
-          object = operation.statement.evaluate(**args)
-        end
-
-        object
-      end
-    end
-  end
-end

data/lib/code/node/range.rb

@@ -1,31 +0,0 @@
-class Code
-  class Node
-    class Range < Node
-      INCLUSIVE_RANGE = ".."
-      EXCLUSIVE_RANGE = "..."
-
-      def initialize(range)
-        @left = ::Code::Node::Statement.new(range.fetch(:left))
-        @operator = range.fetch(:operator)
-        @right = ::Code::Node::Statement.new(range.fetch(:right))
-      end
-
-      def evaluate(**args)
-        left = @left.evaluate(**args)
-        right = @right.evaluate(**args)
-
-        if operator == INCLUSIVE_RANGE
-          ::Code::Object::Range.new(left, right, exclude_end: false)
-        elsif operator == EXCLUSIVE_RANGE
-          ::Code::Object::Range.new(left, right, exclude_end: true)
-        else
-          raise NotImplementedError.new(operator)
-        end
-      end
-
-      private
-
-      attr_reader :operator
-    end
-  end
-end

data/lib/code/node/regular_call_argument.rb

@@ -1,34 +0,0 @@
-class Code
-  class Node
-    class RegularCallArgument < Node
-      def initialize(argument)
-        @splat = argument.key?(:splat)
-        @keyword_splat = argument.key?(:keyword_splat)
-        @block = argument.key?(:block)
-        @value = ::Code::Node::Code.new(argument.fetch(:value))
-      end
-
-      def evaluate(**args)
-        object = @value.evaluate(**args)
-
-        block? ? simple_call(object, :to_function, **args) : object
-      end
-
-      def block?
-        @block
-      end
-
-      def splat?
-        @splat
-      end
-
-      def keyword_splat?
-        @keyword_splat
-      end
-
-      def name
-        nil
-      end
-    end
-  end
-end

data/lib/code/node/regular_function_argument.rb

@@ -1,36 +0,0 @@
-class Code
-  class Node
-    class RegularFunctionArgument < Node
-      def initialize(argument)
-        @block = argument.key?(:block)
-        @splat = argument.key?(:splat)
-        @keyword_splat = argument.key?(:keyword_splat)
-        @name = argument.fetch(:name)
-
-        if argument.key?(:default)
-          @default = ::Code::Node::Code.new(argument.fetch(:default))
-        end
-      end
-
-      def evaluate(**args)
-        @default ? @default.evaluate(**args) : ::Code::Object::Nothing.new
-      end
-
-      def name
-        ::Code::Object::String.new(@name.to_s)
-      end
-
-      def splat?
-        @splat
-      end
-
-      def keyword_splat?
-        @keyword_splat
-      end
-
-      def block?
-        @block
-      end
-    end
-  end
-end

data/lib/code/node/string_characters.rb

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

data/lib/code/node/string_component.rb

@@ -1,23 +0,0 @@
-class Code
-  class Node
-    class StringComponent < Node
-      def initialize(component)
-        if component.key?(:characters)
-          @component =
-            ::Code::Node::StringCharacters.new(component.fetch(:characters))
-        elsif component.key?(:interpolation)
-          @component =
-            ::Code::Node::StringInterpolation.new(
-              component.fetch(:interpolation),
-            )
-        else
-          raise NotImplementedError.new(component.inspect)
-        end
-      end
-
-      def evaluate(**args)
-        @component.evaluate(**args)
-      end
-    end
-  end
-end

data/lib/code/node/string_interpolation.rb

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

data/lib/code/parser/defined.rb

@@ -1,20 +0,0 @@
-class Code
-  class Parser
-    class Defined < Parslet::Parser
-      rule(:range) { ::Code::Parser::Range.new }
-      rule(:name) { ::Code::Parser::Name.new }
-
-      rule(:defined_keyword) { str("defined?") }
-      rule(:opening_parenthesis) { str("(") }
-      rule(:closing_parenthesis) { str(")") }
-
-      rule(:defined) do
-        (
-          defined_keyword >> opening_parenthesis >> name >> closing_parenthesis
-        ).as(:defined) | range
-      end
-
-      root(:defined)
-    end
-  end
-end

data/lib/code/parser/greater_than.rb

@@ -1,33 +0,0 @@
-class Code
-  class Parser
-    class GreaterThan < Parslet::Parser
-      rule(:bitwise_or) { ::Code::Parser::BitwiseOr.new }
-
-      rule(:right_caret) { str(">") }
-      rule(:left_caret) { str("<") }
-      rule(:equal) { str("=") }
-
-      rule(:operator) do
-        (right_caret >> equal) | (left_caret >> equal) | right_caret |
-          left_caret
-      end
-
-      rule(:space) { str(" ") }
-      rule(:newline) { str("\n") }
-      rule(:whitespace) { (space | newline).repeat(1) }
-      rule(:whitespace?) { whitespace.maybe }
-
-      rule(:greater_than) do
-        (
-          bitwise_or.as(:first) >>
-            (
-              whitespace? >> operator.as(:operator) >> whitespace? >>
-                bitwise_or.as(:statement)
-            ).repeat(1).as(:rest)
-        ).as(:greater_than) | bitwise_or
-      end
-
-      root(:greater_than)
-    end
-  end
-end

data/spec/call_spec.rb

@@ -1,22 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code do
-  subject { described_class.evaluate(input).to_s }
-
-  [
-    %w[(1..2).any?(&:even?) true],
-    %w[(1..1).any?(&:even?) false],
-    %w[(3..3).any?(&:even?) false],
-    %w[(2..5).any?(&:even?) true],
-    ["(2..5).any? { |n| n.even? }", "true"],
-    ["(2..5).select { |i| i.even? }.any? { |n| n.even? }", "true"],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-end

data/spec/code/error/type_error_spec.rb

@@ -1,63 +0,0 @@
-require "spec_helper"
-
-RSpec.describe ::Code::Error::TypeError do
-  describe "Integer" do
-    context "creating an integer with a non-number exponent" do
-      it "raises" do
-        expect { ::Code::Object::Integer.new(1, exponent: "2") }.to raise_error(
-          described_class,
-        )
-      end
-    end
-
-    [
-      '1 / ""',
-      '1 ** ""',
-      '1 % ""',
-      '1 - ""',
-      '1 << ""',
-      '1 >> ""',
-      '1 & ""',
-      '1 | ""',
-      '1 ^ ""',
-      '1 > ""',
-      '1 >= ""',
-      '1 < ""',
-      '1 <= ""',
-    ].each do |input|
-      context input.inspect do
-        it "raises" do
-          expect { ::Code.evaluate(input) }.to raise_error(described_class)
-        end
-      end
-    end
-  end
-
-  describe "Decimal" do
-    context "creating an integer with a non-number exponent" do
-      it "raises" do
-        expect { ::Code::Object::Decimal.new(1, exponent: "2") }.to raise_error(
-          described_class,
-        )
-      end
-    end
-
-    [
-      '1.0 / ""',
-      '1.0 ** ""',
-      '1.0 * ""',
-      '1.0 % ""',
-      '1.0 - ""',
-      '1.0 > ""',
-      '1.0 >= ""',
-      '1.0 < ""',
-      '1.0 <= ""',
-    ].each do |input|
-      context input.inspect do
-        it "raises" do
-          expect { ::Code.evaluate(input) }.to raise_error(described_class)
-        end
-      end
-    end
-  end
-end

data/spec/code/parser/name_spec.rb

@@ -1,15 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code::Parser::Name do
-  subject { described_class.new.parse(input) }
-
-  %w[user dorian User RSpec describe?].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq({ name: input })
-      end
-    end
-  end
-end

data/spec/code/parser/nothing_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code::Parser::Nothing do
-  subject { described_class.new.parse(input) }
-
-  [
-    ["nothing", { nothing: "nothing" }],
-    ["null", { nothing: "null" }],
-    ["nil", { nothing: "nil" }],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-end

data/spec/code_spec.rb

@@ -1,182 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code do
-  let!(:input) { "" }
-  let!(:context) { "" }
-  let!(:io) { StringIO.new }
-  let!(:timeout) { 0.1 }
-  let!(:ruby) { {} }
-
-  subject do
-    Code.evaluate(input, context, io: io, timeout: timeout, ruby: ruby).to_s
-  end
-
-  [
-    ["nothing", ""],
-    ["null", ""],
-    ["nil", ""],
-    %w[true true],
-    %w[false false],
-    %w[1 1],
-    %w[1.2 1.2],
-    %w[0b10 2],
-    %w[0o10 8],
-    %w[0x10 16],
-    %w[1e2 100],
-    %w[1.2e2.2 190.1871830953336182242521644],
-    %w[1e1e1 10000000000],
-    %w['hello' hello],
-    %w["hello" hello],
-    ["[true, 1, nothing]", "[true, 1, nothing]"],
-    ['{a: 1, "b": 2}', '{"a" => 1, "b" => 2}'],
-    %w[!true false],
-    %w[!!true true],
-    %w[!!nothing false],
-    %w[!!1 true],
-    %w[+1 1],
-    %w[++++1 1],
-    ["++++nothing", ""],
-    %w[+{} {}],
-    ["2 ** 2", "4"],
-    ["2 ** 2 ** 3", "256"],
-    %w[-2 -2],
-    %w[--2 2],
-    ["2 * 3", "6"],
-    ["1 / 2", "0.5"],
-    ["1 / 2 / 2", "0.25"],
-    ["12 % 10", "2"],
-    ["8 / -2 ** 3", "-1.0"],
-    ["1 + 2 * 3 + 4", "11"],
-    ["1e1.1 * 2", "25.1785082358833442084790822"],
-    ["1 / 3 * 3", "0.999999999999999999999999999999999999"],
-    ['3 * "hello"', "hellohellohello"],
-    ['"Go" + "od"', "Good"],
-    ["1 << 2", "4"],
-    ["4 >> 2", "1"],
-    ["2 & 1", "0"],
-    ["2 | 1", "3"],
-    ["5 ^ 6", "3"],
-    ["5 > 6", "false"],
-    ["5 > 5", "false"],
-    ["5 > 4", "true"],
-    ["2 > 1 == 3 > 2", "true"],
-    ["true && false", "false"],
-    ["true || false", "true"],
-    %w[1..3 1..3],
-    ['1 > 3 ? "Impossible" : "Sounds about right"', "Sounds about right"],
-    ['1 < 3 ? "OK"', "OK"],
-    ['1 < "" rescue "oops"', "oops"],
-    ['"fine" rescue "oops"', "fine"],
-    ["a = 1", "1"],
-    ["a = 1 a * 2", "2"],
-    ["a = 1 a += 1 a", "2"],
-    ["a = 1 a -= 1 a", "0"],
-    %w[defined?(a) false],
-    ["a = 1 defined?(a)", "true"],
-    ["not true", "false"],
-    ["not false", "true"],
-    ["not not 1", "true"],
-    ["1 or 2", "1"],
-    ["true or false", "true"],
-    ["1 and 2", "2"],
-    ["false and 2", "false"],
-    ["true and false", "false"],
-    ["true and true", "true"],
-    ["1 if false", ""],
-    ["1 if true", "1"],
-    ["1 if true if true", "1"],
-    ["1 unless false", "1"],
-    ["1 unless true", ""],
-    ["a = 0 a += 1 while a < 10 a", "10"],
-    ["a = 0 a += 1 until a > 10 a", "11"],
-    ["if true 1 end", "1"],
-    ["if false 1 end", ""],
-    ["if false 1 else 2 end", "2"],
-    ["unless false 1 end", "1"],
-    ["unless true 1 end", ""],
-    ["if false 1 else if true 2 else 3 end", "2"],
-    ["if false 1 else if false 2 else 3 end", "3"],
-    ["unless false 1 else if false 2 else 3 end", "1"],
-    ["if false 1 else unless false 2 else 3 end", "2"],
-    ["a = 0\n while a < 10 a += 1 end a", "10"],
-    ["a = 0\n until a > 10 a += 1 end a", "11"],
-    ["until true end", ""],
-    ["until true\nend", ""],
-    %w[("Good".."Bad").first Good],
-    ['"Dorian " * 2', "Dorian Dorian "],
-    ["while false end == nothing", "true"],
-    ['"1 + 1 = {1 + 1}"', "1 + 1 = 2"],
-    ["'1 + 1 = {1 + 1}'", "1 + 1 = 2"],
-    ["{}.to_string + [].to_string", "{}[]"],
-    ["'a' + 1", "a1"],
-    ["'a' + 1.0", "a1.0"],
-    ["1 + 'a'", "1a"],
-    ["1.0 + 'a'", "1.0a"],
-    ["1 << 1", "2"],
-    ["1.0 << 1", "2"],
-    ["1 << 1.0", "2"],
-    ["1.0 << 1.0", "2"],
-    ["eval('1 + 1')", "2"],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-
-  context "with ruby" do
-    context "with a constant" do
-      let!(:input) { "a + a" }
-      let!(:ruby) { { a: 1 } }
-
-      it "can access a" do
-        expect(subject).to eq("2")
-      end
-    end
-
-    context "with a function without arguments" do
-      let!(:input) { "a + a" }
-      let!(:ruby) { { a: ->{ "hello" } } }
-
-      it "can call a" do
-        expect(subject).to eq("hellohello")
-      end
-    end
-
-    context "with a function with regular arguments" do
-      let!(:input) { "add(1, 2)" }
-      let!(:ruby) { { add: ->(a, b){ a + b } } }
-
-      it "can call add" do
-        expect(subject).to eq("3")
-      end
-    end
-
-    context "with a function with keyword arguments" do
-      let!(:input) { "add(a: 1, b: 2)" }
-      let!(:ruby) { { add: ->(a:, b:){ a + b } } }
-
-      it "can call add" do
-        expect(subject).to eq("3")
-      end
-    end
-
-    context "with a complex function" do
-      let!(:input) { "add(1, 1, 1, 1, c: 1, d: 1, e: 1)" }
-      let!(:ruby) do
-        {
-          add: ->(a, b = 1, *args, c:, d: 2, **kargs){
-            a + b + args.sum + c + d + kargs.values.sum
-          }
-        }
-      end
-
-      it "can call add" do
-        expect(subject).to eq("7")
-      end
-    end
-  end
-end

data/spec/function_spec.rb

@@ -1,26 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code do
-  subject { described_class.evaluate(input).to_s }
-
-  [
-    ['hello = () => { "Hello" } hello', "Hello"],
-    ["add = (a, b) => { a + b } add(1, 2)", "3"],
-    ["add = (a:, b:) => { a + b } add(a: 1, b: 2)", "3"],
-    ["add = (a = 1, b = 2) => { a + b } add", "3"],
-    ["add = (a: 1, b: 2) => { a + b } add", "3"],
-    ["add = (*args) => { args.first + args.last } add(1, 2)", "3"],
-    [
-      "add = (**kargs) => { kargs.values.first + kargs.values.last } add(a: 1, b: 2)",
-      "3",
-    ],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-end

data/spec/template/parser/template_spec.rb

@@ -1,19 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Template::Parser::Template do
-  subject { described_class.new.parse(input) }
-
-  [
-    ["hello", [{ text: "hello" }]],
-    ["hello {name}", [{ text: "hello " }, { code: [{ name: "name" }] }]],
-    ["{name", [{ code: [{ name: "name" }] }]],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-end

data/spec/template_spec.rb

@@ -1,52 +0,0 @@
-require "spec_helper"
-require "prime"
-
-RSpec.describe Template do
-  let!(:ruby) { {} }
-  let!(:input_context) { "" }
-  let!(:timeout) { 0 }
-  subject { Template.render(input, input_context, ruby: ruby, timeout: timeout) }
-
-  [
-    ["Hello World", "", "Hello World"],
-    ["1 + 1 = {2}", "", "1 + 1 = 2"],
-    ["Hello {name}", '{ name: "Dorian" }', "Hello Dorian"],
-    [
-      "Hello {user.first_name}",
-      '{ user: { first_name: "Dorian" } }',
-      "Hello Dorian",
-    ],
-    ["{add(1, 2)", "add = (a, b) => { a + b } { add: context(:add) }", "3"],
-    ["Hello {", "", "Hello "],
-    ["{{a: 1}.each { |k, v| print(k) } nothing", "", "a"],
-    ["{{a: 1}.each { |k, v| puts(k) } nothing", "", "a\n"],
-    ["", "", ""],
-  ].each do |(input, input_context, expected)|
-    context "#{input.inspect} #{input_context.inspect}" do
-      let(:input) { input }
-      let(:input_context) { input_context }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-
-  context "with a function from ruby" do
-    let!(:ruby) { { prime: ->(n){ n.prime? } } }
-    let!(:input) { "{prime(19201)" }
-
-    it "calls the ruby function" do
-      expect(subject).to eq("false")
-    end
-  end
-
-  context "with a function from ruby in an object" do
-    let!(:ruby) { { Prime: { prime: ->(n){ n.prime? } } } }
-    let!(:input) { "{Prime.prime(19201)" }
-
-    it "calls the ruby function" do
-      expect(subject).to eq("false")
-    end
-  end
-end