ruby-trello 2.3.1 → 3.2.0

data/lib/trello/custom_field.rb

@@ -1,53 +1,54 @@
 module Trello
   # A Custom Field can be activated on a board. Values are stored at the card level.
   #
-  # @!attribute id
+  # @!attribute [r] id
   #   @return [String]
-  # @!attribute model_id
+  # @!attribute [rw] model_id
   #   @return [String]
-  # @!attribute model_type
+  # @!attribute [rw] model_type
   #   @return [String]
-  # @!attribute field_group
+  # @!attribute [r] field_group
   #   @return [String]
-  # @!attribute name
+  # @!attribute [rw] name
   #   @return [String]
-  # @!attribute pos
+  # @!attribute [rw] position
   #   @return [Float]
-  # @!attribute type
+  # @!attribute [rw] type
   #   @return [String]
-  # @!attribute options
+  # @!attribute [rw] checkbox_options
   #   @return [Array<Hash>]
+  # @!attribute [w] enable_display_on_card
+  #   @return [Boolean]
   class CustomField < BasicData
-    register_attributes :id, :model_id, :model_type, :field_group, :name, :pos, :type
-    validates_presence_of :id, :model_id, :model_type, :name, :type, :pos
 
-    SYMBOL_TO_STRING = {
-      id:          'id',
-      name:        'name',
-      model_id:    'idModel',
-      model_type:  'modelType',
-      field_group: 'fieldGroup',
-      type:        'type',
-      pos:         'pos'
-    }
+    schema do
+      # Readonly
+      attribute :id, readonly: true, primary_key: true
+      attribute :field_group, readonly: true, remote_key: 'fieldGroup'
+
+      # Writable
+      attribute :name
+      attribute :position, remote_key: 'pos'
+      attribute :enable_display_on_card, remote_key: 'cardFront', class_name: 'CustomFieldDisplay'
+
+      # Writable but for create only
+      attribute :model_id, remote_key: 'idModel', create_only: true
+      attribute :model_type, remote_key: 'modelType', create_only: true
+      attribute :type, create_only: true
+      attribute :checkbox_options, remote_key: 'options', create_only: true
+    end
+
+    validates_presence_of :id, :model_id, :model_type, :name, :type, :position
 
     class << self
       # Find a custom field by its id.
       def find(id, params = {})
         client.find('customFields', id, params)
       end
+    end
 
-      # Create a new custom field and save it on Trello.
-      def create(options)
-        client.create('customFields',
-          'name'       => options[:name],
-          'idModel'    => options[:model_id],
-          'modelType'  => options[:model_type],
-          'fieldGroup' => options[:field_group],
-          'type'       => options[:type],
-          'pos'        => options[:pos]
-        )
-      end
+    def collection_name
+      'customFields'
     end
 
     # References Board where this custom field is located
@@ -57,43 +58,6 @@ module Trello
     # If type == 'list'
     many :custom_field_options, path: 'options'
 
-    def update_fields(fields)
-      send('name_will_change!') if fields_has_key?(fields, :name)
-      send('pos_will_change!') if fields_has_key?(fields, :pos)
-
-      initialize_fields(fields)
-    end
-
-    def initialize(fields = {})
-      initialize_fields(fields)
-    end
-
-    # Saves a record.
-    def save
-      # If we have an id, just update our fields.
-      return update! if id
-
-      from_response client.post("/customFields", {
-        name:       name,
-        idModel:    model_id,
-        modelType:  model_type,
-        type:       type,
-        pos:        pos,
-        fieldGroup: field_group
-      })
-    end
-
-    # Update an existing custom field.
-    def update!
-      @previously_changed = changes
-      # extract only new values to build payload
-      payload = Hash[changes.map { |key, values| [SYMBOL_TO_STRING[key.to_sym].to_sym, values[1]] }]
-      @changed_attributes.clear if @changed_attributes.respond_to?(:clear)
-      changes_applied if respond_to?(:changes_applied)
-
-      client.put("/customFields/#{id}", payload)
-    end
-
     # Delete this custom field
     # Also deletes all associated values across all cards
     def delete
@@ -110,22 +74,5 @@ module Trello
     def delete_option(option_id)
       client.delete("/customFields/#{id}/options/#{option_id}")
     end
