From fc38ff6e4417295c870f419f7c164ab5a7dbc4a5 Mon Sep 17 00:00:00 2001 From: Ryuta Kamizono Date: Sat, 15 Jun 2019 22:17:20 +0900 Subject: Remove unused `DepthFirst` visitor We only use `ToSQL` visitors in the our codebase, do not use `DepthFirst` and `Dot` visitors. The `DepthFirst` visitor (which was introduced at c86c37e5f) is used to traverse an Arel (partial) ast with depth first. Is there any worth to keep that undocumented feature with much code and test cases. This removes that unused `DepthFirst` code and test cases. --- activerecord/test/cases/arel/nodes/node_test.rb | 19 -- .../test/cases/arel/select_manager_test.rb | 10 - .../test/cases/arel/visitors/depth_first_test.rb | 276 --------------------- .../arel/visitors/dispatch_contamination_test.rb | 8 +- 4 files changed, 7 insertions(+), 306 deletions(-) delete mode 100644 activerecord/test/cases/arel/visitors/depth_first_test.rb (limited to 'activerecord/test') diff --git a/activerecord/test/cases/arel/nodes/node_test.rb b/activerecord/test/cases/arel/nodes/node_test.rb index f4f07ef2c5..f1e0ce1ea9 100644 --- a/activerecord/test/cases/arel/nodes/node_test.rb +++ b/activerecord/test/cases/arel/nodes/node_test.rb @@ -18,24 +18,5 @@ module Arel assert klass.ancestors.include?(Nodes::Node), klass.name end end - - def test_each - list = [] - node = Nodes::Node.new - node.each { |n| list << n } - assert_equal [node], list - end - - def test_generator - list = [] - node = Nodes::Node.new - node.each.each { |n| list << n } - assert_equal [node], list - end - - def test_enumerable - node = Nodes::Node.new - assert_kind_of Enumerable, node - end end end diff --git a/activerecord/test/cases/arel/select_manager_test.rb b/activerecord/test/cases/arel/select_manager_test.rb index e6c49cd429..526fe6787a 100644 --- a/activerecord/test/cases/arel/select_manager_test.rb +++ b/activerecord/test/cases/arel/select_manager_test.rb @@ -369,16 +369,6 @@ module Arel mgr = table.from assert mgr.ast end - - it "should allow orders to work when the ast is grepped" do - table = Table.new :users - mgr = table.from - mgr.project Arel.sql "*" - mgr.from table - mgr.orders << Arel::Nodes::Ascending.new(Arel.sql("foo")) - mgr.ast.grep(Arel::Nodes::OuterJoin) - mgr.to_sql.must_be_like %{ SELECT * FROM "users" ORDER BY foo ASC } - end end describe "taken" do diff --git a/activerecord/test/cases/arel/visitors/depth_first_test.rb b/activerecord/test/cases/arel/visitors/depth_first_test.rb deleted file mode 100644 index 106be2311d..0000000000 --- a/activerecord/test/cases/arel/visitors/depth_first_test.rb +++ /dev/null @@ -1,276 +0,0 @@ -# frozen_string_literal: true - -require_relative "../helper" - -module Arel - module Visitors - class TestDepthFirst < Arel::Test - Collector = Struct.new(:calls) do - def call(object) - calls << object - end - end - - def setup - @collector = Collector.new [] - @visitor = Visitors::DepthFirst.new @collector - end - - def test_raises_with_object - assert_raises(TypeError) do - @visitor.accept(Object.new) - end - end - - - # unary ops - [ - Arel::Nodes::Not, - Arel::Nodes::Group, - Arel::Nodes::On, - Arel::Nodes::Grouping, - Arel::Nodes::Offset, - Arel::Nodes::Ordering, - Arel::Nodes::StringJoin, - Arel::Nodes::UnqualifiedColumn, - Arel::Nodes::ValuesList, - Arel::Nodes::Limit, - Arel::Nodes::Else, - ].each do |klass| - define_method("test_#{klass.name.gsub('::', '_')}") do - op = klass.new(:a) - @visitor.accept op - assert_equal [:a, op], @collector.calls - end - end - - # functions - [ - Arel::Nodes::Exists, - Arel::Nodes::Avg, - Arel::Nodes::Min, - Arel::Nodes::Max, - Arel::Nodes::Sum, - ].each do |klass| - define_method("test_#{klass.name.gsub('::', '_')}") do - func = klass.new(:a, "b") - @visitor.accept func - assert_equal [:a, "b", false, func], @collector.calls - end - end - - def test_named_function - func = Arel::Nodes::NamedFunction.new(:a, :b, "c") - @visitor.accept func - assert_equal [:a, :b, false, "c", func], @collector.calls - end - - def test_lock - lock = Nodes::Lock.new true - @visitor.accept lock - assert_equal [lock], @collector.calls - end - - def test_count - count = Nodes::Count.new :a, :b, "c" - @visitor.accept count - assert_equal [:a, "c", :b, count], @collector.calls - end - - def test_inner_join - join = Nodes::InnerJoin.new :a, :b - @visitor.accept join - assert_equal [:a, :b, join], @collector.calls - end - - def test_full_outer_join - join = Nodes::FullOuterJoin.new :a, :b - @visitor.accept join - assert_equal [:a, :b, join], @collector.calls - end - - def test_outer_join - join = Nodes::OuterJoin.new :a, :b - @visitor.accept join - assert_equal [:a, :b, join], @collector.calls - end - - def test_right_outer_join - join = Nodes::RightOuterJoin.new :a, :b - @visitor.accept join - assert_equal [:a, :b, join], @collector.calls - end - - def test_comment - comment = Nodes::Comment.new ["foo"] - @visitor.accept comment - assert_equal ["foo", ["foo"], comment], @collector.calls - end - - [ - Arel::Nodes::Assignment, - Arel::Nodes::Between, - Arel::Nodes::Concat, - Arel::Nodes::DoesNotMatch, - Arel::Nodes::Equality, - Arel::Nodes::GreaterThan, - Arel::Nodes::GreaterThanOrEqual, - Arel::Nodes::In, - Arel::Nodes::LessThan, - Arel::Nodes::LessThanOrEqual, - Arel::Nodes::Matches, - Arel::Nodes::NotEqual, - Arel::Nodes::NotIn, - Arel::Nodes::Or, - Arel::Nodes::TableAlias, - Arel::Nodes::As, - Arel::Nodes::DeleteStatement, - Arel::Nodes::JoinSource, - Arel::Nodes::When, - ].each do |klass| - define_method("test_#{klass.name.gsub('::', '_')}") do - binary = klass.new(:a, :b) - @visitor.accept binary - assert_equal [:a, :b, binary], @collector.calls - end - end - - def test_Arel_Nodes_InfixOperation - binary = Arel::Nodes::InfixOperation.new(:o, :a, :b) - @visitor.accept binary - assert_equal [:a, :b, binary], @collector.calls - end - - # N-ary - [ - Arel::Nodes::And, - ].each do |klass| - define_method("test_#{klass.name.gsub('::', '_')}") do - binary = klass.new([:a, :b, :c]) - @visitor.accept binary - assert_equal [:a, :b, :c, binary], @collector.calls - end - end - - [ - Arel::Attributes::Integer, - Arel::Attributes::Float, - Arel::Attributes::String, - Arel::Attributes::Time, - Arel::Attributes::Boolean, - Arel::Attributes::Attribute - ].each do |klass| - define_method("test_#{klass.name.gsub('::', '_')}") do - binary = klass.new(:a, :b) - @visitor.accept binary - assert_equal [:a, :b, binary], @collector.calls - end - end - - def test_table - relation = Arel::Table.new(:users) - @visitor.accept relation - assert_equal ["users", relation], @collector.calls - end - - def test_array - node = Nodes::Or.new(:a, :b) - list = [node] - @visitor.accept list - assert_equal [:a, :b, node, list], @collector.calls - end - - def test_set - node = Nodes::Or.new(:a, :b) - set = Set.new([node]) - @visitor.accept set - assert_equal [:a, :b, node, set], @collector.calls - end - - def test_hash - node = Nodes::Or.new(:a, :b) - hash = { node => node } - @visitor.accept hash - assert_equal [:a, :b, node, :a, :b, node, hash], @collector.calls - end - - def test_update_statement - stmt = Nodes::UpdateStatement.new - stmt.relation = :a - stmt.values << :b - stmt.wheres << :c - stmt.orders << :d - stmt.limit = :e - - @visitor.accept stmt - assert_equal [:a, :b, stmt.values, :c, stmt.wheres, :d, stmt.orders, - :e, stmt], @collector.calls - end - - def test_select_core - core = Nodes::SelectCore.new - core.projections << :a - core.froms = :b - core.wheres << :c - core.groups << :d - core.windows << :e - core.havings << :f - - @visitor.accept core - assert_equal [ - :a, core.projections, - :b, [], - core.source, - :c, core.wheres, - :d, core.groups, - :e, core.windows, - :f, core.havings, - core], @collector.calls - end - - def test_select_statement - ss = Nodes::SelectStatement.new - ss.cores.replace [:a] - ss.orders << :b - ss.limit = :c - ss.lock = :d - ss.offset = :e - - @visitor.accept ss - assert_equal [ - :a, ss.cores, - :b, ss.orders, - :c, - :d, - :e, - ss], @collector.calls - end - - def test_insert_statement - stmt = Nodes::InsertStatement.new - stmt.relation = :a - stmt.columns << :b - stmt.values = :c - - @visitor.accept stmt - assert_equal [:a, :b, stmt.columns, :c, stmt], @collector.calls - end - - def test_case - node = Arel::Nodes::Case.new - node.case = :a - node.conditions << :b - node.default = :c - - @visitor.accept node - assert_equal [:a, :b, node.conditions, :c, node], @collector.calls - end - - def test_node - node = Nodes::Node.new - @visitor.accept node - assert_equal [node], @collector.calls - end - end - end -end diff --git a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb index a07a1a050a..36f9eb49a2 100644 --- a/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb +++ b/activerecord/test/cases/arel/visitors/dispatch_contamination_test.rb @@ -48,7 +48,13 @@ module Arel node = Nodes::Union.new(Nodes::True.new, Nodes::False.new) assert_equal "( TRUE UNION FALSE )", node.to_sql - node.first # from Nodes::Node's Enumerable mixin + visitor = Class.new(Visitor) { + def visit_Arel_Nodes_Union(o); end + alias :visit_Arel_Nodes_True :visit_Arel_Nodes_Union + alias :visit_Arel_Nodes_False :visit_Arel_Nodes_Union + }.new + + visitor.accept(node) assert_equal "( TRUE UNION FALSE )", node.to_sql end -- cgit v1.2.3