active_record_schema_scrapper 0.2.2 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ef33781189d4aa1c90773b52cdd1179945a8d2c8
-  data.tar.gz: e0843604a1056ba0fd29f83d571c9166b94af1bf
+  metadata.gz: 9192c10faa23a478681dcb27ee417137a5c87fb0
+  data.tar.gz: 5aab4259565e9e2bceeac4e99657ed2b2741513c
 SHA512:
-  metadata.gz: c0d78d6b35ced6f3135ef9e6020a3a8c97502416941794714e51163dace28e03b91c9d39d5f12330fe57324a6c6d42627f82e6cde14d10ca4890fec3cb802fab
-  data.tar.gz: a1b1240a0c741dbf9c19efcf183a4ffa462bbc0d5a3264a377ae554ad530d2e50b4113f167f8bf8a8a342b102fff2a55461ad39cf7f9d6c4e518af938d12de2d
+  metadata.gz: 8c2da7d9a5ff97a8e1d740e8ffbc74b02aeb67c6d666d0852cbcb5add1dab58e9a73ec9e47df8edefe6076ae2970b834a2c6326be16cd34913482abcc7877d13
+  data.tar.gz: d17eb5518af3df8dd980fdf5e2c423ae831473c5cb87a8ff42a2a5f2672526bfe1f1c420cdb3a7d234f2cefe4bbb842e771f7215733ee809f6a74bfde6ab3a8c

data/README.md

@@ -40,6 +40,36 @@ Or install it yourself as:
         #=> []
 ```
 
+#### Registering Types
+
+This gem does not include all the mappings from any DB type to a Ruby type. (most common types are included)
+So any arbitrary type can be registered.
+
+# Postgres Array Type
+```ruby
+
+    # schema.rb
+      #...
+      t.string :tags, array: true, default: []
+      #...
+      
+    # initilizers/active_mocker.rb
+    ActiveRecordSchemaScrapper::Attributes.register_type(
+      name:      :string, 
+      klass:     Array[String], 
+      cast_type: -> (c) { c.class.name.include?("Array") } 
+    )
+    
+     ActiveRecordSchemaScrapper::Attributes.register_default(
+       name:      "{}", 
+       klass:     [], 
+       cast_type: -> (c) { c.class.name.include?("Array") } 
+     )
+    
+    ActiveRecordSchemaScrapper::Attributes.new(model: User).map(&:to_h)
+      #=>[{ name: "tags",               type: Array[String], default: []  }]
+```
+
 ### Associations
 ```ruby
     ActiveRecordSchemaScrapper::Associations.new(model: User).map(&:to_h)

data/lib/active_record_schema_scrapper/attribute.rb

@@ -8,9 +8,48 @@ class ActiveRecordSchemaScrapper
     include Virtus.model
     attribute :name
 
+    def initialize(type: nil,
+                   precision: nil,
+                   scale: nil,
+                   default: nil,
+                   cast_type: nil,
+                   name: nil,
+                   limit: nil,
+                   null: nil)
+
+      type    = init_type(type, cast_type)
+      default = init_default(default, cast_type, type)
+      super
+    end
+
+    def init_type(type, cast_type)
+      return type unless type
+      registered_type = Attributes.registered_types.detect do |reg_type, klass, reg_cast_type|
+        if type.to_sym == reg_type.to_sym && reg_cast_type && reg_cast_type === cast_type
+          klass
+        elsif type.to_sym == reg_type.to_sym
+          klass
+        end
+      end
+      (registered_type && !registered_type.empty?) ? registered_type[1] : type
+    end
+
+    def init_default(default, cast_type, type)
+      return default unless default
+      registered_default = Attributes.registered_defaults.detect do |reg_default, klass, reg_cast_type, reg_type|
+        if (default.to_s == reg_default.to_s) && ((reg_cast_type && reg_cast_type === cast_type) || (type === reg_type))
+          klass
+        elsif default.to_s == reg_default.to_s
+          klass
+        end
+      end
+      (registered_default && !registered_default.empty?) ? registered_default[1] : default
+    end
+
     class DBToRubyType < Virtus::Attribute
       def coerce(value)
         return value if value.nil?
+        return value unless value.is_a?(String) || value.is_a?(Symbol)
         case value.to_sym
           when :integer
             Fixnum
@@ -38,7 +77,7 @@ class ActiveRecordSchemaScrapper
       end
 
       def registered(value)
-        if (a = Attributes.registered_types.detect { |name, klass| value.to_sym == name.to_sym })
+        if (a = Attributes.registered_types.detect { |name, _, _| value.to_sym == name.to_sym })
           a.last
         else
           yield
