eventbrite_sdk 3.0.2

data/lib/eventbrite_sdk/resource/null_schema_definition.rb

@@ -0,0 +1,13 @@
+module EventbriteSDK
+  class Resource
+    class NullSchemaDefinition
+      def writeable?(_key)
+        true
+      end
+
+      def defined_keys
+        []
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/operations/attribute_schema.rb

@@ -0,0 +1,57 @@
+module EventbriteSDK
+  class Resource
+    module Operations
+      module AttributeSchema
+        module ClassMethods
+          attr_reader :prefix, :schema
+
+          def schema_definition(&block)
+            @schema = SchemaDefinition.new(name)
+            @schema.instance_eval(&block)
+          end
+
+          def attributes_prefix(prefix)
+            @prefix = prefix
+          end
+        end
+
+        module InstanceMethods
+          %i(changes changed?).each do |method|
+            define_method(method) { attrs.public_send(method) }
+          end
+
+          %i([] assign_attributes).each do |method|
+            define_method(method) { |arg| attrs.public_send(method, arg) }
+          end
+
+          def build_attrs(new_attrs)
+            @attrs = Attributes.new(
+              new_attrs, self.class.schema || NullSchemaDefinition.new
+            )
+          end
+
+          private
+
+          def method_missing(method_name, *_args, &_block)
+            if attrs.respond_to?(method_name)
+              attrs.public_send(method_name)
+            else
+              super
+            end
+          end
+
+          def respond_to_missing?(method_name, _include_private = false)
+            attrs.respond_to?(method_name) || super
+          end
+
+          attr_reader :attrs
+        end
+
+        def self.included(receiver)
+          receiver.extend ClassMethods
+          receiver.prepend InstanceMethods
+        end
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/operations/endpoint.rb

@@ -0,0 +1,101 @@
+module EventbriteSDK
+  class Resource
+    module Operations
+      module Endpoint
+        module ClassMethods
+          attr_reader :path, :path_opts
+
+          # Retrieve a resource.
+          #
+          # params: Hash of supported parameters. The keys and values are
+          #         used to build the request URL by substituting supported
+          #         keys in the resource_path with the value defined in params.
+          #
+          #         The :expand key allows the support of expansions of child
+          #         objects. It supports strings, symbols and arrays.
+          #
+          #         expand: :something
+          #         expand: %i(something another)
+          #         expand: %w(something another)
+          #         expand: 'something,another'
+          #
+          # Example:
+          #
+          # class Thing < Resource
+          #   resource_path('things/:id')
+          # end
+          #
+          # Thing.retrieve(id: 1234, expand: :others)
+          #
+          # This tells the resource to replace the :id placeholder with the
+          # value 1234. It also will pass the :expand option with the
+          def retrieve(params, request = EventbriteSDK)
+            url_path = params.reduce(@path) do |path, (key, value)|
+              path.gsub(":#{key}", value.to_s)
+            end
+
+            if params[:expand]
+              query = { expand: [*params[:expand]].join(',') }
+            end
+
+            new request.get(url: url_path, query: query)
+          end
+
+          # Define the url path for the resource. It also implicitly defines
+          # the primary key and any additional foreign keys required for this
+          # resource.
+          #
+          # Example:
+          #
+          # TicketClass is a resource that requires a primary key of id and a
+          # foreign key of event_id to be retrieved, modified or deleted.
+          #
+          # resource_path('events/:event_id/ticket_classes/:id')
+          #
+          # The resource now has #id and #event_id accessor methods, and
+          # requires those parameters to build the correct resource url path.
+          # See the retrieve method (above) for additional details.
+          def resource_path(path)
+            @path = path
+
+            path.scan(/:\w+/).each do |path_attr|
+              attr = path_attr.delete(':').to_sym
+
+              define_method(attr) do
+                @attrs[attr] if @attrs.respond_to?(attr)
+              end
+            end
+          end
+        end
+
+        module InstanceMethods
+          def path(postfixed_path = '')
+            resource_path = self.class.path.dup
+            tokens = resource_path.scan(/:\w+/)
+
+            full_path = tokens.reduce(resource_path) do |path_frag, token|
+              method = token.delete(':')
+              path_frag.gsub(token, send(method).to_s)
+            end
+
+            if postfixed_path.empty?
+              full_path
+            else
+              full_path += '/' unless full_path.end_with?('/')
+              "#{full_path}#{postfixed_path}"
+            end
+          end
+
+          def full_url(request = EventbriteSDK)
+            request.url path
+          end
+        end
+
+        def self.included(receiver)
+          receiver.extend ClassMethods
+          receiver.send(:include, InstanceMethods)
+        end
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/operations/list.rb

@@ -0,0 +1,15 @@
+module EventbriteSDK
+  class Resource
+    module Operations
+      module List
+        def list
+          ResourceList.new(
+            key: path.split('/').first,
+            object_class: EventbriteSDK.const_get(name.split('::').last),
+            url_base: new.path.gsub(/\/\Z/, '')
+          )
+        end
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/operations/relationships.rb

@@ -0,0 +1,120 @@
+module EventbriteSDK
+  class Resource
+    module Operations
+      # Adds +belongs_to+ and +has_many+
+      # relationship functionality to Resource instances
+      #
+      # Requires that included class responds_to:
+      # :resource_path
+      #   returns a path that will be given to the list_class on instantiation
+      #   must have an arity of 1
+      # :resource_class_from_string
+      #   Should constantize the string into the
+      #   class of the operating relationship
+      # :list_class
+      #   Should return the class responsible for handling many of a resource
+      module Relationships
+        module ClassMethods
+          # Builds a memoized single relationship to another Resource
+          # by dynamically defining a method on the instance
+          # with the given +rel_method+
+          # ============================================
+          #
+          # class Wheel
+          #   include Resource::Operations::Relationships
+          #
+          #   belongs_to :car, object_class: 'Car', mappings: { id: :car_id }
+          #
+          #   ...
+          # end
+          #
+          # Wheel.new('id' => 4,  'car_id' => 1).
+          #   car #=> EventbriteSDK::Car.retrieve('id' => 1)
+          #
+          # rel_method: Symbol of the method we are defining on this instance
+          #             e.g. belongs_to :thing => defines self#thing
+          # object_class: String representation of resource
+          #               e.g. 'Event' => EventbriteSDK::Event
+          #
+          def belongs_to(rel_method, object_class: nil)
+            define_method(rel_method) do
+              query = { id: public_send(:"#{rel_method}_id") }
+
+              relationships[rel_method] ||= begin
+                resource_class_from_string(object_class).retrieve(query)
+              end
+            end
+          end
+
+          # Builds a memoized ResourceList relationship, dynamically defining
+          # a method on the instance with the given +rel_method+
+          # ============================================
+          #
+          # class Car
+          #   include Resource::Operations::Relationships
+          #
+          #   has_many :wheels, object: 'Wheel', key: 'wheels'
+          #
+          #   def resource_path(postfix)
+          #     "my_path/1/#{postfix}"
+          #   end
+          #
+          #   ...
+          # end
+          #
+          # Car.new('id' => '1').wheels
+          #
+          # Would instantiate a new ResourceList
+          #
+          # ResourceList.new(
+          #   url_base: 'my_path/1/wheels',
+          #   object_class: Wheel,
+          #   key: :wheels
+          # )
+          #
+          # rel_method: Symbol of the method we are defining on this instance
+          # object_class: String representation of the Class we will give
+          #               to ResourceList
+          # key: key to use when ResourceList is extracting objects from
+          #      a list payload, if nil then rel_method is used as a default
+          #
+          def has_many(rel_method, object_class: nil, key: nil)
+            define_method(rel_method) do
+              key ||= rel_method
+
+              relationships[rel_method] ||= list_class(rel_method).new(
+                url_base: path(rel_method),
+                object_class: resource_class_from_string(object_class),
+                key: key
+              )
+            end
+          end
+        end
+
+        module InstanceMethods
+          def list_class(resource_list_rel)
+            class_name = resource_list_rel.to_s.split('_').map(&:capitalize).join
+            class_name = "#{class_name}List"
+
+            if Lists.const_defined?(class_name)
+              Lists.const_get(class_name)
+            else
+              ResourceList
+            end
+          end
+
+          private
+
+          def relationships
+            @_relationships ||= {}
+          end
+        end
+
+        def self.included(receiver)
+          receiver.extend ClassMethods
+          receiver.send(:include, InstanceMethods)
+        end
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource/schema_definition.rb

@@ -0,0 +1,50 @@
+module EventbriteSDK
+  class Resource
+    class SchemaDefinition
+      def initialize(resource_name)
+        @resource_name = resource_name
+        @read_only_keys = Set.new
+        @attrs = {}
+      end
+
+      %i(boolean currency datetime integer string).each do |method|
+        define_method(method) do |value, *opts|
+          options = opts.first
+
+          @read_only_keys << value if options && options[:read_only]
+          @attrs[value] = method
+        end
+      end
+
+      def writeable?(key)
+        whitelisted_attribute?(key) && !read_only?(key)
+      end
+
+      def type(key)
+        attrs[key]
+      end
+
+      def defined_keys
+        attrs.keys
+      end
+
+      private
+
+      attr_reader :read_only_keys, :resource_name, :attrs
+
+      def read_only?(key)
+        read_only_keys.member?(key)
+      end
+
+      def whitelisted_attribute?(key)
+        if attrs.has_key?(key)
+          true
+        else
+          raise InvalidAttribute.new(
+            "attribute `#{key}` not present in #{resource_name}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/eventbrite_sdk/resource_list.rb

@@ -0,0 +1,86 @@
+module EventbriteSDK
+  class ResourceList
+    extend Forwardable
+    include Enumerable
+
+    def_delegators :@objects, :[], :each, :empty?
+
+    def initialize(
+      url_base: nil,
+      object_class: nil,
+      key: nil,
+      query: {},
+      request: EventbriteSDK
+    )
+      @key = key
+      @object_class = object_class
+      @objects = []
+      @query = query
+      @request = request
+      @url_base = url_base
+    end
+
+    def retrieve
+      response = load_response
+
+      @objects = (response[key.to_s] || []).map { |raw| object_class.new(raw) }
+      @pagination = response['pagination']
+
+      self
+    end
+
+    def page(num)
+      pagination['page_number'] = num
+
+      retrieve
+    end
+
+    def next_page
+      pagination['page_number'] += 1 unless page_number >= (page_count || 1)
+
+      retrieve
+    end
+
+    def prev_page
+      pagination['page_number'] -= 1 unless page_number <= 1
+
+      retrieve
+    end
+
+    %w(object_count page_number page_size page_count).each do |method|
+      define_method(method) { pagination[method] }
+    end
+
+    def to_json(opts = {})
+      { key => objects.map(&:to_h), 'pagination' => @pagination }.to_json(opts)
+    end
+
+    def with_expansion(*args)
+      if args.first
+        @query[:expand] = args.join(',')
+      else
+        @query.delete(:expand)
+      end
+
+      self
+    end
+
+    private
+
+    def pagination
+      @pagination ||= { 'page_count' => 1, 'page_number' => 1 }
+    end
+
+    def load_response
+      request.get(url: url_base, query: query.merge(page: page_number))
+    end
+
+    attr_reader :expansion,
+                :key,
+                :object_class,
+                :objects,
+                :query,
+                :request,
+                :url_base
+  end
+end