language-ruby 0.5.6 → 0.6.1

data/docs/euler/4.template

@@ -1,10 +0,0 @@
-{
-
-  min = 1
-  max = 999
-
-  (min..max).map do |i|
-    ((min..max).to_list.reverse.detect do |j|
-      (i * j).to_string.reverse == (i * j).to_string
-    end || 0) * i
-  end.max

data/docs/euler/5.template

@@ -1,13 +0,0 @@
-{
-  min = 1
-  max = 20
-
-  step = [2, 3, 5, 7, 11, 13, 17].reduce do |acc, el|
-    acc * el
-  end
-
-  (step..(step * step)).step(step).detect do |i|
-    (min..max).all? do |j|
-      i % j == 0
-    end
-  end

data/docs/fibonnaci.template

@@ -1,14 +0,0 @@
-{
-  fibonnaci = (n) => {
-    if n < 2
-      n
-    else
-      fibonnaci(n - 1) + fibonnaci(n - 2)
-    end
-  }
-
-  (0..20).each do |i|
-    puts("fibonnaci({i}) = {fibonnaci(i)}")
-  end
-
-  nothing

data/docs/meetup.code

@@ -1,12 +0,0 @@
-url = fetch(:url) { "https://www.meetup.com/parisrb" }
-response = HTTP.get(url)
-times = response.css(".groupHome-eventsList-upcomingEvents time")
-times = times.map(&:datetime).map { |time| Time.from_epoch(time.to_integer) }
-
-times.each do |time|
-  if (1.day.from_now...(1.day.from_now + 1.hour)).include?(time)
-    Sms.send("Event in one day {url}")
-  elsif (2.hours.from_now...(1.hour.from_now)).include(time)
-    Sms.send("Event in two hours {url}")
-  end
-end

data/docs/precedence.template

@@ -1,36 +0,0 @@
-- Code
-- Statement
-- Equality
-- Splat
-- Class
-- While
-- If
-- IfModifier
-- OrKeyword
-- NotKeyword
-- Equal
-- Rescue
-- Ternary
-- Range
-- OrOperator
-- AndOperator
-- EqualityLower
-- Greater
-- BitwiseOr
-- BitwiseAnd
-- Shift
-- Addition
-- Multiplication
-- UnaryMinus
-- Power
-- Negation
-- Function
-- ChainedCall
-- Dictionnary
-- List
-- String
-- Number
-- Boolean
-- Nothing
-- Group
-- Call

data/docs/rain.code

@@ -1,22 +0,0 @@
-paris = { latitude: 48.8566, longitude: 2.4022 }
-latitude = fetch(:latitude) { paris.latitude }
-longitude = fetch(:longitude) { paris.longitude }
-duration = fetch(:duration) { 1.hour }
-hour = duration.from_now.hour
-
-response =
-  HTTP.get(
-    "https://api.open-meteo.com/v1/forecast",
-    parameters: {
-      latitude: latitude,
-      longitude: longitude,
-      hourly: :precipitation
-    }
-  )
-
-precipitation = response.hourly.precipitation[hour]
-precipitation = (precipitation * 100).to_integer
-
-if precipitation > 0
-  Sms.send("There will be {precipitation}% of precipitation in the next hour")
-end

data/docs/slack.code

@@ -1,17 +0,0 @@
-Slack.send("Who is leading the syncs?", channel: "#team-template")
-
-Twitter.send("What do you want to do this week?")
-
-Discord.send("Who will be the game master this week?")
-
-Email.send(
-  subject: "What did you do last week?",
-  from: "dorian@thoughtbot.com",
-  reply_to: "rob@thoughtbot.com"
-)
-
-Email.send(
-  subject: "What do you want to do this week?",
-  from: "dorian@thoughtbot.com",
-  reply_to: "rob@thoughtbot.com"
-)

data/docs/stripe.code

@@ -1,7 +0,0 @@
-event = Stripe::Webhook.event
-
-if event.type == "payment_intent.succeeded"
-  payment_intent = event.data.object
-  amount = Money.format(payment_intent.amount, payment_intent.currency)
-  Sms.send("You got paid {amount}")
-end

data/docs/twitter.code

@@ -1,9 +0,0 @@
-twitter_username = fetch(:twitter_username) { "dorianmariefr" }
-
-Twitter
-  .search("to:{twitter_username}", type: :recent)
-  .each do |tweet|
-    next if Storage.exists?(tweet.id)
-    Storage.create!(tweet.id)
-    Sms.send("New mention: {tweet.user.screen_name}: {tweet.text}")
-  end

data/lib/code/error.rb

@@ -1,18 +0,0 @@
-class Code
-  class Error < StandardError
-    class TypeError < ::Code::Error
-    end
-
-    class Undefined < ::Code::Error
-    end
-
-    class UndefinedVariable < ::Code::Error
-    end
-
-    class ArgumentError < ::Code::Error
-    end
-
-    class IncompatibleContext < ::Code::Error
-    end
-  end
-end

data/lib/code/node/base_10.rb

@@ -1,29 +0,0 @@
-class Code
-  class Node
-    class Base10 < Node
-      def initialize(parsed)
-        @whole = parsed.delete(:whole)
-
-        if parsed.key?(:exponent)
-          @exponent = Node::Statement.new(parsed.delete(:exponent))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @exponent
-          exponent = @exponent.evaluate(**args)
-
-          if exponent.is_a?(::Code::Object::Integer)
-            ::Code::Object::Integer.new(@whole.to_i, exponent: exponent)
-          else
-            ::Code::Object::Decimal.new(@whole, exponent: exponent)
-          end
-        else
-          ::Code::Object::Integer.new(@whole.to_i)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/base_16.rb

@@ -1,13 +0,0 @@
-class Code
-  class Node
-    class Base16 < Node
-      def initialize(parsed)
-        @base_16 = parsed
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Integer.new(@base_16.to_i(16))
-      end
-    end
-  end
-end

data/lib/code/node/base_2.rb

@@ -1,13 +0,0 @@
-class Code
-  class Node
-    class Base2 < Node
-      def initialize(parsed)
-        @base_2 = parsed
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Integer.new(@base_2.to_i(2))
-      end
-    end
-  end
-end

data/lib/code/node/base_8.rb

@@ -1,13 +0,0 @@
-class Code
-  class Node
-    class Base8 < Node
-      def initialize(parsed)
-        @base_8 = parsed
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Integer.new(@base_8.to_i(8))
-      end
-    end
-  end
-end

data/lib/code/node/boolean.rb

@@ -1,22 +0,0 @@
-class Code
-  class Node
-    class Boolean < Node
-      TRUE_KEYWORD = "true"
-      FALSE_KEYWORD = "false"
-
-      def initialize(parsed)
-        @boolean = parsed
-      end
-
-      def evaluate(**args)
-        if @boolean == TRUE_KEYWORD
-          ::Code::Object::Boolean.new(true)
-        elsif @boolean == FALSE_KEYWORD
-          ::Code::Object::Boolean.new(false)
-        else
-          raise NotImplementedError.new(@boolean)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/call.rb

@@ -1,47 +0,0 @@
-class Code
-  class Node
-    class Call < Node
-      class Block < Node
-        def initialize(parsed)
-          @parameters =
-            parsed
-              .delete(:parameters) { [] }
-              .map { |parameter| Node::FunctionParameter.new(parameter) }
-
-          @body = Node::Code.new(parsed.delete(:body))
-
-          super(parsed)
-        end
-
-        def evaluate(**args)
-          ::Code::Object::Argument.new(
-            ::Code::Object::Function.new(parameters: @parameters, body: @body)
-          )
-        end
-      end
-
-      def initialize(parsed)
-        @name = parsed.delete(:name)
-        @arguments =
-          parsed
-            .delete(:arguments) { [] }
-            .map { |argument| Node::CallArgument.new(argument) }
-
-        if parsed.key?(:block)
-          @block = Node::Call::Block.new(parsed.delete(:block))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        arguments = @arguments.map { |argument| argument.evaluate(**args) }
-        arguments << @block.evaluate(**args) if @block
-
-        name = ::Code::Object::String.new(@name)
-
-        args.fetch(:object).call(operator: name, arguments: arguments, **args)
-      end
-    end
-  end
-end

data/lib/code/node/call_argument.rb

@@ -1,21 +0,0 @@
-class Code
-  class Node
-    class CallArgument < Node
-      def initialize(parsed)
-        @value = Node::Code.new(parsed.delete(:value))
-        @name = parsed.delete(:name)
-      end
-
-      def evaluate(**args)
-        if @name
-          ::Code::Object::Argument.new(
-            @value.evaluate(**args),
-            name: ::Code::Object::String.new(@name)
-          )
-        else
-          ::Code::Object::Argument.new(@value.evaluate(**args))
-        end
-      end
-    end
-  end
-end

data/lib/code/node/chained_call.rb

@@ -1,23 +0,0 @@
-class Code
-  class Node
-    class ChainedCall < Node
-      def initialize(parsed)
-        @first = Node::Statement.new(parsed.delete(:first))
-        @others =
-          parsed
-            .delete(:others)
-            .map { |operator| Node::Statement.new(operator) }
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        first = @first.evaluate(**args)
-
-        @others.reduce(first) do |acc, element|
-          element.evaluate(**args.merge(object: acc))
-        end
-      end
-    end
-  end
-end

data/lib/code/node/code.rb

@@ -1,20 +0,0 @@
-class Code
-  class Node
-    class Code < Node
-      def initialize(parsed)
-        @statements = parsed.map { |statement| Node::Statement.new(statement) }
-      end
-
-      def evaluate(**args)
-        last = ::Code::Object::Nothing.new
-
-        @statements.each do |statement|
-          last =
-            statement.evaluate(**args.merge(object: ::Code::Object::Global.new))
-        end
-
-        last
-      end
-    end
-  end
-end

data/lib/code/node/decimal.rb

@@ -1,26 +0,0 @@
-class Code
-  class Node
-    class Decimal < Node
-      def initialize(parsed)
-        @decimal = parsed.delete(:decimal)
-
-        if parsed.key?(:exponent)
-          @exponent = Node::Statement.new(parsed.delete(:exponent))
-        end
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @exponent
-          ::Code::Object::Decimal.new(
-            @decimal,
-            exponent: @exponent.evaluate(**args)
-          )
-        else
-          ::Code::Object::Decimal.new(@decimal)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/dictionnary.rb

@@ -1,33 +0,0 @@
-class Code
-  class Node
-    class Dictionnary < Node
-      class KeyValue < Node
-        def initialize(parsed)
-          if parsed.key?(:statement)
-            @key = Node::Statement.new(parsed.delete(:statement))
-          elsif parsed.key?(:name)
-            @key = Node::String.new([{ text: parsed.delete(:name) }])
-          end
-
-          @value = Node::Code.new(parsed.delete(:value))
-        end
-
-        def evaluate(**args)
-          [@key.evaluate(**args), @value.evaluate(**args)]
-        end
-      end
-
-      def initialize(parsed)
-        parsed = [] if parsed == ""
-        @key_values =
-          parsed.map { |key_value| Node::Dictionnary::KeyValue.new(key_value) }
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Dictionnary.new(
-          @key_values.map { |key_value| key_value.evaluate(**args) }.to_h
-        )
-      end
-    end
-  end
-end

data/lib/code/node/equal.rb

@@ -1,34 +0,0 @@
-class Code
-  class Node
-    class Equal < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @left = parsed.delete(:left)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        right = @right.evaluate(**args)
-        left = ::Code::Object::String.new(@left)
-        context = args.fetch(:context)
-
-        if @operator == ""
-          context[left] = right
-        else
-          if context[left].nil?
-            raise ::Code::Error::Undefined.new("#{left} is not defined")
-          end
-
-          context[left] = context.fetch(left).call(
-            operator: @operator,
-            arguments: [::Code::Object::Argument.new(right)],
-            **args
-          )
-        end
-
-        args[:context][left]
-      end
-    end
-  end
-end

data/lib/code/node/function.rb

@@ -1,20 +0,0 @@
-class Code
-  class Node
-    class Function < Node
-      def initialize(parsed)
-        @parameters =
-          parsed
-            .delete(:parameters) { [] }
-            .map { |parameter| Node::FunctionParameter.new(parameter) }
-
-        @body = Node::Code.new(parsed.delete(:body))
-
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        ::Code::Object::Function.new(parameters: @parameters, body: @body)
-      end
-    end
-  end
-end

data/lib/code/node/function_parameter.rb

@@ -1,31 +0,0 @@
-class Code
-  class Node
-    class FunctionParameter < Node
-      def initialize(parsed)
-        @name = parsed.delete(:name)
-        @keyword = !!parsed.delete(:keyword)
-        super(parsed)
-      end
-
-      def name
-        ::Code::Object::String.new(@name)
-      end
-
-      def regular?
-        !@keyword
-      end
-
-      def keyword?
-        !!@keyword
-      end
-
-      def regular_splat?
-        false
-      end
-
-      def keyword_splat?
-        false
-      end
-    end
-  end
-end

data/lib/code/node/if.rb

@@ -1,59 +0,0 @@
-class Code
-  class Node
-    class If < Node
-      IF_KEYWORD = "if"
-      UNLESS_KEYWORD = "unless"
-      ELSIF_KEYWORD = "elsif"
-      ELSE_KEYWORD = "else"
-
-      class Else < Node
-        attr_reader :operator, :statement, :body
-
-        def initialize(parsed)
-          @operator = parsed.delete(:operator)
-          @body = Node::Code.new(parsed.delete(:body))
-
-          if parsed.key?(:statement)
-            @statement = Node::Statement.new(parsed.delete(:statement))
-          end
-        end
-      end
-
-      def initialize(parsed)
-        @first_operator = parsed.delete(:first_operator)
-        @first_statement = Node::Statement.new(parsed.delete(:first_statement))
-        @first_body = Node::Code.new(parsed.delete(:first_body))
-        @elses =
-          parsed.delete(:elses) { [] }.map { |elses| Node::If::Else.new(elses) }
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @first_operator == IF_KEYWORD &&
-             @first_statement.evaluate(**args).truthy?
-          @first_body.evaluate(**args)
-        elsif @first_operator == UNLESS_KEYWORD &&
-              @first_statement.evaluate(**args).falsy?
-          @first_body.evaluate(**args)
-        else
-          @elses.each do |elses|
-            if elses.operator == ELSIF_KEYWORD &&
-                 elses.statement.evaluate(**args).truthy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == IF_KEYWORD &&
-                  elses.statement.evaluate(**args).truthy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == UNLESS_KEYWORD &&
-                  elses.statement.evaluate(**args).falsy?
-              return elses.body.evaluate(**args)
-            elsif elses.operator == ELSE_KEYWORD
-              return elses.body.evaluate(**args)
-            end
-          end
-
-          ::Code::Object::Nothing.new
-        end
-      end
-    end
-  end
-end

data/lib/code/node/if_modifier.rb

@@ -1,47 +0,0 @@
-class Code
-  class Node
-    class IfModifier < Node
-      IF_KEYWORD = "if"
-      UNLESS_KEYWORD = "unless"
-      WHILE_KEYWORD = "while"
-      UNTIL_KEYWORD = "until"
-
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @left = Node::Statement.new(parsed.delete(:left))
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        if @operator == IF_KEYWORD
-          if @right.evaluate(**args).truthy?
-            @left.evaluate(**args)
-          else
-            ::Code::Object::Nothing.new
-          end
-        elsif @operator == UNLESS_KEYWORD
-          if @right.evaluate(**args).falsy?
-            @left.evaluate(**args)
-          else
-            ::Code::Object::Nothing.new
-          end
-        elsif @operator == WHILE_KEYWORD
-          last = ::Code::Object::Nothing.new
-
-          last = @left.evaluate(**args) while @right.evaluate(**args).truthy?
-
-          last
-        elsif @operator == UNTIL_KEYWORD
-          last = ::Code::Object::Nothing.new
-
-          last = @left.evaluate(**args) while @right.evaluate(**args).falsy?
-
-          last
-        else
-          raise NotImplementedError.new(@operator)
-        end
-      end
-    end
-  end
-end

data/lib/code/node/list.rb

@@ -1,16 +0,0 @@
-class Code
-  class Node
-    class List < Node
-      def initialize(parsed)
-        parsed = [] if parsed == ""
-        @elements = parsed.map { |element| Node::Code.new(element) }
-      end
-
-      def evaluate(**args)
-        ::Code::Object::List.new(
-          @elements.map { |element| element.evaluate(**args) }
-        )
-      end
-    end
-  end
-end

data/lib/code/node/negation.rb

@@ -1,15 +0,0 @@
-class Code
-  class Node
-    class Negation < Node
-      def initialize(parsed)
-        @operator = parsed.delete(:operator)
-        @right = Node::Statement.new(parsed.delete(:right))
-        super(parsed)
-      end
-
-      def evaluate(**args)
-        @right.evaluate(**args).call(operator: @operator, arguments: [], **args)
-      end
-    end
-  end
-end