code-ruby 0.3.1 → 0.5.0

data/lib/code/node/function_argument.rb

@@ -1,45 +0,0 @@
-class Code
-  class Node
-    class FunctionArgument < Node
-      def initialize(argument)
-        if argument.key?(:regular)
-          @argument =
-            ::Code::Node::RegularFunctionArgument.new(argument.fetch(:regular))
-        elsif argument.key?(:keyword)
-          @argument =
-            ::Code::Node::KeywordFunctionArgument.new(argument.fetch(:keyword))
-        else
-          raise NotImplementedError.new(argument.inspect)
-        end
-      end
-
-      def evaluate(**args)
-        @argument.evaluate(**args)
-      end
-
-      def splat?
-        @argument.splat?
-      end
-
-      def keyword_splat?
-        @argument.keyword_splat?
-      end
-
-      def name
-        @argument.name
-      end
-
-      def block?
-        @argument.block?
-      end
-
-      def regular?
-        @argument.is_a?(::Code::Node::RegularFunctionArgument)
-      end
-
-      def keyword?
-        @argument.is_a?(::Code::Node::KeywordFunctionArgument)
-      end
-    end
-  end
-end

data/lib/code/node/group.rb

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

data/lib/code/node/keyword_call_argument.rb

@@ -1,30 +0,0 @@
-class Code
-  class Node
-    class KeywordCallArgument < Node
-      def initialize(argument)
-        @name = argument.fetch(:name)
-        @value = ::Code::Node::Code.new(argument.fetch(:value))
-      end
-
-      def evaluate(**args)
-        @value.evaluate(**args)
-      end
-
-      def name
-        ::Code::Object::String.new(@name.to_s)
-      end
-
-      def block?
-        false
-      end
-
-      def splat?
-        false
-      end
-
-      def keyword_splat?
-        false
-      end
-    end
-  end
-end

data/lib/code/node/keyword_function_argument.rb

@@ -1,33 +0,0 @@
-class Code
-  class Node
-    class KeywordFunctionArgument < Node
-      def initialize(argument)
-        @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?
-        false
-      end
-
-      def keyword_splat?
-        false
-      end
-
-      def block?
-        false
-      end
-    end
-  end
-end

data/lib/code/node/name.rb

@@ -1,55 +0,0 @@
-class Code
-  class Node
-    class Name < Node
-      def initialize(name)
-        @name = name
-      end
-
-      def evaluate(**args)
-        context = args.fetch(:context)
-        arguments = args.fetch(:arguments, [])
-        object = args.fetch(:object, nil)
-        io = args.fetch(:io)
-
-        if object
-          object.call(
-            context: context,
-            operator: name,
-            arguments: arguments,
-            io: io,
-          )
-        elsif context.key?(name)
-          object = context[name]
-
-          if object.is_a?(::Code::Object::Function)
-            object.call(
-              context: context,
-              operator: nil,
-              arguments: arguments,
-              io: io,
-            )
-          else
-            object
-          end
-        elsif name == "puts"
-          arguments.each { |argument| io.puts argument.value }
-          ::Code::Object::Nothing.new
-        elsif name == "print"
-          arguments.each { |argument| io.print argument.value }
-          ::Code::Object::Nothing.new
-        elsif name == "context"
-          return ::Code::Object::Nothing.new if arguments.size != 1
-          context[arguments.first&.value] || ::Code::Object::Nothing.new
-        else
-          raise ::Code::Error::Undefined.new("#{name} undefined")
-        end
-      end
-
-      private
-
-      def name
-        ::Code::Object::String.new(@name.to_s)
-      end
-    end
-  end
-end

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,120 +0,0 @@
-require "spec_helper"
-
-RSpec.describe Code do
-  subject { described_class.evaluate(input).to_s }
-
-  [
-    ["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"],
-  ].each do |(input, expected)|
-    context input.inspect do
-      let(:input) { input }
-
-      it "succeeds" do
-        expect(subject).to eq(expected)
-      end
-    end
-  end
-end