what_dya_return 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 0f7dfddc7b09e314b0c96b8e8ad634f517f03e5252722c8aa16f3883caba8293
+  data.tar.gz: 3f6ec35cc912717543a3811c38bfbce34a92b9256ea753d02a0580e06cb252d8
+SHA512:
+  metadata.gz: 11effd57e51749aac58251616c68d3494eab40bff6d0df63b4c8f29e182ff17fa4e35210f8c57b298b9efe68699f7822acb4c3a3af761a4f66bd7835e641aad0
+  data.tar.gz: 1718c98ba23d4801ba67449843e2742d3f4449a867fa00518c683328765f404263704ef4a3389685c0d55ef782fa83b4a0210a0c7936b7e4991b4fff709bd2fe

data/.rubocop.yml

@@ -0,0 +1,10 @@
+require:
+  - rubocop-performance
+
+Metrics/ClassLength:
+  Exclude:
+    - 'test/what_dya_return/extractor_test.rb'
+
+Metrics/MethodLength:
+  Exclude:
+    - 'test/what_dya_return/extractor_test.rb'

data/.ruby-version

@@ -0,0 +1 @@
+3.0.6

data/Gemfile

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in what_dya_return.gemspec
+gemspec
+
+group :development, :test do
+  gem 'rake', '~> 13.0'
+  gem 'rubocop'
+  gem 'rubocop-performance'
+  gem 'test-unit', '~> 3.0'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2023 Wataru MIYAGUNI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,47 @@
+# WhatDyaReturn
+
+:angel: "What do you return?"
+
+```rb
+def foo
+  if bar
+    42
+  else
+    'baz'
+  end
+end
+```
+
+:robot: "42 and 'baz'"
+
+## Installation
+
+    $ gem install what_dya_return
+
+## Usage
+
+```rb
+result = WhatDyaReturn::Extractor.new.extract(<<-CODE)
+  def foo
+    if bar
+      42
+    else
+      'baz'
+    end
+  end
+CODE
+
+result # => ['42', "'baz'"]
+```
+
+## Caution
+
+`what_dya_return` is an experimental project. There are still many statements that are not supported.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/gongo/what_dya_return .
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.libs << 'lib'
+  t.test_files = FileList['test/**/*_test.rb']
+end
+
+task default: %i[test]

data/lib/what_dya_return/ast/node/begin_node.rb

@@ -0,0 +1,6 @@
+module WhatDyaReturn
+  module AST
+    class BeginNode < ::RuboCop::AST::Node
+    end
+  end
+end

data/lib/what_dya_return/ext/rubocop/ast/builder.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative '../../../ast/node/begin_node'
+
+module RuboCop
+  module AST
+    class Builder
+      EXT_NODE_MAP = NODE_MAP.merge(
+        {
+          begin: WhatDyaReturn::AST::BeginNode,
+          kwbegin: WhatDyaReturn::AST::BeginNode
+        }
+      )
+
+      #
+      # @override
+      #
+      def node_klass(type)
+        EXT_NODE_MAP.fetch(type, ::RuboCop::AST::Node)
+      end
+    end
+  end
+end

data/lib/what_dya_return/ext/rubocop/ast/node/if_node.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module RuboCop
+  module AST
+    class RuboCop::AST::IfNode
+      #
+      # @example
+      #
+      #   if false # or `nil`
+      #     42 # unreachable
+      #   else
+      #     run
+      #   end
+      #
+      # @return [Boolean]
+      #
+      def if_branch_reachable?
+        ((if? || ternary? || elsif?) && condition.falsey_literal?.!) || (unless? && condition.truthy_literal?.!)
+      end
+
+      #
+      # @example
+      #
+      #   if true
+      #     42
+      #   else
+      #     run # unreachable
+      #   end
+      #
+      # @return [Boolean]
+      #
+      def else_branch_reachable?
+        ((if? || ternary? || elsif?) && condition.truthy_literal?.!) || (unless? && condition.falsey_literal?.!)
+      end
+    end
+  end
+end

data/lib/what_dya_return/extractor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require 'rubocop-ast'
+require 'unparser'
+require_relative 'processor'
+
+module WhatDyaReturn
+  class Extractor
+    #
+    # @param [String] source_code
+    # @return [Array<String>]
+    # @raise [WhatDyaReturn::SyntaxErrfor] if `source_code` cannot be parsed
+    #
+    def extract(source_code)
+      processed = ::RuboCop::AST::ProcessedSource.new(source_code, RUBY_VERSION.to_f)
+      raise WhatDyaReturn::SyntaxError unless processed.valid_syntax?
+
+      Processor.new.process(processed.ast).map do |node|
+        node.nil? ? 'nil' : Unparser.unparse(node)
+      end
+    end
+  end
+end

data/lib/what_dya_return/processor.rb

