language-ruby 0.6.0 → 0.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdf5e247df3ee0c287a560265c60107d161eb4b7cb71610f6f50c15c81c2e3aa
-  data.tar.gz: acfe4eea02eb399831fd378adb0bd69100efbdecaeead3c99a2faaec11e552cb
+  metadata.gz: fe75dad140254848b0688e73fc0361003867abf259e3efd57eb8709072808461
+  data.tar.gz: 592c2cf305d38613461981802bb63a9288b2a7bac862220cb818c4e1b9e1922c
 SHA512:
-  metadata.gz: 318d1dd9888a5aee6aec7fef5410b9092f169e6e12e1d4a0608c6a2e36b2ae4b3bfc6412052a8e331a9b1260bf4387ccfa6340e1ea74f7511da049ff222d4050
-  data.tar.gz: 5c0c443194c047a08c461f9b713fcf131ebd12ce479b81d344415202694106a7db00e19547c37319c6d69d4a0bc78a768b0a8aaf1d29e1b9a7ae1369d87c520e
+  metadata.gz: b61958d200d6d2e2f1a0ed41e93a992320e3b224c8e65f0cfb3e3ff35ad78f07b930234d2ec190cad4384b1127a347d7651597831033bf1b14bda18a488f6f41
+  data.tar.gz: eb44f9c8522a461b4b40e7b369a9ac0653ff30c710c2c5395840e3e5b8181596ce4553fa7033370636e6974dd79e2e326e0e7bf6d0f2061be84468d30b670b49

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/.rspec

@@ -0,0 +1 @@
+--require spec_helper

data/.ruby-version

@@ -0,0 +1 @@
+3.3.0

data/.tool-versions

@@ -0,0 +1 @@
+ruby 3.3.0

data/Gemfile

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
 source "https://rubygems.org"
 
 gemspec
 
+ruby "3.3.0"
+
 gem "rspec"

data/Gemfile.lock

