ruby-trello 2.0.1 → 3.0.0

data/lib/trello/association_fetcher/has_one.rb

@@ -0,0 +1,25 @@
+module Trello
+  module AssociationFetcher
+    class HasOne
+      autoload :Params, 'trello/association_fetcher/has_one/params'
+      autoload :Fetch, 'trello/association_fetcher/has_one/fetch'
+
+      attr_reader :model, :name, :options
+
+      def initialize(model, name, options)
+        @model = model
+        @name = name
+        @options = options
+      end
+
+      def fetch
+        params = Params.new(
+          association_owner: model,
+          association_name: name,
+          association_options: options
+        )
+        Fetch.execute(params)
+      end
+    end
+  end
+end

data/lib/trello/association_fetcher/has_one/fetch.rb

@@ -0,0 +1,49 @@
+module Trello
+  module AssociationFetcher
+    class HasOne
+      class Fetch
+        class << self
+          def execute(params)
+            new(params).execute
+          end
+        end
+
+        def initialize(params)
+          @params = params
+        end
+
+        def execute
+          if association_restful_name
+            client.find(association_restful_name, association_restful_id)
+          else
+            association_class.find(association_restful_id)
+          end
+        end
+
+        private
+
+        attr_reader :params
+
+        def client
+          association_owner.client
+        end
+
+        def association_owner
+          params.association_owner
+        end
+
+        def association_restful_name
+          params.association_restful_name
+        end
+
+        def association_restful_id
+          params.association_restful_id
+        end
+
+        def association_class
+          params.association_class
+        end
+      end
+    end
+  end
+end

data/lib/trello/association_fetcher/has_one/params.rb

@@ -0,0 +1,36 @@
+module Trello
+  module AssociationFetcher
+    class HasOne
+      class Params
+        attr_reader :association_owner
+
+        def initialize(association_owner:, association_name:, association_options:)
+          @association_owner = association_owner
+          @association_name = association_name
+          @association_options = association_options || {}
+        end
+
+        def association_class
+          association_options[:via] || infer_class_on(association_name)
+        end
+
+        def association_restful_name
+          association_options[:path]
+        end
+
+        def association_restful_id
+          id_field = association_options[:using] || :id
+          association_owner.send(id_field)
+        end
+
+        private
+
+        attr_reader :association_name, :association_options
+
+        def infer_class_on(name)
+          AssociationInferTool.infer_class_on_name(name)
+        end
+      end
+    end
+  end
+end

data/lib/trello/association_infer_tool.rb

@@ -0,0 +1,13 @@
+module Trello
+  class AssociationInferTool
+    class << self
+      def infer_restful_resource_on_class(klass)
+        klass.to_s.split('::').last.downcase.pluralize
+      end
+
+      def infer_class_on_name(name)
+        Trello.const_get(name.to_s.singularize.camelize)
+      end
+    end
+  end
+end

data/lib/trello/association_proxy.rb

@@ -31,7 +31,7 @@ module Trello
     end
 
     def to_ary
-      proxy_assocation.dup
+      proxy_assocation.target.dup
     end
     alias_method :to_a, :to_ary
 

data/lib/trello/attachment.rb

@@ -1,40 +1,53 @@
 module Trello
   # A file or url that is linked to a Trello card
   #
-  # @!attribute id
+  # @!attribute [r] id
   #   @return [String]
-  # @!attribute name
-  #   @return [String]
-  # @!attribute url
-  #   @return [String]
-  # @!attribute pos
+  # @!attribute [r] position
   #   @return [Float]
-  # @!attribute bytes
+  # @!attribute [r] bytes
   #   @return [Fixnum]
-  # @!attribute date
+  # @!attribute [r] member_id
+  #   @return [String]
+  # @!attribute [r] date
   #   @return [Datetime]
-  # @!attribute is_upload
+  # @!attribute [r] is_upload
   #   @return [Boolean]
-  # @!attribute mime_type
+  # @!attribute [r] previews
+  #   @return [Array]
+  # @!attribute [r] file_name
+  #   @return [String]
+  # @!attribute [r] edge_color
+  #   @return [String]
+  # @!attribute [rw] name
   #   @return [String]
+  # @!attribute [rw] url
+  #   @return [String]
+  # @!attribute [rw] mime_type
+  #   @return [String]
+  # @!attribute [w] file
+  #   @return [String]
+  # @!attribute [w] set_as_cover
+  #   @return [Boolean]
   class Attachment < BasicData
-    register_attributes :name, :id, :pos, :url, :bytes, :member_id, :date, :is_upload, :mime_type, :previews
-    # Update the fields of an attachment.
-    #
-    # Supply a hash of stringkeyed data retrieved from the Trello API representing
-    # an attachment.
-    def update_fields(fields)
-      attributes[:name]      = fields['name'] || attributes[:name]
-      attributes[:id]        = fields['id'] || attributes[:id]
-      attributes[:pos]       = fields['pos'] || attributes[:pos]
-      attributes[:url]       = fields['url'] || attributes[:url]
-      attributes[:bytes]     = fields['bytes'].to_i || attributes[:bytes]
-      attributes[:member_id] = fields['idMember'] || attributes[:member_id]
-      attributes[:date]      = Time.parse(fields['date']).presence || attributes[:date]
-      attributes[:is_upload] = fields['isUpload'] if fields.has_key?('isUpload')
-      attributes[:mime_type] = fields['mimeType'] || attributes[:mime_type]
-      attributes[:previews]  = fields['previews'] if fields.has_key?('previews')
-      self
+    schema do
+      # Readonly
+      attribute :id, readonly: true, primary_key: true
+      attribute :position, readonly: true, remote_key: 'pos'
+      attribute :bytes, readonly: true
+      attribute :member_id, remote_key: 'idMember', readonly: true
+      attribute :date, serializer: 'Time', readonly: true
+      attribute :is_upload, remote_key: 'isUpload', readonly: true
+      attribute :previews, readonly: true
+      attribute :file_name, remote_key: 'fileName', readonly: true
+      attribute :edge_color, remote_key: 'edgeColor', readonly: true
+
+      # Writable but create only
+      attribute :name, create_only: true
+      attribute :url, create_only: true
+      attribute :mime_type, remote_key: 'mimeType', create_only: true
+      attribute :file, create_only: true
+      attribute :set_as_cover, remote_key: 'setCover', create_only: true
     end
   end
 end

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
+
+      @schema
+    end
 
-        define_attribute_methods names
+    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.
@@ -122,11 +146,49 @@ module Trello
 
     # Two objects are equal if their _id_ methods are equal.
     def ==(other)
-      id == other.id
+      self.class == other.class && id == other.id
+    end
+
+    # Alias hash equality to equality
+    alias eql? ==
+
+    # Delegate hash key computation to class and id pair
+    def hash
+      [self.class, id].hash
     end
 
     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,81 +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.clear
-
-      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]
@@ -167,6 +177,9 @@ module Trello
     # Returns a list of plugins associated with the board
     many :plugin_data, path: "pluginData"
 
+    # Returns custom fields activated on this board
+    many :custom_fields, path: "customFields"
+
     def labels(params = {})
       # Set the limit to as high as possible given there is no pagination in this API.
       params[:limit] = 1000 unless params[:limit]
@@ -184,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