ubiquitously 0.0.1.6 → 0.1.0

data/README.markdown

@@ -14,37 +14,242 @@ Fill out `test/config.yml` with your credentials for the different services, the
 
     rake test
     
-### Register for the services you haven't already
-
-First edit the config file with a username, password, and other fields that all the systems might have.  Then run this
-
-    rake ubiquitously:me
-    
 ### Automatically Post to Services
 
     require 'rubygems'
     require 'ubiquitously'
     
-    # dzone
-    Ubiquitously::Dzone::Post.create(
-      :title => "A Dzone Post!",
-      :description => "Dzone does not let you edit or delete posts once you submit them, so be careful!",
-      :tags => ["dzone", "web 2.0"]
+    user = Ubiquitously::User.new(
+      :username => "viatropos",
+      :name => "Lance Pollard",
+      :email => "lancejpollard@gmail.com",
+      :cookies_path => "_cookies.yml"
+    )
+    post = Ubiquitously::Post.new(
+      :url          => "http://postable.com",
+      :title        => "An Interesting Post!",
+      :description  => "This is one of those rare things on the web...",
+      :tags         => ["writing", "programming", "javascript", "html", "ruby on rails"],
+      :user         => user
     )
+    post.save("stumbleupon", "delicious", "dzone", "digg", "diigo", "reddit", "tumblr", "mixx")
+
+## Command-line
+
+You can post to any of these services (even via oauth) completely from the command line.
+
+    u.me post twitter "Check out xyz!"
+
+The anatomy of a command is this:
+
+    u.me post [services] [title] [options]
+
+The `[services]` are a list of services you want this command to post to, and the `[title]` is whatever follows (in single/double quotes).  The following will post to Twitter, Tumblr, and Posterous:
+
+    u.me post twitter tumblr posterous "Managing multiple interfaces"
     
+You can get more precise by specifying options:
+
+- `-l`: label, aka the Post "title"
+- `-d`: description
+- `-u`: url
+- `-t`: tags (`comma,separated,without,any-spaces`)
+- `-U`: username for the service
+- `-P`: password for the service
+
+So you can write a command like this:
+
+    u.me post digg "Oauth on the Command line!?" -d "You can now use Oauth from the command line" -t "oauth, ruby, unix" -u "http://ubiquitously.me"
+
+Ubiquitously will save your login data (cookies, secrets, tokens, and params) in `~/.u.me`.  You can open those files and edit them (add passwords, app keys, etc.) with these commands:
+
+    u.me cookies
+    u.me secrets
+    u.me tokens
+    u.me params
+
+## How it thinks
+
+It treats everything as a `Post`.  A post has these properties:
+
+- `title`: Name of the post/file/content
+- `url`: Url to the post
+- `description`: Description/summary/comment for the post.  Ranges from 50-1000 characters.  Most services only allow plain, but some (code snippets, and tumblr) allow html or code.
+- `tags`: Array of lowercased tags.  Formats tags how services want them (e.g. comma separated vs. dashed).  Applies tag limits if necessary.  These are user-defined.
+- `categories`: Category for the post.  Most services allow 1 category, some up to 4.  These are specific to the service.
+- `vote`: Vote for the post, either "up", "down", or "none" (or 1, 0, -1).  Only if applicable to the service.
+- `rating`: Rating for the post, 1-5, if applicable.
+- `privacy`: Whether the service is public or private (0 || "public", 1 || "private")
+- `state`: Status of the post, either "published", "draft", "submitted", or "queued".
+- `kind`: The type of post, either post, link, quote, comment, image, video, audio, or answer.
+- `format`: The format of your post content, either "plain", "html", "markdown", "textile", or any code (ruby, c, php, etc.).
+- `service`: This is generated from the class, e.g. "digg".
+- `service_url`: The url the service provides to the post.
+
+Each service requires different things, which are determined by the `validates_presence_of` declaration for each class.  Conceptually, you can divide the services into these categories:
+
+1. Microblogging (twitter, yahoo meme, google buzz, identica)
+2. Tumblelogging (tumblr, posterous)
+3. Blogging (large posts)
+4. Bookmarking (delicious, diigo, mixx, newsvine, reddit, digg...)
+5. Code Sharing (gist, snipplr, dzone snippets, snipt, flikode, smipple)
+
 ## How it works
 
-Everything is built around [Mechanize](http://mechanize.rubyforge.org/mechanize/GUIDE_rdoc.html) and [Nokogiri](http://nokogiri.org/tutorials/parsing_an_html_xml_document.html), both led by [Aaron Patterson](http://tenderlovemaking.com/).
+Everything is built around [Mechanize](http://mechanize.rubyforge.org/mechanize/GUIDE_rdoc.html) and [Nokogiri](http://nokogiri.org/tutorials/parsing_an_html_xml_document.html), both led by [Aaron Patterson](http://tenderlovemaking.com/) (watch [Yehuda's "How to do the Impossible video"](http://www.youtube.com/watch?v=mo-lMdQMsdw)).
 
 Many social bookmarking services do not have API's in order to prevent spammers from ruining their system.  But what about for those of us that actually create content several times a day and want automation?  We're out of luck.
 
 So Ubiquitously creates a simple, RESTful API around some services I need to publish to now, and hopefully it will grow as you guys need more.  The goal is to be semi-low-level and not to provide a full featured api to a service, as some services already have very well-done API's in Ruby.
 
-## Other Possible Services (and Resources)
+## Why
+
+Currently there's plenty of services to post about yourself: ping.fm, onlywire, posterous...  But what if you want to do the same for other people?  You're left having to go to the page and click one of their social buttons, and filling out the form.  No way I'm filling out more than one for a page.  This solves that problem, making it so you can post someone else's site to a million places just like yours, helping you build a community.
+
+## What you should be doing...
+
+### Posting in Forums
+
+- Comment in the forums
+
+### Adding to Article Directories
+
+- Delicious
+
+### Guest Posting
+
+- Envato
+
+### Publishing Documents
+
+- Scribd
+
+### Contributing Code
+
+- snippets, github
+
+### Sharing and Tagging
+
+- Share others' content to stumbleupon, delicious, digg, diigo, reddit, tumblr, twitter, mixx, and identica.
+- Tag other's posts on stumbleupon, delicious, digg, diigo, and reddit.
+- Stumble other peoples posts that link to you.  You'll benefit them and yourself.
+- Write 2-3 sentences to describe each thing you post.  So if you can share 10 things a day, that's 20-30 sentences.
+
+### Commenting on Blogs
+
+- Comment on other people's blogs
+
+## What you should _not_ be doing...
+
+### Self Promoting
+
+- Only posting your content, you will get banned from the sites.
+
+### Spamming
+
+- Posting just the default description to all the sites
+- Posting too much
+
+## Tips and Resources
+
+- [http://www.highrevenue.com/free-website-traffic/critique-of-50-top-ways-to-drive-traffic-to-your-site](http://www.highrevenue.com/free-website-traffic/critique-of-50-top-ways-to-drive-traffic-to-your-site)
+- [http://www.highrevenue.com/linkbuilding-techniques/make-link-building-the-cornerstone-of-you-daily-activities](http://www.highrevenue.com/linkbuilding-techniques/make-link-building-the-cornerstone-of-you-daily-activities)
+- [http://hubpages.com/hub/viatropos](http://hubpages.com/hub/viatropos)
+- [http://www.mybloglog.com/](http://www.mybloglog.com/)
+- [http://www.doshdosh.com/a-comprehensive-guide-to-stumbleupon-how-to-build-massive-traffic-to-your-website-and-monetize-it/](http://www.doshdosh.com/a-comprehensive-guide-to-stumbleupon-how-to-build-massive-traffic-to-your-website-and-monetize-it/)
+- [http://www.thedesigncubicle.com/2009/12/websites-to-submit-your-design-articles-that-produce-heavy-traffic/](http://www.thedesigncubicle.com/2009/12/websites-to-submit-your-design-articles-that-produce-heavy-traffic/)
+- [http://www.warriorforum.com/](http://www.warriorforum.com/)
+- [http://lifehacker.com/5509815/how-to-declutter-and-streamline-your-google-reader-inbox](http://lifehacker.com/5509815/how-to-declutter-and-streamline-your-google-reader-inbox)
+- [http://www.netvibes.com/](http://www.netvibes.com/)
+- [http://www.noodlesoft.com/hazel.php](http://www.noodlesoft.com/hazel.php)
+- [http://www.webdesignerdepot.com/2010/07/30-places-to-submit-your-website-designs/](http://www.webdesignerdepot.com/2010/07/30-places-to-submit-your-website-designs/)
+- [http://knowem.com/](http://knowem.com/)
+- [hriscredendino.com/](hriscredendino.com/)
+- [http://www.networkworld.com/news/2010/080210-social-media-sucks-up-23.html](http://www.networkworld.com/news/2010/080210-social-media-sucks-up-23.html)
+- [http://opensource.newscloud.com](http://opensource.newscloud.com)
+- [http://www.doshdosh.com/list-of-social-media-news-websites/](http://www.doshdosh.com/list-of-social-media-news-websites/)
+- [http://popurls.com/](http://popurls.com/)
+- [http://www.webdesignerdepot.com/2010/07/30-places-to-submit-your-website-designs/](http://www.webdesignerdepot.com/2010/07/30-places-to-submit-your-website-designs/)
+- [http://www.shareaholic.com/](http://www.shareaholic.com/)
+
+> Linkbuilding is not a sprint... it is a MARATHON!
+
+1. Get a bunch of feeds
+2. Read the feeds
+3. Share the feeds
+
+## Todo
+
+- find most appropriate tags for each service
+- slideshare
+- if submission already exists (digg, dzone, reddit...), then make description a comment and digg it.
+- validations for each service (description wordcount, num tags, categories, title)
+- who can post (is it for just me or for other people)?
+- programmers_heaven, meta_filter, propeller, sharebrain, shoutwire, sphinn, stumpedia, web_blend, who_freelance, youblr, zabox
+- Find image on page for display
+- logging at stages in the process
+- addthis-like javascript bookmarking tool
+- flow:
+  - content type: video, image, post, status
+  - edit
+  - sumbit
+- each needs to check to see if post already exists
+- handle categories in a generic way
+- handle captchas
+- if this is actually useful, maybe creating accounts programmatically
+- optimize login, i could probably skip the entire "parse form" section and just do a raw post.
+- I don't want to support _every_ service because most of them are spammy or are not used much lately.  Let's keep it clean here.  Some services are also invite only and are in very very specific niches outside my realm.  If you would like to support them, feel free to fork and customize.
+
+<cite>copyright @viatropos 2010</cite>
+
+## Future additions
+
+- http://www.noupe.com/
+- mashable
+- smashing-magazine
+- tripwire
+- http://www.instantshift.com/user-submitted-news/
+- http://designm.ag/submit-news/
+- http://speckyboy.com/designnews/design-news-submission-form/
+- http://net.tutsplus.com/link-feed/#add
+- http://qik.com/
+- http://www.associatedcontent.com/
+- http://inboundmarketing.com
+- http://clipmarks.com
+- http://www.addurl.nu/
+- http://blog.sponsoredreviews.com/?p=47
+- http://www.metamags.com/
+- http://www.developersniche.com/
+- http://add.io/
+- http://www.arto.com/section/frontpage/
+- https://www.google.com/bookmarks/l
+- amazon wishlist
+- netvibes
+- evernote
+- http://www.evri.com/
+- http://pinboard.in
+- http://weheartit.com/about
+- http://www.soup.io/
+- http://izeby.com/
+- http://linkmarking.com/
+- yahoo meme
+- reddit, digg, diigo, and mixx still don't work
+- diigo doesn't work because cookie expires.  create mechanize to re-login if cookie doesn't work
+- evernote
+- http://www.rubyflow.com
+
+## Lists
+
+- http://www.digalist.com
+- listiki.com
+- tipbo.com
+
+## Tips from out there
+
+Ask yourself the following questions about the linkability of your content:
+
+- Am I Digging this because I want others to see it, and pressing a single button is an easy way for me to say "this is cool?"
+- Or am I Digging this because People need to know about this, because they can’t live without it or because without it they would be out of the loop.
+- Is it possible that my information is so new and/or informative that I will actually become an authority on this information, or serve as a reference for others interested in writing about similar content?
 
-- [http://www.iwoodpecker.com/collection-of-70-best-social-bookmarking-sites-with-pr-and-alexa/](http://www.iwoodpecker.com/collection-of-70-best-social-bookmarking-sites-with-pr-and-alexa/)
-- buzz.yahoo.com
-- http://www.wikio.com/about-us
-- http://designbump.com/
-- http://scriptandstyle.com/submit
-- http://www.stumpedia.com/submitlink.php
+> It is only one step more to make it so we fully create all the user accounts if they don't exist on all the services

data/Rakefile

@@ -5,18 +5,26 @@ require 'rake/gempackagetask'
 # http://docs.rubygems.org/read/chapter/20
 spec = Gem::Specification.new do |s|
   s.name              = "ubiquitously"
-  s.version           = "0.0.1.6"
+  s.version           = "0.1.0"
   s.author            = "Lance Pollard"
-  s.summary           = "Ubiquitously: Making it easy for you to be everywhere, even if there's no API"
+  s.summary           = "Ubiquitously: Social Publishing to everywhere from anywhere, even if there's no API"
   s.homepage          = "http://github.com/viatropos/ubiquitously"
   s.email             = "lancejpollard@gmail.com"
-  s.description       = "Making it easy for you to be everywhere, even if there's no API"
+  s.description       = "Social Publishing Rubygem"
   s.has_rdoc          = true
   s.rubyforge_project = "ubiquitously"
   s.platform          = Gem::Platform::RUBY
-  s.files             = %w(README.markdown Rakefile init.rb MIT-LICENSE) + Dir["{lib,rails,test}/**/*"] - Dir["test/tmp"]
+  s.files             = %w(README.markdown Rakefile init.rb MIT-LICENSE) + Dir["{lib,rails,test,bin}/**/*"] - Dir["test/tmp"]
   s.require_path      = "lib"
+  s.executables       = ["u.me"]
+  s.add_dependency("json")
   s.add_dependency("activesupport", ">= 2.3.5")
+  s.add_dependency("mechanize")
+  s.add_dependency("highline")
+  s.add_dependency("rack")
+  s.add_dependency("httparty")
+  s.add_dependency("activemodel")
+  s.add_dependency("passport")
 end
 
 Rake::GemPackageTask.new(spec) do |pkg|

data/bin/u.me

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../lib/ubiquitously'
+
+Ubiquitously.run(ARGV)

data/lib/ubiquitously.rb

@@ -1,38 +1,70 @@
 require 'rubygems'
 require 'open-uri'
 require 'cgi'
+require 'rack/utils'
 require 'yaml'
 require 'json'
-require 'nokogiri'
 require 'mechanize'
 require 'highline/import'
 require 'logger'
+require 'httparty'
 require 'active_support'
 require 'active_model'
+require 'passport'
 
 this = File.dirname(__FILE__)
-require "#{this}/ext"
-Dir["#{this}/ubiquitously/mixins/*"].each { |c| require c }
-require "#{this}/ubiquitously/base"
 
 module Ubiquitously
   class SettingsError < StandardError; end
   class AuthenticationError < StandardError; end
   class DuplicateError < StandardError; end
-
+  class RecordInvalid < StandardError; end
+  class CommandInvalid < StandardError; end
+  
   class << self
-    attr_accessor :config
+    attr_accessor :config, :logger
+    
+    def run(args)
+      command = args.shift
+      if command =~ /(secrets|tokens|cookies|credentials)/
+        system("open", File.expand_path("~/.u.me/#{$1}.yml"))
+        exit
+      end
+      unless command =~ /(?:post|user)/
+        message = "\nUbiquitously command must be for either 'post' or 'user', e.g.:\n"
+        message << "u.me post twitter 'Working with Rails today...'"
+        raise CommandInvalid.new(message)
+      end
+      "Ubiquitously::Command::#{command.camelize}".constantize.run(args)
+    end
     
     def configure(value)
       self.config = value.is_a?(String) ? YAML.load_file(value) : value
     end
     
+    def logger
+      unless @logger
+        @logger = Logger.new(STDOUT)
+        @logger.level = Logger::INFO
+      end
+      
+      @logger
+    end
+    
+    def debug?
+      logger.debug?
+    end
+    
     def key(path)
       result = self.config
       path.to_s.split(".").each { |node| result = result[node.to_s] if result }
       result.to_s
     end
     
+    def include?(service)
+      services.include?(service)
+    end
+    
     def credentials(service)
       result = key(service)
       unless result && result.has_key?("key") && result.has_key?("secret")
@@ -40,7 +72,24 @@ module Ubiquitously
       end
       result
     end
+    
+    def services
+      Dir.entries(File.dirname(__FILE__) + '/ubiquitously/services')[2..-1].collect do |service|
+        service = File.basename(service).split(".").first
+      end
+    end
   end
 end
 
-Dir["#{this}/ubiquitously/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/ubiquitously/extensions/*"].each { |c| require c }
+Dir["#{this}/ubiquitously/models/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/ubiquitously/services/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/ubiquitously/support/*"].each { |c| require c unless File.directory?(c) }
+Dir["#{this}/ubiquitously/commands/*"].each { |c| require c unless File.directory?(c) }
+
+overrides = Dir["#{this}/ubiquitously/services/*"].map do |file|
+  name = File.basename(file).split(".").first.camelize
+  ["Ubiquitously::#{name}::Account".constantize, "Ubiquitously::#{name}::Post".constantize]
+end.flatten
+
+SubclassableCallbacks.override(*overrides)

data/lib/ubiquitously/commands/base.rb

@@ -0,0 +1,118 @@
+module Ubiquitously
+  module Command
+    class Base
+      class << self
+        def run(args)
+          new(args).run
+        end
+      end
+      
+      attr_accessor :services, :attributes
+      
+      def write(to, content = "")
+        File.open(to, "w+") { |file| file.puts content }
+      end
+      
+      def configure(folder)
+        Dir.mkdir(folder) unless File.exists?(folder)
+        secrets_path     = File.join(folder, "secrets.yml")
+        tokens_path      = File.join(folder, "tokens.yml")
+        
+        # usernames and passwords for post services
+        unless File.exists?(secrets_path)
+          secrets = "# #{secrets_path}, in your home directory\n"
+          secrets << "# write your username and passwords for the different services\n"
+          secrets << "# as necessary.\n\n"
+          Ubiquitously.services.each do |service|
+            secrets << "#{service}:\n"
+            secrets << "  key: your_username\n"
+            secrets << "  secret: your_password\n"
+          end
+          write(secrets_path, secrets)
+          system("open", secrets_path)
+          puts "Please configure your service username and passwords and rerun your command."
+          exit
+        end
+        
+        Ubiquitously.configure(secrets_path)
+        
+        # oauth keys and secrets from services
+        unless File.exists?(tokens_path)
+          tokens = "# #{tokens_path}, in your home directory\n"
+          tokens << "# Get app key/secrets from the oauth providers below\n"
+          tokens << "# and fill them out as desired.\n\n"
+          tokens << "services:\n"
+          Passport.services.each do |service|
+            tokens << "  #{service}:\n"
+            tokens << "    key: app_key\n"
+            tokens << "    secrets: app_secret\n"
+          end
+          write(tokens_path, tokens)
+          system("open", tokens_path)
+          puts "Please configure your oauth keys and secrets and rerun your command."
+          exit
+        end
+        
+        Passport.configure(tokens_path)
+      end
+      
+      def main_folder
+        File.expand_path("~/.u.me")
+      end
+      
+      def show
+        tmp = File.join(main_folder, "post.yml")
+        if File.exists?(tmp)
+          post = IO.read(tmp)
+        else
+          post = ""
+          post << "services: \n"
+          post << "url: \n"
+          post << "title: \n"
+          post << "description: \n"
+          post << "tags: \n"
+          write(tmp, post)
+        end
+        system("open", tmp)
+        require 'timeout'
+        begin
+          Timeout::timeout(30) {
+            puts "Will timeout in 30 seconds. Press Enter when you're ready."
+            STDIN.gets.chomp
+            self.attributes = YAML.load_file(tmp).symbolize_keys
+            #File.delete(tmp) if File.exists?(tmp)
+            # Something that should be interrupted if it takes too much time...
+          }
+        rescue Exception => e
+          puts e.inspect
+          puts "Resubmit post with same command.  Finished process executing to clean things up."
+          exit
+        end
+        
+      end
+      
+      def initialize(args)
+        configure(main_folder)
+        self.services = []
+        self.attributes = {}
+        show if args.blank?
+        self.services << args.shift while args.length > 0 && args.first !~ /^-/
+        self.services << attributes.delete(:services) if attributes.has_key?(:services)
+        self.attributes[:title] = self.services.pop unless Ubiquitously.include?(self.services.last)
+        self.attributes = parse_options(args, attributes)
+        
+        self.attributes.each do |key, value|
+          self.send("#{key.to_s}=", value) if self.respond_to?(key)
+        end 
+      end
+      
+      def parse_options(attributes)
+        
+      end
+      
+      def run
+        
+      end
+    end
+  end
+end