ubiquitously 0.0.1.6 → 0.1.0

data/lib/ubiquitously/commands/post.rb

@@ -0,0 +1,108 @@
+module Ubiquitously
+  module Command
+    class Post < Ubiquitously::Command::Base
+      
+      def run
+        user = Ubiquitously::User.new(:storage => main_folder)
+        user.accountables(services) do |account|
+          account = account.new(
+            :user => user,
+            :username => attributes[:username] || Ubiquitously.key("#{account.service}.key"),
+            :password => attributes[:password] || Ubiquitously.key("#{account.service}.secret")
+          )
+        end
+        Ubiquitously::Post.new(attributes.merge(:user => user)).save(services)
+      end
+      
+      def required(attributes)
+        missing = %w(description).delete_if { |i| !attributes[i.to_sym].blank? }
+        unless missing.blank?
+          raise CommandInvalid.new("Missing arguments for post: #{missing.join(", ")}")
+        end
+        attributes
+      end
+      
+      def parse_options(args, attributes = {})
+
+        option_parser = OptionParser.new do |o|
+          o.extend Ubiquitously::Command::Post::Opts
+          o.options(attributes)
+          
+          o.banner = "Usage: u.me [command] [service(s)] [options]\n" +
+                     "\n" +
+                     "Supported Commands:\n#{Ubiquitously.services.sort.join(', ')}"
+          
+          o.section "Post attributes:" do
+            url
+            title
+            description
+            tags
+            username
+            password
+          end
+        end
+        
+        option_parser.parse!(args)
+        
+        required attributes
+      end
+      
+      module Opts
+        
+        def options(value = nil)
+          @options = value if value
+          @options
+        end
+        
+        def section(heading, &block)
+          separator ""
+          separator heading
+          
+          instance_eval(&block)
+        end
+        
+        def url
+          on('-u', '--url URL', "Post url (required)") do |url|
+            options[:url] = url
+          end
+        end
+        
+        def title
+          on('-l', '--title TITLE', "Post title (required)") do |title|
+            options[:title] = title
+          end
+        end
+        
+        def tags
+          on('-t', '--tags TAGS', "Post tags (required)") do |tags|
+            options[:tags] = tags.split(/,(?:\s+)?/)
+          end
+        end
+        
+        def description
+          on('-d', '--description DESCRIPTION', "Post description (required)") do |description|
+            options[:description] = description
+          end
+        end
+        
+        def username
+          on('-U', '--username [username]', "Username for service") do |username|
+            options[:username] = username
+          end
+        end
+
+        def password
+          on('-P', '--password [password]', "Password for service") do |password|
+            options[:password] = password
+          end
+        end
+        
+        def help
+          on_tail("-h", "--help", "Show this message") do
+            exit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/commands/user.rb

