metamorpher 0.1.0

data/examples/refactorings/rails/where_first/app.rb

@@ -0,0 +1,50 @@
+require "optparse"
+require_relative "refactorers/refactor_where_first_to_find_by.rb"
+require_relative "refactorers/refactor_where_first_not_called_expectations.rb"
+require_relative "refactorers/refactor_where_first_mocks.rb"
+require_relative "refactorers/refactor_where_first_strict_mocks.rb"
+
+options = { overwrite: true }
+OptionParser.new do |opts|
+  opts.banner = "Usage: refactorer.rb [options]"
+
+  opts.on("-d", "--dry-run", "Write changes to console, rather than to source files.") do |v|
+    options[:overwrite] = false
+  end
+end.parse!
+
+source_dir = ARGV.first || "."
+base = File.expand_path(File.join("**", "*.rb"), source_dir)
+puts "Refactoring in source directory: #{base}"
+
+[
+  # Refactor "where(...).first -> find_by(...)"
+  RefactorWhereFirstToFindBy,
+
+  # Refactor ".expect(:where).never" to ".expect(:find_by).never"
+  RefactorWhereFirstNotCalledExpectations,
+
+  # Refactor ".expect(:where).return([X])" to ".expect(:find_by).return(X)"
+  #      and ".stubs(:where).return([X])" to ".stubs(:find_by).return(X)"
+  RefactorWhereFirstMocks,
+
+  # Refactor ".expect(:where).with(...).return([X])" to ".expect(:find_by).with(...).return(X)"
+  RefactorWhereFirstStrictMocks
+
+].each do |refactorer|
+  refactorer.new.refactor_files(Dir.glob(base)) do |path, refactored, changes|
+    if changes.empty?
+      puts "No changes in #{path}"
+
+    else
+      puts "In #{path}:"
+
+      changes.each do |change|
+        puts "\tAt #{change.original_position}, inserting:\n\t\t#{change.refactored_code}"
+        puts ""
+      end
+
+      File.open(path, "w") { |f| f.write(refactored) } if options[:overwrite]
+    end
+  end
+end

data/examples/refactorings/rails/where_first/refactorers/refactor_where_first_mocks.rb

@@ -0,0 +1,31 @@
+require "metamorpher"
+
+class RefactorWhereFirstMocks
+  include Metamorpher::Refactorer
+  include Metamorpher::Builders::Ruby
+
+  def pattern
+    builder
+     .build("TYPE.DOUBLE_METHOD(:where).returns(ARRAY_VALUE)")
+     .ensuring("DOUBLE_METHOD") { |m| m.name == :expects || m.name == :stubs }
+     .ensuring("ARRAY_VALUE") { |v| v.name == :array }
+     # Doesn't match non-array return types, such as Topic.stubs(:where).returns(Topic)
+  end
+
+  def replacement
+    builder
+     .build("TYPE.DOUBLE_METHOD(:find_by).returns(SINGLE_VALUE)")
+     .deriving("SINGLE_VALUE", "ARRAY_VALUE") { |array_value| take_first(array_value) }
+  end
+
+  private
+
+  # Refactor the argument from [] to nil, or from [X] to X
+  def take_first(array_value)
+    if array_value.children.empty?
+      builder.build("nil")
+    else
+      array_value.children.first
+    end
+  end
+end

data/examples/refactorings/rails/where_first/refactorers/refactor_where_first_not_called_expectations.rb

@@ -0,0 +1,14 @@
+require "metamorpher"
+
+class RefactorWhereFirstNotCalledExpectations
+  include Metamorpher::Refactorer
+  include Metamorpher::Builders::Ruby
+
+  def pattern
+    builder.build("TYPE.expects(:where).never")
+  end
+
+  def replacement
+    builder.build("TYPE.expects(:find_by).never")
+  end
+end

data/examples/refactorings/rails/where_first/refactorers/refactor_where_first_strict_mocks.rb

