lrama 0.5.0 → 0.5.2

data/lib/lrama/state.rb

@@ -0,0 +1,184 @@
+require "lrama/state/reduce"
+require "lrama/state/shift"
+
+module Lrama
+  class State
+    # * symbol: A symbol under discussion
+    # * reduce: A reduce under discussion
+    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
+    ResolvedConflict = Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true) do
+      def report_message
+        s = symbol.display_name
+        r = reduce.rule.precedence_sym.display_name
+        case
+        when which == :shift && same_prec
+          msg = "resolved as #{which} (%right #{s})"
+        when which == :shift
+          msg = "resolved as #{which} (#{r} < #{s})"
+        when which == :reduce && same_prec
+          msg = "resolved as #{which} (%left #{s})"
+        when which == :reduce
+          msg = "resolved as #{which} (#{s} < #{r})"
+        when which == :error
+          msg = "resolved as an #{which} (%nonassoc #{s})"
+        else
+          raise "Unknown direction. #{self}"
+        end
+
+        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
+      end
+    end
+
+    Conflict = Struct.new(:symbols, :reduce, :type, keyword_init: true)
+
+    attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
+                :default_reduction_rule, :closure, :items
+    attr_accessor :shifts, :reduces
+
+    def initialize(id, accessing_symbol, kernels)
+      @id = id
+      @accessing_symbol = accessing_symbol
+      @kernels = kernels.freeze
+      @items = @kernels
+      # Manage relationships between items to state
+      # to resolve next state
+      @items_to_state = {}
+      @conflicts = []
+      @resolved_conflicts = []
+      @default_reduction_rule = nil
+    end
+
+    def closure=(closure)
+      @closure = closure
+      @items = @kernels + @closure
+    end
+
+    def non_default_reduces
+      reduces.select do |reduce|
+        reduce.rule != @default_reduction_rule
+      end
+    end
+
+    def compute_shifts_reduces
+      _shifts = {}
+      reduces = []
+      items.each do |item|
+        # TODO: Consider what should be pushed
+        if item.end_of_rule?
+          reduces << Reduce.new(item)
+        else
+          key = item.next_sym
+          _shifts[key] ||= []
+          _shifts[key] << item.new_by_next_position
+        end
+      end
+
+      # It seems Bison 3.8.2 iterates transitions order by symbol number
+      shifts = _shifts.sort_by do |next_sym, new_items|
+        next_sym.number
+      end.map do |next_sym, new_items|
+        Shift.new(next_sym, new_items.flatten)
+      end
+      self.shifts = shifts.freeze
+      self.reduces = reduces.freeze
+    end
+
+    def set_items_to_state(items, next_state)
+      @items_to_state[items] = next_state
+    end
+
+    #
+    def set_look_ahead(rule, look_ahead)
+      reduce = reduces.find do |r|
+        r.rule == rule
+      end
+
+      reduce.look_ahead = look_ahead
+    end
+
+    # Returns array of [nterm, next_state]
+    def nterm_transitions
+      return @nterm_transitions if @nterm_transitions
+
+      @nterm_transitions = []
+
+      shifts.each do |shift|
+        next if shift.next_sym.term?
+
+        @nterm_transitions << [shift, @items_to_state[shift.next_items]]
+      end
+
+      @nterm_transitions
+    end
+
+    # Returns array of [term, next_state]
+    def term_transitions
+      return @term_transitions if @term_transitions
+
+      @term_transitions = []
+
+      shifts.each do |shift|
+        next if shift.next_sym.nterm?
+
+        @term_transitions << [shift, @items_to_state[shift.next_items]]
+      end
+
+      @term_transitions
+    end
+
+    def selected_term_transitions
+      term_transitions.select do |shift, next_state|
+        !shift.not_selected
+      end
+    end
+
+    # Move to next state by sym
+    def transition(sym)
+      result = nil
+
+      if sym.term?
+        term_transitions.each do |shift, next_state|
+          term = shift.next_sym
+          result = next_state if term == sym
+        end
+      else
+        nterm_transitions.each do |shift, next_state|
+          nterm = shift.next_sym
+          result = next_state if nterm == sym
+        end
+      end
+
+      raise "Can not transit by #{sym} #{self}" if result.nil?
+
+      result
+    end
+
+    def find_reduce_by_item!(item)
+      reduces.find do |r|
+        r.item == item
+      end || (raise "reduce is not found. #{item}")
+    end
+
+    def default_reduction_rule=(default_reduction_rule)
+      @default_reduction_rule = default_reduction_rule
+
+      reduces.each do |r|
+        if r.rule == default_reduction_rule
+          r.default_reduction = true
+        end
+      end
+    end
+
+    def sr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :shift_reduce
+      end
+    end
+
+    def rr_conflicts
+      @conflicts.select do |conflict|
+        conflict.type == :reduce_reduce
+      end
+    end
+  end
+end

