relation 0.1.5 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df6322bf0f490d490afb201cf26f915bfeb80be2baf9719c2a038c896a653d85
-  data.tar.gz: 4d2b576cb95debcedcb8116a1f1eaf898ca3b79e70c4472afd3b17f520cbfd69
+  metadata.gz: 5527b21869e536172e48b7d49e14c6bddeb1f7c522c8c1e9a23005d9a008f635
+  data.tar.gz: ad2d9f23632c38ed4f65ce9e367de6ad051b28f3dfc8de447fe62b07f129d3ed
 SHA512:
-  metadata.gz: 5a796bb464316ee82537a1116b54f66900615242ad5c12f1acd097a0216e45ebb0e39dce2d959982339a334108c1e37bd10361f4e1c06a305bef41c63ad57970
-  data.tar.gz: 1fc49c642dbb8030bd83810415de6cfd1e9d5e9f98d1a44db219e6278dd4fc86ab346f6a68a6eec3d908ce34f5628e78c775f8aee651256551bfd2458002f741
+  metadata.gz: 33fcd78c742fbd5c768595b4c4f7badabcdfbb54084acfacf971d603c923f6c746c80ca5cfdd69e4a652680f6c2620dd9bbf059cd0a7738dce05ae7d61bad68c
+  data.tar.gz: 7ec3c167144696171214d1a525a78fed82ad202efc5fe8e2655441f918a748e9f4aaeb321664cfed9576919fad90566d403e61c0851678f5a135c45d82d72d12

data/.gitignore

