template-ruby-parser 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 67bbbdf0c0e64c96b6f81824ccc09709ebf052c7673534845d603706570d96e8
+  data.tar.gz: 14f5d04f9e1ca82141d72fbd485b42614d9a89fbd75005f3d0cc9be8b4de48e4
+SHA512:
+  metadata.gz: 26749ce437c50f9c1abb9c736c1b42da827a8bd9eceb00ad5494935fafdf72ae35b6a944fc64a1d4547960467a73ffd43cdad3cf50f8d31374e7a2123f40884c
+  data.tar.gz: 9c11b4ea8624de55a3388b0b63ffba1605d87d5f7ac535c0e80e30412812b70aade514e04e0618b4aaba1cc3b9c90374e01cd3759968a6e6b8e1d7165ab2005f

data/.gitignore

@@ -0,0 +1 @@
+tmp/

data/.overcommit.yml

@@ -0,0 +1,4 @@
+PreCommit:
+  Format:
+    enabled: true
+    command: ["bin/format"]

data/Gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "rspec"
+gem "syntax_tree"
+gem "profile"

data/Gemfile.lock

@@ -0,0 +1,32 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    prettier_print (1.0.2)
+    profile (0.4.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.0)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.0)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.0)
+    syntax_tree (4.3.0)
+      prettier_print (>= 1.0.2)
+
+PLATFORMS
+  arm64-darwin-21
+
+DEPENDENCIES
+  profile
+  rspec
+  syntax_tree
+
+BUNDLED WITH
+   2.3.22

data/bin/code-parser

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require_relative "../lib/code-ruby-parser"
+require "json"
+
+options = {}
+
+OptionParser
+  .new do |opts|
+    opts.banner = "Usage: bin/code-parser [options]"
+
+    opts.on(
+      "-i INPUT",
+      "--input=INPUT",
+      "Input in the code language (String or File)"
+    ) do |input|
+      input = File.read(input) if File.exists?(input)
+
+      options[:input] = input
+    end
+  end
+  .parse!
+
+input = options.fetch(:input, "")
+
+puts JSON.pretty_generate(::Code::Parser.parse(input))

data/bin/format

@@ -0,0 +1,3 @@
+#!/usr/bin/env fish
+
+stree write Gemfile lib/**/*.rb spec/**/*.rb bin/code-parser

data/bin/template-parser

@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+
+require "optparse"
+require_relative "../lib/code-ruby-parser"
+require "json"
+
+options = {}
+
+OptionParser
+  .new do |opts|
+    opts.banner = "Usage: bin/template-parser [options]"
+
+    opts.on(
+      "-i INPUT",
+      "--input=INPUT",
+      "Input in the code language (String or File)"
+    ) do |input|
+      input = File.read(input) if File.exists?(input)
+
+      options[:input] = input
+    end
+  end
+  .parse!
+
+input = options.fetch(:input, "")
+
+puts JSON.pretty_generate(::Template::Parser.parse(input))

data/docs/class.code

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

data/docs/meetup.code

@@ -0,0 +1,14 @@
+url = fetch(:url) { "https://www.meetup.com/parisrb" }
+response = HTTP.get(url)
+times = response.css(".groupHome-eventsList-upcomingEvents time")
+times = times.map(&:datetime).map do |time|
+  Time.from_epoch(time.to_integer)
+end
+
+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/rain.code

@@ -0,0 +1,23 @@
+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

@@ -0,0 +1,17 @@
+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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,7 @@
+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/parser/addition.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Addition < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [PLUS, MINUS],
+          subclass: ::Code::Parser::Multiplication
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/and_operator.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class AndOperator < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [AMPERSAND + AMPERSAND],
+          subclass: ::Code::Parser::GreaterThan
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/bitwise_and.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class BitwiseAnd < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [AMPERSAND],
+          subclass: ::Code::Parser::Shift
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/bitwise_or.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class BitwiseOr < ::Code::Parser
+      def parse
+        parse_subclass(
+          ::Code::Parser::Operation,
+          operators: [PIPE, CARET],
+          subclass: ::Code::Parser::BitwiseAnd
+        )
+      end
+    end
+  end
+end

data/lib/code/parser/boolean.rb

@@ -0,0 +1,13 @@
+class Code
+  class Parser
+    class Boolean < ::Code::Parser
+      def parse
+        if match(BOOLEAN_KEYWORDS)
+          { boolean: buffer }
+        else
+          parse_subclass(::Code::Parser::Nothing)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/call.rb