@@ -0,0 +1,27 @@
+require "metamorpher"
+
+class RefactorWhereFirstStrictMocks
+  include Metamorpher::Refactorer
+  include Metamorpher::Builders::Ruby
+
+  def pattern
+    builder.build("TYPE.expects(:where).with(PARAMS_).returns(ARRAY_VALUE)")
+  end
+
+  def replacement
+    builder
+     .build("TYPE.expects(:find_by).with(PARAMS_).returns(SINGLE_VALUE)")
+     .deriving("SINGLE_VALUE", "ARRAY_VALUE") { |array_value| take_first(array_value) }
+  end
+
+  private
+
+  # Refactor the argument from [] to nil, or from [X] to X
+  def take_first(array_value)
+    if array_value.children.empty?
+      builder.build("nil")
+    else
+      array_value.children.first
+    end
+  end
+end

data/examples/refactorings/rails/where_first/refactorers/refactor_where_first_to_find_by.rb

@@ -0,0 +1,14 @@
+require "metamorpher"
+
+class RefactorWhereFirstToFindBy
+  include Metamorpher::Refactorer
+  include Metamorpher::Builders::Ruby
+
+  def pattern
+    builder.build("TYPE.where(PARAMS_).first")
+  end
+
+  def replacement
+    builder.build("TYPE.find_by(PARAMS_)")
+  end
+end

data/examples/refactorings/rails/where_first/sample_controller.rb

