custom_fielder 0.6.5 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 309a3ca9a168664f17e363a3a273237d14e0665e
-  data.tar.gz: bbb3b343f7f4bbb322effb26855f1b842eee1d85
+  metadata.gz: 05064a476fcba8652d4ea0a5069c89fa351e1e86
+  data.tar.gz: 23c2c0ba4ddf69b51f7df13ba4a3779413b82772
 SHA512:
-  metadata.gz: a252ea2459830ca898a149deb1d71c43ebcdd91965b6107c6c26f37cc8cd864a1254b400d722a6468aa60a3cb24c7c4bbf86a88a75ef5c7c73c39a61b27843fe
-  data.tar.gz: 4a8511ccf1d8c491aec26fdcb14a94091bc4e49387e41d15377728f26c9a768781d33e23fdbd14f50b09e99904126605828a573d91306959a1ec747b34ecd992
+  metadata.gz: 38a908cd70cd6021fb227ed68d2a05b460d20a5c024377fc0e894f2647a0e6fb844f7d2e91a2b997fc71cf678bf08cf9fb67de4deebe18189bc31e33b645eba5
+  data.tar.gz: fa544cdc7d5bc6da3c475d01340fd931dea95300c8bf386fada02c8d725001c0a5b27b3eeb05068e09737dd25f3f0c2c3a2ffbf5aad7e7e3d755197704dac0fb

data/app/helpers/custom_fielder/deserialization_helper.rb

@@ -4,6 +4,11 @@ module CustomFielder
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF']
 
     ##
+    # Runs the the deserialization function for the passed type
+    #
+    # @param type  [String] the type to deserialize to
+    # @param value [String] the value to be deserialized
+    #
     # @return [Array|Integer|Float|Date|DateTime|Boolean|String]
     #
     def deserialize(type, value)

data/app/helpers/custom_fielder/type_checking_helper.rb

@@ -5,6 +5,11 @@ module CustomFielder
     FALSE_VALUES = [false, 0, '0', 'f', 'F', 'false', 'FALSE', 'off', 'OFF']
 
     ##
+    # Runs the the type checking function for the passed type
+    #
+    # @param type  [String] the type to be checked
+    # @param value [String] the value to be type checked
+    #
     # @return [Boolean]
     #
     def is_correct_type?(type, value)
@@ -43,6 +48,9 @@ module CustomFielder
     # @return [Boolean]
     #
     def is_date_time?(value)
+      value =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}$/ or
+      value =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/ or
+      value =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}$/ or
       value =~ /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}-\d{2}:\d{2}$/
     end
 

data/app/models/custom_fielder/field.rb

@@ -13,23 +13,49 @@ module CustomFielder
       'List' => 'Array'
     }
 
-    FORM_FIELD_TYPES = ['Text Entry', 'Multiple Choice', 'Date', 'DateTime', 'Boolean', 'List']
+    FORM_FIELD_TYPES = {
+      'Text - Entry' => :text_entry_fields,
+      'Text - Multiple Choice' => :text_choice_fields,
+      'Integer - Entry' => :int_entry_fields,
+      'Integer - Multiple Choice' => :int_choice_fields,
+      'Decimal - Entry' => :float_entry_fields,
+      'Decimal - Multiple Choice' => :float_choice_fields,
+      'Date - Entry' => :date_entry_fields,
+      'Date - Multiple Choice' => :date_choice_fields,
+      'Date & Time - Entry' => :datetime_entry_fields,
+      'Date & Time - Multiple Choice' => :datetime_choice_fields,
+      'True/False' => :boolean_fields
+    }
+
+    validate  :default_type
+    validate  :field_options_types
+    validate  :field_options_unique
+
+    validates :name,                presence: true,
+                                    uniqueness: {
+                                      scope: [:fieldable_type],
+                                      message: "Field name already exists"
+                                    }
+    validates :field_type,          presence: true,
+                                    inclusion: { in: %w[Array Fixnum Float Date DateTime Boolean String] }
+    validates :fieldable_type,      presence: true
+
 
-    has_many :values
 