-
-    private
-
-    def fields_has_key?(fields, key)
-      fields.key?(SYMBOL_TO_STRING[key]) || fields.key?(key)
-    end
-
-    def initialize_fields(fields)
-      attributes[:id]          = fields[SYMBOL_TO_STRING[:id]] || fields[:id] || attributes[:id]
-      attributes[:name]        = fields[SYMBOL_TO_STRING[:name]] || fields[:name] || attributes[:name]
-      attributes[:model_id]    = fields[SYMBOL_TO_STRING[:model_id]] || fields[:model_id] || attributes[:model_id]
-      attributes[:model_type]  = fields[SYMBOL_TO_STRING[:model_type]] || fields[:model_type] || attributes[:model_type]
-      attributes[:field_group] = fields[SYMBOL_TO_STRING[:field_group]] || fields[:field_group] || attributes[:field_group]
-      attributes[:type]        = fields[SYMBOL_TO_STRING[:type]] || fields[:type] || attributes[:type]
-      attributes[:pos]         = fields[SYMBOL_TO_STRING[:pos]] || fields[:pos] || attributes[:pos]
-      self
-    end
   end
 end

data/lib/trello/custom_field_item.rb

@@ -1,9 +1,30 @@
 module Trello
   # A custom field item contains the value for a custom field on a particular card.
   #
+  # @!attribute [r] id
+  #   @return [String]
+  # @!attribute [r] model_id
+  #   @return [String]
+  # @!attribute [r] model_type
+  #   @return [String]
+  # @!attribute [r] custom_field_id
+  #   @return [String]
+  # @!attribute [r] option_id
+  #   @return [String]
+  # @!attribute [rw] value
+  #   @return [Hash]
   class CustomFieldItem < BasicData
-    register_attributes :id, :model_id, :model_type, :custom_field_id, :value, :option_id,
-                        readonly: [ :id, :custom_field_id, :model_id, :model_type, :option_id ]
+
+    schema do
+      attribute :id, readonly: true, primary_key: true
+      attribute :model_id, readonly: true, remote_key: 'idModel'
+      attribute :model_type, readonly: true, remote_key: 'modelType'
+      attribute :custom_field_id, readonly: true, remote_key: 'idCustomField'
+      attribute :option_id, readonly: true, remote_key: 'idValue'
+
+      attribute :value
+    end
+
     validates_presence_of :id, :model_id, :custom_field_id
 
     # References the card with this custom field value
@@ -12,57 +33,33 @@ module Trello
     # References the parent custom field that this item is an instance of
     one :custom_field, path: 'customFields', using: :custom_field_id
 
-    # Update the fields of a custom field item.
-    #
-    # Supply a hash of string keyed data retrieved from the Trello API representing
-    # an item state.
-    def update_fields(fields)
-      if fields_has_key?(fields, 'value')
-        send('value_will_change!')
-      elsif fields_has_key?(fields, 'idValue')
-        send('option_id_will_change!')
-      end
-
-      initialize_fields(fields)
-    end
+    def save
+      return update! if id
 
-    def initialize(fields = {})
-      initialize_fields(fields)
-    end
+      payload = {}
 
-    def update!
-      @previously_changed = changes
-      # extract only new values to build payload
-      payload = Hash[changes.map { |key, values| [key.to_sym, values[1]] }]
-      @changed_attributes.clear if @changed_attributes.respond_to?(:clear)
-      changes_applied if respond_to?(:changes_applied)
+      schema.attrs.each do |_, attribute|
+        payload = attribute.build_payload_for_create(attributes, payload)
+      end
 
-      client.put("/card/#{model_id}/customField/#{custom_field_id}/item", payload)
+      put(element_path, payload)
     end
 
-    # Saves a record.
-    #
-    # @raise [Trello::Error] if the card could not be saved
-    #
-    # @return [String] The JSON representation of the saved custom field item returned by
-    # the Trello API.
-    def save
-      # If we have an id, just update our fields.
-      return update! if id
+    def collection_path
+      "/cards/#{model_id}/#{collection_name}"
+    end
 
-      from_response client.put("/card/#{model_id}/customField/#{custom_field_id}/item", {
-        value: value
-      })
+    def element_path
+      "/cards/#{model_id}/customField/#{custom_field_id}/item"
     end
 
     # You can't "delete" a custom field item, you can only clear the value
     def remove
       params = { value: {} }
-      client.put("/card/#{model_id}/customField/#{custom_field_id}/item", params)
+      client.put(element_path, params)
     end
 
     # Type is saved at the CustomField level
-    # Can equally be derived from :value, with a little parsing work: {"number": 42}
     def type
       custom_field.type
     end
@@ -75,24 +72,5 @@ module Trello
         option.value
       end
     end
