activerecord-refined 0.6.1 → 0.8.0

data/test/test_block_syntax.rb

@@ -697,7 +697,7 @@ class TestBlockSyntax < Minitest::Test
   end
 
   # A relation without an explicit select list selects its primary key, the
-  # same way ActiveRecord's own where(id: relation) does.
+  # same way Active Record's own where(id: relation) does.
   def test_in_subquery_selects_primary_key_by_default
     assert_sql(/WHERE "authors"."id" IN \(SELECT "posts"."id" FROM "posts"\)/,
       Author.where { :id.in?(Post.all) }.to_sql)
@@ -878,6 +878,80 @@ class TestBlockSyntax < Minitest::Test
     assert_raises(ArgumentError) { Author.left_outer_joins(:posts, as: :p) }
   end
 
+  # The other two outer joins, which Active Record has no method for.  MySQL
+  # has no FULL OUTER JOIN either, and says so before the SQL is built.
+  def test_right_outer_joins_with_block
+    assert_sql(/RIGHT OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/,
+      Author.right_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql)
+  end
+
+  def test_full_outer_joins_with_block
+    skip_without_full_outer_joins
+    assert_sql(/FULL OUTER JOIN "posts" ON "posts"."author_id" = "authors"."id"/,
+      Author.full_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }.to_sql)
+  end
+
+  def test_full_outer_joins_says_where_it_cannot_go
+    skip "#{ADAPTER} has FULL OUTER JOIN" unless ADAPTER == 'mysql2'
+    e = assert_raises(NotImplementedError) do
+      Author.full_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }
+    end
+    assert_match(/no equivalent on MySQL/, e.message)
+  end
+
+  def test_right_outer_joins_with_alias
+    assert_sql(
+      /RIGHT OUTER JOIN "authors" (?:AS )?"mentors" ON "mentors"."id" = "authors"."id"/,
+      Author.right_outer_joins(:authors, as: :mentors) { :mentors[:id] == :authors[:id] }.to_sql)
+  end
+
+  # An association is what joins and left_outer_joins read; there is nothing
+  # for these two to read one as.
+  def test_the_other_outer_joins_need_a_block
+    e = assert_raises(ArgumentError) { Author.right_outer_joins(:posts) }
+    assert_match(/takes a table and the block/, e.message)
+    unless ADAPTER == 'mysql2'
+      assert_raises(ArgumentError) { Author.full_outer_joins(:posts) }
+    end
+  end
+
+  # CROSS JOIN: every row against every row, so there is no condition to give.
+  def test_cross_joins
+    assert_sql(/FROM "authors" CROSS JOIN "posts"/, Author.cross_joins(:posts).to_sql)
+  end
+
+  def test_cross_joins_with_alias
+    assert_sql(/CROSS JOIN "authors" "others"/,
+      Author.cross_joins(:authors, as: :others).to_sql)
+  end
+
+  def test_cross_joins_takes_no_block
+    e = assert_raises(ArgumentError) { Author.cross_joins(:posts) { :id == 1 } }
+    assert_match(/no condition/, e.message)
+  end
+
+  def test_cross_joins_execution
+    Author.delete_all
+    Post.delete_all
+    Author.create!(name: 'a')
+    Author.create!(name: 'b')
+    Post.create!(title: 'one')
+    Post.create!(title: 'two')
+    Post.create!(title: 'three')
+    assert_equal(6, Author.cross_joins(:posts).count)
+  end
+
+  def test_right_outer_joins_execution
+    Author.delete_all
+    Post.delete_all
+    author = Author.create!(name: 'a')
+    Post.create!(title: 'hers', author_id: author.id)
+    Post.create!(title: 'nobody\'s', author_id: nil)
+    assert_equal(['a', nil],
+      Author.right_outer_joins(:posts) { :posts[:author_id] == :authors[:id] }.
+        order { :posts[:title] }.pluck(:'authors.name'))
+  end
+
   def test_joins_without_alias_still_delegates
     assert_sql(/INNER JOIN "posts" ON "posts"."author_id" = "authors"."id"/,
       Author.joins(:posts).to_sql)
@@ -892,7 +966,7 @@ class TestBlockSyntax < Minitest::Test
         pluck(:name).sort)
   end
 
-  # ActiveRecord's from only takes a table name as a string.
+  # Active Record's from only takes a table name as a string.
   def test_from_symbol
     assert_sql(/FROM "tree"/, Node.from(:tree).to_sql)
   end
@@ -1817,48 +1891,115 @@ class TestBlockSyntax < Minitest::Test
     Doc.create!(name: 'two', meta: json_document({ 'n' => 9 }))
   end
 