data/lib/lrama/states.rb

@@ -2,228 +2,6 @@ require "forwardable"
 require "lrama/report"
 
 module Lrama
-  class State
-    class Reduce
-      # https://www.gnu.org/software/bison/manual/html_node/Default-Reductions.html
-      attr_reader :item, :look_ahead, :not_selected_symbols
-      attr_accessor :default_reduction
-
-      def initialize(item)
-        @item = item
-        @look_ahead = nil
-        @not_selected_symbols = []
-      end
-
-      def rule
-        @item.rule
-      end
-
-      def look_ahead=(look_ahead)
-        @look_ahead = look_ahead.freeze
-      end
-
-      def add_not_selected_symbol(sym)
-        @not_selected_symbols << sym
-      end
-
-      def selected_look_ahead
-        if @look_ahead
-          @look_ahead - @not_selected_symbols
-        else
-          []
-        end
-      end
-    end
-
-    class Shift
-      attr_reader :next_sym, :next_items
-      attr_accessor :not_selected
-
-      def initialize(next_sym, next_items)
-        @next_sym = next_sym
-        @next_items = next_items
-      end
-    end
-
-    # * symbol: A symbol under discussion
-    # * reduce: A reduce under discussion
-    # * which: For which a conflict is resolved. :shift, :reduce or :error (for nonassociative)
-    ResolvedConflict = Struct.new(:symbol, :reduce, :which, :same_prec, keyword_init: true) do
-      def report_message
-        s = symbol.display_name
-        r = reduce.rule.precedence_sym.display_name
-        case
-        when which == :shift && same_prec
-          msg = "resolved as #{which} (%right #{s})"
-        when which == :shift
-          msg = "resolved as #{which} (#{r} < #{s})"
-        when which == :reduce && same_prec
-          msg = "resolved as #{which} (%left #{s})"
-        when which == :reduce
-          msg = "resolved as #{which} (#{s} < #{r})"
-        when which == :error
-          msg = "resolved as an #{which} (%nonassoc #{s})"
-        else
-          raise "Unknown direction. #{self}"
-        end
-
-        "Conflict between rule #{reduce.rule.id} and token #{s} #{msg}."
-      end
-    end
-
-    Conflict = Struct.new(:symbols, :reduce, :type, keyword_init: true)
-
-    attr_reader :id, :accessing_symbol, :kernels, :conflicts, :resolved_conflicts,
-                :default_reduction_rule, :closure, :items
-    attr_accessor :shifts, :reduces
-
-    def initialize(id, accessing_symbol, kernels)
-      @id = id
-      @accessing_symbol = accessing_symbol
-      @kernels = kernels.freeze
-      @items = @kernels
-      # Manage relationships between items to state
-      # to resolve next state
-      @items_to_state = {}
-      @conflicts = []
-      @resolved_conflicts = []
-      @default_reduction_rule = nil
-    end
-
-    def closure=(closure)
-      @closure = closure
-      @items = @kernels + @closure
-    end
-
-    def non_default_reduces
-      reduces.select do |reduce|
-        reduce.rule != @default_reduction_rule
-      end
-    end
-
-    def compute_shifts_reduces
-      _shifts = {}
-      reduces = []
-      items.each do |item|
-        # TODO: Consider what should be pushed
-        if item.end_of_rule?
-          reduces << Reduce.new(item)
-        else
-          key = item.next_sym
-          _shifts[key] ||= []
-          _shifts[key] << item.new_by_next_position
-        end
-      end
-
-      # It seems Bison 3.8.2 iterates transitions order by symbol number
-      shifts = _shifts.sort_by do |next_sym, new_items|
-        next_sym.number
-      end.map do |next_sym, new_items|
-        Shift.new(next_sym, new_items.flatten)
-      end
-      self.shifts = shifts.freeze
-      self.reduces = reduces.freeze
-    end
-
-    def set_items_to_state(items, next_state)
-      @items_to_state[items] = next_state
-    end
-
-    #
-    def set_look_ahead(rule, look_ahead)
-      reduce = reduces.find do |r|
-        r.rule == rule
-      end
-
-      reduce.look_ahead = look_ahead
-    end
-
-    # Returns array of [nterm, next_state]
-    def nterm_transitions
-      return @nterm_transitions if @nterm_transitions
-
-      @nterm_transitions = []
-
-      shifts.each do |shift|
-        next if shift.next_sym.term?
-
-        @nterm_transitions << [shift, @items_to_state[shift.next_items]]
-      end
-
-      @nterm_transitions
-    end
-
-    # Returns array of [term, next_state]
-    def term_transitions
-      return @term_transitions if @term_transitions
-
-      @term_transitions = []
-
-      shifts.each do |shift|
-        next if shift.next_sym.nterm?
-
-        @term_transitions << [shift, @items_to_state[shift.next_items]]
-      end
-
-      @term_transitions
-    end
-
-    def selected_term_transitions
-      term_transitions.select do |shift, next_state|
-        !shift.not_selected
-      end
-    end
-
-    # Move to next state by sym
-    def transition(sym)
-      result = nil
-
-      if sym.term?
-        term_transitions.each do |shift, next_state|
-          term = shift.next_sym
-          result = next_state if term == sym
-        end
-      else
-        nterm_transitions.each do |shift, next_state|
-          nterm = shift.next_sym
-          result = next_state if nterm == sym
-        end
-      end
-
-      raise "Can not transit by #{sym} #{self}" if result.nil?
-
-      result
-    end
-
-    def find_reduce_by_item!(item)
-      reduces.find do |r|
-        r.item == item
-      end || (raise "reduce is not found. #{item}, #{state}")
-    end
-
-    def default_reduction_rule=(default_reduction_rule)
-      @default_reduction_rule = default_reduction_rule
-
-      reduces.each do |r|
-        if r.rule == default_reduction_rule
-          r.default_reduction = true
-        end
-      end
-    end
-
-    def sr_conflicts
-      @conflicts.select do |conflict|
-        conflict.type == :shift_reduce
-      end
-    end
-
-    def rr_conflicts
-      @conflicts.select do |conflict|
-        conflict.type == :reduce_reduce
-      end
-    end
-  end
-
   # States is passed to a template file
   #
   # "Efficient Computation of LALR(1) Look-Ahead Sets"