-
-    private
-
-    def fields_has_key?(fields, key)
-      fields.key?(key.to_s) || fields.key?(key.to_sym)
-    end
-
-    def initialize_fields(fields)
-      attributes[:id]               = fields['id'] || fields[:id] || attributes[:id]
-      attributes[:model_id]         = fields['idModel'] || fields[:model_id] || attributes[:model_id]
-      attributes[:custom_field_id]  = fields['idCustomField'] || fields[:custom_field_id] || attributes[:custom_field_id]
-      attributes[:model_type]       = fields['modelType'] || fields[:model_type] || attributes[:model_type]
-      # Dropdown custom field items do not have a value, they have an ID that maps to
-      # a different endpoint to get the value
-      attributes[:option_id]       = fields['idValue'] || fields[:idValue] if fields_has_key?(fields, 'idValue')
-      # value format: { "text": "hello world" }
-      attributes[:value]            = fields['value'] || fields[:value] if fields_has_key?(fields, 'value')
-      self
-    end
   end
 end

data/lib/trello/custom_field_option.rb

@@ -1,22 +1,49 @@
 module Trello
   # A custom field option contains the individual items in a custom field dropdown menu.
   #
+  # @!attribute [r] id
+  #   @return [String]
+  # @!attribute [r] custom_field_id
+  #   @return [String]
+  # @!attribute [rw] value
+  #   @return [Hash]
+  # @!attribute [rw] color
+  #   @return [String]
+  # @!attribute [rw] position
+  #   @return [Float]
   class CustomFieldOption < BasicData
-    register_attributes :id, :value, :pos, :color,
-                        readonly: [:id]
+
+    schema do
+      # Readonly
+      attribute :id, remote_key: '_id', readonly: true, primary_key: true
+      attribute :custom_field_id, remote_key: 'idCustomField', readonly: true
+
+      # Writable but for create only
+      attribute :value, create_only: true
+      attribute :color, create_only: true
+      attribute :position, remote_key: 'pos', create_only: true
+    end
+
     validates_presence_of :id, :value
 
-    # Update the fields of a custom field option.
-    #
-    # Supply a hash of string keyed data retrieved from the Trello API representing
-    # an item state.
-    def update_fields(fields)
-      attributes[:id]               = fields['_id'] || fields[:id] || attributes[:id]
-      attributes[:color]            = fields['color'] || fields[:color] || attributes[:color]
-      attributes[:pos]              = fields['pos'] || fields[:pos] || attributes[:pos]
-      # value format: { "text": "hello world" }
-      attributes[:value]            = fields['value'] || fields[:value] || attributes[:value]
-      self
+    def self.find(id, params = {})
+      params = params.with_indifferent_access
+      custom_field_id = params.delete(:custom_field_id)
+      return if custom_field_id.nil?
+
+      from_response client.get("/customFields/#{custom_field_id}/options/#{id}")
+    end
+
+    def delete
+      client.delete(element_path)
+    end
+
+    def collection_path
+      "/customFields/#{custom_field_id}/options"
+    end
+
+    def element_path
+      "/customFields/#{custom_field_id}/options/#{id}"
     end
   end
 end

data/lib/trello/item.rb

@@ -5,31 +5,42 @@ module Trello
   #   @return [String]
   # @!attribute [r] name
   #   @return [String]
+  # @!attribute [r] name_data
+  #   @return [String]
   # @!attribute [r] type
   #   @return [Object]
   # @!attribute [r] state
   #   @return [Object]
-  # @!attribute [r] pos
+  # @!attribute [r] position
   #   @return [Object]
+  # @!attribute [r] due_date
+  #   @return [Datetime]
+  # @!attribute [r] member_id
+  #   @return [String]
+  # @!attribute [r] checklist_id
+  #   @return [String]
+  # @!attribute [w] checked
+  #   @return [Boolean]
   class Item < BasicData
-    register_attributes :id, :name, :type, :state, :pos, readonly: [ :id, :name, :type, :state, :pos ]
-    validates_presence_of :id, :type
 
-    # Updates the fields of an item.
-    #
-    # Supply a hash of string keyed data retrieved from the Trello API representing
-    # an item.
-    def update_fields(fields)
-      attributes[:id]           = fields['id'] || attributes[:id]
-      attributes[:card_id]      = fields['idCard'] || attributes[:card_id]
-      attributes[:checklist_id] = fields['idChecklist'] || attributes[:checklist_id]
-      attributes[:name]         = fields['name'] || attributes[:name]
-      attributes[:type]         = fields['type'] || attributes[:type]
-      attributes[:state]        = fields['state'] || attributes[:state]
-      attributes[:pos]          = fields['pos'] || attributes[:pos]
-      self
+    schema do
+      # Readonly
+      attribute :id, readonly: true, primary_key: true
+      attribute :type, readonly: true
+      attribute :name_data, readonly: true, remote_key: 'nameData'
+      attribute :due_date, readonly: true, remote_key: 'due', serializer: 'Time'
+      attribute :member_id, readonly: true, remote_key: 'idMember'
+      attribute :state, readonly: true
+      attribute :checklist_id, readonly: true, remote_key: 'idChecklist'
+
+      # Writable and write only
+      attribute :name, write_only: true
+      attribute :position, write_only: true, remote_key: 'pos'
+      attribute :checked, write_only: true
     end
 
