active_record_schema_scrapper 0.3.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9192c10faa23a478681dcb27ee417137a5c87fb0
-  data.tar.gz: 5aab4259565e9e2bceeac4e99657ed2b2741513c
+  metadata.gz: 71ac9fbebc69db610a118ff0b8653d5c3f205d24
+  data.tar.gz: 69018e554e6d26845da497baf003843eeda34e4d
 SHA512:
-  metadata.gz: 8c2da7d9a5ff97a8e1d740e8ffbc74b02aeb67c6d666d0852cbcb5add1dab58e9a73ec9e47df8edefe6076ae2970b834a2c6326be16cd34913482abcc7877d13
-  data.tar.gz: d17eb5518af3df8dd980fdf5e2c423ae831473c5cb87a8ff42a2a5f2672526bfe1f1c420cdb3a7d234f2cefe4bbb842e771f7215733ee809f6a74bfde6ab3a8c
+  metadata.gz: fb40ede397f3378c6c3775d1fd1e26fb655e5bb1a4e3c8c8a9fe55f9965891021f2736708571f1916a5e678d6dea5dee24572b030d9bd4cfcaea9bc2126bb010
+  data.tar.gz: 8c1a428a4593e8b596948b22232f69066556ec9fe9b6ed6e9d9eeec2fc33ebb9fd06584412773e600c3dc67243a292e27f0d1d17d1b45be850b8cfad858d95eb

data/lib/active_record_schema_scrapper/attribute.rb

@@ -17,98 +17,51 @@ class ActiveRecordSchemaScrapper
                    limit: nil,
                    null: nil)
 
-      type    = init_type(type, cast_type)
-      default = init_default(default, cast_type, type)
+      default = init_default({ default: default, cast_type: cast_type, type: type })
+      type    = init_type(type, { type: type, cast_type: cast_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
+    private
+
+    def init_type(name, attr_values)
+      type = match_abstract(:replacement_type, :type, Attributes.registered_types, attr_values)
+      if type.is_a?(String) || type.is_a?(Symbol)
+        raise UnregisteredType.new "Database type '#{attr_values[:type]}' is not a registered type.\nTo register use ActiveRecordSchemaScrapper::Attributes.register_type(name: :#{name}, klass: <RubyClass>)"
+      else
+        type
       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
+    def init_default(attr_values)
+      match_abstract(:replacement_default, :default, Attributes.registered_defaults, attr_values)
     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
-          when :float
-            Float
-          when :decimal
-            BigDecimal
-          when :timestamp, :time
-            Time
-          when :datetime
-            DateTime
-          when :date
-            Date
-          when :text, :string, :binary
-            String
-          when :boolean
-            Axiom::Types::Boolean
-          when :hstore
-            Hash
-          else
-            registered(value) do
-              raise UnregisteredType.new "Database type '#{value}' is not a registered type.\nTo register use ActiveRecordSchemaScrapper::Attributes.register_type(name: :#{value}, klass: <RubyClass>)"
-            end
-        end
-      end
+    def match_abstract(replacement_key, default, registers, attr_values)
+      return unless attr_values[default]
+      top_ranked_match     = nil
+      last_top_match_count = 0
+      registers.each do |register|
+        all_given = register.reject { |_, v| v == :not_given }.dup
+        all_given.delete(replacement_key)
 
-      def registered(value)
-        if (a = Attributes.registered_types.detect { |name, _, _| value.to_sym == name.to_sym })
-          a.last
-        else
-          yield
+        matches         = all_given.map do |k, v|
+          attr_values.has_key?(k) ? (v === attr_values[k] || v == attr_values[k]) : true
         end
-      end
-    end
-    attribute :type, DBToRubyType
-    attribute :precision, Fixnum
-    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
-          when 't'
-            true
-          else
-            registered(value)
+        max_match_count = matches.inject(0) { |sum, bool| bool ? sum += 1 : sum -= 10 }
+        if max_match_count > 0 && max_match_count > last_top_match_count
+          last_top_match_count = max_match_count
+          top_ranked_match     = register
         end
       end
 
-      def registered(value)
-        if (r = Attributes.registered_defaults.detect { |name, _, _| name.to_s == value.to_s })
-          r[1]
-        else
-          value
-        end
-      end
+      top_ranked_match ? top_ranked_match[replacement_key] : attr_values[default]
     end
-    attribute :default, DefaultValueType
+
+    attribute :type
+    attribute :precision, Fixnum
+    attribute :scale, Fixnum
+    attribute :default
     attribute :cast_type
   end
 end

data/lib/active_record_schema_scrapper/attributes.rb

@@ -1,28 +1,78 @@
 class ActiveRecordSchemaScrapper
   class Attributes
+    DEFAULT_REGISTERED_TYPES = [
+      { type: :integer,                                            replacement_type: Integer },
+      { type: :float,                                              replacement_type: Float },
+      { type: :decimal,                                            replacement_type: BigDecimal },
+      { type: Proc.new { |t| [:timestamp, :time].include?(t) },    replacement_type: Time },
+      { type: :datetime,                                           replacement_type: DateTime },
+      { type: :date,                                               replacement_type: Date },
+      { type: Proc.new { |t| %i{text string binary}.include?(t) }, replacement_type: String },
+      { type: :boolean,                                            replacement_type: Axiom::Types::Boolean },
+      { type: :hstore,                                             replacement_type: Hash },
+    ].freeze
+
+    DEFAULT_REGISTERED_DEFAULTS = [
+      { default: Proc.new { |d| d == "t" }, replacement_default: true },
+      { default: Proc.new { |d| d == "f" }, replacement_default: false }
+    ].freeze
 
     class << self
       # @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]
+      def register_type(name:, klass:, cast_type: :not_given)
+        registered_types << { type: name, replacement_type: klass, cast_type: cast_type }
       end
 
       def registered_types
-        @registered_types ||= []
+        @registered_types ||= DEFAULT_REGISTERED_TYPES.dup
+      end
+
+      def reset_registered_types
+        @registered_types = DEFAULT_REGISTERED_TYPES.dup
+      end
+
+      module DeprecatedRegisterDefaultKeywords
+        # @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(**args)
+          if args.has_key?(:name)
+            deprecation_warning(:name, :default)
+            args[:default] = args.delete(:name)
+          end
+          if args.has_key?(:klass)
+            deprecation_warning(:klass, :replacement_default)
+            args[:replacement_default] = args.delete(:klass)
+          end
+          super(args)
+        end
+
+        private
+
+        def deprecation_warning(old_key, new_key)
+          puts "Deprecation warning ActiveRecordSchemaScrapper::Attributes.register_default: keyword `#{old_key}` is replaced by `#{new_key}`"
+        end
       end
 
-      # @param [String] name original default value from schema
-      # @param [Object] klass the replacement value
+      prepend DeprecatedRegisterDefaultKeywords
+
+      # @param [String] default original default value from schema
+      # @param [Object] replacement_default 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]
+      def register_default(default:, replacement_default:, cast_type: :not_given, type: :not_given)
+        registered_defaults << { default: default, replacement_default: replacement_default, cast_type: cast_type, type: type }
       end
 
       def registered_defaults
-        @registered_defaults ||= []
+        @registered_defaults ||= DEFAULT_REGISTERED_DEFAULTS.dup
+      end
+
+      def reset_registered_defaults
+        @registered_defaults = DEFAULT_REGISTERED_DEFAULTS.dup
       end
     end
 

data/lib/active_record_schema_scrapper/version.rb

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

metadata

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