@@ -0,0 +1,184 @@
+# Taken from Discourse: https://github.com/discourse/discourse
+
+require_dependency "user_destroyer"
+require_dependency "admin_user_index_query"
+require_dependency "boost_trust_level"
+
+class Admin::UsersController < Admin::AdminController
+  before_filter :fetch_user, only: [:suspend,
+                                    :unsuspend,
+                                    :refresh_browsers,
+                                    :revoke_admin,
+                                    :grant_admin,
+                                    :revoke_moderation,
+                                    :grant_moderation,
+                                    :approve,
+                                    :activate,
+                                    :deactivate,
+                                    :block,
+                                    :unblock,
+                                    :trust_level,
+                                    :primary_group,
+                                    :generate_api_key,
+                                    :revoke_api_key]
+
+  def index
+    query = ::AdminUserIndexQuery.new(params)
+    render_serialized(query.find_users, AdminUserSerializer)
+  end
+
+  def show
+    @user = User.where(username_lower: params[:id]).first
+    fail Discourse::NotFound.new unless @user
+    render_serialized(@user, AdminDetailedUserSerializer, root: false)
+  end
+
+  def delete_all_posts
+    @user = User.where(id: params[:user_id]).first
+    @user.delete_all_posts!(guardian)
+    render nothing: true
+  end
+
+  def suspend
+    guardian.ensure_can_suspend!(@user)
+    @user.suspended_till = params[:duration].to_i.days.from_now
+    @user.suspended_at = DateTime.now
+    @user.save!
+    StaffActionLogger.new(current_user).log_user_suspend(@user, params[:reason])
+    render nothing: true
+  end
+
+  def unsuspend
+    guardian.ensure_can_suspend!(@user)
+    @user.suspended_till = nil
+    @user.suspended_at = nil
+    @user.save!
+    StaffActionLogger.new(current_user).log_user_unsuspend(@user)
+    render nothing: true
+  end
+
+  def refresh_browsers
+    MessageBus.publish "/file-change", ["refresh"], user_ids: [@user.id]
+    render nothing: true
+  end
+
+  def revoke_admin
+    guardian.ensure_can_revoke_admin!(@user)
+    @user.revoke_admin!
+    render nothing: true
+  end
+
+  def generate_api_key
+    api_key = @user.generate_api_key(current_user)
+    render_serialized(api_key, ApiKeySerializer)
+  end
+
+  def revoke_api_key
+    @user.revoke_api_key
+    render nothing: true
+  end
+
+  def grant_admin
+    guardian.ensure_can_grant_admin!(@user)
+    @user.grant_admin!
+    render_serialized(@user, AdminUserSerializer)
+  end
+
+  def revoke_moderation
+    guardian.ensure_can_revoke_moderation!(@user)
+    @user.revoke_moderation!
+    render nothing: true
+  end
+
+  def grant_moderation
+    guardian.ensure_can_grant_moderation!(@user)
+    @user.grant_moderation!
+    render_serialized(@user, AdminUserSerializer)
+  end
+
+  def primary_group
+    guardian.ensure_can_change_primary_group!(@user)
+    @user.primary_group_id = params[:primary_group_id]
+    @user.save!
+    render nothing: true
+  end
+
+  def trust_level
+    guardian.ensure_can_change_trust_level!(@user)
+    logger = StaffActionLogger.new(current_user)
+    BoostTrustLevel.new(user: @user, level: params[:level], logger: logger).save!
+    render_serialized(@user, AdminUserSerializer)
+  end
+
+  def approve
+    guardian.ensure_can_approve!(@user)
+    @user.approve(current_user)
+    render nothing: true
+  end
+
+  def approve_bulk
+    User.where(id: params[:users]).each do |u|
+      u.approve(current_user) if guardian.can_approve?(u)
+    end
+    render nothing: true
+  end
+
+  def activate
+    guardian.ensure_can_activate!(@user)
+    @user.activate
+    render nothing: true
+  end
+
+  def deactivate
+    guardian.ensure_can_deactivate!(@user)
+    @user.deactivate
+    render nothing: true
+  end
+
+  def block
+    guardian.ensure_can_block_user! @user
+    UserBlocker.block(@user, current_user)
+    render nothing: true
+  end
+
+  def unblock
+    guardian.ensure_can_unblock_user! @user
+    UserBlocker.unblock(@user, current_user)
+    render nothing: true
+  end
+
+  def reject_bulk
+    d = UserDestroyer.new(current_user)
+    success_count = 0
+    User.where(id: params[:users]).each do |u|
+      success_count += 1 if guardian.can_delete_user?(u) and d.destroy(u, params.slice(:context)) rescue UserDestroyer::PostsExistError
+    end
+    render json: { success: success_count, failed: (params[:users].try(:size) || 0) - success_count }
+  end
+
+  def destroy
+    user = User.where(id: params[:id]).first
+    guardian.ensure_can_delete_user!(user)
+    begin
+      if UserDestroyer.new(current_user).destroy(user, params.slice(:delete_posts, :block_email, :block_urls, :block_ip, :context))
+        render json: { deleted: true }
+      else
+        render json: { deleted: false, user: AdminDetailedUserSerializer.new(user, root: false).as_json }
+      end
+    rescue UserDestroyer::PostsExistError
+      raise Discourse::InvalidAccess.new("User #{user.username} has #{user.post_count} posts, so can't be deleted.")
+    end
+  end
+
+  def badges
+  end
+
+  def leader_requirements
+  end
+
+  private
+
+  def fetch_user
+    @user = User.where(id: params[:user_id]).first
+  end
+end

data/lib/metamorpher/builders/ast/builder.rb