-  def test_dig_a_key
+  def test_dig_text_a_key
     seed_docs
-    assert_equal(%w[5 9], Doc.order(:name).select { :meta.dig(:n).as(:v) }.map(&:v))
+    assert_equal(%w[5 9], Doc.order(:name).select { :meta.dig_text(:n).as(:v) }.map(&:v))
   end
 
-  def test_dig_a_path
+  def test_dig_text_a_path
     seed_docs
     assert_equal(['deep', nil],
-      Doc.order(:name).select { :meta.dig(:a, :b).as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:a, :b).as(:v) }.map(&:v))
   end
 
-  def test_dig_an_array_index
+  def test_dig_text_an_array_index
     seed_docs
     assert_equal(['x', nil],
-      Doc.order(:name).select { :meta.dig(:tags, 0).as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:tags, 0).as(:v) }.map(&:v))
   end
 
   # A key that is not a plain name travels as itself rather than being refused.
-  def test_dig_a_key_that_needs_quoting
+  def test_dig_text_a_key_that_needs_quoting
     seed_docs
     assert_equal(['1', nil],
-      Doc.order(:name).select { :meta.dig(:'odd key').as(:v) }.map(&:v))
+      Doc.order(:name).select { :meta.dig_text(:'odd key').as(:v) }.map(&:v))
   end
 
-  # dig gives text on every adapter -- SQLite's ->> would otherwise give the
+  # dig_text gives text on every adapter -- SQLite's ->> would otherwise give the
   # value with its type -- so a number is compared through a cast.
-  def test_dig_is_text_everywhere
+  def test_dig_text_is_text_everywhere
     seed_docs
-    assert_equal(['one'], Doc.where { :meta.dig(:n) == '5' }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == '5' }.pluck(:name))
     type = integer_type
-    assert_equal(['two'], Doc.where { cast(:meta.dig(:n), type) > 6 }.pluck(:name))
+    assert_equal(['two'], Doc.where { cast(:meta.dig_text(:n), type) > 6 }.pluck(:name))
   end
 
-  def test_dig_json_keeps_the_json
+  def test_dig_keeps_the_json
     seed_docs
-    value = Doc.where { :name == 'one' }.select { :meta.dig_json(:tags).as(:v) }.first.v
+    value = Doc.where { :name == 'one' }.select { :meta.dig(:tags).as(:v) }.first.v
     assert_equal(%w[x y], value.is_a?(String) ? JSON.parse(value) : value)
   end
 
-  def test_dig_from_a_qualified_column
+  # What text compared with a number means is a question the three adapters
+  # answer three ways -- `dig_text(:n) == 5` is true on SQLite, an error on
+  # PostgreSQL and true on MySQL, and `dig_text(:flag) == true` is true, an error
+  # and false -- so the comparison is refused rather than left to them.
+  def test_dig_text_refuses_a_comparison_with_anything_but_text
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) == 5 } }
+    assert_match(/cast/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) != 5 } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n) > 6 } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:flag) == true } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n).in?([1, 2]) } }
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:n).between?(1, 9) } }
+  end
+
+  # A string is what a dug value compares to; so is anything the block built
+  # rather than wrote as a literal, since that is nobody's guess to make.
+  def test_dig_text_compares_with_text_and_with_expressions
     seed_docs