@@ -0,0 +1,174 @@
+class Code
+  class Parser
+    class Call < ::Code::Parser
+      def parse
+        identifier = parse_subclass(::Code::Parser::Identifier)
+        return unless identifier
+
+        if match(OPENING_PARENTHESIS)
+          arguments = []
+
+          arguments << (parse_keyword_argument || parse_regular_argument)
+
+          while match(COMMA) && !end_of_input?
+            arguments << (parse_keyword_argument || parse_regular_argument)
+          end
+
+          arguments.compact!
+
+          match(CLOSING_PARENTHESIS)
+        else
+          arguments = nil
+        end
+
+        previous_cursor = cursor
+        comments = parse_comments
+
+        if match(DO_KEYWORD)
+          block = parse_block
+          match(END_KEYWORD)
+        elsif match(OPENING_CURLY_BRACKET)
+          block = parse_block
+          match(CLOSING_CURLY_BRACKET)
+        else
+          @cursor = previous_cursor
+          buffer!
+          block = nil
+        end
+
+        {
+          call: {
+            **identifier,
+            arguments: arguments,
+            block: block,
+            comments: comments
+          }.compact
+        }
+      end
+
+      private
+
+      def parse_block
+        comments = parse_comments
+
+        if match(PIPE)
+          parameters = []
+
+          parameters << (parse_keyword_parameter || parse_regular_parameter)
+
+          while match(COMMA) && !end_of_input?
+            parameters << (parse_keyword_parameter || parse_regular_parameter)
+          end
+
+          match(PIPE)
+
+          {
+            comments: comments,
+            parameters: parameters.compact,
+            body: parse_code
+          }.compact
+        else
+          { comments: comments, body: parse_code }.compact
+        end
+      end
+
+      def parse_keyword_argument
+        previous_cursor = cursor
+
+        comments_before = parse_comments
+        key = parse_subclass(::Code::Parser::Statement)
+        comments_after = parse_comments
+
+        if key && match(COLON) || match(EQUAL + GREATER)
+          default = parse_code
+          default = nil if default.empty?
+          {
+            comments_before: comments_before,
+            comments_after: comments_after,
+            default: default,
+            keyword: true,
+            statement: key
+          }.compact
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+      end
+
+      def parse_regular_argument
+        code = parse_code
+        return if code.empty?
+        code
+      end
+
+      def parse_keyword_parameter
+        previous_cursor = cursor
+
+        comments_before = parse_comments
+        key = parse_subclass(::Code::Parser::Identifier)
+        comments_after = parse_comments
+
+        if key && match(COLON) || match(EQUAL + GREATER)
+          default = parse_default
+
+          {
+            comments_before: comments_before,
+            comments_after: comments_after,
+            default: default,
+            keyword: true,
+            **key
+          }.compact
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+      end
+
+      def parse_regular_parameter
+        previous_cursor = cursor
+        comments_before = parse_comments
+        identifier = parse_subclass(::Code::Parser::Identifier)
+        if identifier
+          comments_after = parse_comments
+
+          if match(EQUAL)
+            default = parse_default
+
+            {
+              comments_before: comments_before,
+              comments_after: comments_after,
+              default: default,
+              **identifier
+            }.compact
+          else
+            {
+              comments_before: comments_before,
+              comments_after: comments_after,
+              **identifier
+            }.compact
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          return
+        end
+      end
+
+      def parse_default
+        comments_before = parse_comments
+        statement = parse_subclass(::Code::Parser::BitwiseAnd)
+        comments_after = parse_comments
+
+        default = {
+          comments_before: comments_before,
+          statement: statement,
+          comments_after: comments_after
+        }.compact
+
+        default.empty? ? nil : default
+      end
+    end
+  end
+end

data/lib/code/parser/chained_call.rb

