ruby-trello-czuger 2.0.0

data/lib/trello/attachment.rb

@@ -0,0 +1,40 @@
+module Trello
+  # A file or url that is linked to a Trello card
+  #
+  # @!attribute id
+  #   @return [String]
+  # @!attribute name
+  #   @return [String]
+  # @!attribute url
+  #   @return [String]
+  # @!attribute pos
+  #   @return [Float]
+  # @!attribute bytes
+  #   @return [Fixnum]
+  # @!attribute date
+  #   @return [Datetime]
+  # @!attribute is_upload
+  #   @return [Boolean]
+  # @!attribute mime_type
+  #   @return [String]
+  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
+    end
+  end
+end

data/lib/trello/authorization.rb

@@ -0,0 +1,187 @@
+require 'securerandom'
+require "oauth"
+
+module Trello
+  module Authorization
+
+    AuthPolicy = Class.new do
+      def initialize(attrs = {}); end
+
+      def authorize(*args)
+        raise Trello::ConfigurationError, "Trello has not been configured to make authorized requests."
+      end
+    end
+
+    class BasicAuthPolicy
+      class << self
+        attr_accessor :developer_public_key, :member_token
+
+        def authorize(request)
+          new.authorize(request)
+        end
+      end
+
+      attr_accessor :developer_public_key, :member_token
+
+      def initialize(attrs = {})
+        @developer_public_key = attrs[:developer_public_key]  || self.class.developer_public_key
+        @member_token         = attrs[:member_token]          || self.class.member_token
+      end
+
+      def authorize(request)
+        the_uri = Addressable::URI.parse(request.uri)
+        existing_values = the_uri.query_values.nil? ? {} : the_uri.query_values
+        new_values = { key: @developer_public_key, token: @member_token }
+        the_uri.query_values = new_values.merge existing_values
+
+        Request.new request.verb, the_uri, request.headers, request.body
+      end
+    end
+
+    class Clock
+      def self.timestamp; Time.now.to_i; end
+    end
+
+    class Nonce
+      def self.next
+        SecureRandom.hex()
+      end
+    end
+
+    OAuthCredential = Struct.new "OAuthCredential", :key, :secret
+
+    # Handles the OAuth connectivity to Trello.
+    #
+    # For 2-legged OAuth, do the following:
+    #
+    #    OAuthPolicy.consumer_credential = OAuthCredential.new "public_key", "secret"
+    #    OAuthPolicy.token               = OAuthCredential.new "token_key", nil
+    #
+    # For 3-legged OAuth, do the following:
+    #
+    #    OAuthPolicy.consumer_credential = OAuthCredential.new "public_key", "secret"
+    #    OAuthPolicy.return_url          = "http://your.site.com/path/to/receive/post"
+    #    OAuthPolicy.callback            = Proc.new do |request_token|
+    #      DB.save(request_token.key, request_token.secret)
+    #      redirect_to request_token.authorize_url
+    #    end
+    #
+    # Then, recreate the request token given the request token key and secret you saved earlier,
+    # and the consumer, and pass that RequestToken instance the #get_access_token method, and
+    # store that in OAuthPolicy.token as a OAuthCredential.
+    class OAuthPolicy
+      class << self
+        attr_accessor :consumer_credential, :token, :return_url, :callback
+
+        def authorize(request)
+          new.authorize(request)
+        end
+      end
+
+      attr_accessor :attributes
+      attr_accessor :consumer_credential, :token, :return_url, :callback
+
+      def initialize(attrs = {})
+        @consumer_key       = attrs[:consumer_key]
+        @consumer_secret    = attrs[:consumer_secret]
+        @oauth_token        = attrs[:oauth_token]
+        @oauth_token_secret = attrs[:oauth_token_secret]
+        @return_url         = attrs[:return_url]          || self.class.return_url
+        @callback           = attrs[:callback]            || self.class.callback
+      end
+
+      def authorize(request)
+        unless consumer_credential
+          Trello.logger.error "The consumer_credential has not been supplied."
+          fail "The consumer_credential has not been supplied."
+        end
+
+        if token
+          request.headers = {"Authorization" => get_auth_header(request.uri, :get)}
+          request
+        else
+          consumer(return_url: return_url, callback_method: :postMessage)
+          request_token = consumer.get_request_token(oauth_callback: return_url)
+          callback.call request_token
+          return nil
+        end
+      end
+
+      def consumer_credential
+        @consumer_credential ||= build_consumer_credential
+      end
+
+      def token
+        @token ||= build_token
+      end
+
+      def consumer_key
+        consumer_credential.key
+      end
+
+      def consumer_secret
+        consumer_credential.secret
+      end
+
+      def oauth_token
+        token.key
+      end
+
+      def oauth_token_secret
+        token.secret
+      end
+
+      private
+
+      def build_consumer_credential
+        if @consumer_key && @consumer_secret
+          OAuthCredential.new @consumer_key, @consumer_secret
+        else
+          self.class.consumer_credential
+        end
+      end
+
+      def build_token
+        if @oauth_token
+          OAuthCredential.new @oauth_token, @oauth_token_secret
+        else
+          self.class.token
+        end
+      end
+
+      def consumer_params(params = {})
+        {
+          scheme: :header,
+          scope: 'read,write,account',
+          http_method: :get,
+          request_token_path: "https://trello.com/1/OAuthGetRequestToken",
+          authorize_path: "https://trello.com/1/OAuthAuthorizeToken",
+          access_token_path: "https://trello.com/1/OAuthGetAccessToken"
+        }.merge!(params)
+      end
+
+      def consumer(options = {})
+        @consumer ||= OAuth::Consumer.new(
+          consumer_credential.key,
+          consumer_credential.secret,
+          consumer_params(options)
+        )
+      end
+
+      def get_auth_header(url, verb, options = {})
+        request = Net::HTTP::Get.new Addressable::URI.parse(url).to_s
+
+        consumer.options[:signature_method] = 'HMAC-SHA1'
+        consumer.options[:nonce]            = Nonce.next
+        consumer.options[:timestamp] 	      = Clock.timestamp
+        consumer.options[:uri]              = url
+        consumer.key                        = consumer_credential.key
+        consumer.secret                     = consumer_credential.secret
+
+        consumer.sign!(request, OAuth::Token.new(token.key, token.secret))
+
+        request['authorization']
+      end
+    end
+  end
+end