@@ -0,0 +1,136 @@
+# frozen_string_literal: true
+
+require_relative 'ext/rubocop/ast/builder'
+require_relative 'ext/rubocop/ast/node/if_node'
+require_relative 'statement_checker'
+
+module WhatDyaReturn
+  class Processor
+    #
+    # @param [RuboCop::AST::DefNode] node
+    # @return [Array<RuboCop::AST::Node>]
+    #
+    def process(node)
+      @return_nodes = []
+
+      check_branch(node.body, true)
+
+      @return_nodes
+    end
+
+    private
+
+    #
+    # @param [RuboCop::AST::Node] node
+    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @return [void]
+    #
+    def check_branch(node, is_ret_expr)
+      unless node
+        @return_nodes << node if is_ret_expr
+        return
+      end
+
+      case node
+      when WhatDyaReturn::AST::BeginNode
+        check_begin_node(node, is_ret_expr)
+      when ::RuboCop::AST::ReturnNode
+        check_return_node(node)
+      when ::RuboCop::AST::IfNode
+        check_if_node(node, is_ret_expr)
+      when ::RuboCop::AST::CaseNode
+        check_case_node(node, is_ret_expr)
+      when ::RuboCop::AST::RescueNode
+        check_rescue_node(node, is_ret_expr)
+      when ::RuboCop::AST::EnsureNode
+        check_ensure_node(node, is_ret_expr)
+      else
+        @return_nodes << node if is_ret_expr
+      end
+    end
+
+    #
+    # @param [WhatDyaReturn::AST::BeginNode] node
+    # @return [void]
+    #
+    def check_begin_node(node, is_ret_expr)
+      node.children[0..-2].each do |child|
+        check_branch(child, false)
+        return unless StatementChecker.reachable_to_next_statement?(child) # rubocop:disable Lint/NonLocalExitFromIterator
+      end
+
+      check_branch(node.children[-1], is_ret_expr)
+    end
+
+    #
+    # @param [RuboCop::AST::ReturnNode] node
+    # @return [void]
+    #
+    def check_return_node(node)
+      check_branch(node.children.first, true)
+    end
+
+    #
+    # @param [RuboCop::AST::IfNode] node
+    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @return [void]
+    #
+    def check_if_node(node, is_ret_expr)
+      node.if_branch_reachable? && check_branch(node.if_branch, is_ret_expr)
+      node.else_branch_reachable? && check_branch(node.else_branch, is_ret_expr)
+    end
+
+    #
+    # @param [RuboCop::AST::CaseNode] node
+    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @return [void]
+    #
+    def check_case_node(node, is_ret_expr)
+      node.when_branches.each do |when_branch|
+        #
+        # case # no condition
+        # when false
+        #   1 # unreachable
+        # when 'qux'
+        #   2 # reachable
+        # end
+        #
+        next if node.condition.nil? && when_branch.conditions.all?(&:falsey_literal?)
+
+        check_branch(when_branch.body, is_ret_expr)
+      end
+
+      check_branch(node.else_branch, is_ret_expr)
+    end
+
+    #
+    # @param [RuboCop::AST::RescueNode] node
+    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @return [void]
+    #
+    def check_rescue_node(node, is_ret_expr)
+      if node.else_branch && StatementChecker.reachable_to_next_statement?(node.body)
+        check_branch(node.else_branch, is_ret_expr)
+      else
+        check_branch(node.body, is_ret_expr)
+      end
+
+      node.resbody_branches.each do |resbody_branch|
+        check_branch(resbody_branch.body, is_ret_expr)
+      end
+    end
+
+    #
+    # @param [RuboCop::AST::EnsureNode] node
+    # @param [Boolean] is_ret_expr Whether current scope is within return expression
+    # @return [void]
+    #
+    def check_ensure_node(node, is_ret_expr)
+      if StatementChecker.reachable_to_next_statement?(node.body)
+        check_branch(node.node_parts[0], is_ret_expr) # begin or rescue node
+      else
+        check_branch(node.body, false)
+      end
+    end
+  end
+end