@@ -0,0 +1,50 @@
+require "metamorpher/builders/ast/literal_builder"
+require "metamorpher/builders/ast/variable_builder"
+require "metamorpher/builders/ast/greedy_variable_builder"
+require "metamorpher/builders/ast/derivation_builder"
+
+module Metamorpher
+  module Builders
+    module AST
+      class Builder
+        extend Forwardable
+        def_delegator :literal_builder, :literal!
+        def_delegator :variable_builder, :variable!
+        def_delegator :greedy_variable_builder, :greedy_variable!
+        def_delegator :derivation_builder, :derivation!
+
+        def method_missing(method, *arguments, &block)
+          builders_with_shorthand
+            .find { |builder| builder.shorthand?(method, *arguments, &block) }
+            .method_missing(method, *arguments, &block)
+        end
+
+        private
+
+        def builders_with_shorthand
+          @builders ||= [
+            literal_builder,
+            variable_builder,
+            greedy_variable_builder
+          ]
+        end
+
+        def literal_builder
+          @literal_builder ||= LiteralBuilder.new
+        end
+
+        def variable_builder
+          @variable_builder ||= VariableBuilder.new
+        end
+
+        def greedy_variable_builder
+          @greedy_variable_builder ||= GreedyVariableBuilder.new
+        end
+
+        def derivation_builder
+          @derivation_builder ||= DerivationBuilder.new
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ast/derivation_builder.rb

@@ -0,0 +1,20 @@
+require "metamorpher/terms/derived"
+require "metamorpher/builders/ast/builder"
+
+module Metamorpher
+  module Builders
+    module AST
+      class DerivationBuilder
+        def derivation!(*base, &block)
+          fail ArgumentError, "wrong number of arguments (0)" if base.empty?
+          fail ArgumentError, "a block must be provided" if block.nil?
+
+          Terms::Derived.new(
+            base: base,
+            derivation: ->(*args) { block.call(*args, Builder.new) }
+          )
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ast/greedy_variable_builder.rb