-    validates :name,                  presence: true
-    validates :field_type,            presence: true,
-                                      inclusion: { in: %w[Array Fixnum Float Date DateTime Boolean String] }
-    validates :fieldable_type,        presence: true
-    validates :allow_blank,           inclusion: { in: [true, false] }
-    validate  :type_of_allowed_values
 
-    scope :text_entry_fields, -> { all.where(field_type: ['String', 'Fixnum', 'Float'], allowed_values: nil) }
-    scope :multiple_choice_fields, -> { all.where.not(allowed_values: nil) }
-    scope :date_fields, -> { all.where(field_type: 'Date', allowed_values: nil) }
-    scope :date_time_fields, -> { all.where(field_type: 'DateTime', allowed_values: nil) }
-    scope :boolean_fields, -> { all.where(field_type: 'Boolean', allowed_values: nil) }
-    scope :list_fields, -> { all.where(field_type: 'Array') }
+    has_many :values, dependent: :destroy
+
+    scope :text_entry_fields,       -> { all.where(field_type: 'String', field_options: nil) }
+    scope :text_choice_fields,      -> { all.where(field_type: 'String').where.not(field_options: nil) }
+    scope :int_entry_fields,        -> { all.where(field_type: 'Fixnum', field_options: nil) }
+    scope :int_choice_fields,       -> { all.where(field_type: 'Fixnum').where.not(field_options: nil) }
+    scope :float_entry_fields,      -> { all.where(field_type: 'Float', field_options: nil) }
+    scope :float_choice_fields,     -> { all.where(field_type: 'Float').where.not(field_options: nil) }
+    scope :date_entry_fields,       -> { all.where(field_type: 'Date', field_options: nil) }
+    scope :date_choice_fields,      -> { all.where(field_type: 'Date').where.not(field_options:nil) }
+    scope :datetime_entry_fields,   -> { all.where(field_type: 'DateTime', field_options: nil) }
+    scope :datetime_choice_fields,  -> { all.where(field_type: 'DateTime').where.not(field_options:nil) }
+    scope :boolean_fields,          -> { all.where(field_type: 'Boolean') }
 
     ##
     # Creates a hash of form field types mapped to array of field, field id pairs
@@ -39,41 +65,79 @@ module CustomFielder
     #
     def self.all_fields_hashed_for_opt_group
       FORM_FIELD_TYPES.inject(Hash.new) do |hash, form_field|
-        fields = send("#{form_field.delete(' ').underscore}_fields")
-        hash[form_field] = fields.map { |field| [field.name, field.id] }
+        fields = send(form_field.last)
+        hash[form_field.first] = fields.map { |field| [field.name, field.id] } unless fields.empty?
         hash
-      end.delete_if { |k, v| v == [] }
+      end
     end
 
     ##
-    # Returns the deserialized version of allowed_values
+    # Returns the deserialized version of field_options
     #
     # @return [Array]
     #
     def options
-      allowed_values.nil? ? nil : deserialize('Array', allowed_values)
+      field_options.nil? ? nil : deserialize('Array', field_options)
     end
 
 
     private
 
     ##
-    # Checks to make sure all values in allowed_values are of the correct type
+    # Checks to make sure all values in field_options are of the correct type
+    #
+    # @return [Nil]
+    #
+    def field_options_types
+      return if field_options.nil?
+      options.each { |v| (field_options_type_error; return) unless v.class.to_s == field_type }
+    end
+
+    ##
+    # Checks to make sure all values in field_options are unique
+    #
+    # @return [Nil]
+    #
+    def field_options_unique
+      return if field_options.nil?
+      field_options_unique_error unless options.uniq.count == options.count
+    end
+
+    ##
+    # Checks that the default value is of the correct type
+    #
+    # @return [Nil]
+    #
+    def default_type
+      return if default.nil?
+      default_type_error unless is_correct_type?(field_type, default)
+    end
+
+    ##
+    # Adds error if there is an field_options_error
+    #
+    # @return [Nil]
+    #
+    def field_options_type_error
+      errors.add(:field_options, 'Value in options is not the correct type')
+    end
+
+    ##
+    # Adds error if values in field_options aren't unique
     #
     # @return [Nil]
     #