@@ -8,9 +8,7 @@ pkg/*
 # Ignore the default SQLite database.
 /db/*.sqlite3
 /db/*.sqlite3-journal
-/spec/internal/db/*.sqlite3
 
 # Ignore all logfiles and tempfiles.
-/spec/internal/log
 log
 tmp

data/.watchr

@@ -16,7 +16,7 @@ end
 
 def run_it(type, file)
   case type
-  when 'test';  run %Q{ruby -I"lib:test" -rubygems #{file}}
+  when 'test';  run %Q{ruby -I test #{file}}
 #  when 'spec';  run %Q{spring rspec -X #{file}}
   else;         puts "#{H} unknown type: #{type}, file: #{file}"
   end

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright 2015-2017 Dittmar Krall - http://matique.de
+Copyright 2015-2018 Dittmar Krall - http://matique.de
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/app/models/dangling.rb

@@ -0,0 +1,31 @@
+# extended Relation: extracts relation from rows
+class Relation < ActiveRecord::Base
+
+  def self.dangling
+    names = Relation.pluck(:name).uniq
+    models = []
+    names.each { |name|
+      models |= name.split(' ')
+    }
+    hsh = {}
+    models.each { |class_name|
+      klass = class_name.constantize
+      ids = klass.pluck(:id)
+      idx = Relation.where('name like ?', "#{class_name} %").pluck(:x_id)
+      idy = Relation.where('name like ?', "% #{class_name}").pluck(:y_id)
+      arr = (idx | idy) - ids
+      hsh[class_name] = arr  if arr.length > 0
+    }
+    hsh
+  end
+
+  def self.remove_dangling(hsh)
+    hsh.each { |name, arr|
+      arr.each { |idx|
+	Relation.where(x_id: idx).where('name like ?', "#{name} %").delete_all
+	Relation.where(y_id: idx).where('name like ?', "% #{name}").delete_all
+      }
+    }
+  end
+
+end

data/app/models/relation.rb

@@ -1,78 +1,21 @@
 class Relation < ActiveRecord::Base
 
-  def self.add(row_from, row_to)
-    name_from, id_from = name_id(row_from)
-    name_to, id_to     = name_id(row_to)
-    name = "#{name_from} #{name_to}"
+  def self.add_raw(name, id_from, id_to)
     hsh = { name: name, x_id: id_from, y_id: id_to }
-
     Relation.create!(hsh)  if Relation.where(hsh).first == nil
   end
 
-  def self.delete(row_from, row_to)
-    name_from, id_from = name_id(row_from)
-    name_to, id_to     = name_id(row_to)
-    name = "#{name_from} #{name_to}"
+  def self.delete_raw(name, id_from, id_to)
     hsh = { name: name, x_id: id_from, y_id: id_to }
     Relation.where(hsh).delete_all
   end
 
-  def self.references(row, kind)
-    klass = kind
-    klass = kind.constantize  unless klass.kind_of?(Class)
-    ids = self.references_ids(row, klass)
-    klass.where(id: ids)
-  end
-
-  def self.followers(kind, row)
-    klass = kind
-    klass = kind.constantize  unless klass.kind_of?(Class)
-    ids = self.followers_ids(klass, row)
-    klass.where(id: ids)
-  end
-
-  def self.dangling
-    names = Relation.pluck(:name).uniq
-    models = []
-    names.each { |name|
-      models |= name.split(' ')
-    }
-    hsh = {}
-    models.each { |class_name|
-      klass = class_name.constantize
-      ids = klass.pluck(:id)
-      idx = Relation.where('name like ?', "#{class_name} %").pluck(:x_id)
-      idy = Relation.where('name like ?', "% #{class_name}").pluck(:y_id)
-      arr = (idx | idy) - ids
-      hsh[class_name] = arr  if arr.length > 0
-    }
-    hsh
-  end
-
-  def self.remove_dangling(hsh)
-    hsh.each { |name, arr|
-      arr.each { |idx|
-	Relation.where(x_id: idx).where('name like ?', "#{name} %").delete_all
-	Relation.where(y_id: idx).where('name like ?', "% #{name}").delete_all
-      }
-    }
-  end
-
- private
-  def self.name_id(resource)
-    raise 'missing resource'  unless resource
-    [resource.class.name, resource.id]
-  end
-
-  def self.references_ids(row, klass)
-    name_from, id_from = name_id(row)
-    name = "#{name_from} #{klass.name}"
+  def self.references_raw(name, id_from)
     Relation.where(name: name, x_id: id_from).pluck(:y_id)
   end
 
-  def self.followers_ids(klass, row)
-    name_to, id_to = name_id(row)
-    name = "#{klass.name} #{name_to}"
+  def self.followers_raw(name, id_to)
     Relation.where(name: name, y_id: id_to).pluck(:x_id)
   end
+
 end

data/app/models/relation_ext.rb

@@ -0,0 +1,48 @@
+# extended Relation: extracts relation from rows
+class Relation < ActiveRecord::Base
+
+  def self.add(row_from, row_to)
+    hsh = normalize(row_from, row_to)
+    Relation.create!(hsh)  if Relation.where(hsh).first == nil
+  end
+
+  def self.delete(row_from, row_to)
+    hsh = normalize(row_from, row_to)
+    Relation.where(hsh).delete_all
+  end
+
+  def self.references(row, kind)
+    klass, name, id_from = normalize2(kind, row)
+    name = "#{name} #{klass.name}"
+    ids = references_raw(name, id_from)
+    klass.where(id: ids)
+  end
+
+  def self.followers(kind, row)
+    klass, name, id_to = normalize2(kind, row)
+    name = "#{klass.name} #{name}"
+    ids = followers_raw(name, id_to)
+    klass.where(id: ids)
+  end
+
+ private
+  def self.name_id(resource)
+    raise 'missing resource'  unless resource
+    [resource.class.name, resource.id]
+  end
+
+  def self.normalize(row_from, row_to)
+    name_from, id_from = name_id(row_from)
+    name_to, id_to     = name_id(row_to)
+    name = "#{name_from} #{name_to}"
+    { name: name, x_id: id_from, y_id: id_to }
+  end
+
+  def self.normalize2(kind, row)
+    klass = kind
+    klass = kind.constantize  unless klass.kind_of?(Class)
+    name, id = name_id(row)
+    [klass, name, id]
+  end
+
+end

data/lib/relation/version.rb

@@ -1,3 +1,3 @@
 module ModRelation
-  VERSION = '0.1.5'
+  VERSION = '0.2.1'
 end

data/test/relation_ext_test.rb

@@ -0,0 +1,63 @@
+require 'test_helper'
+
+describe Relation do
+  let(:user)   { User.create! name: 'user' }
+  let(:user2)  { User.create! name: 'user2' }
+  let(:order)  { Order.create! name: 'order' }
+  let(:order2) { Order.create! name: 'order2' }
+
+  def setup
+    DB.setup
+
+    Relation.add user,  order
+    Relation.add user2, order
+    Relation.add user2, order2
+  end
+
+  def teardown
+    DB.teardown
+  end
+
+  it "should add a connection" do
+    assert_difference('Relation.count') do
+      Relation.add user2, user
+    end
+  end
+
+  it "should delete a connection" do
+    Relation.add user2, user
+    assert_difference('Relation.count', -1) do
+      Relation.delete user2, user
+    end
+  end
+
+  it "should return references (using class name)" do
+    arr = Relation.references(user, 'Order')
+    assert_equal [order].sort, arr.sort
+
+    arr = Relation.references(user2, 'Order')
+    assert_equal [order, order2].sort, arr.sort
+  end
+
+  it "should return followers (using class name)" do
+    arr = Relation.followers('User', order)
+    assert_equal [user, user2].sort, arr.sort
+
+    arr = Relation.followers('User', order2)
+    assert_equal [user2].sort, arr.sort
+  end
+
+  it "should not add twice the same connection" do
+    assert_difference('Relation.count') do
+      Relation.add user2, user
+      Relation.add user2, user
+    end
+  end
+
+  it "should handle unexistent connection" do
+    assert_difference('Relation.count', 0) do
+      Relation.delete user2, user
+    end
+  end
+
+end

data/test/relation_test.rb

@@ -1,72 +1,64 @@
 require 'test_helper'
 
+# testing raw/basic relations
 describe Relation do
-  let(:user)   { User.create! name: 'user' }
-  let(:user2)  { User.create! name: 'user2' }
-  let(:order)  { Order.create! name: 'order' }
-  let(:order2) { Order.create! name: 'order2' }
+  let(:u_id)   { User.create!(name: 'user').id }
+  let(:u2_id)  { User.create!(name: 'user2').id }
+  let(:o_id)   { Order.create!(name: 'order').id }
+  let(:o2_id)  { Order.create!(name: 'order2').id }
+  let(:unknown_id)  { 123456 }
 
   def setup
     DB.setup
 
-    Relation.add user,  order
-    Relation.add user2, order
-    Relation.add user2, order2
+    Relation.add_raw :rel, u_id, o_id
+    Relation.add_raw :rel, u2_id, o_id
+    Relation.add_raw :rel, u2_id, o2_id
   end
 
   def teardown
     DB.teardown
   end
 
-  it "should add a connection" do
+  it "should add a relation" do
     assert_difference('Relation.count') do
-      Relation.add user2, user
+      Relation.add_raw :raw, u2_id, u_id
     end
   end
 
-  it "should delete a connection" do
-    Relation.add user2, user
+  it "should delete a relation" do
+    Relation.add_raw :raw, u2_id, u_id
     assert_difference('Relation.count', -1) do
-      Relation.delete user2, user
+      Relation.delete_raw :raw, u2_id, u_id
     end
   end
 
-  it "should return references (using class name)" do
-    arr = Relation.references(user, 'Order')
-    assert_equal [order].sort, arr.sort
+  it "should return referenced ids" do
+    arr = Relation.references_raw(:rel, u_id)
+    assert_equal [o_id].sort, arr.sort
 
-    arr = Relation.references(user2, 'Order')
-    assert_equal [order, order2].sort, arr.sort
+    arr = Relation.references_raw(:rel, u2_id)
+    assert_equal [o_id, o2_id].sort, arr.sort
   end
 
-  it "should return references (using class)" do
-    arr = Relation.references(user, Order)
-    assert_equal [order].sort, arr.sort
-  end
-
-  it "should return followers (using class name)" do
-    arr = Relation.followers('User', order)
-    assert_equal [user, user2].sort, arr.sort
-
-    arr = Relation.followers('User', order2)
-    assert_equal [user2].sort, arr.sort
-  end
+  it "should return followers ids" do
+    arr = Relation.followers_raw(:rel, o_id)
+    assert_equal [u_id, u2_id].sort, arr.sort
 
-  it "should return followers (using class)" do
-    arr = Relation.followers(User, order)
-    assert_equal [user, user2].sort, arr.sort
+    arr = Relation.followers_raw(:rel, o2_id)
+    assert_equal [u2_id].sort, arr.sort
   end
 
   it "should not add twice the same connection" do
     assert_difference('Relation.count') do
-      Relation.add user2, user
-      Relation.add user2, user
+      Relation.add_raw :rel, u2_id, unknown_id
+      Relation.add_raw :rel, u2_id, unknown_id
     end
   end
 
   it "should handle unexistent connection" do
     assert_difference('Relation.count', 0) do
-      Relation.delete user2, user
+      Relation.delete_raw :rel, u2_id, unknown_id
     end
   end
 

data/test/support/database.rb

@@ -55,3 +55,5 @@ class User < ActiveRecord::Base
 end
 
 require_relative ('../../app/models/relation')
+require_relative ('../../app/models/relation_ext')
+require_relative ('../../app/models/dangling')

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: relation
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.1
 platform: ruby
 authors:
 - Dittmar Krall
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-22 00:00:00.000000000 Z
+date: 2018-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -127,7 +127,9 @@ files:
 - MIT-LICENSE
 - README.md
 - Rakefile
+- app/models/dangling.rb
 - app/models/relation.rb
+- app/models/relation_ext.rb
 - db/migrate/20150810152808_relation.rb
 - gemfiles/rails_4.gemfile
 - gemfiles/rails_5.0.gemfile
@@ -136,6 +138,7 @@ files:
 - lib/relation/version.rb
 - relation.gemspec
 - test/dangling_test.rb
+- test/relation_ext_test.rb
 - test/relation_test.rb
 - test/support/database.rb
 - test/test_helper.rb