+    validates_presence_of :id
+
     def complete?
       state == "complete"
     end

data/lib/trello/item_state.rb

@@ -5,26 +5,18 @@ module Trello
   #   @return [String]
   # @!attribute [r] state
   #   @return [Object]
-  # @!attribute [r] item_id
-  #   @return [String]
   class CheckItemState < BasicData
-    register_attributes :id, :state, :item_id, readonly: [ :id, :state, :item_id ]
-    validates_presence_of :id, :item_id
-
-    # Update the fields of an item state.
-    #
-    # Supply a hash of string keyed data retrieved from the Trello API representing
-    # an item state.
-    def update_fields(fields)
-      attributes[:id]      = fields['id'] || attributes[:id]
-      attributes[:state]   = fields['state'] || attributes[:state]
-      attributes[:item_id] = fields['idCheckItem'] || attributes[:item_id]
-      self
+    schema do
+      #Readonly
+      attribute :id, remote_key: 'idCheckItem', readonly: true, primary_key: true
+      attribute :state
     end
 
+    validates_presence_of :id
+
     # Return the item this state belongs to.
     def item
-      Item.find(item_id)
+      Item.find(id)
     end
   end
 end

data/lib/trello/json_utils.rb

@@ -7,7 +7,7 @@ module Trello
 
     module InstanceMethods
       def from_response(*args)
-        update_fields parse_json(*args)
+        initialize_fields parse_json(*args)
       end
 
       def parse_json(*args)
@@ -32,8 +32,8 @@ module Trello
       #   thing.a == 42
       #   thing.b == "foo"
       #
-      def from_response(data, encoding = 'UTF-8')
-        from_json(parse_json(data, encoding))
+      def from_response(response, encoding = 'UTF-8')
+        from_json(parse_json(response, encoding))
       end
 
       def from_json(json)
@@ -47,8 +47,14 @@ module Trello
         end
       end
 
-      def parse_json(string, encoding = 'UTF-8')
-        JSON.parse(string.force_encoding(encoding))
+      def parse_json(data, encoding = 'UTF-8')
+        # Trello.http_client.parse_json(data, encoding)
+        case data
+        when Trello::Response
+          JSON.parse(data.body.force_encoding(encoding))
+        else
+          JSON.parse(data.force_encoding(encoding))
+        end
       rescue JSON::ParserError => json_error
         if json_error.message =~ /model not found/
           Trello.logger.error "Could not find that record."

data/lib/trello/label.rb

@@ -6,121 +6,34 @@ module Trello
   #   @return [String]
   # @!attribute [rw] color
   #   @return [String]
+  # @!attribute [rw] name
+  #   @return [String]
+  # @!attribute [rw] board_id
+  #   @return [String]
   class Label < BasicData
-    register_attributes :id, :name, :board_id, :uses,
-      readonly: [ :id, :uses, :board_id ]
-    validates_presence_of :id, :board_id, :name
-    validates_length_of   :name,        in: 1..16384
-
-    SYMBOL_TO_STRING = {
-      id: 'id',
-      name: 'name',
-      board_id: 'idBoard',
-      color: 'color',
-      uses: 'uses'
-    }
-
-    class << self
-      VALID_LABEL_COLOURS = %w{green yellow orange red purple blue sky lime pink black} << ''
-
-      # Find a specific label by its id.
-      def find(id, params = {})
-        client.find(:label, id, params)
-      end
-
-      # Create a new label and save it on Trello.
-      def create(options)
-        client.create(:label,
-          'name' => options[:name],
-          'idBoard' => options[:board_id],
-          'color'   => options[:color],
-        )
-      end
-
-      # Label colours
-      def label_colours
-        VALID_LABEL_COLOURS
-      end
-    end
-
-    define_attribute_methods [:color]
-
-    def color
-      @__attributes[:color]
-    end
-
-    def color= colour
-      unless Label.label_colours.include? colour
-        errors.add(:label, "color '#{colour}' does not exist")
-        return Trello.logger.warn "The label colour '#{colour}' does not exist."
-      end
 
