corkboard 0.1.0

data/app/controllers/corkboard/application_controller.rb

@@ -0,0 +1,15 @@
+module Corkboard
+  class ApplicationController < ActionController::Base
+    def auth_admin
+      send(Corkboard.authentication[:admin]) if Corkboard.authentication[:admin]
+    end
+
+    def auth_board
+      send(Corkboard.authentication[:board]) if Corkboard.authentication[:board]
+    end
+
+    def disallow!
+      raise Corkboard::ActionForbidden
+    end
+  end
+end

data/app/controllers/corkboard/authorizations_controller.rb

@@ -0,0 +1,65 @@
+module Corkboard
+  class AuthorizationsController < Corkboard::ApplicationController
+    before_filter(:auth_admin, {
+      :except => [:create]
+    })
+
+    # GET  /:mount_point/authorizations
+    def index
+      authorizations = Corkboard::Authorization.all
+      providers      = authorizations.map(&:provider)
+      available      = Corkboard.services.reject { |s| providers.include?(s) }
+
+      render(:index, :locals => {
+        :activated => authorizations,
+        :available => available
+      })
+    end
+
+    # GET  /:mount_point/auth/:provider/callback
+    # POST /:mount_point/auth/:provider/callback
+    def create
+      # TODO:
+      #   * guard based on "state" param:
+      #     if `session['omniauth.state]`, `params[:state]` must match.
+
+      authorization = Corkboard::Authorization.create!(auth_attrs)
+      subscription  = Corkboard::Subscription.create!(provider, authorization)
+
+      Corkboard.publish!(subscription.backlog)
+      redirect_to(authorizations_path)
+    end
+
+    # DELETE /:mount_point/auth/:provider
+    def destroy
+      # TODO: resolve the fact that there may be more than one for the same
+      # provider.  either disallow multiple, or select the correct one.
+      auth = Corkboard::Authorization.find_by_provider(params[:provider])
+      auth.destroy if auth
+      Corkboard.clear_all!
+
+      redirect_to(authorizations_path)
+    end
+
+    private
+
+      def auth_attrs
+        @auth_attrs ||= {
+          :resource_owner => nil, # TODO
+          :provider       => auth_params.provider,
+          :uid            => auth_params.uid,
+          :token          => auth_params.credentials.token,
+          :info           => auth_params.info,
+          :extra          => auth_params.extra
+        }
+      end
+
+      def auth_params
+        @auth_params ||= request.env['omniauth.auth']
+      end
+
+      def provider
+        @provider ||= params[:provider]
+      end
+  end
+end

data/app/controllers/corkboard/board_controller.rb

@@ -0,0 +1,10 @@
+module Corkboard
+  class BoardController < Corkboard::ApplicationController
+    before_filter(:auth_board)
+
+    # GET /:mount_point
+    def show
+      render(:show, :locals => { :posts => Corkboard::Post.recent })
+    end
+  end
+end

data/app/controllers/corkboard/posts_controller.rb

@@ -0,0 +1,72 @@
+module Corkboard
+  class PostsController < Corkboard::ApplicationController
+    def create
+      send(:"create_for_#{provider}")
+    end
+
+    private
+
+      def provider
+        @provider ||= params[:provider]
+      end
+
+      def create_for_instagram
+        instagram_challenge || instagram_callback || instagram_refresh
+      end
+
+      def instagram_challenge
+        if request.get? && params['hub.challenge'].present?
+          render(:text => params['hub.challenge'])
+          return true
+        end
+
+        false
+      end
+
+      def instagram_callback
+        if request.post?
+          # TODO: cache "friends"
+          # TODO: move to Subscription model
+          client  = Corkboard.client(:instagram, { :access_token => instagram_authorization.token })
+          friends = client.user_follows.map(&:username)
+
+          ::Instagram.process_subscription(params['_json'].to_json) do |handler|
+            handler.on_tag_changed do |tag, change|
+              # Get "my" recent feed items... includes updates from my "friends".
+              response = client.recent
+
+              # Filter those based on configured "interests".
+              relevant = response.data.select do |entry|
+                friendly    = friends.include?(entry.user.username)
+                interesting = (entry.tags.map(&:intern) & Corkboard.settings(:instagram)[:interests]).present?
+                friendly && interesting
+              end
+
+              Corkboard.publish!(relevant)
+            end
+          end
+
+          head :ok and return true
+        end
+
+        false
+      end
+
+      def instagram_refresh
+        if params[:refresh]
+          client = Corkboard.client(:instagram, { :access_token => instagram_authorization.token })
+          response = client.recent
+
+          Corkboard.publish!(response)
+
+          head :ok and return true
+        end
+
+        false
+      end
+
+      def instagram_authorization
+        @instagram_authorization ||= Corkboard::Authorization.find_by_provider('instagram')
+      end
+  end
+end

