enum_machine-contrib 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8e7266c9b63527eb71ba12e52d236c39dfb32f7efb2119a7171181b535030e9b
-  data.tar.gz: 1aff769ce18c3addf053e73bb7672727eda86ad3f4707dda11f45a0f50005900
+  metadata.gz: 35d405c0c7a47abceee4a0b4a970f2974249803b6caec8b6b5a335638b3d97fb
+  data.tar.gz: dc3710df781b062e8023f3b35d3f8e6e34629501b6e5b2423b6b49042759a9af
 SHA512:
-  metadata.gz: 8135da25b19be77b3266baaa828d1e4e97bcf2cf8df76ceaca72c0cc394288b707629e39d6242c92446b6c4ff6b33e6e4dd39f5ef05ad0d6b875f5f15d706877
-  data.tar.gz: 90c6af41a3aacfc09659647ce9af33114a58c09fd68b3560cb73c6fec35235ffe9c2c54f783674025db1a609e0675a0fd275b6631330d664f3fc4852ac0aab5b
+  metadata.gz: 2e5205c070cf6b358971938add7774d831234ed96c567434eb77e9f741f4aff23b3f174f754cf6c02896eebe5a42e66e90928151523e974408d62ade5f1552f2
+  data.tar.gz: f65b922b38231001950b9e7a9b3077d1e541a1aa497450929a95de327f468b9be6f05357f9c1e4bc19c14275b8e66f4c120d3450f62bede4ead8d15723fa8a27

data/.rubocop.yml

@@ -19,4 +19,8 @@ Style/ClassVars:
 
 Naming/FileName:
   Exclude:
-    - lib/enum_machine-contrib.rb
+    - lib/enum_machine-contrib.rb
+
+Gp/ClassOrModuleDeclaredInWrongFile:
+  Exclude:
+    - lib/enum_machine_contrib/enum_machine/**/*.rb

data/Gemfile

@@ -2,11 +2,11 @@
 
 source 'https://rubygems.org'
 
-gemspec
-
 gem 'enum_machine', github: 'corp-gp/enum_machine'
 gem 'priscilla', github: 'corp-gp/priscilla'
 gem 'pry', '~> 0.12'
 gem 'rake', '~> 13.0'
 gem 'rspec', '~> 3.9'
 gem 'rubocop-gp', github: 'corp-gp/rubocop-gp'
+
+gemspec

data/Gemfile.lock

@@ -28,7 +28,7 @@ GIT
 PATH
   remote: .
   specs:
-    enum_machine-contrib (0.1.0)
+    enum_machine-contrib (1.0.0)
       activesupport
       enum_machine
       ruby-graphviz

data/README.md

@@ -6,22 +6,17 @@ This repository contains extensions and development tools for the [enum_machine]
 
 Install the gem and add to the application's Gemfile by executing:
 
-    $ bundle add enum_machine-contrib ruby-graphviz --group "development"
+    $ bundle add enum_machine-contrib --group "development"
 
 If bundler is not being used to manage dependencies, install the gem by executing:
 
