trelloapi 0.1.1

data/lib/trello/item_state.rb

@@ -0,0 +1,30 @@
+module Trello
+  # Represents the state of an item.
+  #
+  # @!attribute [r] id
+  #   @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[:state]   = fields['state']
+      attributes[:item_id] = fields['idCheckItem']
+      self
+    end
+
+    # Return the item this state belongs to.
+    def item
+      Item.find(item_id)
+    end
+  end
+end

data/lib/trello/json_utils.rb

@@ -0,0 +1,64 @@
+module Trello
+  module JsonUtils
+    def self.included(base)
+      base.send :include, InstanceMethods
+      base.send :extend, ClassMethods
+    end
+
+    module InstanceMethods
+      def from_response(*args)
+        update_fields parse_json(*args)
+      end
+
+      def parse_json(*args)
+        self.class.parse_json(*args)
+      end
+    end
+
+    module ClassMethods
+      # Public - Decodes some JSON text in the receiver, and marshals it into a class specified
+      # in _obj_.
+      #
+      # For instance:
+      #
+      #   class Stuff
+      #     attr_reader :a, :b
+      #     def initialize(values)
+      #       @a = values['a']
+      #       @b = values['b']
+      #     end
+      #   end
+      #   thing = Stuff.from_response '{"a":42,"b":"foo"}'
+      #   thing.a == 42
+      #   thing.b == "foo"
+      #
+      def from_response(data, encoding = 'UTF-8')
+        from_json(parse_json(data, encoding))
+      end
+
+      def from_json(json)
+        case json
+        when Array
+          json.map { |element| from_json(element) }
+        when Hash
+          self.new(json)
+        else
+          json
+        end
+      end
+
+      def parse_json(string, encoding = 'UTF-8')
+        JSON.parse(string.force_encoding(encoding))
+      rescue JSON::ParserError => json_error
+        if json_error.message =~ /model not found/
+          Trello.logger.error "Could not find that record."
+          raise Trello::Error, "Request could not be found."
+        elsif json_error.message =~ /A JSON text must at least contain two octets/
+        else
+          Trello.logger.error "Unknown error."
+          raise
+        end
+      end
+    end
+  end
+end

data/lib/trello/label.rb

@@ -0,0 +1,108 @@
+module Trello
+
+  # A colored Label attached to a card
+  #
+  # @!attribute [rw] id
+  #   @return [String]
+  # @!attribute [rw] color
+  #   @return [String]
+  class Label < BasicData
+    register_attributes :id, :name, :board_id, :uses,
+      readonly: [ :id, :uses, :board_id ]
+    validates_presence_of :id, :uses, :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 card 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
+
+    # 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[:id] = fields['id']
+      attributes[:name]  = fields['name'] || fields[:name]
+      attributes[:color] = fields['color'] || fields[:color]
+      attributes[:board_id] = fields['idBoard'] || fields[:board_id]
+      attributes[:uses] = fields['uses']
+      self
+    end
+
+    # 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
+
+      client.put("/labels/#{id}", payload)
+    end
+
+    # Delete this label
+    def delete
+      client.delete("/labels/#{id}")
+    end
+  end
+end

data/lib/trello/label_name.rb

@@ -0,0 +1,31 @@
+module Trello
+
+  # A colored Label attached to a card
+  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[:red] = fields['red']
+      attributes[:orange] = fields['orange']
+      attributes[:green] = fields['green']
+      attributes[:purple] = fields['purple']
+      attributes[:blue] = fields['blue']
+      attributes[:sky] = fields['sky']
+      attributes[:pink] = fields['pink']
+      attributes[:lime] = fields['lime']
+      attributes[:black] = fields['black']
+
+      self
+    end
+
+    one :board, path: :boards, using: :board_id
+
+    many :cards, filter: :all
+
+  end
+end

data/lib/trello/list.rb

@@ -0,0 +1,114 @@
+module Trello
+  # A List is a container which holds cards. Lists are items on a board.
+  #
+  # @!attribute [r] id
+  #   @return [String]
+  # @!attribute [rw] name
+  #   @return [String]
+  # @!attribute [rw] closed
+  #   @return [Boolean]
+  # @!attribute [r] board_id
+  #   @return [String] A 24-character hex string
+  # @!attribute [rw] pos
+  #   @return [Object]
+  class List < BasicData
+    register_attributes :id, :name, :closed, :board_id, :pos, :source_list_id, readonly: [ :id, :board_id ]
+    validates_presence_of :id, :name, :board_id
+    validates_length_of   :name, in: 1..16384
+
+    include HasActions
+
+    class << self
+      # Finds a specific list, given an id.
+      #
+      # @param [id] id the list's ID on Trello (24-character hex string).
+      # @param [Hash] params
+      def find(id, params = {})
+        client.find(:list, id, params)
+      end
+
+      def create(options)
+        client.create(:list,
+            'name'         => options[:name],
+            'idBoard'      => options[:board_id],
+            'pos'          => options[:pos],
+            'idListSource' => options[:source_list_id])
+      end
+    end
+
+    # Updates the fields of a list.
+    #
+    # Supply a hash of string keyed data retrieved from the Trello API representing
+    # a List.
+    def update_fields(fields)
+      attributes[:id]             = fields['id']
+      attributes[:name]           = fields['name'] || fields[:name]
+      attributes[:closed]         = fields['closed']
+      attributes[:board_id]       = fields['idBoard'] || fields[:board_id]
+      attributes[:pos]            = fields['pos'] || fields[:pos]
+      attributes[:source_list_id] = fields['idListSource'] || fields[:source_list_id]
+      self
+    end
+
+    def save
+      return update! if id
+
+      from_response client.post("/lists", {
+        name: name,
+        closed: closed || false,
+        idBoard: board_id,
+        pos: pos,
+        idListSource: source_list_id
+      })
+    end
+
+    def update!
+      client.put("/lists/#{id}", {
+        name: name,
+        closed: closed,
+        pos: pos
+      })
+    end
+
+    # Check if the list is not active anymore.
+    def closed?
+      closed
+    end
+
+    def close
+      self.closed = true
+    end
+
+    def close!
+      close
+      save
+    end
+
+    # Return the board the list is connected to.
+    one :board, path: :boards, using: :board_id
+
+    # Returns all the cards on this list.
+    #
+    # The options hash may have a filter key which can have its value set as any
+    # of the following values:
+    #    :filter => [ :none, :open, :closed, :all ] # default :open
+    many :cards, filter: :open
+
+    def move_all_cards(other_list)
+      client.post("/lists/#{id}/moveAllCards", {
+        idBoard: other_list.board_id,
+        idList: other_list.id
+       })
+    end
+
+    # Archives all the cards of the list
+    def archive_all_cards
+      client.post("/lists/#{id}/archiveAllCards")
+    end
+
+    # :nodoc:
+    def request_prefix
+      "/lists/#{id}"
+    end
+  end
+end

data/lib/trello/member.rb

@@ -0,0 +1,112 @@
+module Trello
+  # A Member is a user of the Trello service.
+  #
+  # @!attribute [r] id
+  #   @return [String]
+  # @!attribute [r] username
+  #   @return [String]
+  # @!attribute [rw] email
+  #   @return [String]
+  # @!attribute [rw] full_name
+  #   @return [String]
+  # @!attribute [rw] initials
+  #   @return [String]
+  # @!attribute [r] avatar_id
+  #   @return [String]
+  # @!attribute [rw] bio
+  #   @return [String]
+  # @!attribute [r] url
+  #   @return [String]
+  class Member < BasicData
+    register_attributes :id, :username, :email, :full_name, :initials, :avatar_id, :bio, :url, readonly: [ :id, :username, :avatar_id, :url ]
+    validates_presence_of :id, :username
+    validates_length_of   :full_name, minimum: 4
+    validates_length_of   :bio,       maximum: 16384
+
+    include HasActions
+
+    class << self
+      # Finds a user
+      #
+      # The argument may be specified as either an _id_ or a _username_.
+      def find(id_or_username, params = {})
+        client.find(:member, id_or_username, params)
+      end
+    end
+
+    # Update the fields of a member.
+    #
+    # Supply a hash of string keyed data retrieved from the Trello API representing
+    # an Member.
+    def update_fields(fields)
+      attributes[:id]        = fields['id']
+      attributes[:full_name] = fields['fullName']
+      attributes[:email]     = fields['email']
+      attributes[:username]  = fields['username']
+      attributes[:initials]  = fields['initials']
+      attributes[:avatar_id] = fields['avatarHash']
+      attributes[:bio]       = fields['bio']
+      attributes[:url]       = fields['url']
+      self
+    end
+
+    # Retrieve a URL to the avatar.
+    #
+    # Valid values for options are:
+    #   :large (170x170)
+    #   :small (30x30)
+    def avatar_url(options = { size: :large })
+      size = options[:size] == :small ? 30 : 170
+      "https://trello-avatars.s3.amazonaws.com/#{avatar_id}/#{size}.png"
+    end
+
+    # Returns a list of the boards a member is a part of.
+    #
+    # This method, when called, can take a hash table with a filter key containing any
+    # of the following values:
+    #   :filter => [ :none, :members, :organization, :public, :open, :closed, :all ] # default: :all
+    # i.e.,
+    #    me.boards(:filter => :closed) # retrieves all closed boards
+    many :boards, filter: :all
+
+    # Returns a list of cards the member is assigned to.
+    #
+    # 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
+    # i.e.,
+    #    me.cards(:filter => :closed) # retrieves all closed cards
+    many :cards, filter: :open
+
+    # Returns a list of the organizations this member is a part of.
+    #
+    # This method, when called, can take a hash table with a filter key containing any
+    # of the following values:
+    #   :filter => [ :none, :members, :public, :all ] # default: all
+    # i.e.,
+    #    me.organizations(:filter => :public) # retrieves all public organizations
+    many :organizations, filter: :all
+
+    # Returns a list of notifications for the user
+    many :notifications
+
+    def save
+      @previously_changed = changes
+      @changed_attributes.clear
+
+      return update! if id
+    end
+
+    def update!
+      from_response client.put(request_prefix, {
+        fullName: full_name,
+        bio: bio
+      })
+    end
+
+    # :nodoc:
+    def request_prefix
+      "/members/#{id}"
+    end
+  end
+end