language-ruby 0.5.5 → 0.6.0

data/bin/template

@@ -1,85 +0,0 @@
-#!/usr/bin/env ruby
-
-require "optparse"
-require_relative "../lib/template-ruby"
-
-options = { timeout: 0, profile: false, profiler: "text" }
-
-OptionParser
-  .new do |opts|
-    opts.banner = "Usage: template [options]"
-
-    opts.on(
-      "-i INPUT",
-      "--input=INPUT",
-      "Input in the template language (String or File)"
-    ) do |input|
-      input = File.read(input) if File.exists?(input)
-
-      options[:input] = input
-    end
-
-    opts.on(
-      "-c CONTEXT",
-      "--context=CONTEXT",
-      "Context in the code language (String or File)"
-    ) do |context|
-      context = File.read(context) if File.exists?(context)
-
-      options[:context] = context
-    end
-
-    opts.on("-p", "--parse", "Get parser results for input") do |parse|
-      options[:parse] = parse
-    end
-
-    opts.on(
-      "-t TIMEOUT",
-      "--timeout=TIMEOUT",
-      "Set timeout in seconds"
-    ) { |timeout| options[:timeout] = timeout.to_f }
-
-    opts.on(
-      "--profile",
-      "Profile Ruby code"
-    ) do |timeout|
-      require "ruby-prof"
-      options[:profile] = true
-    end
-
-    opts.on(
-      "--profiler TYPE",
-      "Profiler output type (text (default) or html)"
-    ) do |profiler|
-      require "ruby-prof"
-      options[:profile] = true
-      options[:profiler] = profiler
-    end
-  end
-  .parse!
-
-input = options.fetch(:input, "")
-context = options.fetch(:context, "")
-
-if options[:profile]
-  RubyProf.start
-end
-
-if options[:parse]
-  pp ::Template::Parser.parse(input).to_raw
-else
-  Template.render(input, context, io: $stdout, timeout: options[:timeout])
-end
-
-if options[:profile]
-  result = RubyProf.stop
-  if options[:profiler] == "text"
-    printer = RubyProf::FlatPrinter.new(result)
-    printer.print($stdout)
-  elsif options[:profiler] == "html"
-    printer = RubyProf::GraphHtmlPrinter.new(result)
-    printer.print($stdout)
-  else
-    abort "#{options[:profiler]} not recognized"
-  end
-end

data/bin/test

@@ -1,17 +0,0 @@
-#!/bin/bash
-
-set -e
-
-rspec
-
-for f in docs/**/*.template
-do
-  echo $f
-  bin/template -i $f -p > /dev/null
-done
-
-for f in docs/*.code
-do
-  echo $f
-  bin/code -i $f -p > /dev/null
-done

data/code-ruby.gemspec

@@ -1,17 +0,0 @@
-require_relative "lib/template/version"
-
-Gem::Specification.new do |s|
-  s.name = "code-ruby"
-  s.version = ::Template::Version
-  s.summary = "A programming language"
-  s.description = 'A programming language, like Code.evaluate("1 + 1") # => 2'
-  s.authors = ["Dorian Marié"]
-  s.email = "dorian@dorianmarie.fr"
-  s.files = `git ls-files`.split($/)
-  s.test_files = s.files.grep(%r{^(test|spec|features)/})
-  s.require_paths = ["lib"]
-  s.homepage = "https://github.com/dorianmariefr/template-ruby"
-  s.license = "MIT"
-
-  s.add_dependency "zeitwerk", "~> 2"
-end

data/docs/class.code

@@ -1,9 +0,0 @@
-class ApiClient
-  get = (url) => {
-    fetch(url)
-  }
-end
-
-class Twitter < ApiClient
-  self.base_url = "https://api.twitter.com"
-end

data/docs/euler/1.template

@@ -1,10 +0,0 @@
-{
-  sum = 0
-
-  1000.times do |i|
-    if i % 3 == 0 or i % 5 == 0
-      sum += i
-    end
-  end
-
-  sum

data/docs/euler/2.template

@@ -1,16 +0,0 @@
-{
-  a = 1
-  b = 2
-  sum = 2
-
-  while b < 4000000
-    c = a + b
-    a = b
-    b = c
-
-    if b % 2 == 0
-      sum += b
-    end
-  end
-
-  sum

data/docs/euler/3.template

@@ -1,16 +0,0 @@
-{
-  n = 600851475143
-  max = 0
-
-  i = 2
-
-  until n == 1
-    while n % i == 0
-      max = i
-      n = n / i
-    end
-
-    i += 1
-  end
-
-  max

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