@@ -50,6 +89,7 @@ class ActiveRecordSchemaScrapper
     attribute :scale, Fixnum
     class DefaultValueType < Virtus::Attribute
       def coerce(value)
+        return value unless value.is_a?(String) || value.is_a?(Symbol)
         case value.to_s
           when 'f'
             false
@@ -61,13 +101,14 @@ class ActiveRecordSchemaScrapper
       end
 
       def registered(value)
-        if (r = Attributes.registered_defaults.detect { |name, _| value.to_s == name.to_s })
-          r.last
+        if (r = Attributes.registered_defaults.detect { |name, _, _| name.to_s == value.to_s })
+          r[1]
         else
           value
         end
       end
     end
     attribute :default, DefaultValueType
+    attribute :cast_type
   end
-end
+end

data/lib/active_record_schema_scrapper/attributes.rb

@@ -2,16 +2,23 @@ class ActiveRecordSchemaScrapper
   class Attributes
 
     class << self
-      def register_type(name:, klass:)
-        registered_types << [name, klass]
+      # @param [Symbol] name original type from schema
+      # @param [Object, Virtus::Attribute] klass a ruby type used to coerce values
+      # @param [Object#===, Proc#===] cast_type to be compared to the db schema returned value
+      def register_type(name:, klass:, cast_type: nil)
+        registered_types << [name, klass, cast_type]
       end
 
       def registered_types
         @registered_types ||= []
       end
 
-      def register_default(name:, klass:)
-        registered_defaults << [name, klass]
+      # @param [String] name original default value from schema
+      # @param [Object] klass the replacement value
+      # @param [Object#===, Proc#===] cast_type to be compared to the db schema returned value
+      # @param [Symbol] type matches the type from the schema
+      def register_default(name:, klass:, cast_type: nil, type: nil)
+        registered_defaults << [name, klass, cast_type, type]
       end
 
       def registered_defaults
@@ -49,24 +56,33 @@ class ActiveRecordSchemaScrapper
           scale:     v.scale,
           default:   v.default,
           null:      v.null,
+          cast_type: cast_type(v)
         )
       end
     rescue NoMethodError => e
       @errors << ErrorObject.new(class_name:     model.name,
-                                message:        "#{model.name} is not a valid ActiveRecord model.",
-                                original_error: e,
-                                level:          :error,
-                                type:           :invalid_model)
+                                 message:        "#{model.name} is not a valid ActiveRecord model.",
+                                 original_error: e,
+                                 level:          :error,
+                                 type:           :invalid_model)
       []
     rescue ActiveRecord::StatementInvalid => e
       level   = model.abstract_class? ? :warn : :error
       message = model.abstract_class? ? "#{model.name} is an abstract class and has no associated table." : e.message
       @errors << ErrorObject.new(class_name:     model.name,
-                                message:        message,
-                                original_error: e,
-                                level:          level,
-                                type:           :no_table)
+                                 message:        message,
+                                 original_error: e,
+                                 level:          level,
+                                 type:           :no_table)
       []
     end
+
+    def cast_type(v)
+      if v.respond_to?(:cast_type)
+        v.cast_type
+      elsif v.respond_to?(:sql_type_metadata)
+        v.sql_type_metadata
+      end
+    end
   end
 end

data/lib/active_record_schema_scrapper/object_error.rb

@@ -1,23 +1,17 @@
-class ActiveRecordSchemaScrapper
-  class ErrorObject
-    attr_reader :level, :message, :class_name, :type, :original_error
-
-    def initialize(level: :warn, message:, class_name:, type:, original_error: nil)
-      @level          = level
-      @message        = message
-      @class_name     = class_name
-      @type           = type
-      @original_error = original_error
-    end
+# frozen_string_literal: true
+require "virtus"
 
-    def original_error?
-      original_error.present?
-    end
-
-    private
-
-    def self.levels
-      [:info, :warn, :error, :fatal]
+class ActiveRecordSchemaScrapper
+  if defined?(ActiveMocker::ErrorObject)
+    ErrorObject = Class.new(ActiveMocker::ErrorObject)
+  else
+    class ErrorObject
+      include Virtus.model
+      attribute :message
+      attribute :level
+      attribute :original_error
+      attribute :type
+      attribute :class_name
     end
   end
-end
+end

data/lib/active_record_schema_scrapper/version.rb

@@ -1,3 +1,3 @@
 class ActiveRecordSchemaScrapper
-  VERSION = "0.2.2"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_record_schema_scrapper
 version: !ruby/object:Gem::Version
-  version: 0.2.2
+  version: 0.3.0
 platform: ruby
 authors:
 - Dustin Zeisler
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-05-01 00:00:00.000000000 Z
+date: 2016-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord