ruby-trello 2.2.0 → 3.1.0

data/lib/trello/basic_data.rb

@@ -42,77 +42,101 @@ module Trello
       end
     end
 
-    def self.register_attributes(*names)
-      options = { readonly: [] }
-      options.merge!(names.pop) if names.last.kind_of? Hash
-
-      # Defines the attribute getter and setters.
-      class_eval do
-        define_method :attributes do
-          @__attributes ||= names.reduce({}) { |hash, k| hash.merge(k.to_sym => nil) }
-        end
+    def self.schema(&block)
+      @schema ||= Schema.new
+      return @schema unless block_given?
 
-        names.each do |key|
-          define_method(:"#{key}") { @__attributes[key] }
+      @schema.instance_eval(&block)
 
-          unless options[:readonly].include?(key.to_sym)
-            define_method :"#{key}=" do |val|
-              send(:"#{key}_will_change!") unless val == @__attributes[key]
-              @__attributes[key] = val
-            end
-          end
-        end
+      register_attrs
 
-        define_attribute_methods names
+      @schema
+    end
+
+    def self.register_attrs
+      schema.attrs.values.each do |attribute|
+        attribute.register(self)
       end
     end
 
     def self.one(name, opts = {})
-      class_eval do
-        define_method(:"#{name}") do |*args|
-          options = opts.dup
-          klass   = options.delete(:via) || Trello.const_get(name.to_s.camelize)
-          ident   = options.delete(:using) || :id
-          path    = options.delete(:path)
-
-          if path
-            client.find(path, self.send(ident))
-          else
-            klass.find(self.send(ident))
-          end
-        end
-      end
+      AssociationBuilder::HasOne.build(self, name, opts)
     end
 
     def self.many(name, opts = {})
-      class_eval do
-        define_method(:"#{name}") do |*args|
-          options   = opts.dup
-          resource  = options.delete(:in)  || self.class.to_s.split("::").last.downcase.pluralize
-          klass     = options.delete(:via) || Trello.const_get(name.to_s.singularize.camelize)
-          path = options.delete(:path) || name
-          params    = options.merge(args[0] || {})
-
-          resources = client.find_many(klass, "/#{resource}/#{id}/#{path}", params)
-          MultiAssociation.new(self, resources).proxy
-        end
-      end
+      AssociationBuilder::HasMany.build(self, name, opts)
     end
 
     def self.client
       Trello.client
     end
 
-    register_attributes :id, readonly: [ :id ]
-
     attr_writer :client
 
     def initialize(fields = {})
-      update_fields(fields)
+      initialize_fields(fields)
+    end
+
+    def save
+      return update! if id
+
+      payload = {}
+
+      schema.attrs.each do |_, attribute|
+        payload = attribute.build_payload_for_create(attributes, payload)
+      end
+
+      post(collection_path, payload)
+    end
+
+    def update!
+      fail "Cannot save new instance." unless id
+
+      @previously_changed = changes
+
+      payload = {}
+      changed_attrs = attributes.select {|name, _| changed.include?(name.to_s)}
+
+      schema.attrs.each do |_, attribute|
+        payload = attribute.build_payload_for_update(changed_attrs, payload)
+      end
+
+      from_response client.put(element_path, payload)
+
+      @changed_attributes.clear if @changed_attributes.respond_to?(:clear)
+      changes_applied if respond_to?(:changes_applied)
+
+      self
     end
 
     def update_fields(fields)
-      raise NotImplementedError, "#{self.class} does not implement update_fields."
+      attrs = {}
+
+      schema.attrs.each do |_, attribute|
+        attrs = attribute.build_pending_update_attributes(fields, attrs)
+      end
+
+      attrs.each do |name, value|
+        send("#{name}=", value)
+      end
+
+      self
+    end
+
+    def collection_path
+      "/#{collection_name}"
+    end
+
+    def element_path
+      "/#{collection_name}/#{id}"
+    end
+
+    def collection_name
+      @collection_path ||= ActiveSupport::Inflector.pluralize(element_name)
+    end
+
+    def element_name
+      @element_name ||= model_name.element
     end
 
     # Refresh the contents of our object.
@@ -136,5 +160,35 @@ module Trello
     def client
       @client ||= self.class.client
     end
+
+    def schema
+      self.class.schema
+    end
+
+    def attributes
+      @__attributes ||= ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    private
+
+    def attributes=(attrs)
+      @__attributes = attrs
+    end
+
+    def initialize_fields(fields)
+      schema.attrs.each do |_, attribute|
+        self.attributes = attribute.build_attributes(fields, attributes)
+      end
+
+      self
+    end
+
+    def post(path, body)
+      from_response client.post(path, body)
+    end
+
+    def put(path, body)
+      from_response client.put(path, body)
+    end
   end
 end

data/lib/trello/board.rb

@@ -4,21 +4,100 @@ module Trello
   #
   # @!attribute [r] id
   #   @return [String]
-  # @!attribute [r] name
+  # @!attribute [r] starred
+  #   @return [Boolean]
+  # @!attribute [r] pinned
+  #   @return [Boolean]
+  # @!attribute [r] url
+  #   @return [String]
+  # @!attribute [r] short_url
+  #   @return [String]
+  # @!attribute [r] prefs
+  #   @return [Hash]
+  # @!attribute [r] last_activity_date
+  #   @return [Datetime]
+  # @!attribute [r] description_data
+  #   @return [Datetime]
+  # @!attribute [r] enterprise_id
+  #   @return [String]
+  # @!attribute [rw] name
   #   @return [String]
   # @!attribute [rw] description
   #   @return [String]
-  # @!attribute [rw] closed
+  # @!attribute [rw] organization_id
+  #   @return [String]
+  # @!attribute [rw] visibility_level
+  #   @return [String]
+  # @!attribute [rw] voting_permission_level
+  #   @return [String]
+  # @!attribute [rw] comment_permission_level
+  #   @return [String]
+  # @!attribute [rw] invitation_permission_level
+  #   @return [String]
+  # @!attribute [rw] enable_self_join
   #   @return [Boolean]
-  # @!attribute [r] url
+  # @!attribute [rw] enable_card_covers
+  #   @return [Boolean]
+  # @!attribute [rw] background_color
   #   @return [String]
-  # @!attribute [rw] organization_id
-  #   @return [String] A 24-character hex string
-  # @!attribute [r] prefs
-  #   @return [Hash] A 24-character hex string
+  # @!attribute [rw] background_image
+  #   @return [String]
+  # @!attribute [rw] card_aging_type
+  #   @return [String]
+  # @!attribute [w] use_default_labels
+  #   @return [Boolean]
+  # @!attribute [w] use_default_lists
+  #   @return [Boolean]
+  # @!attribute [w] source_board_id
+  #   @return [String]
+  # @!attribute [w] keep_cards_from_source
+  #   @return [String]
+  # @!attribute [w] power_ups
+  #   @return [String]
+  # @!attribute [rw] closed
+  #   @return [Boolean]
+  # @!attribute [w] subscribed
+  #   @return [Boolean]
   class Board < BasicData
-    register_attributes :id, :name, :description, :closed, :starred, :url, :organization_id, :prefs, :last_activity_date,
-      readonly: [ :id, :url, :last_activity_date ]
+    schema do
+      attribute :id, readonly: true, primary_key: true
+
+      # Readonly
+      attribute :starred, readonly: true
+      attribute :pinned, readonly: true
+      attribute :url, readonly: true
+      attribute :short_url, readonly: true, remote_key: 'shortUrl'
+      attribute :prefs, readonly: true, default: {}
+      attribute :last_activity_date, readonly: true, remote_key: 'dateLastActivity', serializer: 'Time'
+      attribute :description_data, readonly: true, remote_key: 'descData'
+      attribute :enterprise_id, readonly: true, remote_key: 'idEnterprise'
+
+      # Writable
+      attribute :name
+      attribute :description, remote_key: 'desc'
+      attribute :organization_id, remote_key: 'idOrganization'
+      attribute :visibility_level, remote_key: 'permissionLevel', class_name: 'BoardPref'
+      attribute :voting_permission_level, remote_key: 'voting', class_name: 'BoardPref'
+      attribute :comment_permission_level, remote_key: 'comments', class_name: 'BoardPref'
+      attribute :invitation_permission_level, remote_key: 'invitations', class_name: 'BoardPref'
+      attribute :enable_self_join, remote_key: 'selfJoin', class_name: 'BoardPref'
+      attribute :enable_card_covers, remote_key: 'cardCovers', class_name: 'BoardPref'
+      attribute :background_color, remote_key: 'background', class_name: 'BoardPref'
+      attribute :background_image, remote_key: 'backgroundImage', class_name: 'BoardPref'
+      attribute :card_aging_type, remote_key: 'cardAging', class_name: 'BoardPref'
+
+      # Writable but for create only
+      attribute :use_default_labels, create_only: true, remote_key: 'defaultLabels'
+      attribute :use_default_lists, create_only: true, remote_key: 'defaultLists'
+      attribute :source_board_id, create_only: true, remote_key: 'idBoardSource'
+      attribute :keep_cards_from_source, create_only: true, remote_key: 'keepFromSource'
+      attribute :power_ups, create_only: true, remote_key: 'powerUps'
+
+      # Writable but for update only
+      attribute :closed, update_only: true
+      attribute :subscribed, update_only: true
+    end
+
     validates_presence_of :id, :name
     validates_length_of   :name,        in: 1..16384
     validates_length_of   :description, maximum: 16384