-      self.send(:"color_will_change!") unless colour == @__attributes[:color]
-      @__attributes[:color] = colour
-    end
+    schema do
+      # Readonly
+      attribute :id, readonly: true, primary_key: true
 
-    # Update the fields of a label.
-    #
-    # Supply a hash of stringkeyed data retrieved from the Trello API representing
-    # a label.
-    def update_fields(fields)
-      send('name_will_change!') if fields_has_key?(fields, :name)
-      send('color_will_change!') if fields_has_key?(fields, :color)
+      # Writable
+      attribute :name
+      attribute :color
 
-      initialize_fields(fields)
+      # Writable but for create only
+      attribute :board_id, create_only: true, remote_key: 'idBoard'
     end
 
-    def initialize(fields = {})
-      initialize_fields(fields)
-    end
+    validates_presence_of :id, :board_id, :name
+    validates_length_of :name, in: 1..16384
 
     # Returns a reference to the board this label is currently connected.
     one :board, path: :boards, using: :board_id
 
-    # Saves a record.
-    def save
-      # If we have an id, just update our fields.
-      return update! if id
-
-      from_response client.post("/labels", {
-        name:   name,
-        color:   color,
-        idBoard: board_id,
-      })
-    end
-
-    # Update an existing record.
-    # Warning, this updates all fields using values already in memory. If
-    # an external resource has updated these fields, you should refresh!
-    # this object before making your changes, and before updating the record.
-    def update!
-      @previously_changed = changes
-      # extract only new values to build payload
-      payload = Hash[changes.map { |key, values| [SYMBOL_TO_STRING[key.to_sym].to_sym, values[1]] }]
-      @changed_attributes.clear if @changed_attributes.respond_to?(:clear)
-      changes_applied if respond_to?(:changes_applied)
-
-      client.put("/labels/#{id}", payload)
-    end
-
     # Delete this label
     def delete
       client.delete("/labels/#{id}")
     end
 
-    private
-
-    def fields_has_key?(fields, key)
-      fields.key?(SYMBOL_TO_STRING[key]) || fields.key?(key)
-    end
-
-    def initialize_fields(fields)
-      attributes[:id] = fields['id'] || attributes[:id]
-      attributes[:name]  = fields['name'] || fields[:name] || attributes[:name]
-      attributes[:color] = fields['color'] || fields[:color] || attributes[:color]
-      attributes[:board_id] = fields['idBoard'] || fields[:board_id] || attributes[:board_id]
-      attributes[:uses] = fields['uses'] if fields.has_key?('uses')
-      self
-    end
   end
 end

data/lib/trello/label_name.rb

@@ -1,31 +1,28 @@
 module Trello
-
   # A colored Label attached to a card
+  #
+  # @!attribute [r] yellow
+  # @!attribute [r] red
+  # @!attribute [r] orange
+  # @!attribute [r] green
+  # @!attribute [r] purple
+  # @!attribute [r] blue
+  # @!attribute [r] sky
+  # @!attribute [r] pink
+  # @!attribute [r] lime
+  # @!attribute [r] black
   class LabelName < BasicData
-    register_attributes :yellow, :red, :orange, :green, :purple, :blue, :sky, :pink, :lime, :black
-
-    # Update the fields of a label.
-    #
-    # Supply a hash of stringkeyed data retrieved from the Trello API representing
-    # a label.
-    def update_fields(fields)
-      attributes[:yellow]  = fields['yellow'] || attributes[:yellow]
-      attributes[:red] = fields['red'] || attributes[:red]
-      attributes[:orange] = fields['orange'] || attributes[:orange]
-      attributes[:green] = fields['green'] || attributes[:green]
-      attributes[:purple] = fields['purple'] || attributes[:purple]
-      attributes[:blue] = fields['blue'] || attributes[:blue]
-      attributes[:sky] = fields['sky'] || attributes[:sky]
-      attributes[:pink] = fields['pink'] || attributes[:pink]
-      attributes[:lime] = fields['lime'] || attributes[:lime]
-      attributes[:black] = fields['black'] || attributes[:black]
-
-      self
+    schema do
+      attribute :yellow, readonly: true
+      attribute :red, readonly: true
+      attribute :orange, readonly: true
+      attribute :green, readonly: true
+      attribute :purple, readonly: true
+      attribute :blue, readonly: true
+      attribute :sky, readonly: true
+      attribute :pink, readonly: true
+      attribute :lime, readonly: true
+      attribute :black, readonly: true
     end
-
-    one :board, path: :boards, using: :board_id
-
-    many :cards, filter: :all
-
   end
 end