Class: ActsAsTable::ForeignKeyMap

Inherits:
ActiveRecord::Base
  • Object
show all
Defined in:
app/models/acts_as_table/foreign_key_map.rb

Overview

ActsAsTable foreign key map.

Instance Attribute Summary collapse

Belongs to collapse

Instance Method Summary collapse

Instance Attribute Details

#extended ⇒ Boolean

Returns true if the source value for this ActsAsTable foreign key map is an extended regular expression. Otherwise, returns false.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#ignore_case ⇒ Boolean

Returns true if the source value for this ActsAsTable foreign key map is a regular expression that ignores character case. Otherwise, returns false.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#multiline ⇒ Boolean

Returns true if the source value for this ActsAsTable foreign key map is a multiline regular expression. Otherwise, returns false.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#position ⇒ Integer

Returns the position of this ActsAsTable foreign key map.

Returns:

  • (Integer) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#regexp ⇒ Boolean

Returns true if the source value for this ActsAsTable foreign key map is a regular expression. Otherwise, returns false.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#source_value ⇒ Boolean

Returns the source value for this ActsAsTable foreign key map.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

#target_value ⇒ Boolean

Note:

If the source value for this ActsAsTable foreign key map is a regular expression, then the target value may reference any capture groups.

Returns the target value for this ActsAsTable foreign key map.

Returns:

  • (Boolean) 


34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 34

class ForeignKeyMap < ::ActiveRecord::Base
  # @!parse
  #   include ActsAsTable::ValueProvider
  #   include ActsAsTable::ValueProviderAssociationMethods

  self.table_name = ActsAsTable.foreign_key_maps_table

  # Returns the ActsAsTable foreign key for this map.
  belongs_to :foreign_key, **{
    class_name: 'ActsAsTable::ForeignKey',
    inverse_of: :foreign_key_maps,
    required: true,
  }

  # validates :extended, **{}

  # validates :ignore_case, **{}

  # validates :multiline, **{}

  validates :position, **{
    numericality: {
      greater_than_or_equal_to: 1,
      only_integer: true,
    },
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  # validates :regexp, **{}

  validates :source_value, **{
    presence: true,
    uniqueness: {
      scope: ['foreign_key_id'],
    },
  }

  validates :target_value, **{
    presence: true,
  }

  validate :source_value_as_regexp_must_be_valid, **{
    if: ::Proc.new { |foreign_key_map| foreign_key_map.source_value.present? },
  }

  # Returns the source value for this ActsAsTable foreign key map as a regular expression.
  #
  # @return [Regexp]
  # @raise [RegexpError]
  def source_value_as_regexp
    # @return [String]
    pattern = self.source_value.to_s

    unless self.regexp?
      pattern = "\\A#{::Regexp.quote(pattern)}\\z"
    end

    # @return [Integer]
    flags = {
      :extended => :EXTENDED,
      :ignore_case => :IGNORECASE,
      :multiline => :MULTILINE,
    }.each_pair.inject(0) { |acc, pair|
      method_name, const_name = *pair

      self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
    }

    ::Regexp.new(pattern, flags)
  end

  private

  # @return [void]
  def source_value_as_regexp_must_be_valid
    begin
      self.source_value_as_regexp
    rescue ::RegexpError
      self.errors.add('source_value', :invalid)
    end

    return
  end
end

Instance Method Details

#foreign_key ⇒ ActsAsTable::ForeignKey

Returns the ActsAsTable foreign key for this map.

Returns:

See Also:



42
43
44
45
46
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 42

belongs_to :foreign_key, **{
  class_name: 'ActsAsTable::ForeignKey',
  inverse_of: :foreign_key_maps,
  required: true,
}

#source_value_as_regexp ⇒ Regexp

Returns the source value for this ActsAsTable foreign key map as a regular expression.

Returns:

  • (Regexp)

Raises:

  • (RegexpError) 


86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'app/models/acts_as_table/foreign_key_map.rb', line 86

def source_value_as_regexp
  # @return [String]
  pattern = self.source_value.to_s

  unless self.regexp?
    pattern = "\\A#{::Regexp.quote(pattern)}\\z"
  end

  # @return [Integer]
  flags = {
    :extended => :EXTENDED,
    :ignore_case => :IGNORECASE,
    :multiline => :MULTILINE,
  }.each_pair.inject(0) { |acc, pair|
    method_name, const_name = *pair

    self.send(:"#{method_name}?") ? (acc | ::Regexp.const_get(const_name, false)) : acc
  }

  ::Regexp.new(pattern, flags)
end