data/app/helpers/corkboard/application_helper.rb

@@ -0,0 +1,72 @@
+require 'weighted_randomizer'
+
+module Corkboard
+  module ApplicationHelper
+    def attributes_for(key, custom = {})
+      resource = custom.delete(:resource)
+
+      attrs = begin
+        if (framework = Corkboard.presentation[:framework]) && framework.present?
+          { :class => send(:"classes_for_#{framework}", key) }
+        else
+          { :class => classes_for_plain(key) }
+        end
+      end
+
+      attrs.merge!(send(:"data_for_#{key}", resource))
+
+      attrs.tap do |h|
+        custom.each do |name, value|
+          h[name] = [value, h[name]].join(' ')
+        end
+      end
+    end
+
+    private
+
+      def classes_for_bootstrap(key)
+        @_classes_for_bootstrap ||= {
+          :filters_list => 'btn-group',
+          :filters_item => 'btn'
+        }
+
+        @_classes_for_bootstrap[key]
+      end
+
+      def classes_for_plain(key)
+        @_classes_for_plain ||= {
+          :filters_list => nil,
+          :filters_item => nil
+        }
+
+        @_classes_for_plain[key]
+      end
+
+      def data_for_filters_list(*)
+        {}
+      end
+
+      def data_for_filters_item(*)
+        {}
+      end
+
+      def data_for_posts_item(post)
+        special = (Corkboard.interests[:scope] + [:all])
+        tags    = post[:tags].reject { |t| special.include?(t.intern) }
+
+        {
+          :class => ['entry', randomizer.sample].join(' '),
+          :data  => {
+            :eid  => post[:eid],
+            :tags => tags.join(' ')
+          }
+        }
+      end
+
+      def randomizer
+        @randomizer ||= begin
+          WeightedRandomizer.new(Corkboard.presentation[:weights])
+        end
+      end
+  end
+end

data/app/models/corkboard/authorization.rb

@@ -0,0 +1,13 @@
+class Corkboard::Authorization < ActiveRecord::Base
+  @table_name = :corkboard_authorizations
+
+  belongs_to :resource_owner
+
+  attr_accessible :resource_owner, :provider, :uid, :token, :info, :extra
+  serialize :info,  Hash
+  serialize :extra, Hash
+
+  def provider
+    read_attribute(:provider).intern
+  end
+end

data/app/models/corkboard/post.rb

@@ -0,0 +1,19 @@
+class Corkboard::Post
+  class << self
+    def recent
+      posts = []
+      ids   = Corkboard.redis.lrange("corkboard:posts", 0, 100)
+
+      if ids.present?
+        keys  = Corkboard.redis.mget(*ids)
+        posts = (Corkboard.redis.mget(*keys) || []).compact
+
+        if posts.present?
+          posts.map! { |post| JSON.parse(post.sub(/^[0-9]+\|/, '')).with_indifferent_access }
+        end
+      end
+
+      posts
+    end
+  end
+end

data/app/models/corkboard/subscription.rb

@@ -0,0 +1,34 @@
+class Corkboard::Subscription
+  class << self
+    def create!(provider, authorization)
+      client       = Corkboard.client(provider, { :access_token => authorization.token })
+      subscription = self.new(client)
+
+      # TODO: make non-specific to Instagram.
+      Corkboard.interests[:scope].each do |interest|
+        client.subscribe('tag', { :object_id => "#{interest}" })
+      end
+
+      subscription
+    end
+  end
+
+  attr_reader :client
+
+  def initialize(client)
+    @client = client
+  end
+
+  def backlog
+    # TODO: make non-specific to Instagram.
+    friends  = client.user_follows.map(&:username)
+    response = client.preload
+
+    # Filter those based on configured "interests".
+    response.data.select do |entry|
+      friendly    = friends.include?(entry.user.username)
+      interesting = (entry.tags.map(&:intern) & Corkboard.interests[:scope]).present?
+      friendly && interesting
+    end
+  end
+end

data/app/views/corkboard/authorizations/index.html.erb