@@ -0,0 +1,111 @@
+module Ubiquitously
+  module Command
+    class User < Ubiquitously::Command::Base
+      
+      def run
+        Ubiquitously::User.new(attributes).login(services)
+      end
+      
+      def parse_options(args)
+        option_parser = OptionParser.new do |o|
+          o.extend Ubiquitously::Opts
+          
+          o.banner = "Usage: u.me [command] [service(s)] [options]\n" +
+                     "\n" +
+                     "Supported Commands:\n#{SUPPORTED_COMMANDS.sort.join(', ')}"
+        
+          o.section "Getting started:" do
+            tutorial
+          end
+          
+          o.section "Authorization options:" do
+            username
+            password
+            consumer_key
+            consumer_secret
+            access_token
+            password
+          end
+        
+          o.section "Common options:" do
+            trace
+            data
+            host
+            quiet
+            disable_ssl
+            request_method
+            help
+          end
+        end
+
+        option_parser.parse!(args)
+      end
+    
+      module Opts
+
+        def section(heading, &block)
+          separator ""
+          separator heading
+
+          instance_eval(&block)
+        end
+      
+        def tutorial
+          on('-T', '--tutorial', "Narrative overview of how to get started using Ubiquitously.me") do
+            CLI.puts IO.read("README.markdown")
+            exit
+          end
+        end
+        
+        def consumer_key
+          on('-c', '--consumer-key [key]', "Your consumer key (required)") do |key|
+            options.consumer_key = key ? key : CLI.prompt_for('Consumer key')
+          end
+        end
+        
+        def consumer_secret
+          on('-s', '--consumer-secret [secret]', "Your consumer secret (required)") do |secret|
+            options.consumer_secret = secret ? secret : CLI.prompt_for('Consumer secret')
+          end
+        end
+
+        def username
+          on('-u', '--username [name]', 'Your access token') do |name|
+            options.username = name
+          end
+        end
+        
+        def password
+          on('-p', '--password', "Your token secret") do |secret|
+            options.password = secret
+          end
+        end
+        
+        def username
+          on('-u', '--username [username]', 'Username of account to authorize (required)') do |username|
+            options.username = username
+          end
+        end
+      
+        def password
+          on('-p', '--password [password]', 'Password of account to authorize (required)') do |password|
+            options.password = password ? password : CLI.prompt_for('Password')
+          end
+        end
+
+        def quiet
+          on('-q', '--quiet', 'Suppress all output (default: output is printed to STDOUT)') do |quiet|
+            options.output = StringIO.new
+          end
+        end
+
+        def help
+          on_tail("-h", "--help", "Show this message") do
+            CLI.puts self
+            exit
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/extensions/callbacks.rb

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'active_model'
+
+# use this if you want to create before and after filters around a commonly used
+# method, but still want to define the method in subclasses.
+module SubclassableCallbacks
+  def self.included(base)
+    base.extend ClassMethods
+  end
+  
+  module ClassMethods
+    attr_accessor :subclassable_callbacks
+    
+    def subclassable_callbacks(*methods)
+      @subclassable_callbacks ||= []
+      
+      unless methods.empty?
+        @subclassable_callbacks = @subclassable_callbacks.concat(methods).flatten.compact.map(&:to_sym).uniq
+        define_model_callbacks *methods
+        class_eval do
+          methods.each do |variable|
+            define_method "implementation_#{variable.to_s}" do; end
+            define_method variable do
+              send("_run_#{variable.to_s}_callbacks") do
+                send("implementation_#{variable.to_s}")
+              end
+            end
+            alias_method "superclass_#{variable.to_s}", variable
+          end
+        end
+      end
+      
+      @subclassable_callbacks
+    end
+  end
+  
+  # ObjectSpace.each_object(Class).to_a for all of them
+  def self.override(*classes)
+    classes = ObjectSpace.each_object(Class).to_a if classes.blank?
+    classes.flatten.each do |object|
+      if object.ancestors.include?(SubclassableCallbacks)
+        object.class_eval do
+          methods = object.subclassable_callbacks
+          last_index = object.superclass.ancestors.index(SubclassableCallbacks)
+          if last_index && last_index > 0
+            superclasses = object.superclass.ancestors[0..last_index - 1]
+            superclass_methods = superclasses.select do |clazz|
+              clazz.respond_to?(:subclassable_callbacks)
+            end.map(&:subclassable_callbacks)
+            methods = methods.concat(superclass_methods).flatten.uniq
+          end 
+          methods.each do |name|
+            next unless object.overrides?(name)
+            alias_method "subclass_#{name}", "#{name}"
+            alias_method "implementation_#{name}", "subclass_#{name}"
+            alias_method "#{name}", "superclass_#{name}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ubiquitously/extensions/core.rb

@@ -0,0 +1,88 @@
+# thanks to the answer here:
+# http://stackoverflow.com/questions/3488203/how-do-i-see-where-in-the-class-hierarchy-a-method-was-defined-and-overridden-in
+class Object
+  def self.overridden_methods(parent_class = Object, within_tree = true)
+    if within_tree
+      defined_methods = ancestors[0..ancestors.index(parent_class) - 1].map { |object| object.instance_methods(false) }.flatten.uniq
+      parent_methods = superclass.instance_methods
+    else
+      defined_methods = instance_methods(false)
+      parent_methods = parent_class.instance_methods
+    end
+    defined_methods & parent_methods
+  end
+  
+  def overridden_methods(parent_class = Object, within_tree = true)
+    self.class.overridden_methods(parent_class, within_tree)
+  end
+  
+  def self.overrides?(method, parent_class = Object, within_tree = true)
+    overridden_methods(parent_class, within_tree).include?(method.to_s)
+  end
+  
+  def overrides?(method, parent_class = Object, within_tree = true)
+    self.class.overrides?(method, parent_class, within_tree)
+  end
+end
+
+class Hash
+  def recursively_symbolize_keys!
+    self.symbolize_keys!
+    self.values.each do |v|
+      if v.is_a? Hash
+        v.recursively_symbolize_keys!
+      elsif v.is_a? Array
+        v.recursively_symbolize_keys!
+      end
+    end
+    self
+  end
+  
+  def symbolize_keys
+    inject({}) do |options, (key, value)|
+      options[(key.to_sym rescue key) || key] = value
+      options
+    end
+  end
+  
+  # Destructively convert all keys to symbols.
+  def symbolize_keys!
+    self.replace(self.symbolize_keys)
+  end
+end
+
+class Array
+  def chop(separator = "", max = 40, &block)
+    return self if self.join(separator).length < max # opt.
+    result = []
+    self.each do |word|
+      break if (result.join(separator).length + word.length > max)
+      word = yield word if block_given?
+      result << word
+      result
+    end
+    result
+  end
+  
+  # separator = ", ",
+  # max = 10_000
+  # quote = true|false
+  def taggify(space = " ", separator = ", ", max = 10_000)
+    quoted = !(separator =~ /\s+/).nil?
+    chop(separator, max) do |word|
+      result = word.downcase.strip.gsub(/[^a-z0-9\.]/, space).squeeze(space)
+      result = "\"#{result}\"" if quoted && !(result =~ /\s+/).nil?
+      result
+    end.join(separator)
+  end
+  
+  def recursively_symbolize_keys!
+    self.each do |item|
+      if item.is_a? Hash
+        item.recursively_symbolize_keys!
+      elsif item.is_a? Array
+        item.recursively_symbolize_keys!
+      end
+    end
+  end
+end

data/lib/ubiquitously/extensions/mechanize.rb

@@ -0,0 +1,35 @@
+class NilClass; def search(*args); []; end; end
+
+Mechanize::Chain::PostConnectHook.class_eval do
+  
+  def handle(ctx, params)
+    headers = params[:response].to_hash
+    if headers.has_key?("location")
+      headers["location"].each do |location|
+        url = URI.parse(location)
+        # we want mechanize to return if it sees a redirect back to localhost for facebook
+        if url.host == "localhost" && url.port == 4567
+          params[:res_klass] = Net::HTTPSuccess
+        end
+      end
+    end
+    
+    super(ctx, params)
+  end
+  
+end
+
+class Mechanize::CookieJar
+  public
+  def jar=(hash)
+    @jar = hash
+  end
+  
+  def save_string
+    return YAML::dump(@jar)
+  end
+
+  def load_string(str)
+    @jar = YAML::load(str)
+  end
+end

data/lib/ubiquitously/models/base.rb

@@ -0,0 +1,18 @@
+module Ubiquitously
+  class Base
+    include ActiveModel::Validations
+    extend ActiveModel::Callbacks
+    include ActiveModel::Serialization
+    include SubclassableCallbacks
+    
+    def apply(attributes)
+      attributes.each do |key, value|
+        self.send("#{key.to_s}=", value) if self.respond_to?(key)
+      end
+    end
+    
+    def debug?
+      Ubiquitously.debug?
+    end
+  end
+end

data/lib/ubiquitously/models/page.rb

@@ -0,0 +1,28 @@
+module Ubiquitously
+  class Page < Base
+    attr_accessor :url, :title, :description, :tags, :image
+    
+    def initialize(attributes = {})
+      apply attributes
+    end
+    
+    def parse
+      html = Nokogiri::HTML(open(url).read)
+      
+      self.title = html.xpath("//title").first.text.to_s.strip
+      
+      self.description = html.xpath("//meta[@name='description']").first["content"] rescue ""
+      self.description.strip!
+      
+      self.tags = html.xpath("//meta[@name='keywords']").first["content"] rescue ""
+      self.tags = self.tags.split(/,\s+/).taggify("-", ", ").split(", ")
+      
+      self.image = html.xpath("//link[@rel='image_src']").first["image_src"] rescue nil
+      if self.image.blank?
+        self.image = html.xpath("//img").first["src"] rescue nil
+      end
+      
+      self
+    end
+  end
+end