language-ruby 0.5.6 → 0.6.1

data/lib/language/atom.rb

@@ -1,290 +1,13 @@
+# frozen_string_literal: true
+
 class Language
   class Atom
-    class Rule < Atom
-      def initialize(name:)
-        @name = name
-      end
-
-      def parse(parser)
-        parser.find_rule!(@name).parse(parser)
-      end
-
-      def to_s
-        "rule(#{@name.inspect})"
-      end
-    end
-
-    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, min: 0, max: nil)
-        @parent = parent
-        @min = min
-        @max = max
-      end
-
-      def parse(parser)
-        return unless @parent
-
-        if @max.nil?
-          @min.times { match(parser) }
-
-          begin
-            loop { match(parser) }
-          rescue Parser::Interuption
-          end
-        else
-          @min.times { match(parser) }
-
-          begin
-            (@max - @min).times { match(parser) }
-          rescue Parser::Interuption
-          end
-        end
-      end
-
-      def to_s
-        min = @min.zero? ? "" : @min.to_s
-        max = @max.nil? ? "" : ", #{@max}"
-        parenthesis = min.empty? && max.empty? ? "" : "(#{min}#{max})"
-
-        @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)
-        if parser.next?(@string)
-          parser.consume(@string.size)
-        else
-          raise Parser::Str::NotFound.new(parser, @string)
-        end
-      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) if @parent
-      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) if @parent
-        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.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
 
     def str(string)
-      Str.new(string: string)
+      Str.new(string:)
     end
 
     def absent
@@ -299,12 +22,12 @@ class Language
       Maybe.new(parent: self)
     end
 
-    def repeat(min = 0, max = nil)
-      Repeat.new(parent: self, min: min, max: max)
+    def repeat(minimum = 0, maximum = nil)
+      Repeat.new(parent: self, minimum:, maximum:)
     end
 
     def aka(name)
-      Aka.new(parent: self, name: name)
+      Aka.new(parent: self, name:)
     end
 
     def |(other)
@@ -320,19 +43,15 @@ class Language
     end
 
     def then(&block)
-      Then.new(parent: self, block: block)
-    end
-
-    def rule(name)
-      Rule.new(name: name)
+      Then.new(parent: self, block:)
     end
 
-    def parse(parser)
-      raise NotImplementedError.new("#{self.class}#parse")
+    def parse(_parser)
+      raise NotImplementedError, "#{self.class}#parse"
     end
 
     def to_s
-      ""
+      raise NotImplementedError, "#{self.class}#parse"
     end
 
     def inspect

data/lib/language/output.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Output
     attr_reader :raw
@@ -10,7 +12,7 @@ class Language
       if raw.is_a?(Array)
         new(raw.map { |element| from_raw(element) })
       elsif raw.is_a?(Hash)
-        new(raw.map { |key, value| [key, from_raw(value)] }.to_h)
+        new(raw.transform_values { |value| from_raw(value) })
       else
         new(raw)
       end
@@ -20,7 +22,7 @@ class Language
       if raw.is_a?(Array)
         raw.map(&:to_raw)
       elsif raw.is_a?(Hash)
-        raw.map { |key, value| [key, value.to_raw] }.to_h
+        raw.transform_values(&:to_raw)
       else
         raw
       end
@@ -35,7 +37,7 @@ class Language
     end
 
     def ==(other)
-      other.is_a?(Output) ? raw == other.raw : raw == other
+      raw == (other.is_a?(Output) ? other.raw : other)
     end
 
     def to_s
@@ -66,7 +68,7 @@ class Language
       when String
         case other.raw
         when String
-          @raw = @raw + other.raw
+          @raw += other.raw
         when Array
           @raw = other.raw
         when Hash
@@ -75,18 +77,18 @@ class Language
       when Array
         case other.raw
         when String
-          return
+          nil
         when Array
-          @raw = @raw + other.raw
+          @raw += other.raw
         when Hash
           @raw << other
         end
       when Hash
         case other.raw
         when String
-          return
+          nil
         when Array
