ubiquitously 0.0.1.6 → 0.1.0

data/lib/ubiquitously/models/post.rb

@@ -0,0 +1,66 @@
+module Ubiquitously
+  class Post < Base
+    attr_accessor :url, :title, :description, :tags, :categories, :user, :page, :posts, :format, :extension
+    
+    def initialize(attributes = {})
+      apply attributes
+      raise 'please pass Post a User' if self.user.blank?
+      self.posts ||= []
+    end
+    
+    def page
+      @page ||= Ubiquitously::Page.new(:url => self.url).parse
+    end
+    
+    # create or update
+    def save(*services)
+      options = services.extract_options!
+      postables(*services).map { |post| post.save }
+    end
+    
+    def new_record?(service, &block)
+      postables(*service).detect do |post|
+        post.new_record?
+      end
+    end
+    
+    def postables(*services)
+      services = services.flatten.map(&:to_sym)
+      result = services.map do |service|
+        if service.is_a?(Ubiquitously::Service::Post)
+          service
+        else
+          "Ubiquitously::#{service.to_s.camelize}::Post".constantize.new(
+            :user => self.user,
+            :url => self.url,
+            :title => self.title,
+            :description => self.description,
+            :tags => self.tags,
+            :categories => self.categories,
+            :format => self.format,
+            :extension => self.extension
+          )
+        end
+      end.uniq
+      
+      self.posts = self.posts.concat(result)
+      
+      self.posts.select { |post| services.include?(post.service.to_sym) }
+    end
+    
+    Ubiquitously.services.each do |service|
+      define_method service do
+        postables(service).first
+      end
+      
+      define_method "#{service.to_s}?" do
+        !send(service).new_record?
+      end
+    end
+    
+    def inspect
+      "#<#{self.class.inspect} @url=#{self.url.inspect} @title=#{self.title.inspect} @description=#{self.description.inspect} @tags=#{self.tags.inspect}>"
+    end
+    
+  end
+end

data/lib/ubiquitously/models/service.rb

@@ -0,0 +1 @@
+Dir["#{File.dirname(__FILE__)}/service/*"].each { |c| require c unless File.directory?(c) }

data/lib/ubiquitously/models/service/account.rb

@@ -0,0 +1,57 @@
+Dir["#{File.dirname(__FILE__)}/account/*"].each { |c| require c unless File.directory?(c) }
+
+module Ubiquitously
+  module Service
+    class Account < Ubiquitously::Base
+      include Ubiquitously::Account::Restful
+      include Ubiquitously::Account::Loggable
+      include Ubiquitously::Account::Authorizable
+      
+      attr_accessor :username, :password, :credentials
+      attr_accessor :logged_in, :ip, :user
+      
+      def initialize(attributes = {})
+        attributes = attributes.symbolize_keys
+        
+        attributes[:username] = Ubiquitously.key("#{service}.key") if attributes[:username].blank?
+        attributes[:password] = Ubiquitously.key("#{service}.secret") if attributes[:password].blank?
+        
+        if attributes[:username].blank? || attributes[:password].blank?
+          raise "Where is the username and password for #{service}?"
+        end
+        
+        @logged_in = false
+        
+        apply attributes
+      end
+      
+      def credentials
+        @credentials ||= {}
+      end
+      
+      def agent
+        user.agent
+      end
+      
+      def cookies?
+        user.cookies_for?(service)
+      end
+      
+      def credentials?
+        !self.credentials.blank?
+      end
+      
+      def access_token
+        if uses?(:oauth) && @access_token.blank?
+          @access_token = "#{service.camelize}Token".constantize.new
+          @access_token.token = credentials["token"]
+          @access_token.secret = credentials["secret"]
+          @access_token.key = credentials["key"]
+        end
+        
+        @access_token
+      end
+      
+    end
+  end
+end

data/lib/ubiquitously/models/service/account/authorizable.rb

@@ -0,0 +1,58 @@
+module Ubiquitously
+  module Account
+    module Authorizable
+      def self.included(base)
+        base.extend ClassMethods
+        base.validates_presence_of :username, :password
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def uses(*protocols)
+          @uses = protocols.flatten.map(&:to_s) unless protocols.blank?
+          @uses ||= []
+          @uses
+        end
+        
+        def uses?(protocol)
+          uses.include?(protocol.to_s)
+        end
+      end
+      
+      module InstanceMethods
+        def authorize!(condition)
+          authorize(condition)
+          
+          unless logged_in?
+            raise AuthenticationError.new("Invalid username or password for #{service.titleize}")
+          end
+          
+          logged_in?
+        end
+        
+        def authorize(condition)
+          @logged_in = !!condition
+        end
+        
+        def logged_in?
+          @logged_in == true
+        end
+        
+        def uses?(protocol)
+          self.class.uses?(protocol)
+        end
+        
+        def requires_credentials?
+          uses?(:oauth)
+        end
+        
+        def authorized?
+          return true if logged_in?
+          return (credentials? && cookies?) if requires_credentials?
+          return cookies?
+        end
+        
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/account/loggable.rb

@@ -0,0 +1,50 @@
+module Ubiquitously
+  module Account
+    module Loggable
+      def self.included(base)
+        base.extend ClassMethods
+        base.loggable
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+        def loggable
+          before_login do
+            if authorized?
+              @logged_in = true 
+              return false
+            end
+            logger.info "[login:before] #{inspect}"
+          end
+          
+          after_login do
+            user.save
+            logger.info "[login:after] #{inspect}"
+          end
+        end
+        
+        def service
+          name.split("::")[1].underscore.gsub(/\s+/, "_")
+        end
+        
+        def logger
+          Ubiquitously.logger
+        end
+      end
+      
+      module InstanceMethods
+        def logger
+          self.class.logger
+        end
+        
+        def service
+          self.class.service
+        end
+        
+        def inspect
+          "#<#{self.class.inspect} @username=#{username.inspect} @password=#{password.gsub(/./, "*").inspect} @service=#{service.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/account/restful.rb

@@ -0,0 +1,21 @@
+module Ubiquitously
+  module Account
+    module Restful
+      def self.included(base)
+        base.extend ClassMethods
+        base.restful
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+        def restful
+          subclassable_callbacks :login
+        end
+      end
+      
+      module InstanceMethods
+        
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/post.rb

@@ -0,0 +1,59 @@
+Dir["#{File.dirname(__FILE__)}/post/*"].each { |c| require c unless File.directory?(c) }
+
+module Ubiquitously
+  module Service
+    class Post < Ubiquitously::Base
+      include Ubiquitously::Ownable::Post
+      include Ubiquitously::Postable::Post
+      include Ubiquitously::Restful::Post
+      include Ubiquitously::Loggable::Post
+      
+      #validates_presence_of :title, :description, :tags
+      attr_accessor :token
+      attr_accessor :title, :url, :description, :tags, :categories, :remote, :service_id
+      # some sites check to see if you're posting duplicate content!
+      # perhaps "vote" can mean "favorite" also
+      attr_accessor :image, :rating, :privacy, :vote, :status, :must_be_unique, :captcha
+      attr_accessor :service_url, :user, :upvotes, :downvotes
+      # the application that automates! ("Posted by TweetMeme")
+      attr_accessor :source, :source_url
+      # kind == regular, link, quote, photo, conversation, video, audio, answer
+      attr_accessor :kind
+      # plain, html, markdown
+      attr_accessor :format, :extension
+      # max 55 chars, for custom url if possible
+      attr_accessor :slug
+      # published, draft, submission, queue
+      attr_accessor :state
+      
+      before_create { self.token = tokenize }
+      before_update { self.token = tokenize }
+      after_create { self.token = nil }
+      after_update { self.token = nil }
+      
+      def initialize(attributes = {})
+        apply attributes
+        
+        raise 'please give me a user' if self.user.blank?
+        
+        self.format ||= "text"
+        self.privacy = 0 if self.privacy.nil?
+        self.categories ||= []
+        self.tags ||= []
+        self.upvotes ||= 0
+        self.downvotes ||= 0
+        
+        # for httparty
+        @auth = {:username => username, :password => password}
+      end
+      
+      def remote
+        @remote ||= self.class.find(:url => self.url, :user => self.user)
+      end
+      
+      def access_token
+        user.account_for(self).access_token
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/post/loggable.rb

@@ -0,0 +1,64 @@
+module Ubiquitously
+  module Loggable
+    module Post
+      def self.included(base)
+        base.extend ClassMethods
+        base.loggable
+        base.send :include, InstanceMethods
+      end
+      
+      module ClassMethods
+        def logger
+          Ubiquitously.logger
+        end
+        
+        def loggable
+          before_create do
+            unless valid?
+              logger.info "[invalid] #{errors.full_messages}"
+              return false
+            end
+            authorize
+            return false unless new_record?
+            logger.info "[create:before] #{tokenize.inspect}"
+          end
+          
+          after_create do
+            logger.info "[create:after] #{tokenize.inspect}"
+          end
+          
+          before_update do
+            unless valid?
+              logger.info "[invalid] #{errors.full_messages}"
+              return false
+            end
+            authorize
+            logger.info "[update:before] #{tokenize.inspect}"
+          end
+          
+          after_update do
+            logger.info "[update:after] #{tokenize.inspect}"
+          end
+        end
+        
+        def service
+          to_s.split("::")[1].underscore.gsub(/\s+/, "_").downcase
+        end
+      end
+      
+      module InstanceMethods
+        def service
+          self.class.service
+        end
+        
+        def logger
+          self.class.logger
+        end
+        
+        def inspect
+          "#<#{self.class.inspect} @url=#{self.url.inspect} @title=#{self.title.inspect} @tags=#{self.tags.inspect} @categories=#{self.categories.inspect}>"
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/post/ownable.rb

@@ -0,0 +1,31 @@
+module Ubiquitously
+  module Ownable
+    module Post
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+      end
+      
+      module InstanceMethods
+        def agent
+          user.agent
+        end
+        
+        def username
+          user.username_for(self)
+        end
+        
+        def password
+          user.password_for(self)
+        end
+        
+        def authorize
+          user.login(service)
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/models/service/post/postable.rb

@@ -0,0 +1,73 @@
+module Ubiquitously
+  module Postable
+    module Post
+      def self.included(base)
+        base.extend ClassMethods
+        base.send :include, InstanceMethods
+      end
+    
+      module ClassMethods
+        
+        def submit_to(url = nil)
+          @submit_to = url if url
+          @submit_to
+        end
+
+        def submit_url(post)
+          post.tokenize.inject(submit_to) do |result, token|
+            result.gsub(/:#{token.first}/, token.last)
+          end
+        end
+      
+        # with and without trailing slash, in case we saved it as one over the other
+        def url_permutations(url)
+          url, params = url.split("?")
+          # without_trailing_slash, with www
+          a = url.gsub(/\/$/, "").gsub(/http(s)?:\/\/([^\/]+)/) do |match|
+            protocol = "http#{$1.to_s}"
+            domain = $2
+            domain = "www.#{domain}" if domain.split(".").length < 3 # www.google.com == 3, google.com == 2
+            "#{protocol}://#{domain}"
+          end
+          # with_trailing_slash, with www
+          b = "#{a}/"
+          # without_trailing_slash, without www
+          c = a.gsub(/http(s)?:\/\/www\./, "http#{$1.to_s}://")
+          # with_trailing_slash, without www
+          d = "#{c}/"
+        
+          [a, b, c, d].map { |url| "#{url}?#{params}".gsub(/\?$/, "") }
+        end
+        
+      end
+    
+      module InstanceMethods
+        def tokenize
+          {
+            :url => self.url,
+            :title => self.title,
+            :description => self.description,
+            :tags => self.tags.map { |tag| tag.downcase.gsub(/[^a-z0-9\.]/, " ").squeeze(" ") }.join(", "),
+            :categories => self.categories.map { |tag| tag.downcase.gsub(/[^a-z0-9\.]/, " ").squeeze(" ") }
+          }
+        end
+      
+        def private?
+          privacy == 1 || privacy == "1" || privacy == "private"
+        end
+      
+        def public?
+          privacy == 0 || privacy == "0" || privacy == "public"
+        end
+      
+        def url_permutations(url)
+          self.class.url_permutations(url)
+        end
+      
+        def submit_url
+          self.class.submit_url(self)
+        end
+      end
+    end
+  end
+end