data/lib/trello/basic_data.rb

@@ -0,0 +1,132 @@
+require 'active_support/inflector'
+
+module Trello
+  class BasicData
+    include ActiveModel::Validations
+    include ActiveModel::Dirty
+    include ActiveModel::Serializers::JSON
+
+    include Trello::JsonUtils
+
+    class << self
+      def path_name
+        name.split("::").last.underscore
+      end
+
+      def find(id, params = {})
+        client.find(path_name, id, params)
+      end
+
+      def create(options)
+        client.create(path_name, options)
+      end
+
+      def save(options)
+        new(options).tap do |basic_data|
+          yield basic_data if block_given?
+        end.save
+      end
+
+      def parse(response)
+        from_response(response).tap do |basic_data|
+          yield basic_data if block_given?
+        end
+      end
+
+      def parse_many(response)
+        from_response(response).map do |data|
+          data.tap do |d|
+            yield d if block_given?
+          end
+        end
+      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
+
+        names.each do |key|
+          define_method(:"#{key}") { @attributes[key] }
+
+          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
+
+        define_attribute_methods names
+      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
+    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
+    end
+
+    def self.client
+      Trello.client
+    end
+
+    register_attributes :id, readonly: [ :id ]
+
+    attr_writer :client
+
+    def initialize(fields = {})
+      update_fields(fields)
+    end
+
+    def update_fields(fields)
+      raise NotImplementedError, "#{self.class} does not implement update_fields."
+    end
+
+    # Refresh the contents of our object.
+    def refresh!
+      self.class.find(id)
+    end
+
+    # Two objects are equal if their _id_ methods are equal.
+    def ==(other)
+      id == other.id
+    end
+
+    def client
+      @client ||= self.class.client
+    end
+  end
+end

data/lib/trello/board.rb

@@ -0,0 +1,211 @@
+module Trello
+
+  # A board on Trello
+  #
+  # @!attribute [r] id
+  #   @return [String]
+  # @!attribute [r] name
+  #   @return [String]
+  # @!attribute [rw] description
+  #   @return [String]
+  # @!attribute [rw] closed
+  #   @return [Boolean]
+  # @!attribute [r] url
+  #   @return [String]
+  # @!attribute [rw] organization_id
+  #   @return [String] A 24-character hex string
+  # @!attribute [r] prefs
+  #   @return [Hash] A 24-character hex string
+  class Board < BasicData
+    register_attributes :id, :name, :description, :closed, :starred, :url, :organization_id, :prefs, :last_activity_date,
+      readonly: [ :id, :url, :last_activity_date ]
+    validates_presence_of :id, :name
+    validates_length_of   :name,        in: 1..16384
+    validates_length_of   :description, maximum: 16384
+
+    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]
+    end
+
+    # @return [Boolean]
+    def starred?
+      attributes[:starred]
+    end
+
+    # @return [Boolean]
+    def has_lists?
+      lists.size > 0
+    end
+
+    # Find a card on this Board with the given ID.
+    # @return [Trello::Card]
+    def find_card(card_id)
+      Card.from_response client.get("/boards/#{self.id}/cards/#{card_id}")
+    end
+
+    # Add a member to this Board.
+    #    type => [ :admin, :normal, :observer ]
+    def add_member(member, type = :normal)
+      client.put("/boards/#{self.id}/members/#{member.id}", { type: type })
+    end
+
+    # Remove a member of this Board.
+    def remove_member(member)
+      client.delete("/boards/#{self.id}/members/#{member.id}")
+    end
+
+    # Return all the cards on this board.
+    #
+    # This method, when called, can take a hash table with a filter key containing any
+    # of the following values:
+    #    :filter => [ :none, :open, :closed, :all ] # default :open
+    many :cards, filter: :open
+
+    # Returns all the lists on this board.
+    #
+    # This method, when called, can take a hash table with a filter key containing any
+    # of the following values:
+    #    :filter => [ :none, :open, :closed, :all ] # default :open
+    many :lists, filter: :open
+
+    # Returns an array of members who are associated with this board.
+    #
+    # This method, when called, can take a hash table with a filter key containing any
+    # of the following values:
+    #    :filter => [ :none, :normal, :owners, :admins, :all ] # default :all
+    many :members, filter: :all
+
+    # Returns a list of checklists associated with the board.
+    #
+    # The options hash may have a filter key which can have its value set as any
+    # of the following values:
+    #    :filter => [ :none, :all ] # default :all
+    many :checklists, filter: :all
+
+    # Returns a reference to the organization this board belongs to.
+    one :organization, path: :organizations, using: :organization_id
+
+    # Returns a list of plugins associated with the board
+    many :plugin_data, path: "pluginData"
+
+    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]
+      labels = Label.from_response client.get("/boards/#{id}/labels", params)
+      MultiAssociation.new(self, labels).proxy
+    end
+
+    def label_names
+      label_names = LabelName.from_response client.get("/boards/#{id}/labelnames")
+      MultiAssociation.new(self, label_names).proxy
+    end
+
+    # :nodoc:
+    def request_prefix
+      "/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