sharkey-web 3.3.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f53d2ea02c3428a8b79fa0d255f81d79df9e5961
+  data.tar.gz: b318484b07be8b692ea824d7e472304feb27c160
+SHA512:
+  metadata.gz: b70b6a52387f1bd8f730d277c3eb2239609b6267bf87dc6a2eb958c220317dd351c0128cd2d3893c2f4c3b98125ec955a0bcb71c25a6ee5477dcc92f24052650
+  data.tar.gz: 3b16133fe035b6f9a219873c2db09d2056d330e0ccf2d522c86b9eaa6fa14efad4c1fed3ffd85f6431c7ad88fe33f6baecc83b4ae8019e44f6ccab936c70136d

data/.gitignore

@@ -0,0 +1,24 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+*.db
+settings.yml

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Dependencies on `sharkey.gemspec`
+gemspec

data/LICENSE.md

@@ -0,0 +1,19 @@
+Copyright (C) <2014> by <Alexandre Dantas>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
+of the Software, and to permit persons to whom the Software is furnished to do
+so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,188 @@
+# Sharkey
+
+`sharkey` is a cute web-based personal bookmarking service.
+
+* **Bookmarking** means it _saves your links_, allows you to _tag them_, arrange
+  in _categories_ and, most important of all, _keep track of what you should visit later_.
+* **Personal** means _you control your own data_. Everything is stored on your
+  computer and _you can import/export/delete as you please_. It is like the anti-social
+  cousin of [Delicious][delicious].
+* **Web-based** means it runs on your browser. _You don't need an internet connection_,
+  though! It doesn't mean you access a site to use it - it runs on _your computer_.
+  It just happens that I prefer to make sites instead of designing windows and buttons
+  and stuff.
+* **Cute** means it has a nice appearance. It comes with _lots of themes_ and you can
+  even customize it _with your own themes_ too.
+
+Here's some screenshots for you:
+
+<!-- Add Screenshots -->
+
+As you can see, `sharkey` is a great tool for [tab hoarders][hoard].
+
+### Why would you do that?
+
+If you know me (which I bet you don't) the following sentence will seem familiar:
+
+<blockquote>
+<em>Nah, I won't close this tab... I might need it later.
+Let's open another one instead</em>
+<footer>
+- <cite>Me, Always</cite>
+</footer>
+</blockquote>
+
+Being like this for years leaves a nasty trail - lots of Firefox crashes,
+everything getting slow as fuark, computer-restarting paranoia, etc... <br />
+And I bet within those 400+ tabs there are _some_ repeated.
+
+Unfortunately most bookmarking services lacked one or another feature;
+some were beautiful but didn't had many things; others had 'em but didn't
+allow you to control your own data; others were super ugly and some
+were very complicated to install.
+
+Well, `sharkey` is an attempt to gather the best things from them.
+
+You should probably [check out the live demo][live]. <br />
+Be warned, though, that since it's completely public it might have some
+nasty spam or _even worse things_. <br />
+But `sharkey` allows you to easily destroy all data so it shouldn't be
+that much of an issue.
+
+### How to use
+
+Hey champ, you have to install it first.
+
+### How to install
+
+You can easily fetch and install `sharkey` via _Ruby Gems_. <br />
+Look at that:
+
+```bash
+$ gem install sharkey-web
+```
+
+That command takes a while because it install all it's dependencies.
+You can also [grab the gem file here][gem] if you want.
+
+But, hey, if you run that command _right now_ it will probably fail.
+That's because you need...
+
+### ...a dependency
+
+`sharkey` requires `sqlite3` - and not just the library that comes with
+your distro, no; it needs the fancy development package.
+
+If you're on Ubuntu/Debian the following command should suffice:
+
+```bash
+$ sudo apt-get install libsqlite3-dev
+```
+
+Other systems may have different names but you get the
+picture - install SQLite!
+
+If you're on Windows... Tough luck, I have no idea what you could do. <br />
+If you ever figure it out, please contact me so I can replace this
+shameful paragraph. <br />
+S-sorry, senpai.
+
+### How to use... again
+
+Alright, so you've installed the dependencies and now you have `sharkey`!
+
+Why don't you run it?
+
+```bash
+$ sharkey-web
+```
+
+This will create the `sharkey`'s web server, launch it on the background
+and call your web browser. It should open a new tab (yet another...!) with
+that cute interface of the screenshots above.
+
+To kill the process, simply run:
+
+```bash
+$ sharkey-web --kill
+```
+
+Anyway, go play with it!
+
+Still reading? Go there, I can wait!
+
+### And Then...
+
+Back, already? ...okay
+
+The rest of the document is just some boring technical talk, you should
+probably just stick with the _Help_ session on the `sharkey` web interface.
+
+Anyway, good talking to you. See ya!
+
+## Development
+
+Great, now that that they're gone, let's go to what _really_ matters!
+
+`sharkey` is essentially:
+
+* A [Ruby][ruby] program;
+* That is a web application, made with [Sinatra][sinatra];
+* Encapsulated on a [Vegas][vegas] executable;
+* That has a GUI made with HTML5/CSS3/Javascript;
+* With a [Bootstrap][bootstrap] layout ([and Bootswatch themes][bootswatch]);
+* Made dynamic and fluid with [jQuery][jquery];
+* And featuring with tons of plugins (see below);
+
+Now, between you and me, this was my first attempt on developing a web
+application. It was a project to learn several web technologies and how to
+integrate them. But don't go around telling anyone this!
+
+## Credits
+
+Besides the links above, I have to point out which tools I've used
+behind the scenes.
+
+### Tools
+
+* [tux: A console with direct access to Sinatra's internal stuff](https://github.com/cldwalker/tux). I used it all the time to directly access the database and simulate some GET/POST requests.
+* [Mousetrap: a nice keyboard helper](http://craig.is/killing/mice). Thanks to it one can use `sharkey` real fast through keyboard shortcuts.
+* [jquery.tagcloud](https://github.com/addywaddy/jquery.tagcloud.js), a simple plugin to create... tag clouds.
+* [Bootstrap Auto-Hiding Navbar](https://github.com/istvan-ujjmeszaros/bootstrap-autohidingnavbar) - pretty self-explanatory. I like how when you scroll down the navbar hides and when you scroll up it pops up again.
+
+### Links
+
+While developing `sharkey` I bumped into several dead-ends.
+These are the people/links who helped me a lot:
+
+* [Sinatra Recipes: DataMapper](http://recipes.sinatrarb.com/p/models/data_mapper?#article)
+* [Sam Stern: Making a Simple, Database-Driven website with Sinatra and Heroku](http://samuelstern.wordpress.com/2012/11/28/making-a-simple-database-driven-website-with-sinatra-and-heroku/)
+* [wooptoot: File Upload with Sinatra](http://www.wooptoot.com/file-upload-with-sinatra)
+* [Random Ruby Thoughts: Upload Files in Sinatra](http://alfuken.tumblr.com/post/874428235/upload-and-download-files-in-sinatra)
+* [The Bastards Book of Ruby: Parsing HTML with Nokogiri](http://ruby.bastardsbook.com/chapters/html-parsing/)
+* [Unheap: showcase of lots and lots of Javascript stuff](http://www.unheap.com/)
+
+### Notes
+
+* When running this under development (with `rake preview`) the requests
+  seems _mother-fricking slow_; that's because of `shotgun` and it's tendency
+  to restart the application on each request.
+
+## License
+
+The whole code is released under the *MIT-license*.
+
+Check file `LICENSE.md` for details on what you can and
+cannot do with it.
+
+[delicious]: https://delicious.com/
+[hoard]: http://www.urbandictionary.com/define.php?term=Tab-Hoarder
+[gem]:   http://link
+[live]:  http://saruman.link/sharkey/
+[sinatra]: http://
+[ruby]:
+[vegas]:
+[bootstrap]:
+[bootswatch]:
+[jquery]:
+

data/Rakefile

@@ -0,0 +1,8 @@
+# See default bundler take tasks with `rake -T`
+require "bundler/gem_tasks"
+
+desc 'Previews Sinatra app, automatically updating on file changes'
+task :preview do
+  `shotgun -Ilib config.ru`
+end
+

data/bin/sharkey-web

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+#
+# Main executable for Sharkey
+
+require File.expand_path(File.dirname(__FILE__) + '/../lib/sharkey')
+require 'vegas'
+
+Vegas::Runner.new(Sharkey::App, 'sharkey')
+

data/config.ru

@@ -0,0 +1,3 @@
+require File.join(File.dirname(__FILE__), 'lib', 'sharkey')
+
+run Sharkey::App.new

data/lib/sharkey.rb

@@ -0,0 +1,12 @@
+# Starting point for Sharkey
+#
+# This file actually does nothing - simply requires everything
+# we need to work
+
+require 'sharkey/version'
+
+module Sharkey
+
+  autoload :App, 'sharkey/app'
+end
+

data/lib/sharkey/app.rb

@@ -0,0 +1,526 @@
+# Application file for Sharkey
+#
+# Here we define the actions that Sinatra needs to take (routes)
+
+require 'sinatra'
+require 'slim'
+require 'data_mapper'
+
+# For making date/time user-friendly
+require 'date'
+require 'chronic_duration'
+
+# To import Sharkey::Links and get page's Titles
+require 'nokogiri'
+require 'metainspector'
+
+# Create and initialize the databases
+require 'sharkey/models'
+
+require 'sharkey/setting'
+require 'sharkey/importerexporter'
+
+require 'json'
+
+module Sharkey
+  class App < Sinatra::Application
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Initializing the server
+
+    # Global in-app settings
+    # (not related to Sinatra per se)
+    Sharkey::Setting.initialize
+
+    # Helper functions that are accessible inside
+    # every place
+    helpers do
+      def delete_link id
+        link = Sharkey::Link.get id
+        return if not link
+
+        # Before deleting the link, we must remove
+        # all Sharkey::Tag associations
+        link.taggings.destroy       if link.taggings
+        link.categorization.destroy if link.categorization
+
+        link.reload
+        link.destroy
+      end
+
+      def delete_tag id
+        tag = Sharkey::Tag.get id
+        return if not tag
+
+        tag.taggings.destroy if tag.taggings
+
+        tag.reload
+        tag.destroy
+      end
+
+      def delete_category id
+        category = Sharkey::Category.get id
+        return if not category
+
+        # * `category.parent` is a pointer to
+        #   another Category
+        # * `category.categoryParent` is a pointer
+        #   to the RELATIONSHIP to another Category
+
+        # Removing ties to other Categories...
+        if category.parent
+          category.parent.remove_child category
+        end
+        if category.categoryParent
+          category.categoryParent.destroy
+        end
+
+        if not category.childs.empty?
+          category.childs.each { |child| category.remove_child(child) }
+        end
+
+        # ...and to other Links...
+        if category.categorizations
+          category.categorizations.destroy
+        end
+
+        # ...and finally to itself
+        category.reload
+        category.destroy
+      end
+
+      def random_sentence
+        @sentences ||= File.readlines(File.join(File.dirname(__FILE__), '/public/data/sentences.txt'))
+        @sentences.sample
+      end
+
+      # Converts `datetime` object into a relative date String
+      # (like "2 days, 8 hours, 15 minutes, 2 seconds")
+      def relative_date datetime
+        return '' if datetime.nil?
+
+        # Now we'll calculate a short, human-friendly
+        # version of the full date (like '2 days, 5 hours')
+        added_secs = datetime.strftime('%s').to_i
+        now_secs   = DateTime.now.strftime('%s').to_i
+
+        ChronicDuration.output(now_secs - added_secs)
+      end
+
+      # Converts `datetime` object into a formatted date String
+      # suited for HTML5's <time datetime=""> attributes!
+      def formatted_date datetime
+        return '' if datetime.nil?
+
+        datetime.strftime '%Y-%m-%d %H:%m'
+      end
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Standalone pages
+
+    get '/' do
+      slim(:dashboard_index,
+           :layout => :dashboard,
+           :locals => { page: "home" })
+    end
+
+    get '/settings' do
+      slim(:settings_index,
+           :layout => :settings,
+           :locals => { page: "settings" })
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Deleting stuff
+
+    delete '/link/:id' do
+      delete_link(params[:id])
+
+      # If this is an AJAX request, we don't need
+      # to redirect anywhere!
+      # The JavaScript is responsible for updating
+      # the page, not us!
+      redirect back unless request.xhr?
+    end
+
+    # Extra parameters:
+    #
+    # - destroy_links If should also destroy links with this tag
+    #
+    delete '/tag/:id' do
+
+      # Welp, here we go!
+      # Send a DELETE request for each link
+      if (params[:destroy_links])
+        links = Sharkey::Link.by_tag(params[:id])
+
+        links.each { |link| delete_link link.id }
+      end
+
+      delete_tag params[:id]
+
+      # If this is an AJAX request, we don't need
+      # to redirect anywhere!
+      # The JavaScript is responsible for updating
+      # the page, not us!
+      redirect back unless request.xhr?
+    end
+
+    # Extra parameters:
+    #
+    # - destroy_links If should also destroy links with this category
+    #
+    delete '/category/:id' do
+
+      # Welp, here we go!
+      # Send a DELETE request for each link
+      if (params[:destroy_links] == 'true')
+        links = Sharkey::Link.by_category(params[:id])
+
+        links.each { |link| delete_link link.id }
+      end
+
+      delete_category params[:id]
+
+      # If this is an AJAX request, we don't need
+      # to redirect anywhere!
+      # The JavaScript is responsible for updating
+      # the page, not us!
+      redirect back unless request.xhr?
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Deleting too much stuff (Caution!)
+
+    delete '/all-links' do
+      Sharkey::Tagging.destroy
+      Sharkey::Link.destroy
+      redirect to '/'
+    end
+
+    delete '/all-tags' do
+      Sharkey::Tagging.destroy
+      Sharkey::Tag.destroy
+      redirect to '/'
+    end
+
+    delete '/all-categories' do
+      Sharkey::Categorization.destroy
+      Sharkey::CategoryParent.destroy
+      Sharkey::CategoryChild.destroy
+      Sharkey::Category.destroy
+      redirect to '/'
+    end
+
+    delete '/everything' do
+      # No need to be cautious
+      FileUtils.rm_f Sharkey::DATABASE_FILE
+      redirect to '/'
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Individual pages
+    get '/link/:id' do
+      the_link = Sharkey::Link.get(params[:id])
+      redirect to '/' if not the_link
+
+      slim(:link,
+           :layout => :dashboard,
+           locals: { page: "link", link: the_link })
+    end
+
+    get '/tag/:id' do
+      the_tag = Sharkey::Tag.get(params[:id])
+      redirect to '/' if not the_tag
+
+      slim(:tag,
+           :layout => :dashboard,
+           locals: { page: "tag", tag: the_tag })
+    end
+
+    get '/category/:id' do
+      the_category = Sharkey::Category.get(params[:id])
+      redirect to '/' if not the_category
+
+      slim(:category,
+           :layout => :dashboard,
+           locals: { page: "category", category: the_category })
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Creating things
+
+    post '/link' do
+      Sharkey::Link.create_link(params[:title],
+                                params[:url],
+                                params[:added_at],
+                                params[:tags],
+                                params[:category],
+                                params[:comment])
+
+      # If AJAX request, don't redirect anywhere!
+      redirect back unless request.xhr?
+    end
+
+    post '/links' do
+
+      params[:url].split.each do |url|
+
+        Sharkey::Link.create_link(nil,
+                                  url,
+                                  nil,
+                                  params[:tags] || [],
+                                  params[:category],
+                                  "")
+      end
+      redirect back unless request.xhr?
+    end
+
+    post '/category' do
+      new_category = Sharkey::Category.first_or_create(name: params[:name]);
+
+      parent_category = Sharkey::Category.get(params[:parent])
+      # Silently fail if invalid ID was given
+      if (parent_category)
+        parent_category.add_child(new_category)
+      end
+
+      # If this is an AJAX request, we'll return a JSON
+      # string with information on the recently-added Category
+      if request.xhr?
+        return "{ \"id\": \"#{new_category.id}\", \"name\": \"#{new_category.name}\" }"
+      else
+        redirect back
+      end
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Updating things
+    #
+    # Unfortunately I couldn't use the PUT method - even when
+    # adding a hidden '<input>' and all that crap.
+    # It ain't the order of Sinatra routes also... So I fell
+    # back to good old POST with different URL.
+
+    post '/update/link/:id' do
+      return 404 if not params[:id]
+
+      Sharkey::Link.update_link(params[:id],
+                                params[:title],
+                                params[:url],
+                                params[:tags],
+                                params[:category],
+                                params[:comment])
+
+      # If AJAX request, don't redirect anywhere!
+      redirect back unless request.xhr?
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Pages that list things
+
+    get '/links' do
+      # Creating an instance variable
+      # (visible inside all Views)
+      @links = Sharkey::Link.all
+
+      slim(:links,
+           :layout => :dashboard,
+           :locals => { page: "links" })
+    end
+
+    get '/tags' do
+      # Creating an instance variable
+      # (visible inside all Views)
+      @tags = Sharkey::Tag.all
+
+      # MagicSuggest, the jQuery plugin, uses this to give
+      # suggestions on Tag input fields.
+      #
+      # If request is AJAX, return a JSON
+      # array with all existing tags
+      if request.xhr?
+        return @tags.sort.to_json
+      end
+
+      # Now, the user can send other values to
+      # specify how they will get sorted
+      case params[:sort]
+      when 'name'
+        @tags = @tags.sort_by { |t| t.name }
+
+      when 'count'
+        @tags = @tags.sort_by { |t| t.taggings.count } .reverse
+
+      when 'id'
+        @tags = @tags.sort_by { |t| t.id }
+      end
+
+      slim(:tags,
+           :layout => :dashboard,
+           :locals => { page: "tags" })
+    end
+
+    get '/categories' do
+
+      # Let's start by showing all Categories
+      # WITHOUT parents.
+      # Then, recursively show their children
+      @categories = Sharkey::Category.orphans
+
+      # Now, the user can send other values to
+      # specify how they will get sorted
+      case params[:sort]
+      when 'name'
+        @categories = @categories.sort_by { |t| t.name }
+
+      when 'count'
+        @categories = @categories.sort_by { |t| t.categorizations.count } .reverse
+
+      when 'id'
+        @categories = @categories.sort_by { |t| t.id }
+      end
+
+      slim(:categories,
+           :layout => :dashboard,
+           :locals => { page: "categories" })
+    end
+
+    get '/favorites' do
+      @links = Sharkey::Link.all(favorite: true)
+
+      slim(:links,
+           :layout => :dashboard,
+           :locals => { page: "favorites" })
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Misc. pages
+
+    post '/debug' do
+      slim("#{params.inspect}")
+    end
+
+    post '/setting' do
+      # HACK
+      # BIG EXCEPTION are <select> elements, who fuck up
+      # the entire standard
+      if (params[:theme])
+        Sharkey::Setting['theme'] = params[:theme]
+        Sharkey::Setting.save
+        redirect back
+      end
+
+      # Error for non-existing setting
+      return 500 unless Sharkey::Setting[params[:name]]
+      return 500 unless params[:value]
+
+      Sharkey::Setting[params[:name]] = params[:value]
+      Sharkey::Setting.save
+
+      if request.xhr?
+        return 200
+      else
+        redirect back
+      end
+    end
+
+    # Import Sharkey::Links from Bookmark HTML files
+    # (eg. Firefox, Delicious, etc)
+    #
+    # POST requests automatically creates a temporary
+    # file for us.
+    #
+    post '/import' do
+
+      # If we got no temporary file from POST let's just
+      # ignore this request
+      unless (params[:file] and params[:file][:tempfile])
+        redirect back
+      end
+
+      ImporterExporter::import params['file'][:tempfile]
+      redirect to '/'
+    end
+
+    get '/tagcloud' do
+      @tags = Sharkey::Tag.all
+
+      slim(:tagcloud,
+           :layout => :dashboard,
+           :locals => { page: "tagcloud" })
+    end
+
+    # Surprise me!
+    get '/random' do
+      the_link = Sharkey::Link.all.sample
+
+      slim(:link,
+           :layout => :dashboard,
+           locals: { page: "link", link: the_link })
+    end
+
+    # Toggles the favorite state of the Link with :id
+    #
+    # Returns the item's favorite state _after_ the change.
+    post '/favorite/:id' do
+      the_link = Sharkey::Link.get params[:id]
+      return 502 if not the_link
+
+      the_link.toggle_favorite
+      return "{ \"isFavorite\": #{the_link.favorite} }"
+    end
+
+    # Increase the visit count of a link
+    post '/visit/:id' do
+      the_link = Sharkey::Link.get params[:id]
+      return 502 if not the_link
+
+      the_link.visit
+      return "{ \"visitCount\": #{the_link.visit_count} }"
+    end
+
+    get '/help' do
+      slim(:help,
+           :layout => :centered,
+           locals: { page: "help" })
+    end
+
+    get '/about' do
+      slim(:about,
+           :layout => :centered,
+           locals: { page: "about" })
+    end
+
+    # AJAX requested metadata from an URL
+    # Let's return, beyb
+    get '/metadata' do
+      return 404 if not params[:url]
+
+      begin
+        page = MetaInspector.new(params[:url], :allow_redirections => :all)
+
+        hash = {
+          'pageTitle'       => "#{page.title}",
+          'pageDescription' => "#{page.description}"
+        }
+        return hash.to_json
+
+      rescue
+        # This error-handling sucks, perhaps I should
+        # return error values according to what actually
+        # happened on the server
+        return 503
+      end
+    end
+
+    # # # # # # # # # # # # # # # # # # # # # # # # # # # # # #
+    # Error-handling
+
+    not_found do
+      slim(:'404', :locals => { url: request.fullpath })
+    end
+  end
+end
+