ruby-trello 2.0.1 → 3.0.0

data/lib/trello/schema.rb

@@ -0,0 +1,31 @@
+module Trello
+  class Schema
+    module Attribute
+      autoload :Base, 'trello/schema/attribute/base'
+      autoload :Default, 'trello/schema/attribute/default'
+      autoload :BoardPref, 'trello/schema/attribute/board_pref'
+      autoload :CustomFieldDisplay, 'trello/schema/attribute/custom_field_display'
+    end
+
+    module Serializer
+      autoload :Default, 'trello/schema/serializer/default'
+      autoload :Time, 'trello/schema/serializer/time'
+      autoload :Labels, 'trello/schema/serializer/labels'
+      autoload :Webhooks, 'trello/schema/serializer/webhooks'
+    end
+
+    autoload :AttributeBuilder, 'trello/schema/attribute_builder'
+    autoload :AttributeRegistration, 'trello/schema/attribute_registration'
+
+    attr_reader :attrs
+
+    def initialize
+      @attrs = ActiveSupport::HashWithIndifferentAccess.new
+    end
+
+    def attribute(name, options={})
+      @attrs[name] = AttributeBuilder.build(name, options)
+      self
+    end
+  end
+end

data/lib/trello/schema/attribute/base.rb

@@ -0,0 +1,79 @@
+module Trello
+  class Schema
+    module Attribute
+      class Base
+
+        attr_reader :name, :options, :serializer
+
+        def initialize(name:, options:, serializer:)
+          @name = name.to_sym
+          @options = options || {}
+          @serializer = serializer
+        end
+
+        def build_attributes(params, attributes)
+          raise 'Need override'
+        end
+
+        def build_pending_update_attributes(params, attributes)
+          params = params.with_indifferent_access
+
+          return attributes unless params.key?(remote_key) || params.key?(name)
+
+          build_attributes(params, attributes)
+        end
+
+        def build_payload_for_create(attributes, payload)
+          raise 'Need override'
+        end
+
+        def build_payload_for_update(attributes, payload)
+          raise 'Need override'
+        end
+
+        def readonly?
+          options[:readonly] == true
+        end
+
+        def update_only?
+          options[:update_only] == true
+        end
+
+        def create_only?
+          options[:create_only] == true
+        end
+
+        def primary_key?
+          return false unless options.key?(:primary_key)
+
+          options[:primary_key] 
+        end
+
+        def for_action?(action)
+          case action
+          when :create
+            create_only? || (!update_only? && !readonly? && !primary_key?)
+          when :update
+            update_only? || primary_key? || (!create_only? && !readonly?)
+          else
+            false
+          end
+        end
+
+        def remote_key
+          (options[:remote_key] || name).to_s
+        end
+
+        def default
+          return nil unless options.key?(:default)
+
+          options[:default]
+        end
+
+        def register(model_klass)
+          AttributeRegistration.register(model_klass, self)
+        end
+      end
+    end
+  end
+end

data/lib/trello/schema/attribute/board_pref.rb

@@ -0,0 +1,45 @@
+module Trello
+  class Schema
+    module Attribute
+      class BoardPref < Base
+
+        def build_attributes(params, attributes)
+          attrs = attributes.with_indifferent_access
+          params = params.with_indifferent_access
+
+          value = if params.key?(:prefs)
+                    params[:prefs][remote_key]
+                  else
+                    params[name]
+                  end
+
+          attrs[name] = serializer.deserialize(value, default)
+          attrs
+        end
+
+        def build_payload_for_create(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:create)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          return payload if value.nil?
+
+          payload["prefs_#{remote_key}"] = serializer.serialize(value)
+          payload
+        end
+
+        def build_payload_for_update(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:update)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          payload["prefs/#{remote_key}"] = serializer.serialize(value)
+          payload
+        end
+
+      end
+    end
+  end
+end

data/lib/trello/schema/attribute/custom_field_display.rb

@@ -0,0 +1,45 @@
+module Trello
+  class Schema
+    module Attribute
+      class CustomFieldDisplay < Base
+
+        def build_attributes(params, attributes)
+          attrs = attributes.with_indifferent_access
+          params = params.with_indifferent_access
+
+          value = if params.key?(:display)
+                    params[:display][remote_key]
+                  else
+                    params[name]
+                  end
+
+          attrs[name] = serializer.deserialize(value, default)
+          attrs
+        end
+
+        def build_payload_for_create(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:create)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          return payload if value.nil?
+
+          payload["display_#{remote_key}"] = serializer.serialize(value)
+          payload
+        end
+
+        def build_payload_for_update(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:update)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          payload["display/#{remote_key}"] = serializer.serialize(value)
+          payload
+        end
+
+      end
+    end
+  end
+end

data/lib/trello/schema/attribute/default.rb

@@ -0,0 +1,45 @@
+module Trello
+  class Schema
+    module Attribute
+      class Default < Base
+
+        def build_attributes(params, attributes)
+          attrs = attributes.with_indifferent_access
+          params = params.with_indifferent_access
+
+          value = if params.key?(remote_key)
+                    params[remote_key]
+                  else
+                    params[name]
+                  end
+
+          attrs[name] = serializer.deserialize(value, default)
+          attrs
+        end
+
+        def build_payload_for_create(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:create)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          return payload if value.nil?
+
+          payload[remote_key] = serializer.serialize(value)
+          payload
+        end
+
+        def build_payload_for_update(attributes, payload)
+          payload ||= {}
+          return payload unless for_action?(:update)
+          return payload unless attributes.key?(name)
+
+          value = attributes[name]
+          payload[remote_key] = serializer.serialize(value)
+          payload
+        end
+
+      end
+    end
+  end
+end

data/lib/trello/schema/attribute_builder.rb

@@ -0,0 +1,42 @@
+module Trello
+  class Schema
+    class AttributeBuilder
+      class << self
+        def build(name, options = {})
+          new(name, options).build
+        end
+      end
+
+      attr_reader :name, :options
+
+      def initialize(name, options)
+        @name = name
+        @options = options
+      end
+
+      def build
+        attribute_class.new(
+          name: name,
+          options: options,
+          serializer: serializer
+        )
+      end
+
+      private
+
+      def attribute_class
+        class_name = options.delete(:class_name)
+        return Schema::Attribute::Default unless class_name
+
+        "Trello::Schema::Attribute::#{class_name}".constantize
+      end
+
+      def serializer
+        serializer_class_name = options.delete(:serializer)
+        return Schema::Serializer::Default unless serializer_class_name
+
+        "Trello::Schema::Serializer::#{serializer_class_name}".constantize
+      end
+    end
+  end
+end

data/lib/trello/schema/attribute_registration.rb

@@ -0,0 +1,47 @@
+module Trello
+  class Schema
+    class AttributeRegistration
+      class << self
+        def register(klass, attribute)
+          new(klass, attribute).register
+        end
+      end
+
+      attr_reader :klass, :attribute
+
+      def initialize(klass, attribute)
+        @klass = klass
+        @attribute = attribute
+      end
+
+      def register
+        define_getter
+        define_setter
+      end
+
+      private
+
+      def define_getter
+        attribute_name = attribute.name
+
+        klass.class_eval do
+          define_method(attribute_name) { @__attributes[attribute_name] }
+        end
+      end
+
+      def define_setter
+        return if attribute.readonly?
+
+        attribute_name = attribute.name
+
+        klass.class_eval do
+          define_method("#{attribute_name}=") do |value|
+            send("#{attribute_name}_will_change!") if value != @__attributes[attribute_name]
+            @__attributes[attribute_name] = value
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/trello/schema/serializer/default.rb

@@ -0,0 +1,17 @@
+module Trello
+  class Schema
+    module Serializer
+      class Default
+        class << self
+          def serialize(value)
+            value
+          end
+
+          def deserialize(value, default)
+            value == nil ? default : value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trello/schema/serializer/labels.rb

@@ -0,0 +1,23 @@
+module Trello
+  class Schema
+    module Serializer
+      class Labels
+        class << self
+          def serialize(labels)
+            labels.map(&:id)
+          end
+
+          def deserialize(labels, default)
+            return default unless labels
+
+            labels.map do |label|
+              next label if label.is_a?(Trello::Label)
+
+              Trello::Label.new(label)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trello/schema/serializer/time.rb

@@ -0,0 +1,25 @@
+module Trello
+  class Schema
+    module Serializer
+      class Time
+        class << self
+          def serialize(time)
+            return nil unless time.respond_to?(:iso8601)
+
+            time.strftime('%FT%T.%LZ')
+          end
+
+          def deserialize(time, default)
+            if time.is_a?(String)
+              ::Time.iso8601(time) rescue default
+            elsif time.respond_to?(:to_time)
+              time.to_time
+            else
+              default
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trello/schema/serializer/webhooks.rb

@@ -0,0 +1,25 @@
+module Trello
+  class Schema
+    module Serializer
+      class Webhooks
+        class << self
+          def serialize(webhooks)
+            webhooks ||= []
+
+            webhooks.map(&:id)
+          end
+
+          def deserialize(webhooks, default)
+            return default unless webhooks
+
+            webhooks.map do |webhook|
+              next webhook if webhook.is_a?(Trello::Webhook)
+
+              Trello::Webhook.new(webhook)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trello/token.rb

@@ -2,17 +2,30 @@ module Trello
 
   # @!attribute [r] id
   #   @return [String]
+  # @!attribute [r] identifier
+  #   @return [String]
   # @!attribute [r] member_id
   #   @return [String]
   # @!attribute [r] created_at
   #   @return [Datetime]
+  # @!attribute [r] expires_at
+  #   @return [Datetime]
   # @!attribute [r] permissions
   #   @return [Object]
   # @!attribute [r] webhooks
   #   @return [Object]
   class Token < BasicData
-    register_attributes :id, :member_id, :created_at, :permissions, :webhooks,
-      readonly: [ :id, :member_id, :created_at, :permissions, :webhooks ]
+
+    schema do
+      # Readonly
+      attribute :id, readonly: true, primary_key: true
+      attribute :identifier, readonly: true
+      attribute :member_id, readonly: true, remote_key: 'idMember'
+      attribute :created_at, readonly: true, remote_key: 'dateCreated', serializer: 'Time'
+      attribute :expires_at, readonly: true, remote_key: 'dateExpires', serializer: 'Time'
+      attribute :permissions, readonly: true
+      attribute :webhooks, readonly: true, default: [], serializer: 'Webhooks'
+    end
 
     class << self
       # Finds a token
@@ -21,16 +34,6 @@ module Trello
       end
     end
 
-    # :nodoc:
-    def update_fields(fields)
-      attributes[:id]          = fields['id'] || attributes[:id]
-      attributes[:member_id]   = fields['idMember'] || attributes[:member_id]
-      attributes[:created_at]  = Time.iso8601(fields['dateCreated']) rescue nil if fields.has_key?('dateCreated')
-      attributes[:permissions] = fields['permissions'] || attributes[:permissions]
-      attributes[:permissions] ||= {}
-      attributes[:webhooks]    = fields['webhooks'] || attributes[:webhooks]
-    end
-
     # Returns a reference to the user who authorized the token.
     one :member, path: :members, using: :member_id
   end