-    def type_of_allowed_values
-      return if allowed_values.nil?
-      options.each { |v| allowed_values_error unless v.class.to_s == field_type }
+    def field_options_unique_error
+      errors.add(:field_options, 'Values in field options must be unique')
     end
 
     ##
-    # Adds error if there is an allowed_values_error
+    # Adds error if the default passed is not the correct type
     #
     # @return [Nil]
     #
-    def allowed_values_error
-      errors.add(:allowed_values, 'Value in options is not the correct type')
+    def default_type_error
+      errors.add(:default, 'Default value is not the correct type')
     end
 
   end

data/app/models/custom_fielder/value.rb

@@ -7,15 +7,12 @@ module CustomFielder
 
     validate :check_type
     validate :check_allow_blank
-    validate :check_allowed_values
+    validate :check_field_options
     validate :check_fieldable_type
 
-    belongs_to :field, dependent: :destroy
+    belongs_to :field
     belongs_to :fieldable, polymorphic: true
 
-    scope :active,   -> { where(active: true) }
-    scope :inactive, -> { where(active: false) }
-
     scope :values_with_field, -> (field) { where(field: field) }
     scope :values_with_class, -> (klass) { where(fieldable_type: klass) }
 
@@ -29,32 +26,6 @@ module CustomFielder
     alias_method :raw_value, :value
     def value; deserialize_value; end;
 
-    class << self
-      ##
-      # Activates all CustomFields that belong to passed field attributes
-      #
-      # @param field_attrs [CustomFielder::Field]
-      #
-      # @return [Nil]
-      #
-      def activate_field_for_all(field)
-        values = all.where(field: field)
-        values.each { |value| value.active = true; value.save }
-      end
-
-      ##
-      # Deactivates all CustomFields that belong to passed field attributes
-      #
-      # @param field_attrs [CustomFielder::Field]
-      #
-      # @return [Nil]
-      #
-      def deactivate_field_for_all(field)
-        values = all.where(field: field)
-        values.each { |value| value.active = false; value.save }
-      end
-    end
-
     private
 
     ##
@@ -89,8 +60,8 @@ module CustomFielder
     #
     # @return [Array]
     #
-    def allowed_values
-      @allowed_values ||= field.options
+    def field_options
+      @field_options ||= field.options
     end
 
     ##
@@ -112,11 +83,12 @@ module CustomFielder
     end
 
     ##
-    # Sets the value to the default if value is blank
+    # Sets the value to the default if value is blank and allow blank is false
     #
     # @return [Nil]
     #
     def set_default
+      return if allow_blank
       update_attribute(:value, default) if default? and raw_value_blank?
     end
 
@@ -138,9 +110,9 @@ module CustomFielder
     ##
     # @return [Nil] Adds error if invalid
     #
-    def check_allowed_values
-      return unless allowed_values
-      value_not_allowed_error unless allowed_values.include?(value)
+    def check_field_options
+      return unless field_options
+      value_not_allowed_error unless field_options.include?(value)
     end
 
     ##

data/db/migrate/20160525133243_create_custom_fielder_values.rb

@@ -1,13 +1,14 @@
 class CreateCustomFielderValues < ActiveRecord::Migration
   def change
     create_table :custom_fielder_values do |t|
-      t.references :fieldable,            polymorphic: true, null: false, index: { name: 'index_values_on_fieldable_type_and_fieldable_id' }
+      t.references :fieldable,            polymorphic: true, null: false
       t.integer    :field_id,                                null: false, index: true
-      t.boolean    :active,                                  null: false, default: true
       t.string     :value
       t.text       :note
 
       t.timestamps null: false
     end
+
+    add_index :custom_fielder_values, [:fieldable_type, :fieldable_id, :field_id], unique: true, name: 'index_values_on_fieldable_type_and_fieldable_id_and_field_id'
   end
 end

data/db/migrate/20160525133922_create_custom_fielder_fields.rb