-    assert_equal(['one'], Doc.where { :docs[:meta].dig(:a, :b) == 'deep' }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == '5' }.pluck(:name))
+    assert_equal([], Doc.where { :meta.dig_text(:n) == :name }.pluck(:name))
+    assert_equal(['one'], Doc.where { :meta.dig_text(:n) == upper('5') }.pluck(:name))
+    type = integer_type
+    assert_equal(['one'], Doc.where { cast(:meta.dig_text(:n), type) == 5 }.pluck(:name))
+  end
+
+  # The JSON for a string carries its quotes, so the same comparison is
+  # refused the other way about: false on SQLite, an error on PostgreSQL and
+  # true on MySQL.
+  def test_dig_refuses_a_comparison_with_a_ruby_value
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig(:a) == 'deep' } }
+    assert_match(/dig_text gives the value/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.dig(:n) == 5 } }
+  end
+
+  # What dig gives is a document, so the JSON operations read it: the
+  # same question asked of a part rather than of the whole.
+  def test_the_json_operations_read_what_dig_kept
+    seed_docs
+    assert_equal(['one'], Doc.where { :meta.dig(:a).key?(:b) }.pluck(:name))
+    assert_equal(%w[one two], Doc.where { :meta.dig(:n).not_null? }.order(:name).pluck(:name))
+    assert_equal(['one'],
+      Doc.where { :meta.dig(:a).dig_text(:b) == 'deep' }.pluck(:name))
+    value = Doc.where { :name == 'one' }.
+      select { :meta.dig(:a).bury(:b, 'x').as(:v) }.first.v
+    assert_equal('x', (value.is_a?(String) ? JSON.parse(value) : value)['b'])
+  end
+
+  def test_containment_reads_what_dig_kept
+    skip_without_json_containment
+    seed_docs
+    assert_equal(['one'], Doc.where { :meta.dig(:tags).contains?(['x']) }.pluck(:name))
+    assert_equal([], Doc.where { :meta.dig(:tags).contains?(['z']) }.pluck(:name))
+  end
+
+  # Reading text back as a document is where the adapters part company:
+  # SQLite parses it, MySQL takes it as written, PostgreSQL has no such
+  # function for text at all.
+  def test_the_json_operations_are_refused_on_a_dug_value
+    e = assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:a).key?(:b) } }
+    assert_match(/dig keeps it/, e.message)
+    assert_raises(ArgumentError) { Doc.where { :meta.dig_text(:a).contains?(b: 1) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).dig_text(:b) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).dig(:b) } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).bury(:b, 'x') } }
+    assert_raises(ArgumentError) { Doc.select { :meta.dig_text(:a).except(:b) } }
+  end
+
+  def test_dig_text_from_a_qualified_column
+    seed_docs
+    assert_equal(['one'], Doc.where { :docs[:meta].dig_text(:a, :b) == 'deep' }.pluck(:name))
   end
 
   def test_key
@@ -1881,7 +2022,7 @@ class TestBlockSyntax < Minitest::Test
 
   def test_dig_needs_a_path
     assert_raises(ArgumentError) { Doc.select { :meta.dig } }
-    e = assert_raises(ArgumentError) { Doc.select { :meta.dig(1.5) } }
+    e = assert_raises(ArgumentError) { Doc.select { :meta.dig_text(1.5) } }
     assert_match(/key or an array index/, e.message)
   end
 
@@ -2012,7 +2153,7 @@ class TestBlockSyntax < Minitest::Test
   def test_lateral_join
     skip_without_lateral
     seed_for_lateral
-    rows = Author.joins(top_post, as: :top, lateral: true).
+    rows = Author.joins(top_post.lateral, as: :top).
       select { [:name, :top[:title].as(:v)] }.map {|r| [r.name, r.v] }
     assert_equal([['writes', 'b']], rows)
   end
@@ -2021,7 +2162,7 @@ class TestBlockSyntax < Minitest::Test
   def test_left_outer_lateral_join
     skip_without_lateral
     seed_for_lateral
-    rows = Author.left_outer_joins(top_post, as: :top, lateral: true).
+    rows = Author.left_outer_joins(top_post.lateral, as: :top).
       select { [:name, :top[:title].as(:v)] }.order { :name }.map {|r| [r.name, r.v] }
     assert_equal([['does not', nil], ['writes', 'b']], rows)
   end
@@ -2031,22 +2172,28 @@ class TestBlockSyntax < Minitest::Test
   def test_lateral_join_takes_an_on_clause
     skip_without_lateral
     seed_for_lateral
-    assert_equal(0, Author.joins(top_post, as: :top, lateral: true) {
+    assert_equal(0, Author.joins(top_post.lateral, as: :top) {
       :top[:title] == 'nothing'
     }.count)
-    assert_sql(/ON TRUE/, Author.joins(top_post, as: :top, lateral: true).to_sql)
+    assert_sql(/ON TRUE/, Author.joins(top_post.lateral, as: :top).to_sql)
   end
 
-  def test_lateral_join_needs_a_relation_and_a_name
-    e = assert_raises(ArgumentError) { Author.joins(:posts, as: :top, lateral: true) }
-    assert_match(/takes a relation/, e.message)
-    e = assert_raises(ArgumentError) { Author.joins(top_post, lateral: true) }
+  def test_lateral_join_needs_the_mark_and_a_name
+    e = assert_raises(ArgumentError) { Author.joins(top_post, as: :top) }
+    assert_match(/mark it/, e.message)
+    e = assert_raises(ArgumentError) { Author.joins(top_post.lateral) }
     assert_match(/needs a name/, e.message)
   end
 
+  def test_lateral_spawns
+    relation = top_post
+    assert(relation.lateral.lateral_value)
+    refute(relation.lateral_value)
+  end
+
   def test_lateral_join_says_where_it_cannot_go
     skip 'this one has LATERAL' if ADAPTER == 'postgresql' || (ADAPTER == 'mysql2' && !mariadb?)
-    e = assert_raises(NotImplementedError) { Author.joins(top_post, as: :top, lateral: true) }
+    e = assert_raises(NotImplementedError) { Author.joins(top_post.lateral, as: :top) }
     assert_match(/lateral join has no equivalent/, e.message)
   end
 
@@ -2136,7 +2283,7 @@ class TestBlockSyntax < Minitest::Test
 
   # The value can be read out of the document it is going into.
   def test_bury_an_expression
-    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig(:n)) } }['copy'].to_s)
+    assert_equal('5', buried { { meta: :meta.bury(:copy, :meta.dig_text(:n)) } }['copy'].to_s)
   end
 
   # It is an expression, so it does not have to be written anywhere.
@@ -2151,6 +2298,44 @@ class TestBlockSyntax < Minitest::Test
     assert_raises(ArgumentError) { Doc.select { :meta.bury(1.5, 'v') } }
   end
 
+  # except takes keys out, by the name of what Hash does.  PostgreSQL
+  # subtracts them where the others remove a path apiece, and what comes back
+  # is the same document on all three.
+  def test_except_a_key
+    assert_equal({ 'a' => { 'b' => 'deep' }, 'tags' => %w[x y], 'odd key' => 1 },
+      buried { { meta: :meta.except(:n) } })
+  end
+
+  def test_except_several_keys
+    assert_equal({ 'a' => { 'b' => 'deep' } },
+      buried { { meta: :meta.except(:n, :tags, :'odd key') } })
+  end
+
+  # A key that is not there is not an error, as Hash#except has none for it.
+  def test_except_a_key_that_is_not_there
+    assert_equal(5, buried { { meta: :meta.except(:nothing) } }['n'])
+  end
+
+  # The document a bury gives back is one to take keys out of.
+  def test_except_after_bury
+    document = buried { { meta: :meta.bury(:fresh, 9).except(:n) } }
+    assert_equal(9, document['fresh'])
+    assert_nil(document['n'])
+  end
+
+  def test_except_in_a_select
+    seed_docs
+    value = Doc.where { :name == 'one' }.select { :meta.except(:n).as(:v) }.first.v
+    assert_nil((value.is_a?(String) ? JSON.parse(value) : value)['n'])
+  end
+
+  # An index is not what the name says anywhere, and a path is bury's.
+  def test_except_takes_keys
+    assert_raises(ArgumentError) { Doc.select { :meta.except } }
+    e = assert_raises(ArgumentError) { Doc.select { :meta.except(0) } }
+    assert_match(/keys of the document/, e.message)
+  end
+
   def test_default_where_syntax
     assert_sql(/WHERE "users"."name" = 'Ruby' AND "users"."age" = 19/,
       User.where(name: 'Ruby', age: 19).to_sql)

data/test/test_helper.rb

@@ -74,7 +74,12 @@ module SqlAssertions
     skip "#{ADAPTER} has no JSON containment" if ADAPTER == 'sqlite3'
   end
 
-  # MariaDB's json is a checked longtext, which ActiveRecord sees as a string
+  # MySQL is the one without a FULL OUTER JOIN, and so is MariaDB.
+  def skip_without_full_outer_joins
+    skip "#{ADAPTER} has no full outer join" if ADAPTER == 'mysql2'
+  end
+
+  # MariaDB's json is a checked longtext, which Active Record sees as a string
   # and does not serialise a hash into -- what would go in is Ruby's inspect,
   # which the check refuses.  MySQL's json is a type of its own and takes the
   # hash; handing that one a string would store the document as a JSON string

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-refined
 version: !ruby/object:Gem::Version
-  version: 0.6.1
+  version: 0.8.0
 platform: ruby
 authors:
   - Shugo Maeda
@@ -73,7 +73,23 @@ dependencies:
           - ">="
           - !ruby/object:Gem::Version
             version: "0"
-description: Adding clean and powerful query syntax on AR using refinements
+  - !ruby/object:Gem::Dependency
+    name: bump
+    requirement: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+    type: :development
+    prerelease: false
+    version_requirements: !ruby/object:Gem::Requirement
+      requirements:
+        -
+          - ">="
+          - !ruby/object:Gem::Version
+            version: "0"
+description: Adding clean and powerful query syntax on Active Record using refinements
 email:
   - shugo@ruby-lang.org
 executables: []
@@ -127,7 +143,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 rubygems_version: 4.1.0.dev
 specification_version: 4
-summary: "ActiveRecord + Ruby 4.1 Proc#refined"
+summary: Write Active Record queries as Ruby expressions
 test_files:
   - test/test_block_syntax.rb
   - test/test_helper.rb