@@ -0,0 +1,38 @@
+PATH
+  remote: .
+  specs:
+    language-ruby (0.6.0)
+      zeitwerk (~> 2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    diff-lcs (1.5.0)
+    rspec (3.12.0)
+      rspec-core (~> 3.12.0)
+      rspec-expectations (~> 3.12.0)
+      rspec-mocks (~> 3.12.0)
+    rspec-core (3.12.2)
+      rspec-support (~> 3.12.0)
+    rspec-expectations (3.12.3)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-mocks (3.12.6)
+      diff-lcs (>= 1.2.0, < 2.0)
+      rspec-support (~> 3.12.0)
+    rspec-support (3.12.1)
+    zeitwerk (2.6.12)
+
+PLATFORMS
+  arm64-darwin-22
+  arm64-darwin-23
+
+DEPENDENCIES
+  language-ruby!
+  rspec
+
+RUBY VERSION
+   ruby 3.3.0p0
+
+BUNDLED WITH
+   2.4.21

data/README.md

@@ -0,0 +1,3 @@
+# language-ruby
+
+A Parsing Expression Grammar (PEG) for making parsers

data/language-ruby.gemspec

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require "English"
 require_relative "lib/language/version"
 
 Gem::Specification.new do |s|
@@ -7,8 +10,7 @@ Gem::Specification.new do |s|
   s.description = s.summary
   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.files = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
   s.require_paths = ["lib"]
   s.homepage = "https://github.com/dorianmariefr/language-ruby"
   s.license = "MIT"

data/lib/language/atom/absent.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Absent < Atom
+      def initialize(parent: nil)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @parent&.parse(clone)
+      rescue Parser::Interuption
+      else
+        raise Parser::Interuption.new(parser, self)
+      end
+
+      def to_s
+        @parent ? "(#{@parent}).absent" : "absent"
+      end
+    end
+  end
+end

data/lib/language/atom/aka.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Aka < Atom
+      def initialize(name:, parent:)
+        @name = name
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(root: self, input: parser.input, cursor: parser.cursor)
+
+        @parent.parse(clone)
+
+        if clone.output?
+          parser.output = Output.new(@name => clone.output)
+        else
+          parser.output[@name] = Output.new(clone.buffer)
+          parser.buffer = ""
+        end
+
+        parser.cursor = clone.cursor
+      end
+
+      def to_s
+        @parent ? "#{@parent}.aka(#{@name.inspect})" : "aka(#{@name.inspect})"
+      end
+    end
+  end
+end

data/lib/language/atom/and.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class And < Atom
+      def initialize(left:, right:)
+        @left = left
+        @right = right
+      end
+
+      def parse(parser)
+        @left.parse(parser)
+        right_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @right.parse(right_clone)
+        parser.cursor = right_clone.cursor
+        parser.buffer = right_clone.buffer
+
+        parser.output.merge(right_clone.output)
+      end
+
+      def to_s
+        "#{@left} >> #{@right}".to_s
+      end
+    end
+  end
+end

data/lib/language/atom/any.rb

@@ -3,6 +3,13 @@
 class Language
   class Atom
     class Any < Atom
+      def parse(parser)
+        parser.consume(1)
+      end
+
+      def to_s
+        "any"
+      end
     end
   end
 end

data/lib/language/atom/ignore.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Ignore < Atom
+      def initialize(parent:)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+        @parent.parse(clone)
+        parser.cursor = clone.cursor
+      end
+
+      def to_s
+        "#{@parent}.ignore"
+      end
+    end
+  end
+end

data/lib/language/atom/maybe.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Maybe < Atom
+      def initialize(parent:)
+        @parent = parent
+      end
+
+      def parse(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        @parent.parse(clone)
+      rescue Parser::Interuption
+      else
+        parser.buffer = clone.buffer
+        parser.cursor = clone.cursor
+        parser.output = clone.output
+      end
+
+      def to_s
+        @parent ? "#{@parent}.maybe" : "maybe"
+      end
+    end
+  end
+end

data/lib/language/atom/or.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Or < Atom
+      def initialize(left:, right:)
+        @left = left
+        @right = right
+      end
+
+      def parse(parser)
+        left_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        right_clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        begin
+          @left.parse(left_clone)
+          parser.cursor = left_clone.cursor
+          parser.buffer = left_clone.buffer
+          parser.output.merge(left_clone.output)
+        rescue Parser::Interuption
+          @right.parse(right_clone)
+          parser.cursor = right_clone.cursor
+          parser.buffer = right_clone.buffer
+          parser.output.merge(right_clone.output)
+        end
+      end
+
+      def to_s
+        "((#{@left}) | (#{@right}))"
+      end
+    end
+  end
+end

data/lib/language/atom/repeat.rb

@@ -3,13 +3,55 @@
 class Language
   class Atom
     class Repeat < Atom
-      def initialize(parent:)
+      def initialize(parent: nil, minimum: 0, maximum: nil)
         @parent = parent
+        @minimum = minimum
+        @maximum = maximum
+      end
+
+      def parse(parser)
+        return unless @parent
+
+        @minimum.times { match(parser) }
+        if @maximum.nil?
+          begin
+            loop { match(parser) }
+          rescue Parser::Interuption
+          end
+        else
+          begin
+            (@maximum - @minimum).times { match(parser) }
+          rescue Parser::Interuption
+          end
+        end
+      end
+
+      def to_s
+        minimum = @minimum.zero? ? "" : @minimum.to_s
+        maximum = @maximum.nil? ? "" : ", #{@maximum}"
+        parenthesis =
+          (minimum.empty? && maximum.empty?) ? "" : "(#{minimum}#{maximum})"
+
+        @parent ? "(#{@parent}).repeat#{parenthesis}" : "repeat#{parenthesis}"
       end
 
       private
 
-      attr_reader :parent
+      def match(parser)
+        clone =
+          Parser.new(
+            root: self,
+            input: parser.input,
+            cursor: parser.cursor,
+            buffer: parser.buffer
+          )
+
+        @parent.parse(clone)
+
+        parser.cursor = clone.cursor
+        parser.buffer = clone.buffer
+        parser.output << clone.output
+      end
     end
   end
 end

data/lib/language/atom/str.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Str < Atom
+      def initialize(string:)
+        @string = string
+      end
+
+      def parse(parser)
+        raise Parser::Str::NotFound.new(parser, @string) unless parser.next?(@string)
+
+        parser.consume(@string.size)
+      end
+
+      def to_s
+        "str(#{@string.inspect})"
+      end
+    end
+  end
+end

data/lib/language/atom/then.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Language
+  class Atom
+    class Then < Atom
+      def initialize(parent:, block:)
+        @parent = parent
+        @block = block
+      end
+
+      def parse(parser)
+        @parent.parse(parser)
+        parser.output = Output.from_raw(@block.call(parser.output.to_raw))
+      end
+
+      def to_s
+        "(#{@parent}).then {}"
+      end
+    end
+  end
+end

data/lib/language/atom.rb

@@ -2,270 +2,6 @@
 
 class Language
   class Atom
-    class Any < Atom
-      def parse(parser)
-        parser.consume(1)
-      end
-
-      def to_s
-        "any"
-      end
-    end
-
-    class Then < Atom
-      def initialize(parent:, block:)
-        @parent = parent
-        @block = block
-      end
-
-      def parse(parser)
-        @parent.parse(parser)
-        parser.output = Output.from_raw(@block.call(parser.output.to_raw))
-      end
-
-      def to_s
-        "(#{@parent}).then {}"
-      end
-    end
-
-    class Repeat < Atom
-      def initialize(parent: nil, minimum: 0, maximum: nil)
-        @parent = parent
-        @minimum = minimum
-        @maximum = maximum
-      end
-
-      def parse(parser)
-        return unless @parent
-
-        @minimum.times { match(parser) }
-        if @maximum.nil?
-          begin
-            loop { match(parser) }
-          rescue Parser::Interuption
-          end
-        else
-          begin
-            (@maximum - @minimum).times { match(parser) }
-          rescue Parser::Interuption
-          end
-        end
-      end
-
-      def to_s
-        minimum = @minimum.zero? ? "" : @minimum.to_s
-        maximum = @maximum.nil? ? "" : ", #{@maximum}"
-        parenthesis =
-          minimum.empty? && maximum.empty? ? "" : "(#{minimum}#{maximum})"
-
-        @parent ? "(#{@parent}).repeat#{parenthesis}" : "repeat#{parenthesis}"
-      end
-
-      private
-
-      def match(parser)
-        clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-
-        @parent.parse(clone)
-
-        parser.cursor = clone.cursor
-        parser.buffer = clone.buffer
-        parser.output << clone.output
-      end
-    end
-
-    class Str < Atom
-      def initialize(string:)
-        @string = string
-      end
-
-      def parse(parser)
-        unless parser.next?(@string)
-          raise Parser::Str::NotFound.new(parser, @string)
-        end
-
-        parser.consume(@string.size)
-      end
-
-      def to_s
-        "str(#{@string.inspect})"
-      end
-    end
-
-    class Absent < Atom
-      def initialize(parent: nil)
-        @parent = parent
-      end
-
-      def parse(parser)
-        clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-        @parent&.parse(clone)
-      rescue Parser::Interuption
-      else
-        raise Parser::Interuption.new(parser, self)
-      end
-
-      def to_s
-        @parent ? "(#{@parent}).absent" : "absent"
-      end
-    end
-
-    class Ignore < Atom
-      def initialize(parent: nil)
-        @parent = parent
-      end
-
-      def parse(parser)
-        clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-        @parent&.parse(clone)
-        parser.cursor = clone.cursor
-      end
-
-      def to_s
-        @parent ? "#{@parent}.ignore" : "ignore"
-      end
-    end
-
-    class Maybe < Atom
-      def initialize(parent:)
-        @parent = parent
-      end
-
-      def parse(parser)
-        clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-
-        @parent.parse(clone)
-      rescue Parser::Interuption
-      else
-        parser.buffer = clone.buffer
-        parser.cursor = clone.cursor
-        parser.output = clone.output
-      end
-
-      def to_s
-        @parent ? "#{@parent}.maybe" : "maybe"
-      end
-    end
-
-    class Aka < Atom
-      def initialize(name:, parent:)
-        @name = name
-        @parent = parent
-      end
-
-      def parse(parser)
-        clone =
-          Parser.new(root: self, input: parser.input, cursor: parser.cursor)
-
-        @parent.parse(clone)
-
-        if clone.output?
-          parser.output = Output.new(@name => clone.output)
-        else
-          parser.output[@name] = Output.new(clone.buffer)
-          parser.buffer = ""
-        end
-
-        parser.cursor = clone.cursor
-      end
-
-      def to_s
-        @parent ? "#{@parent}.aka(#{@name.inspect})" : "aka(#{@name.inspect})"
-      end
-    end
-
-    class Or < Atom
-      def initialize(left:, right:)
-        @left = left
-        @right = right
-      end
-
-      def parse(parser)
-        left_clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-
-        right_clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-
-        begin
-          @left.parse(left_clone)
-          parser.cursor = left_clone.cursor
-          parser.buffer = left_clone.buffer
-          parser.output.merge(left_clone.output)
-        rescue Parser::Interuption
-          @right.parse(right_clone)
-          parser.cursor = right_clone.cursor
-          parser.buffer = right_clone.buffer
-          parser.output.merge(right_clone.output)
-        end
-      end
-
-      def to_s
-        "((#{@left}) | (#{@right}))"
-      end
-    end
-
-    class And < Atom
-      def initialize(left:, right:)
-        @left = left
-        @right = right
-      end
-
-      def parse(parser)
-        @left.parse(parser)
-        right_clone =
-          Parser.new(
-            root: self,
-            input: parser.input,
-            cursor: parser.cursor,
-            buffer: parser.buffer
-          )
-        @right.parse(right_clone)
-        parser.cursor = right_clone.cursor
-        parser.buffer = right_clone.buffer
-
-        parser.output.merge(right_clone.output)
-      end
-
-      def to_s
-        "#{@left} >> #{@right}".to_s
-      end
-    end
-
     def any
       Any.new
     end
@@ -315,7 +51,7 @@ class Language
     end
 
     def to_s
-      ""
+      raise NotImplementedError, "#{self.class}#parse"
     end
 
     def inspect

data/lib/language/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative "../language"
 
-Language::Version = Gem::Version.new("0.6.0")
+Language::Version = Gem::Version.new("0.6.1")

data/lib/language-ruby.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)

data/spec/language_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class Code
+  class Parser
+    class Nothing < Language
+      def nothing_keyword
+        str("nothing")
+      end
+
+      def root
+        nothing_keyword.aka(:nothing)
+      end
+    end
+  end
+end
+
+RSpec.describe Language do
+  it "works" do
+    expect(Code::Parser::Nothing.parse("nothing")).to eq({ nothing: "nothing" })
+  end
+end

data/spec/spec_helper.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative "../lib/language-ruby"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: language-ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.1
 platform: ruby
 authors:
 - Dorian Marié
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-11-10 00:00:00.000000000 Z
+date: 2024-01-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: zeitwerk
@@ -30,13 +30,27 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-version"
+- ".tool-versions"
 - Gemfile
+- Gemfile.lock
+- README.md
 - language-ruby.gemspec
 - lib/language-ruby.rb
 - lib/language.rb
 - lib/language/atom.rb
+- lib/language/atom/absent.rb
+- lib/language/atom/aka.rb
+- lib/language/atom/and.rb
 - lib/language/atom/any.rb
+- lib/language/atom/ignore.rb
+- lib/language/atom/maybe.rb
+- lib/language/atom/or.rb
 - lib/language/atom/repeat.rb
+- lib/language/atom/str.rb
+- lib/language/atom/then.rb
 - lib/language/output.rb
 - lib/language/parser.rb
 - lib/language/parser/absent.rb
@@ -47,6 +61,7 @@ files:
 - lib/language/parser/str.rb
 - lib/language/parser/str/not_found.rb
 - lib/language/version.rb
+- spec/language_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/dorianmariefr/language-ruby
 licenses:
@@ -67,9 +82,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.14
+rubygems_version: 3.5.3
 signing_key:
 specification_version: 4
 summary: A Parsing Expression Grammar (PEG) for making parsers
-test_files:
-- spec/spec_helper.rb
+test_files: []