-    $ gem install enum_machine-contrib ruby-graphviz
+    $ gem install enum_machine-contrib
 
 The gem depends on [GraphViz](https://graphviz.org/). See the [installation notes](https://graphviz.org/download/)
 
 ## Usage
 
-Suppose we have `Order` AR-model with the state machine specified by [enum_machine](https://github.com/corp-gp/enum_machine)
-
-`config/initializers/enum_machine.rb`
-```ruby
-require 'enum_machine_contrib/enum_machine'
-```
+Suppose we have AR-model `Order` with the state machine specified by [enum_machine](https://github.com/corp-gp/enum_machine)
 
 `app/models/order.rb`
 ```ruby
@@ -50,11 +45,9 @@ class Order < ActiveRecord::Base
 end
 ```
 
-The gem allows you to get a visual representation of the graph of state transitions.
+The gem allows to get a visual representation of the state's graph. Model name `Order` and attribute constant `STATE` should be defined in rake task to render image.
 
-```ruby
-Order::STATE.machine.decision_tree.visualize.output(png: 'states.png')
-```
+    $ bundle exec rake enum_machine:vis[Order::STATE]
 
 You will see:
 

data/README.ru.md

@@ -0,0 +1,114 @@
+# Расширения EnumMachine 
+
+Репозиторий содержит дополнение к [enum_machine](https://github.com/corp-gp/enum_machine), которое позволяет генерировать графическое представление графа состояний. Для отображения используется open-source решение [Graphviz](https://graphviz.org/).
+
+## Установка
+
+При использовании bundler добавить в Gemfile:
+
+    $ bundle add enum_machine-contrib --group "development"
+
+Или установить gem в систему:
+
+    $ gem install enum_machine-contrib
+
+Установку [GraphViz](https://graphviz.org/) смотрите в соответствующей [инструкции](https://graphviz.org/download/)
+
+## Использование
+
+Предположим, имеется AR-модель `Order` с машиной состояний, заданной [enum_machine](https://github.com/corp-gp/enum_machine)
+
+`app/models/order.rb`
+```ruby
+class Order < ActiveRecord::Base
+  enum_machine :state, %w[created wait_for_send billed need_to_pay paid cancelled shipped lost received closed] do
+    transitions(
+      nil                                          => 'created',
+      'created'                                    => %w[wait_for_send billed],
+      'wait_for_send'                              => 'billed',
+      %w[created billed wait_for_send]             => 'need_to_pay',
+      %w[created billed wait_for_send need_to_pay] => %w[paid cancelled],
+      %w[billed need_to_pay paid]                  => 'shipped',
+      %w[paid shipped]                             => 'lost',
+      %w[billed need_to_pay paid shipped]          => 'received',
+      %w[paid shipped received]                    => 'closed',
+    )
+  end
+end
+```
+
+Графическое представление графа (`state`) можно получить rake-командой:
+
+    $ bundle exec rake enum_machine:vis[Order::STATE]
+
+Результатом будет файл `tmp/order.png`:
+
+![states.png](docs/states.png?raw=true "states")
+
+## Дерево решения графа
+
+Граф состояний представляется из себя направленный и возможно циклический граф, из начальной вершины которого можно попасть в одну из конечных. При сложных взаимосвязях даже графическое представление становится нагруженным для восприятия, особенно при наличии [зацикленных вершин](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB_(%D0%B3%D1%80%D0%B0%D1%84)). Поэтому помимо ребер графа на рисунке выше имеется дополнительная разметка. Красными линиями отмечено дерево решения, в котором вершины соединены в [топологическом порядке](https://ru.wikipedia.org/wiki/%D0%A2%D0%BE%D0%BF%D0%BE%D0%BB%D0%BE%D0%B3%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%81%D0%BE%D1%80%D1%82%D0%B8%D1%80%D0%BE%D0%B2%D0%BA%D0%B0). Простыми словами, требуется найти такой порядок вершин, в котором все ребра графа ведут из более ранней вершины в более позднюю.
+
+Алгоритмы топологической сортировки для ориентированного ациклического графа известны. В ядре `ruby` есть встроенный модуль [TSort](https://ruby-doc.org/stdlib-3.0.0/libdoc/tsort/rdoc/TSort.html), использующй, в частности, алгоритм Тарьяна. `RubyOnRails` применяет топологическую сортировку для инициализации приложения. Каждый `Railtie` должен быть загружен не раньше, чем будут загружены все его зависимости.
+
+Для циклического графа топологическая сортировка невозможна. На практике state-машина вряд ли будет представлять из себя полностью цикличный граф, где все вершины связаны со всеми. Скорее возможны островки [компонент сильной связности](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%BC%D0%BF%D0%BE%D0%BD%D0%B5%D0%BD%D1%82%D0%B0_%D1%81%D0%B8%D0%BB%D1%8C%D0%BD%D0%BE%D0%B9_%D1%81%D0%B2%D1%8F%D0%B7%D0%BD%D0%BE%D1%81%D1%82%D0%B8). Это допущение позволяет сделать первое упрощение задачи построения дерева графа. Ищем в графе компоненты сильной связности, заменяем их на комбинированную вершину, а затем строим топологическую сортировку для комбинированных вершин.
+
+![strongly_connected_component.png](docs/strongly_connected_component.png?raw=true "strongly connected component")
+
+В общем случае с циклическим подграфом сделать ничего не получится. Однако некоторые частные (но довольно частые), все же позволяют доопределить дерево решения. 
+
+### Вершины с единственным входом
+
+Среди вершин зацикленного графа могут оказаться те, которые имеют единственное входящее ребро. Это означает, что это ребро неминуемо должно появится в дереве решения. Следствием является несколько моментов:
+
+1) В вершину S2 есть едиственный путь из S1, из обеих вершин можно попасть в S4. Вершина S1 предшествует S2, значит более поздней зависимостью S4 будет S2, а переход S1 -> S4 не должен попасть в дерево решения. 
+
+![move_forward_single.png](docs/move_forward_single.png?raw=true "move forward single")
+
+2) Это также справедливо для цепочек вершин. Если из S1 и S4 можно попасть в S5, то S1 -> S5 опять же можно игнорировать. Одноименные выходы "перетекают" в конец цепочки.
+
+![move_forward_chain.png](docs/move_forward_chain.png?raw=true "move forward chain")
+
+3) У первой вершины цепочки может быть несколько возможных входов. В некоторых случаях возможно определить, какой из них попадет в дерево решения. Если входящие ребра включают в себя достижимые в дальнейшем по цепочке вершины, можно попробовать их отбросить. Если после этого остается единственный вход - включаем его в дерево решения. 
+
+![resolve_backward.png](docs/resolve_backward.png?raw=true "resolve backward")
+
+### bottleneck-вершины
+
+Иногда в сильной компоненте графа может встретиться особый случай вершины, минуя которую, невозможно попасть из одной части графа в другую, все ребра сходятся через эту узловую точку. У этой вершины могут быть как прямые, так и обратные ребра, однако дерево решение должно пройти через эту вершину строго в направлении от входа. Для обнаружения такого варианта можно поочередно удалять вершины, проверяя достижимость всех вершин компоненты. Если в какой-то момент обнаружили, что часть подграфа недоступна - делим его по этой bottleneck-вершине (S5): 
+
+![bottleneck.png](docs/bottleneck.png?raw=true "bottleneck")
+
+4) Отбрасываем входящие ребра, которые ведут из второй половины подграфа, недостижимой от входа.
+
+![bottleneck_incoming.png](docs/bottleneck_incoming.png?raw=true "bottleneck incoming")
+
+5) Из узловой вершины некоторые исходящие ребра будут вести в первую половину подграфа. По аналогии с вершинами с единственным входом, одноименные выходы "перетекают" на bottleneck-вершину. 
+
+![bottleneck_outcoming.png](docs/bottleneck_outcoming.png?raw=true "bottleneck outcoming")
+
+После применения описанных приемов часть дуг из подграфа удаляются и можно попробовать вновь поискать компоненты сильной связности. Алгоритм можно повторять до тех пор, пока не перестанет изменяться сложность графа (сумма активных ребер). Также для облегчения восприятия можно объединить вершины, которые имеют одинаковые входы/выходы и объединить двунаправленные ребра в одну. В результате получаем такую картинку:
+
+![bottleneck_resolved.png](docs/bottleneck_resolved.png?raw=true "bottleneck resolved")
+
+## Использованная литература
+
+1) Джефф Эриксон, Алгоритмы / пер. с англ. А.  В. Снастина. – М.: ДМК Пресс, 2023.
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/enum_machine-contrib. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/[USERNAME]/enum_machine-contrib/blob/master/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the EnumMachine::Contrib project's codebases, issue trackers, chat rooms and mailing lists is expected to follow the [code of conduct](https://github.com/[USERNAME]/enum_machine-contrib/blob/master/CODE_OF_CONDUCT.md).

data/enum_machine-contrib.gemspec

@@ -27,8 +27,6 @@ Gem::Specification.new do |spec|
         (f == __FILE__) || f.match(%r{\A(?:(?:bin|test|spec|features)/|\.(?:git|circleci)|appveyor)})
       end
     end
-  spec.bindir = 'exe'
-  spec.executables = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
 
   spec.add_dependency 'activesupport'

data/lib/enum_machine_contrib/decision_graph.rb

@@ -22,7 +22,7 @@ module EnumMachineContrib
           to_vertex = vertex_by_value[to_value]
           @vertexes << to_vertex
 
-          @edges << from_vertex.add_edge(to_vertex)
+          @edges << from_vertex.edge_to(to_vertex)
         end
       end
     end
@@ -63,7 +63,7 @@ module EnumMachineContrib
       vertexes.filter(&:active?).to_h do |vertex|
         [
           vertex.value,
-          vertex.outcoming_edges.filter_map { |edge| edge.to.value if edge.active? },
+          vertex.outcoming_edges.map { |edge| edge.to.value },
         ]
       end
     end
@@ -93,50 +93,31 @@ module EnumMachineContrib
     end
 
     def resolve_strong_component!(component_cycled_vertex) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      input_values  = component_cycled_vertex.incoming_edges.filter(&:active?).flat_map { |edge| edge.from.value }
-      output_values = component_cycled_vertex.outcoming_edges.filter(&:active?).flat_map { |vertex| vertex.to.value }
+      input_values  = component_cycled_vertex.incoming_edges.flat_map { |edge| edge.from.value }
+      output_values = component_cycled_vertex.outcoming_edges.flat_map { |vertex| vertex.to.value }
 
       active_vertexes = vertexes.filter(&:active?)
-      input_vertexes = active_vertexes.filter { |vertex| (input_values & vertex.value).any? }
-      output_vertexes = active_vertexes.filter { |vertex| (output_values & vertex.value).any? }
+      input_vertexes  = active_vertexes.reject { |vertex| (input_values & vertex.value).empty? }
+      output_vertexes = active_vertexes.reject { |vertex| (output_values & vertex.value).empty? }
 
-      component_vertexes = active_vertexes.filter { |vertex| (component_cycled_vertex.value & vertex.value).any? }
+      component_vertexes = active_vertexes.reject { |vertex| (component_cycled_vertex.value & vertex.value).empty? }
 
-      single_incoming_vertexes = (component_vertexes + output_vertexes).filter { |vertex| vertex.incoming_edges.size == 1 }
-      single_incoming_vertexes.each do |to_vertex|
-        from_vertex = to_vertex.incoming_edges.first.from
-
-        (from_vertex.incoming_edges + from_vertex.outcoming_edges)
-          .group_by { |edge| [edge.from.value.to_s, edge.to.value.to_s].sort }
-          .values
-          .filter { |current_edges| current_edges.size > 1 }.each do |current_edges|
-            current_edges.each do |edge|
-              # S1 -> S2; S2 -> [S1, S3]
-              # drops back reference S2 -> S1
-              edge.dropped! if edge.from == from_vertex
-            end
+      component_vertexes.each do |vertex|
+        vertex.incoming_edges.each do |edge|
+          if (input_vertexes + component_vertexes).exclude?(edge.from)
+            # drop insignificant incoming edges
+            edge.dropped!
           end
+        end
       end
 
-      resolved_not_visited_vertexes = []
-
-      current_vertexes = [component_cycled_vertex]
-      loop do
-        next_vertexes = current_vertexes.flat_map { |vertex| vertex.outcoming_edges.filter_map { |edge| edge.to if edge.active? } }
-        resolved_not_visited_vertexes += next_vertexes.reject(&:cycled?)
-        current_vertexes = next_vertexes
-        break if next_vertexes.empty?
-      end
+      single_incoming_vertexes = (component_vertexes + output_vertexes).filter { |vertex| vertex.incoming_edges.size == 1 }
 
       single_incoming_chains = []
       single_incoming_vertexes.each do |vertex|
         single_incoming_edge = vertex.incoming_edges.first
-        # S1 -> [S2, S3]; S2 -> S3
-        # resolve S1 -> S2 because it is only one path to S2
         single_incoming_edge.resolved!
 
-        resolved_not_visited_vertexes << single_incoming_edge.to
-
         current_chain = single_incoming_chains.detect { |chain| chain.first == single_incoming_edge.to || chain.last == single_incoming_edge.from }
         if current_chain
           current_chain.replace(
@@ -152,48 +133,69 @@ module EnumMachineContrib
       end
 
       single_incoming_chains.each do |chain|
+        chain_preceding_vertexes  = chain[0].incoming_edges.map(&:from) & (input_vertexes + component_vertexes)
+        chain_achievable_vertexes = chain[1..].flat_map { |vertex| vertex.outcoming_edges.map(&:to) }
+
+        pre_chain_vertexes = chain_preceding_vertexes - chain_achievable_vertexes
+
+        if pre_chain_vertexes.size == 1
+          single_incoming_edge = chain[0].incoming_edges.detect { |edge| edge.from == pre_chain_vertexes[0] }
+          single_incoming_edge.resolved!
+
+          chain.unshift(single_incoming_edge.from)
+        end
+
         chain.flat_map { |vertex| vertex.outcoming_edges.to_a }.group_by(&:to).each_value do |outcoming_edges|
           next if outcoming_edges.size < 2
 
-          # S1 -> [S2, S3]; S2 -> S3
-          # drops S1 -> S3, because S1 -> S2 resolved as only one path and S3 is reachable from S2
           outcoming_edges[0..outcoming_edges.size - 2].each(&:dropped!)
         end
       end
 
-      current_vertexes = input_vertexes
-      visited_vertexes = []
-      loop do
-        current_following_vertexes = current_vertexes.flat_map { |vertex| vertex.outcoming_edges.map(&:to) }.uniq - visited_vertexes
+      around_vertexes = input_vertexes + component_vertexes + output_vertexes
+
+      component_vertexes.each do |maybe_bottlneck_vertex|
+        rest_vertexes = around_vertexes.excluding(maybe_bottlneck_vertex)
 
-        if current_following_vertexes.size > 1
-          reachable_vertexes = resolved_not_visited_vertexes.flat_map { |vertex| vertex.outcoming_edges.map(&:to) }.uniq
-          break if reachable_vertexes.empty?
+        input_achievable_vertexes = next_achievable_vertexes(input_vertexes[0], rest_vertexes, visited: Set.new([maybe_bottlneck_vertex]))
+        next if input_achievable_vertexes.size == rest_vertexes.size
 
-          current_following_vertexes -= reachable_vertexes
+        maybe_bottlneck_vertex.outcoming_edges.each do |current_edge|
+          if input_achievable_vertexes.include?(current_edge.to) && maybe_bottlneck_vertex.incoming_edges.map(&:from).exclude?((current_edge.to))
+            current_edge.to.incoming_edges.each do |edge|
+              unless edge.from == maybe_bottlneck_vertex
+                edge.dropped!
+              end
+            end
+          end
         end
 
-        current_vertexes.each do |from_vertex|
-          from_vertex.outcoming_edges.each do |edge|
-            next if edge.resolved?
+        rest_vertexes -= input_achievable_vertexes
 
-            if current_following_vertexes.include?(edge.to)
-              edge.resolved! if current_following_vertexes.size == 1
-            elsif resolved_not_visited_vertexes.include?(edge.to)
-              edge.dropped!
-            end
+        maybe_bottlneck_vertex.incoming_edges.each do |edge|
+          if rest_vertexes.include?(edge.from)
+            edge.dropped!
           end
         end
+      end
+    end
+
+    def next_achievable_vertexes(vertex, all, visited: Set.new)
+      return [] if visited.include?(vertex)
 
-        current_vertexes = current_following_vertexes
-        resolved_not_visited_vertexes -= current_following_vertexes
-        visited_vertexes += current_vertexes
+      achievable_vertexes = [vertex]
+      visited << vertex
 
-        break if current_vertexes.empty?
+      vertex.outcoming_edges.each do |edge|
+        if all.include?(edge.to)
+          achievable_vertexes += next_achievable_vertexes(edge.to, all, visited: visited)
+        end
       end
+
+      achievable_vertexes
     end
 
-    def array_wrap(value)
+    private def array_wrap(value)
       if value.nil?
         [nil]
       else

data/lib/enum_machine_contrib/decision_tree.rb

@@ -8,7 +8,7 @@ module EnumMachineContrib
     include TSort
 
     def tsort_each_child(node, &_block)
-      fetch(node).outcoming_edges.each { |edge| yield(edge.to.value) if edge.active? }
+      fetch(node).outcoming_edges.each { |edge| yield(edge.to.value) }
     end
 
     def tsort_each_node(&_block)
@@ -24,7 +24,7 @@ module EnumMachineContrib
 
         to_value_list.each do |to_value|
           vertex_by_value[to_value] ||= Vertex[to_value]
-          from_vertex.add_edge(vertex_by_value[to_value])
+          from_vertex.edge_to(vertex_by_value[to_value])
         end
       end
 
@@ -73,7 +73,7 @@ module EnumMachineContrib
       each_value do |vertex|
         next unless vertex.active?
 
-        resolved_hash[vertex.value] = vertex.outcoming_edges.filter_map { |edge| edge.to.value if edge.active? }
+        resolved_hash[vertex.value] = vertex.outcoming_edges.map { |edge| edge.to.value }
       end
 
       resolved_hash
@@ -110,8 +110,11 @@ module EnumMachineContrib
 
       vertexes_by_level = visible_vertexes.filter(&:level).sort_by(&:level).group_by(&:level)
       node_ranks =
-        vertexes_by_level.map do |_level, vertexes_same_rank|
-          "{ rank=same #{vertexes_same_rank.reject(&:combined?).reject(&:cycled?).map { |vertex| nodes[vertex][:id] }.join(' ')} }"
+        vertexes_by_level.filter_map do |_level, vertexes_same_rank|
+          vertex_ids = vertexes_same_rank.filter_map { |vertex| nodes[vertex][:id] if !vertex.cycled? && !vertex.combined? }
+          next if vertex_ids.empty?
+
+          "{ rank=same #{vertex_ids.join(' ')} }"
         end
 
       node_labels = plain_vertexes.map { |vertex| "#{nodes[vertex][:id]} [label=\"#{nodes[vertex][:label]}\"]" }
@@ -121,26 +124,62 @@ module EnumMachineContrib
           "subgraph #{nodes[vertex][:cluster_id]} { color=blue style=dashed #{vertex.value.join(' ')} }"
         end
 
-      transitions =
+      resolved_not_active_edges = []
+
+      pending_edges =
         visible_vertexes.flat_map do |vertex|
-          vertex.outcoming_edges.filter_map do |edge|
+          vertex.incoming_edges.with_dropped.filter_map do |edge|
             if (!edge.from.combined? && (combined_values & edge.from.value).any?) ||
                (!edge.to.combined? && (combined_values & edge.to.value).any?)
               next
             end
 
-            attrs = []
-            if edge.active?
-              attrs << ACTIVE_EDGE_STYLE
-              attrs << "ltail=#{nodes[edge.from][:cluster_id]}" if edge.from.cycled?
-              attrs << "lhead=#{nodes[edge.to][:cluster_id]}" if edge.to.cycled?
-            else
-              attrs << INACTIVE_EDGE_STYLE
+            if !edge.active? && (edge.from.combined? || edge.to.combined? || edge.from.cycled? || edge.to.cycled?)
+              next
+            end
+
+            if edge.resolved? && !edge.active?
+              resolved_not_active_edges << edge
             end
-            "#{nodes[edge.from][:id]} -> #{nodes[edge.to][:id]} [#{attrs.join(' ')}]"
+
+            edge
           end
         end
 
+      resolved_not_active_edges.each do |current_edge|
+        pending_edges.delete_if do |edge|
+          (edge.from.cycled? && (edge.from.value & current_edge.from.value).any? && edge.to == current_edge.to) ||
+            (edge.from == current_edge.from && edge.to.cycled? && (edge.to.value & current_edge.to.value).any?)
+        end
+      end
+
+      transitions = []
+
+      until pending_edges.empty?
+        current_edge = pending_edges.shift
+
+        attrs = []
+
+        if current_edge.resolved?
+          attrs << ACTIVE_EDGE_STYLE
+          attrs << "ltail=#{nodes[current_edge.from][:cluster_id]}" if current_edge.from.cycled?
+          attrs << "lhead=#{nodes[current_edge.to][:cluster_id]}" if current_edge.to.cycled?
+        else
+          attrs << INACTIVE_EDGE_STYLE
+        end
+
+        unless current_edge.resolved?
+          reverse_edge = pending_edges.detect { |edge| edge.from == current_edge.to && edge.to == current_edge.from }
+
+          if reverse_edge && !reverse_edge.resolved?
+            pending_edges.delete(reverse_edge)
+            attrs << 'dir=both'
+          end
+        end
+
+        transitions << "#{nodes[current_edge.from][:id]} -> #{nodes[current_edge.to][:id]} [#{attrs.join(' ')}]"
+      end
+
       <<~DOT
         digraph {
           ranksep="1.0 equally"

data/lib/enum_machine_contrib/edge.rb

@@ -6,12 +6,13 @@ module EnumMachineContrib
     Struct.new(:from, :to) do
       attr_accessor :mode
 
-      EDGE_MODES = %i[pending resolved dropped].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+      EDGE_MODES = %i[pending dropped].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
 
       def initialize(from, to)
         self.from = from
         self.to   = to
 
+        @resolved = false
         pending!
       end
 
@@ -37,16 +38,31 @@ module EnumMachineContrib
         !dropped?
       end
 
+      def dropped!
+        self.mode = :dropped
+
+        to.incoming_edges.delete(self)
+        from.outcoming_edges.delete(self)
+      end
+
+      def resolved?
+        @resolved == true
+      end
+
       def resolved!
-        self.mode = :resolved
+        @resolved = true
 
         to.incoming_edges.each do |edge|
           edge.dropped! unless edge == self
         end
+
+        to.outcoming_edges.detect { |edge| edge.to == from }&.dropped!
+
+        to.resolved!
       end
 
       def inspect
-        "<Edge [#{mode}] #{from.inspect} -> #{to.inspect}>"
+        "<Edge [#{mode}]#{'[resolved]' if resolved?} #{from.inspect} -> #{to.inspect}>"
       end
     end
 

data/lib/enum_machine_contrib/edge_set.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module EnumMachineContrib
+  class EdgeSet < Set
+
+    attr_accessor :with_dropped
+
+    def initialize(*)
+      @with_dropped = Set.new
+      super
+    end
+
+    def add(value)
+      @with_dropped << value
+      super
+    end
+
+  end
+end

data/lib/enum_machine_contrib/enum_machine/errors.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module EnumMachine
+  class InvalidTransitionGraph < Error; end
+end

data/lib/enum_machine_contrib/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module EnumMachineContrib
+  class Railtie < Rails::Railtie
+
+    rake_tasks do
+      path = File.expand_path(__dir__)
+      Dir.glob("#{path}/tasks/**/*.rake").each { |f| load f }
+    end
+
+  end
+end

data/lib/enum_machine_contrib/tasks/enum_machine/vis.rake

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+namespace :enum_machine do
+  desc 'Visualize graph for enum_machine attribute with enum_machine:vis[Order::STATE]'
+  task :vis, [:attr] => :environment do |_t, args|
+    require 'ruby-graphviz'
+    require 'fileutils'
+
+    FileUtils.mkdir_p('tmp')
+
+    enum_machine = args[:attr].constantize.machine
+    enum_machine.singleton_class.include(EnumMachineContrib::HasDecisionTree)
+
+    file_path = "./tmp/#{enum_machine.base_klass.name.demodulize.underscore}.png"
+    enum_machine.decision_tree.visualize.output(png: file_path)
+
+    puts <<~TEXT
+      Rendered to #{file_path}, open in browser with:#{' '}
+      xdg-open file://#{File.expand_path(file_path)}
+    TEXT
+  end
+end

data/lib/enum_machine_contrib/version.rb

@@ -2,6 +2,6 @@
 
 module EnumMachineContrib
 
-  VERSION = '0.1.0'
+  VERSION = '1.0.0'
 
 end

data/lib/enum_machine_contrib/vertex.rb

@@ -4,16 +4,19 @@ module EnumMachineContrib
 
   Vertex =
     Struct.new(:value) do
-      attr_accessor :mode, :incoming_edges, :outcoming_edges, :level
+      attr_accessor :mode, :level
+      attr_reader :incoming_edges, :outcoming_edges
 
-      VERTEX_MODES = %i[plain dropped combined cycled].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
+      VERTEX_MODES = %i[pending dropped combined cycled].freeze # rubocop:disable Lint/ConstantDefinitionInBlock
 
       def initialize(value)
         self.value = value
-        self.outcoming_edges = Set.new
-        self.incoming_edges = Set.new
 
-        plain!
+        @incoming_edges  = EdgeSet.new
+        @outcoming_edges = EdgeSet.new
+
+        @resolved = false
+        pending!
       end
 
       VERTEX_MODES.each do |mode|
@@ -38,6 +41,14 @@ module EnumMachineContrib
         !dropped?
       end
 
+      def resolved!
+        @resolved = true
+      end
+
+      def resolved?
+        @resolved == true
+      end
+
       def dropped!
         return if dropped?
 
@@ -47,11 +58,11 @@ module EnumMachineContrib
         outcoming_edges.each(&:dropped!)
       end
 
-      def add_edge(to_vertex)
+      def edge_to(to_vertex)
         new_edge = Edge.new(self, to_vertex)
 
-        outcoming_edges << new_edge
-        to_vertex.incoming_edges << new_edge
+        outcoming_edges.add(new_edge)
+        to_vertex.incoming_edges.add(new_edge)
 
         new_edge
       end
@@ -61,17 +72,15 @@ module EnumMachineContrib
 
         replacing_vertexes.each do |replacing_vertex|
           replacing_vertex.incoming_edges.each do |edge|
-            next unless edge.active?
             next if replacing_vertexes.include?(edge.from)
 
-            edge.from.add_edge(new_vertex)
+            edge.from.edge_to(new_vertex)
           end
 
           replacing_vertex.outcoming_edges.filter_map do |edge|
-            next unless edge.active?
             next if replacing_vertexes.include?(edge.to)
 
-            new_vertex.add_edge(edge.to)
+            new_vertex.edge_to(edge.to)
           end
 
           replacing_vertex.dropped!
@@ -81,7 +90,7 @@ module EnumMachineContrib
       end
 
       def inspect
-        "<Vertex [#{mode}] value=#{value || 'nil'}>"
+        "<Vertex [#{mode}]#{'[resolved]' if resolved?} value=#{value || 'nil'}>"
       end
     end
 

data/lib/enum_machine_contrib.rb

@@ -5,6 +5,8 @@ require 'active_support/core_ext/enumerable'
 require 'active_support/core_ext/array/wrap'
 
 require 'enum_machine_contrib/version'
+require 'enum_machine_contrib/railtie' if defined?(Rails::Railtie)
+require 'enum_machine_contrib/enum_machine/errors'
 
 module EnumMachineContrib
 
@@ -13,5 +15,6 @@ module EnumMachineContrib
   autoload :DecisionTree, 'enum_machine_contrib/decision_tree'
   autoload :Vertex, 'enum_machine_contrib/vertex'
   autoload :Edge, 'enum_machine_contrib/edge'
+  autoload :EdgeSet, 'enum_machine_contrib/edge_set'
 
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: enum_machine-contrib
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Sergei Malykh
 autorequire: 
-bindir: exe
+bindir: bin
 cert_chain: []
-date: 2023-03-14 00:00:00.000000000 Z
+date: 2023-05-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -68,18 +68,30 @@ files:
 - LICENSE
 - LICENSE.txt
 - README.md
+- README.ru.md
 - Rakefile
+- docs/bottleneck.png
+- docs/bottleneck_incoming.png
+- docs/bottleneck_outcoming.png
+- docs/bottleneck_resolved.png
+- docs/move_forward_chain.png
+- docs/move_forward_single.png
+- docs/resolve_backward.png
+- docs/states.png
+- docs/strongly_connected_component.png
 - enum_machine-contrib.gemspec
 - lib/enum_machine-contrib.rb
 - lib/enum_machine_contrib.rb
 - lib/enum_machine_contrib/decision_graph.rb
 - lib/enum_machine_contrib/decision_tree.rb
 - lib/enum_machine_contrib/edge.rb
-- lib/enum_machine_contrib/enum_machine.rb
+- lib/enum_machine_contrib/edge_set.rb
+- lib/enum_machine_contrib/enum_machine/errors.rb
 - lib/enum_machine_contrib/has_decision_tree.rb
+- lib/enum_machine_contrib/railtie.rb
+- lib/enum_machine_contrib/tasks/enum_machine/vis.rake
 - lib/enum_machine_contrib/version.rb
 - lib/enum_machine_contrib/vertex.rb
-- states.png
 homepage: https://github.com/corp-gp/enum_machine-contrib
 licenses:
 - MIT

data/lib/enum_machine_contrib/enum_machine.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module EnumMachine
-
-  class Machine
-
-    include EnumMachineContrib::HasDecisionTree
-
-  end
-
-  class InvalidTransitionGraph < StandardError; end
-
-end