-          return
+          nil
         when Hash
           @raw.merge!(other.raw)
         end
@@ -107,7 +109,7 @@ class Language
       when String
         case other.raw
         when String
-          @raw = @raw + other.raw
+          @raw += other.raw
         when Array
           @raw = [other]
         when Hash
@@ -118,9 +120,9 @@ class Language
       when Hash
         case other.raw
         when String
-          return
+          nil
         when Array
-          return
+          nil
         when Hash
           @raw.merge!(other.raw)
         end

data/lib/language/parser/absent/present.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class Absent

data/lib/language/parser/absent.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class Absent

data/lib/language/parser/end_of_input.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class EndOfInput < Interuption

data/lib/language/parser/interuption.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class Interuption < StandardError

data/lib/language/parser/not_end_of_input.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class NotEndOfInput < Interuption

data/lib/language/parser/str/not_found.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class Str

data/lib/language/parser/str.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     class Str

data/lib/language/parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   class Parser
     attr_accessor :input, :buffer, :output, :root, :cursor
@@ -13,20 +15,18 @@ class Language
     def parse(check_end_of_input: true)
       @root.parse(self)
 
-      if @cursor == @input.size || !check_end_of_input
-        @output.present? ? @output : Output.new(@buffer)
-      else
-        raise NotEndOfInput.new(self)
+      unless @cursor == @input.size || !check_end_of_input
+        raise NotEndOfInput, self
       end
+
+      @output.present? ? @output : Output.new(@buffer)
     end
 
     def consume(n)
-      if @cursor + n <= @input.size
-        @buffer += @input[@cursor, n]
-        @cursor += n
-      else
-        raise EndOfInput.new(self)
-      end
+      raise EndOfInput, self unless @cursor + n <= @input.size
+
+      @buffer += @input[@cursor, n]
+      @cursor += n
     end
 
     def aka(name)

data/lib/language/version.rb

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

data/lib/language-ruby.rb

@@ -1,10 +1,7 @@
-require "bigdecimal"
-require "stringio"
-require "timeout"
+# frozen_string_literal: true
+
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem(warn_on_extra_files: false)
-loader.ignore("#{__dir__}/template-ruby.rb")
-loader.ignore("#{__dir__}/code-ruby.rb")
 loader.ignore("#{__dir__}/language-ruby.rb")
 loader.setup

data/lib/language.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Language
   def self.parse(input)
     new.parse(input)
@@ -15,12 +17,12 @@ class Language
     Atom::Maybe.new(parent: new)
   end
 
-  def self.repeat(min = 0, max = nil)
-    Atom::Repeat.new(parent: new, min: min, max: max)
+  def self.repeat(minimum = 0, maximum = nil)
+    Atom::Repeat.new(parent: new, minimum:, maximum:)
   end
 
   def self.aka(name)
-    Atom::Aka.new(parent: new, name: name)
+    Atom::Aka.new(parent: new, name:)
   end
 
   def self.|(other)
@@ -36,7 +38,7 @@ class Language
   end
 
   def self.then(&block)
-    Atom::Then.new(parent: new, block: block)
+    Atom::Then.new(parent: new, block:)
   end
 
   def parse(input_or_parser)
@@ -44,7 +46,7 @@ class Language
       parser = input_or_parser
       clone =
         Parser.new(
-          root: root,
+          root:,
           input: parser.input,
           cursor: parser.cursor,
           buffer: parser.buffer,
@@ -58,12 +60,12 @@ class Language
       parser.output = clone.output
     else
       input = input_or_parser
-      Parser.new(root: root, input: input).parse
+      Parser.new(root:, input:).parse
     end
   end
 
   def str(string)
-    Atom::Str.new(string: string)
+    Atom::Str.new(string:)
   end
 
   def any

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,6 +1,3 @@
-require_relative "../lib/template-ruby"
-require "json"
+# frozen_string_literal: true
 
-RSpec.configure do |c|
-  c.example_status_persistence_file_path = "tmp/examples.txt"
-end
+require_relative "../lib/language-ruby"