userlist 0.2.2 → 0.6.0

data/lib/userlist/push/client.rb

@@ -10,10 +10,25 @@ module Userlist
 
       def initialize(config = {})
         @config = Userlist.config.merge(config)
+
+        raise Userlist::ConfigurationError, :push_key unless @config.push_key
+        raise Userlist::ConfigurationError, :push_endpoint unless @config.push_endpoint
+      end
+
+      def get(endpoint)
+        request(Net::HTTP::Get, endpoint)
+      end
+
+      def post(endpoint, payload = nil)
+        request(Net::HTTP::Post, endpoint, payload)
+      end
+
+      def put(endpoint, payload = nil)
+        request(Net::HTTP::Put, endpoint, payload)
       end
 
-      def post(endpoint, payload = {})
-        request(endpoint, payload)
+      def delete(endpoint)
+        request(Net::HTTP::Delete, endpoint)
       end
 
     private
@@ -33,12 +48,12 @@ module Userlist
         end
       end
 
-      def request(path, payload = {})
-        request = Net::HTTP::Post.new(path)
+      def request(method, path, payload = nil)
+        request = method.new(path)
         request['Accept'] = 'application/json'
         request['Authorization'] = "Push #{token}"
         request['Content-Type'] = 'application/json; charset=UTF-8'
-        request.body = JSON.dump(payload)
+        request.body = JSON.generate(payload) if payload
 
         logger.debug "Sending #{request.method} to #{URI.join(endpoint, request.path)} with body #{request.body}"
 

data/lib/userlist/push/company.rb

@@ -0,0 +1,23 @@
+module Userlist
+  class Push
+    class Company < Resource
+      include Operations::Create
+      include Operations::Delete
+
+      def self.endpoint
+        '/companies'
+      end
+
+      has_many :relationships, type: 'Userlist::Push::Relationship', inverse: :company
+      has_many :users, type: 'Userlist::Push::User'
+      has_one  :user, type: 'Userlist::Push::User'
+
+      def initialize(payload = {}, config = Userlist.config)
+        raise Userlist::ArgumentError, 'Missing required payload hash' unless payload
+        raise Userlist::ArgumentError, 'Missing required parameter :identifier' unless payload[:identifier]
+
+        super
+      end
+    end
+  end
+end

data/lib/userlist/push/event.rb

@@ -0,0 +1,26 @@
+module Userlist
+  class Push
+    class Event < Resource
+      include Operations::Create
+
+      has_one :user, type: 'Userlist::Push::User'
+      has_one :company, type: 'Userlist::Push::Company'
+
+      def initialize(payload = {}, config = Userlist.config)
+        raise Userlist::ArgumentError, 'Missing required payload' unless payload
+        raise Userlist::ArgumentError, 'Missing required parameter :name' unless payload[:name]
+        raise Userlist::ArgumentError, 'Missing required parameter :user or :company' unless payload[:user] || payload[:company]
+
+        super
+      end
+
+      def occured_at
+        payload[:occured_at] || Time.now
+      end
+
+      def push?
+        (user.nil? || user.push?) && (company.nil? || company.push?)
+      end
+    end
+  end
+end

data/lib/userlist/push/operations/create.rb

@@ -0,0 +1,25 @@
+module Userlist
+  class Push
+    module Operations
+      module Create
+        module ClassMethods
+          def create(payload = {}, config = self.config)
+            return false unless resource = from_payload(payload, config)
+
+            strategy.call(:post, endpoint, resource) if resource.create?
+          end
+
+          alias push create
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        def create?
+          push?
+        end
+      end
+    end
+  end
+end

data/lib/userlist/push/operations/delete.rb

@@ -0,0 +1,23 @@
+module Userlist
+  class Push
+    module Operations
+      module Delete
+        module ClassMethods
+          def delete(payload = {}, config = self.config)
+            return false unless resource = from_payload(payload, config)
+
+            strategy.call(:delete, resource.url) if resource.delete?
+          end
+        end
+
+        def self.included(base)
+          base.extend(ClassMethods)
+        end
+
+        def delete?
+          true
+        end
+      end
+    end
+  end
+end

data/lib/userlist/push/relation.rb

@@ -0,0 +1,30 @@
+module Userlist
+  class Push
+    class Relation
+      def initialize(scope, type, operations = [])
+        @scope = scope
+        @type = type
+
+        operations.each { |operation| singleton_class.send(:include, operation::ClassMethods) }
+      end
+
+      attr_reader :scope, :type
+
+      def from_payload(payload, config = self.config)
+        type.from_payload(payload, config)
+      end
+
+      def endpoint
+        type.endpoint
+      end
+
+      def strategy
+        scope.strategy
+      end
+
+      def config
+        scope.config
+      end
+    end
+  end
+end

data/lib/userlist/push/relationship.rb

@@ -0,0 +1,30 @@
+module Userlist
+  class Push
+    class Relationship < Resource
+      include Operations::Create
+      include Operations::Delete
+
+      has_one :user, type: 'Userlist::Push::User'
+      has_one :company, type: 'Userlist::Push::Company'
+
+      def initialize(payload = {}, config = Userlist.config)
+        raise Userlist::ArgumentError, 'Missing required payload' unless payload
+        raise Userlist::ArgumentError, 'Missing required parameter :user' unless payload[:user]
+        raise Userlist::ArgumentError, 'Missing required parameter :company' unless payload[:company]
+
+        super
+      end
+
+      def url
+        raise Userlist::Error, "Cannot generate url for #{self.class.name} without a user" unless user
+        raise Userlist::Error, "Cannot generate url for #{self.class.name} without a company" unless company
+
+        "#{self.class.endpoint}/#{user.identifier}/#{company.identifier}"
+      end
+
+      def push?
+        user&.push? && company&.push?
+      end
+    end
+  end
+end

data/lib/userlist/push/resource.rb

@@ -0,0 +1,125 @@
+module Userlist
+  class Push
+    class Resource
+      class << self
+        def resource_name
+          name.split('::')[-1]
+        end
+
+        def endpoint
+          "/#{resource_name.downcase}s"
+        end
+
+        def from_payload(payload, config = Userlist.config)
+          return payload if payload.nil?
+          return payload if payload.is_a?(self)
+
+          payload = { identifier: payload } if payload.is_a?(String) || payload.is_a?(Numeric)
+
+          new(payload, config)
+        end
+
+        def relationship_names
+          @relationship_names ||= relationships.keys
+        end
+
+        def relationships
+          @relationships ||= {}
+        end
+
+      protected
+
+        def has_one(name, type:) # rubocop:disable Naming/PredicateName
+          relationships[name.to_sym] = { type: type }
+
+          generated_methods.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              #{type}.from_payload(payload[:#{name}], config)
+            end
+          RUBY
+        end
+
+        def has_many(name, **options) # rubocop:disable Naming/PredicateName
+          relationships[name.to_sym] = options
+
+          generated_methods.class_eval <<-RUBY, __FILE__, __LINE__ + 1
+            def #{name}
+              relationship = self.class.relationships[:#{name}]
+
+              ResourceCollection.new(payload[:#{name}], relationship, self, config)
+            end
+          RUBY
+        end
+
+      private
+
+        def generated_methods
+          @generated_methods ||= Module.new.tap { |mod| include mod }
+        end
+      end
+
+      attr_reader :payload, :config
+
+      def initialize(payload = {}, config = Userlist.config)
+        @payload = payload
+        @config = config
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        attribute = method.to_s.sub(/=$/, '')
+        payload.key?(attribute.to_sym) || super
+      end
+
+      def to_hash
+        Serializer.serialize(self)
+      end
+      alias to_h to_hash
+
+      def to_json(*args)
+        to_hash.to_json(*args)
+      end
+
+      def url
+        "#{self.class.endpoint}/#{identifier}"
+      end
+
+      def identifier
+        payload[:identifier]
+      end
+
+      def hash
+        self.class.hash & payload.hash
+      end
+
+      def eql?(other)
+        hash == other.hash
+      end
+      alias == eql?
+
+      def attribute_names
+        payload.keys.map(&:to_sym) - relationship_names
+      end
+
+      def relationship_names
+        self.class.relationship_names.to_a
+      end
+
+      def push?
+        true
+      end
+
+    private
+
+      def method_missing(method, *args, &block)
+        if method.to_s =~ /=$/
+          attribute = method.to_s.sub(/=$/, '')
+          payload[attribute.to_sym] = args.first
+        elsif payload.key?(method.to_sym)
+          payload[method.to_sym]
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/userlist/push/resource_collection.rb

@@ -0,0 +1,32 @@
+module Userlist
+  class Push
+    class ResourceCollection
+      include Enumerable
+
+      attr_reader :collection, :relationship, :owner, :config
+
+      def initialize(collection, relationship, owner, config = Userlist.config)
+        @collection = Array(collection)
+        @relationship = relationship
+        @owner = owner
+        @config = config
+      end
+
+      def each
+        collection.each do |resource|
+          resource[inverse] = owner if inverse && resource.is_a?(Hash)
+
+          yield type.from_payload(resource, config)
+        end
+      end
+
+      def type
+        Object.const_get(relationship[:type])
+      end
+
+      def inverse
+        relationship[:inverse]
+      end
+    end
+  end
+end

data/lib/userlist/push/serializer.rb

@@ -0,0 +1,66 @@
+require 'set'
+
+module Userlist
+  class Push
+    class Serializer
+      def self.serialize(resource)
+        new.serialize(resource)
+      end
+
+      def serialize(resource)
+        resource = serialize_resource(resource) if resource.is_a?(Userlist::Push::Resource)
+        resource
+      end
+
+    private
+
+      def serialize_resource(resource)
+        return resource.identifier if serialized_resources.include?(resource)
+
+        serialized_resources << resource
+
+        return unless resource.push?
+
+        serialized = {}
+
+        resource.attribute_names.each do |name|
+          serialized[name] = resource.send(name)
+        end
+
+        resource.relationship_names.each do |name|
+          next unless result = serialize_relationship(resource.send(name))
+
+          serialized[name] = result
+        end
+
+        serialized
+      end
+
+      def serialize_relationship(relationship)
+        return unless relationship
+
+        case relationship
+        when Userlist::Push::ResourceCollection
+          serialize_collection(relationship)
+        when Userlist::Push::Resource
+          serialize_resource(relationship)
+        else
+          raise "Cannot serialize relationship type: #{relationship.class}"
+        end
+      end
+
+      def serialize_collection(collection)
+        serialized = collection
+          .map(&method(:serialize_relationship))
+          .compact
+          .reject(&:empty?)
+
+        serialized unless serialized.empty?
+      end
+
+      def serialized_resources
+        @serialized_resources ||= Set.new
+      end
+    end
+  end
+end

data/lib/userlist/push/strategies.rb

@@ -1,17 +1,31 @@
-require 'userlist/push/strategies/null'
-require 'userlist/push/strategies/direct'
-require 'userlist/push/strategies/threaded'
-
 module Userlist
   class Push
     module Strategies
       def self.strategy_for(strategy, config = {})
-        strategy = Userlist::Push::Strategies.const_get(strategy.to_s.capitalize) if strategy.is_a?(Symbol) || strategy.is_a?(String)
-
+        strategy = lookup_strategy(strategy)
         strategy = strategy.new(config) if strategy.respond_to?(:new)
 
         strategy
       end
+
+      def self.lookup_strategy(strategy)
+        return strategy unless strategy.is_a?(Symbol) || strategy.is_a?(String)
+
+        require_strategy(strategy)
+        const_get(strategy.to_s.capitalize, false)
+      end
+
+      def self.strategy_defined?(strategy)
+        return true unless strategy.is_a?(Symbol) || strategy.is_a?(String)
+
+        const_defined?(strategy.to_s.capitalize, false)
+      end
+
+      def self.require_strategy(strategy)
+        return unless strategy.is_a?(Symbol) || strategy.is_a?(String)
+
+        require("userlist/push/strategies/#{strategy}") unless strategy_defined?(strategy)
+      end
     end
   end
 end