@@ -0,0 +1,32 @@
+<article data-view="corkboard/authorizations/index" class="container">
+  <header>
+    <h1>Setup</h1>
+  </header>
+
+  <section>
+    <h2>Activated Services</h2>
+    <ul>
+      <%- activated.each do |authorization| -%>
+      <li>
+        <%#= debug(authorization) %>
+        <p>
+          <%= authorization.provider %>:
+          <%= authorization.info.nickname %>
+          <%= button_to('unlink', authorization_path(authorization.provider), :method => :delete) %>
+        </p>
+      </p>
+      <%- end -%>
+    </ul>
+  </section>
+
+  <section>
+    <h2>Available Services</h2>
+    <ul>
+      <%- available.each do |provider| -%>
+      <li>
+        <%= provider %> <%= link_to('link', authorization_path(provider)) %>
+      </p>
+      <%- end -%>
+    </ul>
+  </section>
+</article>

data/app/views/corkboard/board/_filters.html.erb

@@ -0,0 +1,15 @@
+<%- filters = Corkboard.interests[:filters] %>
+
+<nav class="corkboard filters">
+  <%= content_tag(:ul, attributes_for(:filters_list)) do %>
+    <%= content_tag(:li, attributes_for(:filters_item, :class => :active)) do %>
+      <a href="#all" class="all">all</a>
+    <%- end -%>
+
+    <%- filters.each do |filter| -%>
+    <%= content_tag(:li, attributes_for(:filters_item)) do %>
+      <a href="#<%= filter %>"><%= filter %></a>
+    <%- end -%>
+    <%- end -%>
+  <%- end -%>
+</nav>

data/app/views/corkboard/board/_posts.html.erb

@@ -0,0 +1,10 @@
+<ul class="corkboard posts">
+  <%- posts.each do |post| -%>
+  <%= content_tag(:li, attributes_for(:posts_item, :resource => post)) do %>
+    <figure>
+      <img src="<%= post[:images][:low_resolution][:url] %>">
+      <p class="caption"><%= (post[:caption] || {})['created_time'] %></p>
+    </figure>
+  <%- end -%>
+  <%- end -%>
+</ul>

data/app/views/corkboard/board/show.html.erb

@@ -0,0 +1,4 @@
+<article id="corkboard" data-view="corkboard/board/show" class="corkboard board">
+  <%= render('corkboard/board/filters') %>
+  <%= render('corkboard/board/posts', :posts => posts) %>
+</article>

data/app/views/layouts/corkboard/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Corkboard</title>
+  <%= stylesheet_link_tag    "corkboard/application", :media => "all" %>
+  <%= javascript_include_tag "corkboard/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,29 @@
+Corkboard::Engine.routes.draw do
+  match "/",
+    :to   => "board#show",
+    :as   => :board
+
+  match "/auth",
+    :to   => "authorizations#index",
+    :as   => :authorizations,
+    :via  => [:get]
+
+  # NOTE: This route entry is purely for the sake of generating the desired
+  # url/path helper. In fact, OmniAuth handles the actual request.
+  match "/auth/:action",
+    :to   => nil,
+    :as   => :authorization,
+    :via  => [:get]
+
+  match "/auth/:provider/callback",
+    :to   => "authorizations#create",
+    :via  => [:get, :post]
+
+  match "/auth/:provider",
+    :to   => "authorizations#destroy",
+    :via  => [:delete]
+
+  match "/posts/:provider/callback",
+    :to   => "posts#create",
+    :via  => [:get, :post]
+end

data/db/migrate/01_create_corkboard_authorizations.rb

@@ -0,0 +1,17 @@
+class CreateCorkboardAuthorizations < ActiveRecord::Migration
+  def change
+    create_table :corkboard_authorizations, :force => true do |t|
+      t.references :resource_owner, :polymorphic => { :default => 'User' }
+      t.string     :provider,       :null => false
+      t.string     :uid,            :null => false
+      t.string     :token,          :null => false
+      t.text       :info
+      t.text       :extra
+      t.timestamps
+    end
+
+    add_index :corkboard_authorizations, [:resource_owner_type, :resource_owner_id],
+      :name => 'index_corkboard_authorizations_on_resource_owner'
+    add_index :corkboard_authorizations, :provider
+  end
+end

data/lib/corkboard.rb

@@ -0,0 +1,191 @@
+require 'corkboard/engine'
+require 'omniauth'
+require 'redis'
+
+module Corkboard
+  class ActionForbidden < StandardError ; end
+
+  autoload :Client,      'corkboard/client'
+  autoload :Provider,    'corkboard/provider'
+
+  module Clients
+    autoload :Instagram, 'corkboard/clients/instagram'
+  end
+
+  module Providers
+    autoload :Instagram, 'corkboard/providers/instagram'
+  end
+
+  module Publishers
+    autoload :Mock,      'corkboard/publishers/mock'
+    autoload :Pusher,    'corkboard/publishers/pusher'
+  end
+
+  module Service
+    autoload :Config,    'corkboard/service/config'
+  end
+
+  # The standard mechanism for configuring Corkboard. Run the following to
+  # generate a fresh initializer with configuration defaults and samples:
+  #
+  #     rails generate corkboard:install
+  #
+  def self.setup
+    yield self
+  end
+
+  # Public Configuration
+  # ---------------------------------------------------------------------------
+
+  # Redis connection.
+  mattr_accessor :redis
+  @@redis = nil
+
+  # Authentication defaults.
+  @@authentication = {
+    :admin => :disallow!,
+    :board => nil
+  }
+
+  # Authentication configuration.
+  def self.authentication(config = nil)
+    if config
+      @@authentication.merge!(config)
+    end
+
+    @@authentication
+  end
+
+  # Presentation/view defaults.
+  @@presentation = {
+    :title       => 'Corkboard',
+    :description => 'Corkboard',
+    :framework   => :bootstrap,
+    :weights     => { :s => 10, :m => 3, :l => 1 }
+  }
+
+  # Presentation/view configuration.
+  def self.presentation(config = nil)
+    if config
+      @@presentation.merge!(config)
+    end
+
+    @@presentation
+  end
+
+  # Interests defaults.
+  @@interests = {
+    :scope   => [],
+    :filters => [],
+  }
+
+  # Interests configuration.
+  def self.interests(config = nil)
+    if config
+      @@interests.merge!(config)
+    end
+
+    @@interests
+  end
+
+  # Enable and configure a publisher.
+  #
+  #     config.publisher(:pusher, {
+  #       :client_app    => 'EXAMPLE',
+  #       :client_key    => 'EXAMPLE',
+  #       :client_secret => 'EXAMPLE'
+  #     })
+  #
+  def self.publisher(provider, credentials = nil)
+    @@publisher_configs[provider] = publisher_for(provider).new(credentials)
+  end
+
+  # Providers for enabled publishers.
+  def self.publishers
+    publisher_configs.keys
+  end
+
+  # Publication provider configurations.
+  mattr_accessor :publisher_configs
+  @@publisher_configs = ActiveSupport::OrderedHash.new
+
+  # Enable and configure a service.
+  #
+  #     config.service(:instagram,
+  #       :client_key    => 'EXAMPLE',
+  #       :client_secret => 'EXAMPLE'
+  #     })
+  #
+  def self.service(provider, *args)
+    config = Corkboard::Service::Config.new(provider, args)
+    @@service_configs[provider] = config
+  end
+
+  # Service provider configurations.
+  mattr_accessor :service_configs
+  @@service_configs = ActiveSupport::OrderedHash.new
+
+  # Providers for enabled services.
+  def self.services
+    service_configs.keys
+  end
+
+  # Publishing methods (will likely move elsewhere)
+  # ---------------------------------------------------------------------------
+
+  def self.client(strategy, options = {})
+    provider_for(strategy).client(options)
+  end
+
+  def self.clear_all!
+    keys   = Corkboard.redis.keys("corkboard:*")
+    Corkboard.redis.del(keys) if keys.present?
+  end
+
+  def self.provider_for(key)
+    Corkboard::Providers.const_get(camelcase(key))
+  end
+
+  def self.publisher_for(key)
+    Corkboard::Publishers.const_get(camelcase(key))
+  end
+
+  # TODO: make non-specific to instagram.
+  # TODO: post `data` as a collection (fewer http requests sent)
+  def self.publish!(data)
+    received = Time.now.utc.to_i
+
+    data.reverse.each do |item|
+      eid   = item.id
+      key   = "corkboard:posts:instagram:#{eid}"
+      entry = Hashie::Mash.new({
+        :eid       => eid,           # String
+        :caption   => item.caption,  # Mash [:text]
+        :images    => item.images,   # Mash [:low_resolution, standard_resolution, :thumbnail]
+        :link      => item.link,     # String
+        :location  => item.location, # Mash
+        :tags      => item.tags,     # Array
+        :user      => item.user      # Mash [:id, :username]
+      })
+
+      if Corkboard.redis.setnx(key, "#{received}|#{entry.to_json}")
+        position  = Corkboard.redis.incr("corkboard:counters:post")
+        reference = "corkboard:posts:#{position}"
+
+        Corkboard.redis.set(reference, key)
+        Corkboard.redis.lpush("corkboard:posts", reference)
+        Corkboard.redis.ltrim("corkboard:posts", 0, 1000)
+
+        publishers.each do |name|
+          publisher_configs[name].publish!(entry)
+        end
+      end
+    end
+  end
+
+  private
+
+    def self.camelcase(value)
+      OmniAuth::Utils.camelize(value.to_s)
+    end
+end