@@ -0,0 +1,29 @@
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Builders
+    module AST
+      class GreedyVariableBuilder
+        def greedy_variable!(name, &block)
+          if block
+            Terms::Variable.new(name: name, greedy?: true, condition: block)
+          else
+            Terms::Variable.new(name: name, greedy?: true)
+          end
+        end
+
+        def shorthand?(method, *arguments, &block)
+          !method[/\p{Lower}/] && method.to_s.end_with?("_")
+        end
+
+        def method_missing(method, *arguments, &block)
+          if shorthand?(method, *arguments, &block)
+            greedy_variable!(method.to_s.chomp("_").downcase.to_sym, *arguments, &block)
+          else
+            super.method_missing(method, *arguments, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ast/literal_builder.rb

@@ -0,0 +1,31 @@
+require "metamorpher/terms/literal"
+
+module Metamorpher
+  module Builders
+    module AST
+      class LiteralBuilder
+        def literal!(name, *children)
+          Terms::Literal.new(name: name, children: children.map { |c| termify(c) })
+        end
+
+        def shorthand?(method, *arguments, &block)
+          !method[/\p{Upper}/]
+        end
+
+        def method_missing(method, *arguments, &block)
+          if shorthand?(method, *arguments, &block)
+            literal!(method, *arguments)
+          else
+            super.method_missing(method, *arguments, &block)
+          end
+        end
+
+        private
+
+        def termify(item)
+          item.kind_of?(Terms::Term) ? item : literal!(item)
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ast/variable_builder.rb

@@ -0,0 +1,29 @@
+require "metamorpher/terms/variable"
+
+module Metamorpher
+  module Builders
+    module AST
+      class VariableBuilder
+        def variable!(name, &block)
+          if block
+            Terms::Variable.new(name: name, condition: block)
+          else
+            Terms::Variable.new(name: name)
+          end
+        end
+
+        def shorthand?(method, *arguments, &block)
+          !method[/\p{Lower}/] && !method.to_s.end_with?("_")
+        end
+
+        def method_missing(method, *arguments, &block)
+          if shorthand?(method, *arguments, &block)
+            variable!(method.downcase.to_sym, *arguments, &block)
+          else
+            super.method_missing(method, *arguments, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ast.rb

@@ -0,0 +1,11 @@
+require "metamorpher/builders/ast/builder"
+
+module Metamorpher
+  module Builders
+    module AST
+      def builder
+        @builder ||= Builder.new
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/builder.rb

@@ -0,0 +1,38 @@
+require "metamorpher/drivers/ruby"
+require "metamorpher/builders/ruby/term"
+require "metamorpher/builders/ruby/uppercase_constant_rewriter"
+require "metamorpher/builders/ruby/uppercase_rewriter"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      class Builder
+        def build(source)
+          decorate(rewrite(parse(source)))
+        end
+
+        private
+
+        def decorate(term)
+          term.extend(Term)
+        end
+
+        def rewrite(parsed)
+          rewriters.reduce(parsed) { |a, e| e.reduce(a) }
+        end
+
+        def parse(source)
+          driver.parse(source)
+        end
+
+        def rewriters
+          @rewriters ||= [UppercaseConstantRewriter.new, UppercaseRewriter.new]
+        end
+
+        def driver
+          @driver ||= Drivers::Ruby.new
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/deriving_visitor.rb

@@ -0,0 +1,13 @@
+require "metamorpher/builders/ruby/variable_replacement_visitor"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      class DerivingVisitor < VariableReplacementVisitor
+        def initialize(variable_name, *base, derivation)
+          super(variable_name, Terms::Derived.new(base: base, derivation: derivation))
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/ensuring_visitor.rb

@@ -0,0 +1,13 @@
+require "metamorpher/builders/ruby/variable_replacement_visitor"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      class EnsuringVisitor < VariableReplacementVisitor
+        def initialize(variable_name, condition)
+          super(variable_name, Terms::Variable.new(name: variable_name, condition: condition))
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/term.rb

@@ -0,0 +1,35 @@
+require "metamorpher/builders/ruby/ensuring_visitor"
+require "metamorpher/builders/ruby/deriving_visitor"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      module Term
+        def ensuring(variable_name, &condition)
+          accept_and_decorate(
+            EnsuringVisitor.new(
+              variable_name.downcase.to_sym,
+              condition
+            )
+          )
+        end
+
+        def deriving(variable_name, *base_names, &derivation)
+          accept_and_decorate(
+            DerivingVisitor.new(
+              variable_name.downcase.to_sym,
+              *base_names.map { |n| n.downcase.to_sym },
+              derivation
+            )
+          )
+        end
+
+        private
+
+        def accept_and_decorate(visitor)
+          accept(visitor).extend(Term)
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/uppercase_constant_rewriter.rb

@@ -0,0 +1,31 @@
+require "metamorpher/builders/ast"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      class UppercaseConstantRewriter
+        include Metamorpher::Rewriter
+        include Metamorpher::Builders::AST
+
+        def pattern
+          builder.const(
+            builder.literal!(nil),
+            builder.VARIABLE_TO_BE { |v| v.name && v.name.to_s[/^[A-Z_]*$/] }
+          )
+        end
+
+        def replacement
+          builder.derivation!(:variable_to_be) do |variable_to_be, builder|
+            name = variable_to_be.name.to_s
+
+            if name.end_with?("_")
+              builder.greedy_variable! name.chomp("_").downcase.to_sym
+            else
+              builder.variable! name.downcase.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/metamorpher/builders/ruby/uppercase_rewriter.rb

@@ -0,0 +1,28 @@
+require "metamorpher/builders/ast"
+
+module Metamorpher
+  module Builders
+    module Ruby
+      class UppercaseRewriter
+        include Metamorpher::Rewriter
+        include Metamorpher::Builders::AST
+
+        def pattern
+          builder.VARIABLE_TO_BE { |v| v.name && v.name.to_s[/^[A-Z_]*$/] }
+        end
+
+        def replacement
+          builder.derivation!(:variable_to_be) do |variable_to_be, builder|
+            name = variable_to_be.name.to_s
+
+            if name.end_with?("_")
+              builder.greedy_variable! name.chomp("_").downcase.to_sym
+            else
+              builder.variable! name.downcase.to_sym
+            end
+          end
+        end
+      end
+    end
+  end
+end