@@ -0,0 +1,41 @@
+class Code
+  class Parser
+    class ChainedCall < ::Code::Parser
+      def parse
+        previous_cursor = cursor
+        left = parse_dictionnary
+        comments_before = parse_comments
+
+        if left && match([DOT, COLON + COLON])
+          comments_after = parse_comments
+          right = parse_dictionnary
+          if right
+            chained_call = [{ left: left, right: right }]
+            while match([DOT, COLON + COLON]) && other_right = parse_dictionnary
+              chained_call << { right: other_right }
+            end
+            {
+              chained_call: {
+                calls: chained_call,
+                comments_before: comments_before,
+                comments_after: comments_after
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_dictionnary
+          end
+        else
+          @cursor = previous_cursor
+          buffer!
+          parse_dictionnary
+        end
+      end
+
+      def parse_dictionnary
+        parse_subclass(::Code::Parser::Dictionnary)
+      end
+    end
+  end
+end

data/lib/code/parser/class.rb

@@ -0,0 +1,56 @@
+class Code
+  class Parser
+    class Class < ::Code::Parser
+      def parse
+        previous_cursor = cursor
+
+        if match(CLASS_KEYWORD)
+          first_comments = parse_comments
+
+          name = parse_subclass(::Code::Parser::Identifier, simple: true)
+
+          if name
+            second_comments = parse_comments
+
+            if match(LESSER)
+              previous_cursor = cursor
+              third_comments = parse_comments
+              superclass =
+                parse_subclass(::Code::Parser::Identifier, simple: true)
+
+              if !superclass
+                @cursor = previous_cursor
+                buffer!
+                third_comments = nil
+              end
+            else
+              third_comments = nil
+              superclass = nil
+            end
+
+            body = parse_code
+
+            match(END_KEYWORD)
+
+            {
+              class: {
+                name: name,
+                superclass: superclass,
+                first_comments: first_comments,
+                second_comments: second_comments,
+                third_comments: third_comments,
+                body: body
+              }.compact
+            }
+          else
+            @cursor = previous_cursor
+            buffer!
+            parse_subclass(::Code::Parser::While)
+          end
+        else
+          parse_subclass(::Code::Parser::While)
+        end
+      end
+    end
+  end
+end

data/lib/code/parser/code.rb

@@ -0,0 +1,20 @@
+class Code
+  class Parser
+    class Code < ::Code::Parser
+      def parse
+        output = []
+
+        comments = parse_comments
+        output << { comments: comments } if comments
+
+        while code = parse_subclass(::Code::Parser::Statement)
+          output << code
+          comments = parse_comments
+          output << { comments: comments } if comments
+        end
+
+        output
+      end
+    end
+  end
+end

data/lib/code/parser/comments.rb

@@ -0,0 +1,46 @@
+class Code
+  class Parser
+    class Comments < ::Code::Parser
+      def initialize(input, whitespace: WHITESPACE, **kargs)
+        super(input, **kargs)
+        @whitespace = whitespace
+        @has_line_comments = whitespace.include?(NEWLINE)
+      end
+
+      def parse
+        comments = []
+
+        while next?(whitespace) || next?(SLASH + ASTERISK) ||
+                (line_comments? && (next?(SLASH + SLASH) || next?(HASH)))
+          consume while next?(whitespace)
+          buffer!
+
+          if match(SLASH + SLASH) || match(HASH)
+            consume while !next?(NEWLINE) && !end_of_input?
+            match(NEWLINE)
+            comments << buffer
+          end
+
+          consume while next?(whitespace)
+          buffer!
+
+          if match(SLASH + ASTERISK)
+            consume while !next?(ASTERISK + SLASH) && !end_of_input?
+            match(ASTERISK + SLASH)
+            comments << buffer
+          end
+        end
+
+        comments.empty? ? nil : comments
+      end
+    end
+
+    private
+
+    attr_reader :whitespace, :has_line_comments
+
+    def line_comments?
+      !!has_line_comments
+    end
+  end
+end

data/lib/code/parser/dictionnary.rb

@@ -0,0 +1,48 @@
+class Code
+  class Parser
+    class Dictionnary < ::Code::Parser
+      def parse
+        if match(OPENING_CURLY_BRACKET)
+          dictionnary = []
+
+          comments = parse_comments
+
+          dictionnary << parse_key_value
+
+          dictionnary << parse_key_value while match(COMMA) && !end_of_input?
+
+          match(CLOSING_CURLY_BRACKET)
+
+          { dictionnary: dictionnary.compact, comments: comments }
+        else
+          parse_subclass(::Code::Parser::List)
+        end
+      end
+
+      def parse_key_value
+        comments_before = parse_comments
+
+        key = parse_subclass(::Code::Parser::Statement)
+
+        comments_after = parse_comments
+
+        return unless key
+
+        if match(COLON) || match(EQUAL + GREATER)
+          {
+            key: key,
+            value: parse_code,
+            comments_before: comments_before,
+            comments_after: comments_after
+          }.compact
+        else
+          {
+            key: key,
+            comments_before: comments_before,
+            comments_after: comments_after
+          }.compact
+        end
+      end
+    end
+  end
+end