data/lib/what_dya_return/statement_checker/reachable_to_next_statement.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+# This file is based on https://github.com/rubocop/rubocop/blob/v1.50.2/lib/rubocop/cop/lint/unreachable_code.rb
+# The original code is licensed under the MIT License.
+#
+# https://github.com/rubocop/rubocop/blob/v1.50.2/LICENSE.txt
+
+module WhatDyaReturn
+  module StatementChecker
+    class ReachableToNextStatement
+      #
+      # @param node [::RuboCop::AST::Node]
+      # @return [Boolean]
+      #
+      def ok?(node)
+        return false if flow_terminate_command?(node)
+
+        case node
+        when WhatDyaReturn::AST::BeginNode
+          check_begin(node)
+        when ::RuboCop::AST::IfNode
+          check_if(node)
+        when ::RuboCop::AST::CaseNode
+          check_case(node)
+        else
+          true
+        end
+      end
+
+      private
+
+      #
+      # @example Return true
+      #
+      #    def foo
+      #      ( # begin start
+      #        "a"
+      #        "b"
+      #      ) # begin end
+      #
+      #      "c" # reachable
+      #    end
+      #
+      # @example Return false
+      #
+      #    def foo
+      #      ( # begin start
+      #        "a"
+      #        return "b"
+      #      ) # begin end
+      #
+      #      "c" # unreachable
+      #    end
+      #
+      # @param node [WhatDyaReturn::AST::BeginNode]
+      # @return [Boolean]
+      #
+      def check_begin(node)
+        node.children.all? { |child| ok?(child) }
+      end
+
+      #
+      # @example Return true
+      #
+      #    if foo?
+      #      return "a"
+      #    end
+      #
+      #    "b" # reachable
+      #
+      # @example Return true with else statement
+      #
+      #    if foo?
+      #      return "a"
+      #    else
+      #      "c"
+      #    end
+      #
+      #    "b" # reachable
+      #
+      # @example Return false
+      #
+      #    if foo?
+      #      return "a"
+      #    else
+      #      return "c"
+      #    end
+      #
+      #    "b" # unreachable
+      #
+      # @param node [::RuboCop::AST::IfNode]
+      # @return [Boolean]
+      #
+      def check_if(node)
+        return true if node.else_branch.nil?
+
+        ok?(node.body) || ok?(node.else_branch)
+      end
+
+      #
+      # @example Return true without else statement
+      #
+      #    case foo
+      #    when "bar"
+      #      return :bar
+      #    end
+      #
+      #    "b" # reachable
+      #
+      # @example Return true with else statement
+      #
+      #    case foo
+      #    when "bar"
+      #      return :bar
+      #    else
+      #      :baz
+      #    end
+      #
+      #    "b" # reachable
+      #
+      # @example Return false
+      #
+      #    case foo
+      #    when "bar"
+      #      return :bar
+      #    else
+      #      return :baz
+      #    end
+      #
+      #    "b" # unreachable
+      #
+      # @param node [::RuboCop::AST::CaseNode]
+      # @return [Boolean]
+      #
+      def check_case(node)
+        return true if node.else_branch.nil?
+        return true if ok?(node.else_branch)
+
+        node.when_branches.any? { |when_branch| ok?(when_branch.body) }
+      end
+
+      #
+      # @param node [::RuboCop::AST::Node]
+      # @return [Boolean]
+      #
+      def flow_terminate_command?(node)
+        ::RuboCop::AST::NodePattern.new(<<-PATTERN).match(node)
+          {
+            return next break retry redo
+            (send
+              {nil? (const {nil? cbase} :Kernel)}
+              {:raise :fail :throw :exit :exit! :abort}
+              ...)
+          }
+        PATTERN
+      end
+    end
+  end
+end

data/lib/what_dya_return/statement_checker.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require_relative 'statement_checker/reachable_to_next_statement'
+
+module WhatDyaReturn
+  module StatementChecker
+    #
+    # @param node [::RuboCop::AST::Node]
+    # @return [Boolean]
+    #
+    def self.reachable_to_next_statement?(node)
+      @reachable_to_next_statement ||= ReachableToNextStatement.new
+      @reachable_to_next_statement.ok?(node)
+    end
+  end
+end

data/lib/what_dya_return/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module WhatDyaReturn
+  VERSION = '0.1.0'
+end

data/lib/what_dya_return.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+require_relative 'what_dya_return/extractor'
+require_relative 'what_dya_return/version'
+
+module WhatDyaReturn
+  class Error < StandardError; end
+  class SyntaxError < Error; end
+end

data/sig/what_dya_return.rbs

@@ -0,0 +1,4 @@
+module WhatDyaReturn
+  VERSION: String
+  # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+end

metadata

@@ -0,0 +1,90 @@
+--- !ruby/object:Gem::Specification
+name: what_dya_return
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wataru MIYAGUNI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rubocop-ast
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: unparser
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+- gonngo@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop.yml"
+- ".ruby-version"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/what_dya_return.rb
+- lib/what_dya_return/ast/node/begin_node.rb
+- lib/what_dya_return/ext/rubocop/ast/builder.rb
+- lib/what_dya_return/ext/rubocop/ast/node/if_node.rb
+- lib/what_dya_return/extractor.rb
+- lib/what_dya_return/processor.rb
+- lib/what_dya_return/statement_checker.rb
+- lib/what_dya_return/statement_checker/reachable_to_next_statement.rb
+- lib/what_dya_return/version.rb
+- sig/what_dya_return.rbs
+homepage: https://github.com/gongo/what_dya_return
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/gongo/what_dya_return
+  source_code_uri: https://github.com/gongo/what_dya_return
+  changelog_uri: https://github.com/gongo/what_dya_return/blob/main/CHANGELOG.md
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.33
+signing_key:
+specification_version: 4
+summary: Predict Ruby code return values.
+test_files: []