@@ -5,8 +5,9 @@ class CreateCustomFielderFields < ActiveRecord::Migration
       t.string  :field_type,      null: false
       t.string  :fieldable_type,  null: false
       t.string  :default
+      t.boolean :active,          null: false, default: true
       t.boolean :allow_blank,     null: false, default: false
-      t.string  :allowed_values
+      t.string  :field_options
       t.text    :note
 
       t.timestamps null: false

data/lib/custom_fielder/custom_fieldable.rb

@@ -20,6 +20,76 @@ module CustomFielder
       alias_method :custom_fields,       :custom_fielder_fields
       alias_method :custom_field_values, :custom_fielder_values
 
+      ##
+      # Returns all the objects on the model that have the passed
+      # value, defined on the field with the passed field_id
+      #
+      # @return [ActiveRecord::Relation]
+      #
+      def self.find_objects_with_custom_values_where(value:, field_id:)
+        joins(:custom_fielder_values).
+        where(custom_fielder_values: {
+          value: value,
+          field_id: field_id
+        })
+      end
+
+      ##
+      # Provides a list of columns to be included in an
+      # object search. This is to be able to dynamically
+      # create tables no matter the object
+      #
+      # @note this method should be overridden
+      #
+      # @return [Array]
+      #
+      def self.custom_fielder_columns
+        [:id]
+      end
+
+      ##
+      # Provides a uniform means of accessing data no matter
+      # the object, this can be overridden to suit your
+      # needs
+      #
+      # @note this method can be overridden more specific
+      # @note object selection
+      #
+      # @return [ActiveRecord::Relation]
+      #
+      def self.custom_fielder_search
+        all
+      end
+
+      ##
+      # Provides an array of hashes of objects and Custom Field values (if they exist)
+      # using custom_fielder_search as the means of generating
+      # the sub query to find objects and then using this query
+      # to join the values with the objects if they exist (in one transaction)
+      #
+      # @param field [CustomFielder::Field] field to search for values on
+      #
+      # @return [Array<Hash>]
+      #
+      def self.custom_fielder_objects(field)
+        columns   = custom_fielder_columns
+        sub_query = custom_fielder_search.select(columns).to_sql
+        columns.map! { |column| "objects.#{column} as #{column}" }
+
+        query = <<-SQL
+          SELECT #{columns.join(', ')}, cfv.id AS value_id, cfv.value AS value
+          FROM (#{sub_query}) objects
+          LEFT OUTER JOIN custom_fielder_values cfv
+            ON  objects.id   = cfv.fieldable_id
+            AND cfv.field_id = #{field.id}
+        SQL
+
+        objects = ActiveRecord::Base.connection.execute(query)
+        objects = objects.values.map { |values| Hash[objects.fields.zip(values)] } if objects.class == PG::Result
+
+        return objects
+      end
+
       ##
       # Returns a hash where the keys are the field names
       # and the values are the field values
@@ -32,7 +102,19 @@ module CustomFielder
           h[field_name] = field_value.value; h
         end
       end
-    end
 
+      ##
+      # Provides a shorter method call to retrieve a custom fields
+      # value given the field. Returns the value or nil if the value
+      # does not exist
+      #
+      # @return [String|Nil]
+      #
+      def value_for_custom_field(field)
+        value = self.custom_fielder_values.find_by(field_id: field.id)
+        value.nil? ? nil : value.value
+      end
+
+    end
   end
 end

data/lib/custom_fielder/form_for_helpers.rb

@@ -34,8 +34,6 @@ module CustomFielder
           end
         end
 
-        field << (f.check_box(:active) + ' Active')
-
         safe_join(field)
       end
     end

data/lib/custom_fielder/version.rb

@@ -1,3 +1,3 @@
 module CustomFielder
-  VERSION = "0.6.5"
+  VERSION = "0.7.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: custom_fielder
 version: !ruby/object:Gem::Version
-  version: 0.6.5
+  version: 0.7.0
 platform: ruby
 authors:
 - Nick Hurst
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-02 00:00:00.000000000 Z
+date: 2016-06-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails