arin 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4ebdd4498fb783ba99697abc74fe1843103a55c3
-  data.tar.gz: 1d04dc64e80aa0f233b60b62766f7600a2ab814a
+  metadata.gz: 262fd640382d4faae63d8548a3cc0caecd920a3d
+  data.tar.gz: a6fdc63adb0bd46302e87e39eb38bbff8f37ee83
 SHA512:
-  metadata.gz: b585aab9c5a817056b1f92638ce0a792e2f548d8e1e35542fe68f7bc76d84020cf660d403b497b614813efb16ae118837b50efcf4ffc0aba6ae54d625689335a
-  data.tar.gz: 3ff2d9acbc5b9a2c2a9e34250631cd46490db7b75666b1628c78394aa9b3cb900fcabcd9ad951c0c1054f7119700081f74e6d62e581049a21e405089ed2b2e2b
+  metadata.gz: dbe9e8550bb72cf7e552a826750b710c42b4bae839eed1e11c225e041fe680c728ea27c19bc9ade711acfaa36563f354c7cf5eae90faee5b758f263b1b185414
+  data.tar.gz: d69f2f7fc7ad348fc7a5afdad4d82381537fd9e2f623a3c31343387d9c9b4195d2c782a36997b575471fa6c3aaee1f2e95a2e06c816da5439dcf0ef1790f4c30

data/lib/arin/check.rb

@@ -33,92 +33,104 @@ module Arin
       end
 
       def query
-        queries.join <<-SQL
+        queries.compact.join <<-SQL
           UNION ALL
         SQL
       end
 
       def queries
-        [].tap do |qs|
-          classes.each do |klass|
-            klass.reflect_on_all_associations(:belongs_to).each do |relation|
-              begin
-                if is_polymorphic?(relation)
-                  polymorphics(klass, relation).each do |poly|
-                    poly_class = poly.safe_constantize
-                    if poly_class
-                      qs << polymorphic_relation_query(klass, relation, poly_class)
-                    else
-                      qs << broken_polymorchic_class_query(klass, relation, poly)
-                    end
-                  end
-                else
-                  qs << relation_query(klass, relation) if processable?(klass, relation)
-                end
-              rescue StandardError => e
-                handle_query_failure(klass, relation, e)
-              end
-            end
+        classes.reduce([]) do |qs, klass|
+          qs.push(*class_queries(klass))
+        end
+      end
+
+      def class_queries klass
+        associations_for(klass).reduce([]) do |qs, assoc|
+          qs.push(*association_queries(assoc, klass))
+        end
+      end
+
+      def association_queries assoc, klass
+        if is_polymorphic?(assoc)
+          polymorphic_association_queries(assoc, klass)
+        else
+          association_query(assoc, klass) if processable?(assoc, klass)
+        end
+      rescue StandardError => e
+        handle_query_failure(assoc, klass, e)
+      end
+
+      def polymorphic_association_queries assoc, klass
+        polymorphics(assoc, klass).map do |poly_class_name|
+          poly_class = poly_class_name.safe_constantize
+          if poly_class
+            polymorphic_association_query(assoc, klass, poly_class)
+          else
+            broken_polymorchic_class_query(assoc, klass, poly_class_name)
           end
         end
       end
 
-      def processable?(klass, relation)
+      def associations_for klass
+        klass.reflect_on_all_associations(:belongs_to)
+      end
+
+      def processable?(assoc, klass)
         klass.table_exists? &&
         klass.primary_key &&
-        klass.column_names.include?(relation.foreign_key)
+        klass.column_names.include?(assoc.foreign_key)
       end
 
-      def relation_query(klass, relation)
+      def association_query(assoc, klass)
         <<-SQL
           SELECT "#{klass.name}" AS class_name,
             t.#{klass.primary_key} AS id,
-            "#{relation.class_name}" AS relation_class,
-            t.#{relation.foreign_key} AS relation_id
+            "#{assoc.class_name}" AS relation_class,
+            t.#{assoc.foreign_key} AS relation_id
           FROM #{klass.table_name} AS t
-          LEFT JOIN #{relation.table_name} AS r
-            ON t.#{relation.foreign_key} = r.#{relation.association_primary_key}
-          WHERE r.#{relation.association_primary_key} IS NULL
-            AND t.#{relation.foreign_key} IS NOT NULL
+          LEFT JOIN #{assoc.table_name} AS r
+            ON t.#{assoc.foreign_key} = r.#{assoc.association_primary_key}
+          WHERE r.#{assoc.association_primary_key} IS NULL
+            AND t.#{assoc.foreign_key} IS NOT NULL
         SQL
       end
 
-      def polymorphic_relation_query(klass, relation, relation_class)
+      def polymorphic_association_query(assoc, klass, assoc_class)
         <<-SQL
           SELECT "#{klass.name}" AS class_name,
             t.#{klass.primary_key} AS id,
-            "#{relation_class}" AS relation_class,
-            t.#{relation.foreign_key} AS relation_id
+            "#{assoc_class}" AS relation_class,
+            t.#{assoc.foreign_key} AS relation_id
           FROM #{klass.table_name} AS t
-          LEFT JOIN #{relation_class.table_name} AS r
-            ON t.#{relation.foreign_key} = r.#{relation_class.primary_key}
-            AND t.#{relation.foreign_type} = "#{relation_class}"
-          WHERE r.#{relation_class.primary_key} IS NULL
-            AND t.#{relation.foreign_key} IS NOT NULL
+          LEFT JOIN #{assoc_class.table_name} AS r
+            ON t.#{assoc.foreign_key} = r.#{assoc_class.primary_key}
+            AND t.#{assoc.foreign_type} = "#{assoc_class}"
+          WHERE r.#{assoc_class.primary_key} IS NULL
+            AND t.#{assoc.foreign_key} IS NOT NULL
         SQL
       end
 
-      def broken_polymorphic_class_query(klass, relation, relation_class)
+      def broken_polymorphic_class_query(assoc, klass, assoc_class_name)
         <<-SQL
           SELECT "#{klass.name}" AS class_name,
             t.#{klass.primary_key} AS id,
-            "#{relation_class}" AS relation_class,
-            t.#{relation.foreign_key} AS relation_id
+            "#{assoc_class}" AS relation_class,
+            t.#{assoc.foreign_key} AS relation_id
           FROM #{klass.table_name} AS t
-          WHERE t.#{relation.foreign_type} = "#{relation_class}"
+          WHERE t.#{assoc.foreign_type} = "#{assoc_class_name}"
         SQL
       end
 
-      def polymorphics(klass, relation)
-        klass.pluck(relation.foreign_type).uniq.compact
+      def polymorphics(assoc, klass)
+        klass.pluck(assoc.foreign_type).uniq.compact
       end
 
-      def is_polymorphic?(relation)
-        relation.options[:polymorphic]
+      def is_polymorphic?(assoc)
+        assoc.options[:polymorphic]
       end
 
-      def handle_query_failure(klass, relation, e)
-        warn("Cannot process #{relation.name} relation for #{klass}: #{e.message}")
+      def handle_query_failure(assoc, klass, e)
+        warn("Cannot process #{assoc.name} relation for #{klass}: #{e.message}")
       end
   end
 end

data/lib/arin/version.rb

@@ -1,3 +1,3 @@
 module Arin
-  VERSION = "0.1.3"
+  VERSION = "0.1.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: arin
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - fmnoise@gmail.com