@@ -26,82 +105,12 @@ module Trello
     include HasActions
 
     class << self
-      # Finds a board.
-      #
-      # @param [String] id Either the board's short ID (an alphanumeric string,
-      #     found e.g. in the board's URL) or its long ID (a 24-character hex
-      #     string.)
-      # @param [Hash] params
-      #
-      # @raise  [Trello::Board] if a board with the given ID could not be found.
-      #
-      # @return [Trello::Board]
-      def find(id, params = {})
-        client.find(:board, id, params)
-      end
-
-      def create(fields)
-        data = {
-          'name'   => fields[:name],
-          'desc'   => fields[:description],
-          'closed' => fields[:closed] || false,
-          'starred' => fields[:starred] || false }
-        data.merge!('idOrganization' => fields[:organization_id]) if fields[:organization_id]
-        data.merge!('prefs' => fields[:prefs]) if fields[:prefs]
-        client.create(:board, data)
-      end
-
       # @return [Array<Trello::Board>] all boards for the current user
       def all
         from_response client.get("/members/#{Member.find(:me).username}/boards")
       end
     end
 
-    def save
-      return update! if id
-
-      fields = { name: name }
-      fields.merge!(desc: description) if description
-      fields.merge!(idOrganization: organization_id) if organization_id
-      fields.merge!(flat_prefs)
-
-      from_response(client.post("/boards", fields))
-    end
-
-    def update!
-      fail "Cannot save new instance." unless self.id
-
-      @previously_changed = changes
-      @changed_attributes.try(:clear)
-      changes_applied if respond_to?(:changes_applied)
-
-      fields = {
-        name: attributes[:name],
-        description: attributes[:description],
-        closed: attributes[:closed],
-        starred: attributes[:starred],
-        idOrganization: attributes[:organization_id]
-      }
-      fields.merge!(flat_prefs)
-
-      from_response client.put("/boards/#{self.id}/", fields)
-    end
-
-    def update_fields(fields)
-      attributes[:id]              = fields['id'] || fields[:id]                          if fields['id']   || fields[:id]
-      attributes[:name]            = fields['name'] || fields[:name]                      if fields['name'] || fields[:name]
-      attributes[:description]     = fields['desc'] || fields[:desc]                      if fields['desc'] || fields[:desc]
-      attributes[:closed]          = fields['closed']                                     if fields.has_key?('closed')
-      attributes[:closed]          = fields[:closed]                                      if fields.has_key?(:closed)
-      attributes[:starred]         = fields['starred']                                    if fields.has_key?('starred')
-      attributes[:starred]         = fields[:starred]                                     if fields.has_key?(:starred)
-      attributes[:url]             = fields['url']                                        if fields['url']
-      attributes[:organization_id] = fields['idOrganization'] || fields[:organization_id] if fields['idOrganization'] || fields[:organization_id]
-      attributes[:prefs]           = fields['prefs'] || fields[:prefs] || {}
-      attributes[:last_activity_date] = Time.iso8601(fields['dateLastActivity']) rescue nil
-      self
-    end
-
     # @return [Boolean]
     def closed?
       attributes[:closed]
@@ -188,28 +197,5 @@ module Trello
       "/boards/#{id}"
     end
 
-    private
-
-    # On creation
-    # https://trello.com/docs/api/board/#post-1-boards
-    # - permissionLevel
-    # - voting
-    # - comments
-    # - invitations
-    # - selfJoin
-    # - cardCovers
-    # - background
-    # - cardAging
-    #
-    # On update
-    # https://trello.com/docs/api/board/#put-1-boards-board-id
-    # Same as above plus:
-    # - calendarFeedEnabled
-    def flat_prefs
-      separator = id ? "/" : "_"
-      attributes[:prefs].inject({}) do |hash, (pref, v)|
-        hash.merge("prefs#{separator}#{pref}" => v)
-      end
-    end
   end
 end