selection_field.rb in ecoportal-api-v2-0.8.27

- old
+ new

@@ -8,33 +8,64 @@
             passthrough :other_desc
             passthrough :data_type
 
             embeds_many :options, klass: "Ecoportal::API::V2::Page::Component::SelectionOption", order_key: :weight
 
+            def numeric?
+              self.data_type == "num"
+            end
+
+            def text?
+              self.data_type == "txt"
+            end
+
             def numeric!(&block)
               ordered_options.each {|opt| opt.numeric!(&block)}
               self.data_type = "num"
             end
 
             def text!(&block)
               ordered_options.each {|opt| opt.text!(&block)}
               self.data_type = "str"
             end
 
-            def select(value)
-              opt = options.find {|opt| opt.value == value}
+            def switch_type!(&block)
+              numeric? ? text!(&block) : numeric!(&block)
+            end
+
+            def select(value_name, by_name: false)
+              opt = find_option(value_name, by_name: by_name)
               sel = selected
               return true if !multiple && opt == sel
               sel.selected = false if !multiple && sel
               opt.selected = true unless !opt
             end
 
-            def selected
-              if multiple
-                options.select {|opt| opt.selected}
+            def deselect(value_name, by_name: false)
+              if opt = find_option(value_name, by_name: by_name)
+                opt.selected = false
+              end
+            end
+
+            def selected(by_name: false, by_value: false, value: false, name: false)
+              case
+              when by_value
+                elems = [selected].flatten.compact
+                options_hash(elems) do |option|
+                  name ? option.name : option
+                end
+              when by_name
+                elems = [selected].flatten.compact
+                options_hash(elems, by_name: true) do |option|
+                  value ? option.value : option
+                end
               else
-                options.find {|opt| opt.selected}
+                if multiple
+                  ordered_options.select {|opt| opt.selected}
+                else
+                  options.find {|opt| opt.selected}
+                end
               end
             end
 
             def value
               if multiple
@@ -42,10 +73,26 @@
               else
                 selected&.value
               end
             end
 
+            def values
+              [value].flatten.compact
+            end
+
+            def name
+              if multiple
+                selected.map {|opt| opt.name}
+              else
+                selected&.name
+              end
+            end
+
+            def names
+              [name].flatten.compact
+            end
+
             def add_option(value:, name: nil, pos: NOT_USED, before: NOT_USED, after: NOT_USED)
               opt_doc = options.items_class.new_doc
               options.upsert!(opt_doc, pos: pos, before: before, after: after) do |option|
                 option.name  = name
                 option.value = value
@@ -61,10 +108,30 @@
               options.sort_by.with_index do |option, index|
                 [option.weight, index]
               end
             end
 
+            # @param name [Boolean] whether or not the values of the `Hash` should be the `names`
+            # @return [Hash] of **key** _value_ and **value**:
+            #   1. _option_ if `name` is `false`
+            #   2. _name_ if `name` is `true`
+            def options_by_value(name: false)
+              options_hash do |option|
+                name ? option.name : option
+              end
+            end
+
+            # @param value [Boolean] whether or not the values of the `Hash` should be the `values`
+            # @return [Hash] of **key** _name_ and **value**:
+            #   1. _option_ if `value` is `false`
+            #   2. _value_ if `value` is `true`
+            def options_by_name(value: false)
+              options_hash(by_name: true) do |option|
+                value ? option.value : option
+              end
+            end
+
             def to_s(name: true, delimiter: "\n")
               [selected].flatten.compact.map do |opt|
                 name ? opt.name : opt.value
               end.join(delimiter)
             end
@@ -73,11 +140,11 @@
             # @param conf [Symbol, Array<Symbol>]
             #   - `:flat` to display in flat mode
             #   - `:multiple` to allow multiple selection
             #   - `:single` to set to singular selection
             #   - `:other` to enable `other` button
-            #   - `:options` to add options (`Hash<value, name>`)
+            #   - `:options` to add options (`Hash<value, name>`) or update option names
             #   - `:type` to define the type
             #     - `:num`
             #     - `:str`
             def configure(*conf)
               conf.each_with_object([]) do |cnf, unused|
@@ -120,12 +187,17 @@
             end
 
             private
 
             def configure_options(opts)
+              hopts = self.options_by_value
               opts.each do |val, nm|
-                add_option(value: val, name: nm)
+                if option = hopts[val]
+                  option.name = nm
+                else
+                  add_option(value: val, name: nm)
+                end
               end
             end
 
             def fix_option_weights!
               ordered_options.each_with_index do |option, index|
@@ -138,10 +210,23 @@
               pos  = opts.index(value) - 1
               return if pos < 0
               opts[pos]
             end
 
+            def find_option(value_name, by_name: false)
+              if by_name
+                opt = options.find {|opt| same_string?(opt.name, value_name)}
+              else
+                opt = options.find {|opt| opt.value == value_name}
+              end
+            end
 
+            def options_hash(elems = ordered_options, by_name: false)
+              elems.each_with_object({}) do |option, hash|
+                key = by_name ? option.name : option.value
+                hash[key] = block_given?? yield(option) : option
+              end
+            end
           end
         end
       end
     end
   end