@@ -411,23 +189,13 @@ module Lrama
       @states.flat_map(&:rr_conflicts)
     end
 
-    def initial_attrs
-      h = {}
-
-      attrs.each do |attr|
-        h[attr.id] = false
-      end
-
-      h
-    end
-
     def trace_state
       if @trace_state
         yield STDERR
       end
     end
 
-    def create_state(accessing_symbol, kernels, states_creted)
+    def create_state(accessing_symbol, kernels, states_created)
       # A item can appear in some states,
       # so need to use `kernels` (not `kernels.first`) as a key.
       #
@@ -464,11 +232,11 @@ module Lrama
       #    string_1: string •
       #    string_2: string • '+'
       #
-      return [states_creted[kernels], false] if states_creted[kernels]
+      return [states_created[kernels], false] if states_created[kernels]
 
       state = State.new(@states.count, accessing_symbol, kernels)
       @states << state
-      states_creted[kernels] = state
+      states_created[kernels] = state
 
       return [state, true]
     end
@@ -532,9 +300,9 @@ module Lrama
     def compute_lr0_states
       # State queue
       states = []
-      states_creted = {}
+      states_created = {}
 
-      state, _ = create_state(symbols.first, [Item.new(rule: @grammar.rules.first, position: 0)], states_creted)
+      state, _ = create_state(symbols.first, [Item.new(rule: @grammar.rules.first, position: 0)], states_created)
       enqueue_state(states, state)
 
       while (state = states.shift) do
@@ -550,7 +318,7 @@ module Lrama
         setup_state(state)
 
         state.shifts.each do |shift|
-          new_state, created = create_state(shift.next_sym, shift.next_items, states_creted)
+          new_state, created = create_state(shift.next_sym, shift.next_items, states_created)
           state.set_items_to_state(shift.next_items, new_state)
           enqueue_state(states, new_state) if created
         end

data/lib/lrama/states_reporter.rb

@@ -210,7 +210,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot reads_relation
+          # Report reads_relation
           io << "  [Reads Relation]\n"
           @states.nterms.each do |nterm|
             a = @states.reads_relation[[state.id, nterm.token_id]]
@@ -224,7 +224,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot read_sets
+          # Report read_sets
           io << "  [Read sets]\n"
           read_sets = @states.read_sets
           @states.nterms.each do |nterm|
@@ -239,7 +239,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot includes_relation
+          # Report includes_relation
           io << "  [Includes Relation]\n"
           @states.nterms.each do |nterm|
             a = @states.includes_relation[[state.id, nterm.token_id]]
@@ -267,7 +267,7 @@ module Lrama
           io << "\n"
 
 
-          # Reprot follow_sets
+          # Report follow_sets
           io << "  [Follow sets]\n"
           follow_sets = @states.follow_sets
           @states.nterms.each do |nterm|

data/lib/lrama/version.rb

@@ -1,3 +1,3 @@
 module Lrama
-  VERSION = "0.5.0".freeze
+  VERSION = "0.5.2".freeze
 end

data/lib/lrama.rb

@@ -7,6 +7,7 @@ require "lrama/lexer"
 require "lrama/output"
 require "lrama/parser"
 require "lrama/report"
+require "lrama/state"
 require "lrama/states"
 require "lrama/states_reporter"
 require "lrama/version"

data/lrama.gemspec

@@ -8,7 +8,7 @@ Gem::Specification.new do |spec|
 
   spec.summary       = "LALR (1) parser generator written by Ruby"
   spec.description   = "LALR (1) parser generator written by Ruby"
-  spec.homepage      = "https://github.com/yui-knk/lrama"
+  spec.homepage      = "https://github.com/ruby/lrama"
   # See LEGAL.md file for detail
   spec.license       = "GNU GPLv3"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.5.0")

data/rbs_collection.lock.yaml

@@ -0,0 +1,26 @@
+---
+sources:
+- type: git
+  name: ruby/gem_rbs_collection
+  revision: 28208148c7e64a25e9b86b9723b4c3a2cef14e81
+  remote: https://github.com/ruby/gem_rbs_collection.git
+  repo_dir: gems
+path: ".gem_rbs_collection"
+gems:
+- name: erb
+  version: '0'
+  source:
+    type: stdlib
+- name: stackprof
+  version: '0.2'
+  source:
+    type: git
+    name: ruby/gem_rbs_collection
+    revision: 28208148c7e64a25e9b86b9723b4c3a2cef14e81
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    repo_dir: gems
+- name: strscan
+  version: '0'
+  source:
+    type: stdlib
+gemfile_lock_path: Gemfile.lock

data/rbs_collection.yaml

@@ -0,0 +1,22 @@
+# Download sources
+sources:
+  - type: git
+    name: ruby/gem_rbs_collection
+    remote: https://github.com/ruby/gem_rbs_collection.git
+    revision: main
+    repo_dir: gems
+
+# You can specify local directories as sources also.
+# - type: local
+#   path: path/to/your/local/repository
+
+# A directory to install the downloaded RBSs
+path: .gem_rbs_collection
+
+gems:
+  - name: erb
+  - name: strscan
+  # Skip loading rbs gem's RBS.
+  # It's unnecessary if you don't use rbs as a library.
+  - name: rbs
+    ignore: true