htmlburger /
carbon-fields
Duplicate code is one of the most pungent code smells. A rule that is often used is to re-structure code once it is duplicated in three or more places.
Common duplication problems, and corresponding solutions are:
| 1 | <?php |
||
| 8 | class Key_Toolset { |
||
| 9 | |||
| 10 | /** |
||
| 11 | * Prefix appended to all keys |
||
| 12 | */ |
||
| 13 | const KEY_PREFIX = '_'; |
||
| 14 | |||
| 15 | /** |
||
| 16 | * Glue characters between segments in keys |
||
| 17 | */ |
||
| 18 | const SEGMENT_GLUE = '|'; |
||
| 19 | |||
| 20 | /** |
||
| 21 | * Glue characters between segments values in keys |
||
| 22 | */ |
||
| 23 | const SEGMENT_VALUE_GLUE = ':'; |
||
| 24 | |||
| 25 | /** |
||
| 26 | * Number of segments in a key |
||
| 27 | */ |
||
| 28 | const TOTAL_SEGMENTS = 5; |
||
| 29 | |||
| 30 | /** |
||
| 31 | * "Equal" storage key pattern comparison type constant |
||
| 32 | */ |
||
| 33 | const PATTERN_COMPARISON_EQUAL = '='; |
||
| 34 | |||
| 35 | /** |
||
| 36 | * "Starts with" storage key pattern comparison type constant |
||
| 37 | */ |
||
| 38 | const PATTERN_COMPARISON_STARTS_WITH = '^'; |
||
| 39 | |||
| 40 | /** |
||
| 41 | * Get sanitized hierarchy index for hierarchy |
||
| 42 | * |
||
| 43 | * @param array<string> $full_hierarchy |
||
| 44 | * @param array<int> $full_hierarchy_index |
||
| 45 | * @return array<int> |
||
| 46 | */ |
||
| 47 | 4 | public function get_sanitized_hierarchy_index( $full_hierarchy, $full_hierarchy_index ) { |
|
| 48 | 4 | $full_hierarchy_index = array_slice( $full_hierarchy_index, 0, count( $full_hierarchy ) - 1 ); |
|
| 49 | 4 | if ( empty( $full_hierarchy_index ) ) { |
|
| 50 | 1 | $full_hierarchy_index = array( 0 ); |
|
| 51 | 1 | } |
|
| 52 | 4 | $full_hierarchy_index = array_map( 'intval', $full_hierarchy_index ); |
|
| 53 | 4 | return $full_hierarchy_index; |
|
| 54 | } |
||
| 55 | |||
| 56 | /** |
||
| 57 | * Get a storage key for a simple root field |
||
| 58 | * |
||
| 59 | * @param string $field_base_name |
||
| 60 | * @return string |
||
| 61 | */ |
||
| 62 | protected function get_storage_key_for_simple_root_field( $field_base_name ) { |
||
| 63 | $storage_key = static::KEY_PREFIX . $field_base_name; |
||
| 64 | return $storage_key; |
||
| 65 | } |
||
| 66 | |||
| 67 | /** |
||
| 68 | * Get a storage key for the root field |
||
| 69 | * Suitable for deleting entire trees of values (e.g. Complex_Field) |
||
| 70 | * |
||
| 71 | * @param array $full_hierarchy |
||
| 72 | * @return string |
||
| 73 | */ |
||
| 74 | protected function get_storage_key_root( $full_hierarchy ) { |
||
| 79 | |||
| 80 | /** |
||
| 81 | * Get a storage key up to the hierarchy index segment |
||
| 82 | * Suitable for getting and deleting multiple values for a single field |
||
| 83 | * |
||
| 84 | * @param array<string> $full_hierarchy |
||
| 85 | * @param array<int> $full_hierarchy_index |
||
| 86 | * @return string |
||
| 87 | */ |
||
| 88 | protected function get_storage_key_prefix( $full_hierarchy, $full_hierarchy_index ) { |
||
| 103 | |||
| 104 | /** |
||
| 105 | * Get a full storage key for a single field value |
||
| 106 | * |
||
| 107 | * @param bool $is_simple_root_field |
||
| 108 | * @param array<string> $full_hierarchy |
||
| 109 | * @param array<int> $full_hierarchy_index |
||
| 110 | * @param int $value_group_index |
||
| 111 | * @param string $value_key |
||
| 112 | * @return string |
||
| 113 | */ |
||
| 114 | 6 | public function get_storage_key( $is_simple_root_field, $full_hierarchy, $full_hierarchy_index, $value_group_index, $value_key ) { |
|
| 122 | |||
| 123 | /** |
||
| 124 | * Get a full storage key with optional wildcards for entry and value indexes |
||
| 125 | * |
||
| 126 | * @param bool $is_simple_root_field |
||
| 127 | * @param array<string> $full_hierarchy |
||
| 128 | * @param string $value_key |
||
| 129 | * @param string $wildcard |
||
| 130 | * @return string |
||
| 131 | */ |
||
| 132 | 3 | public function get_storage_key_with_index_wildcards( $is_simple_root_field, $full_hierarchy, $value_key = Value_Set::VALUE_PROPERTY, $wildcard = '%' ) { |
|
| 155 | |||
| 156 | /** |
||
| 157 | * Get an array of storage key patterns for use when getting values from storage |
||
| 158 | * |
||
| 159 | * @param bool $is_simple_root_field |
||
| 160 | * @param array<string> $full_hierarchy |
||
| 161 | * @return array |
||
| 162 | */ |
||
| 163 | 3 | public function get_storage_key_getter_patterns( $is_simple_root_field, $full_hierarchy ) { |
|
| 187 | |||
| 188 | /** |
||
| 189 | * Get an array of storage key patterns for use when deleting values from storage |
||
| 190 | * |
||
| 191 | * @param bool $is_complex_field |
||
| 192 | * @param bool $is_simple_root_field |
||
| 193 | * @param array<string> $full_hierarchy |
||
| 194 | * @param array<int> $full_hierarchy_index |
||
| 195 | * @return array |
||
| 196 | */ |
||
| 197 | 4 | public function get_storage_key_deleter_patterns( $is_complex_field, $is_simple_root_field, $full_hierarchy, $full_hierarchy_index ) { |
|
| 214 | |||
| 215 | /** |
||
| 216 | * Convert an array of storage key patterns to a parentheses-enclosed sql comparison |
||
| 217 | * |
||
| 218 | * @param string $table_column |
||
| 219 | * @param array $patterns |
||
| 220 | * @return string |
||
| 221 | */ |
||
| 222 | 2 | public function storage_key_patterns_to_sql( $table_column, $patterns ) { |
|
| 244 | |||
| 245 | /** |
||
| 246 | * Check if a storage key matches any pattern |
||
| 247 | * |
||
| 248 | * @param string $storage_key |
||
| 249 | * @param array $patterns |
||
| 250 | * @return bool |
||
| 251 | */ |
||
| 252 | 7 | public function storage_key_matches_any_pattern( $storage_key, $patterns ) { |
|
| 267 | |||
| 268 | /** |
||
| 269 | * Check if an array of segments has all of it's segments |
||
| 270 | * |
||
| 271 | * @param array<string> $segments_array |
||
| 272 | * @return bool |
||
| 273 | */ |
||
| 274 | 1 | public function is_segments_array_full( $segments_array ) { |
|
| 277 | |||
| 278 | /** |
||
| 279 | * Convert a storage key to an array of it's segments |
||
| 280 | * |
||
| 281 | * @param string $storage_key |
||
| 282 | * @return array<string> |
||
| 283 | */ |
||
| 284 | 1 | public function storage_key_to_segments_array( $storage_key ) { |
|
| 289 | |||
| 290 | /** |
||
| 291 | * Convert a segment to an array of it's values |
||
| 292 | * |
||
| 293 | * @param string $segment |
||
| 294 | * @return array<mixed> |
||
| 295 | */ |
||
| 296 | 1 | public function segment_to_segment_values_array( $segment ) { |
|
| 299 | |||
| 300 | /** |
||
| 301 | * Get a parsed array of storage key segments and values |
||
| 302 | * |
||
| 303 | * @param string $storage_key |
||
| 304 | * @return array |
||
| 305 | */ |
||
| 306 | 3 | public function parse_storage_key( $storage_key ) { |
|
| 333 | } |
Loading history...
Duplicated code is one of the most pungent code smells. If you need to duplicate the same code in three or more different places, we strongly encourage you to look into extracting the code into a single class or operation.
You can also find more detailed suggestions in the “Code” section of your repository.