droom 0.0.1 → 0.2.1

data/lib/droom/engine.rb

@@ -2,7 +2,12 @@ module Droom
   class Engine < ::Rails::Engine
     isolate_namespace Droom
     initializer "droom.integration" do
-      ActiveRecord::Base.send :include, Droom::Helpers
+      ActiveRecord::Base.send :include, Droom::ModelHelpers
+      ActiveRecord::Base.send :include, Droom::Taggability
+      ActiveRecord::Base.send :include, Droom::Folders
+      ActiveSupport.on_load :action_controller do
+        helper Droom::DroomHelper
+      end
     end
   end
 end

data/lib/droom/folders.rb

@@ -0,0 +1,106 @@
+# Documents in droom are never attached directly to an object. Instead they are always attached to a folder,
+# and the folder is usually attached to an object. The folder itself is a normal ActiveRecord object with a 
+# name and some tree behaviours that allow us to present a filing system.
+#
+# This file defines the interface by which we declare that an object has a folder and would like to receive documents.
+# 
+# It is also possible to have a loose folder: in that case it is considered public and available to everyone.
+# 
+module Droom
+  module Folders
+
+    def self.included(base)
+      base.extend FolderClassMethods
+    end
+
+    module FolderClassMethods
+      def has_folder?
+        false
+      end
+
+      # In most cases all you need is a `has_folder` line in the model class definition.
+      #
+      #   class Thing < ActiveRecord::Base
+      #     has_folder
+      #   end
+      #
+      # This will bring in the folder and document associations and all the instance methods
+      # involved in adding and removing documents. The folder itself is lazy-loaded: the first
+      # time it is requested, it will be created.
+      #
+      # You can specify that the folder should be created inside another folder. For example, the
+      # document folder associated with an agenda_category is always created within the folder of
+      # its event, so that the filing system reflects the organisation of the event. To achieve this,
+      # pass in the name of an associate as the `:within` option:
+      #
+      #   class Subthing < ActiveRecord::Base
+      #     belongs_to :thing
+      #     has_folder :within => :thing
+      #   end
+      #
+      def has_folder( options={} )
+        return if has_folder?
+        has_one :folder, :as => :holder, :class_name => "Droom::Folder"
+        has_many :documents, :through => :folder, :class_name => "Droom::Document"
+        # The :within option is stored as a class variable that will be consulted when the folder is created.
+        class_variable_set(:"@@parent_folder_holder", options[:within])
+        
+        class_eval {
+          extend Droom::Folders::FolderedClassMethods
+          include Droom::Folders::FolderedInstanceMethods
+          alias_method_chain :folder, :lazy_load
+        }
+      end
+    end
+
+    module FolderedClassMethods
+      # The has_folder? method is used to prevent multiple calls to has_folder, but might possibly be useful elsewhere.
+      def has_folder?
+        true
+      end
+    end
+
+    module FolderedInstanceMethods
+      #
+      # Folders are lazy-created. That is, when we need it, we make it. This is achieved by chaining the `:folder` 
+      # association method and creating a folder if none exists. This method definition must occur after the association 
+      # has been defined.
+      #
+      def folder_with_lazy_load
+        folder_without_lazy_load || self.create_folder(:parent => get_parent_folder)
+      end
+
+      def all_documents
+        Droom::Document.in_folders(folder.family)
+      end
+
+      #
+      # Here we refer to the class variable defined during `has_folder` configuration. If it exists, we will put our folder 
+      # inside that of the named associate. The containing folder might be created as a side effect.
+      #
+      def get_parent_folder
+        pfh = self.class.class_variable_get(:"@@parent_folder_holder")
+        if pfh && holder = send(pfh.to_sym)
+          holder.folder
+        else
+          # otherwise we want a root folder like /Events
+          Droom::Folder.find_or_create_by_slug_and_parent_id(self.class.to_s.titlecase.split('/').last.pluralize, nil)
+        end
+      end
+
+      # Create a new document in our folder, with the supplied properties.
+      #
+      def add_document(attributes)
+        folder.documents.create(attributes)
+      end
+
+      # Move an existing document into our folder.
+      #
+      def receive_document(doc)
+        folder.documents << doc
+      end
+
+    end
+  end
+
+end

data/lib/droom/lazy_hash.rb

@@ -0,0 +1,73 @@
+# This is the mechanism by which droom's preferences system is bolted onto the host app's user class.
+# 
+module Droom
+  # LazyHash is a recursive hash descendant that accepts keys in the form `key:subkey:subsubkey` and populates 
+  # nested hashes accordingly.
+  #
+  # In droom this mechanism is used to manage the default values that sit behind user preferences. The motive
+  # is to match the `User#pref(key)` interface, with concatenated keys designating namespaced values:
+  #
+  #   LazyHash.set("key:subkey:otherkey:something", "hippopotamus")
+  #     => {:key => {:subkey => {:otherkey => {:something => "hippopotamus"}}}}
+  #
+  #   LazyHash.get("key:subkey:otherkey") => {:something => "hippopotamus"}
+  #   LazyHash.get("key:subkey:otherkey:something") => "hippopotamus"
+  #
+  # An unset value will always return nil. A set value may be false. You may want to test for the difference.
+  #
+  # NB. keys are always symbolized.
+  #
+  class LazyHash < Hash
+    
+    def initialize(*args)
+      hash = args.extract_options!
+      super
+      hash.each_pair do |k,v|
+        self[k] = v.is_a?(Hash) ? Droom::LazyHash.new(v) : v
+      end
+    end
+  
+    def inspect
+      "lazyhash: #{super}"
+    end
+
+    # *get* will return the value in the named bucket. The bucket is designated
+    # by a key that can either be simple or the dot.separated path to a nested hash. 
+    #
+    def get(path)
+      key, subkeys = split_path(path)
+      if subkeys.any?
+        if self[key].is_a?(Droom::LazyHash)
+          self[key].get(subkeys)
+        else
+          nil
+        end
+      elsif self.key?(key)
+        self[key]
+      else
+        nil
+      end
+    end
+    
+    # *set* will set the value at the named bucket. Note that you should only ever do this from an 
+    # initializer or some other thread-global event that can be relied upon always to have run. Never call
+    # LazyHash#set at runtime unless what you want is a local, non-thread-global nested hash construction.
+    #
+    def set(path, value)
+      key, subkeys = split_path(path)
+      if subkeys.any?
+        self[key] ||= Droom::LazyHash.new({})
+        self[key].set(subkeys, value)
+      else
+        self[key] = value
+      end
+    end
+    
+    #
+    def split_path(key)
+      keys = key.is_a?(Array) ? key : key.to_s.split('.')
+      keys.any? ? [keys.shift.to_sym, keys] : [nil, []]
+    end
+
+  end
+end

data/lib/droom/{helpers.rb → model_helpers.rb}

@@ -1,5 +1,5 @@
 module Droom
-  module Helpers
+  module ModelHelpers
     def self.included(base)
       base.extend Droom::ClassMethods
       base.send :include, Droom::InstanceMethods

data/lib/droom/monkeys.rb

@@ -1,5 +1,4 @@
 class Array
-  
   def to_ics
     to_rical.to_s
   end
@@ -11,5 +10,25 @@ class Array
       end
     end
   end
-  
 end
+
+class Time
+  def ceil(seconds = 60)
+    Time.at((self.to_f / seconds).ceil * seconds)
+  end
+
+  def floor(seconds = 60)
+    Time.at((self.to_f / seconds).floor * seconds)
+  end
+end
+
+class DateTime
+  def ceil(seconds = 60)
+    Time.at(self.to_f).ceil(seconds).to_datetime
+  end
+
+  def floor(seconds = 60)
+    Time.at(self.to_f).floor(seconds).to_datetime
+  end
+end
+

data/lib/droom/routing.rb

@@ -0,0 +1,13 @@
+module ActionDispatch::Routing
+
+  class Mapper
+    def droom
+      droom_at('/')
+    end
+
+    def droom_at(prefix="/")
+      prefix = "#{prefix}/" unless prefix.last == '/'
+      mount Droom::Engine => "#{prefix}droom/", :as => :droom
+    end
+  end
+end

data/lib/droom/searchability.rb

@@ -0,0 +1,25 @@
+require 'droom/title_case'
+
+STOPWORDS = %w{ a about above after again against all am and any are aren't as at be because been before being below between both by can't cannot could couldn't did didn't do does doesn't doing don't down during each few for from further had hadn't has hasn't have haven't having he he'd he'll he's her here here's hers herself himself his how how's i i'd i'll i'm i've if in into is isn't it it's its itself let's me more most mustn't my myself no nor not of off once only other ought our ours ourselves out over own same shan't she she'd she'll she's should shouldn't some such than that that's the their theirs them themselves then there there's these they they'd they'll they're they've this those through too under until up very was wasn't we we'd we'll we're we've were weren't what what's when when's where where's which while who who's whom why why's with won't would wouldn't you you'd you'll you're you've your yours yourself yourselves }
+STOPWORD_RE = %r{\b(#{STOPWORDS.join('|')})\b\s* }
+SMALL_WORDS = %w( is a an and as at but by en for if in of on or the to v[.]? via vs[.]? )
+SMALL_RE = %r{\b(#{SMALL_WORDS.join('|')})\b}io
+
+SMALL_WORDS.join('|')
+
+class String
+  include TitleCase
+
+  def searchable
+    downcase.remove_stopwords.flatten
+  end
+  
+  def flatten
+    split(/[^\w\d\']{1,}/).join(' ')
+  end
+  
+  def remove_stopwords
+    gsub(STOPWORD_RE, '')
+  end
+  
+end

data/lib/droom/taggability.rb

@@ -0,0 +1,60 @@
+module Droom
+  module Taggability
+  
+    def self.included(base)
+      base.extend TaggableClassMethods
+    end
+
+    module TaggableClassMethods
+      def has_tags?
+        false
+      end
+      
+      def has_tags
+        return if has_tags?
+        has_many :taggings, :as => :taggee, :class_name => "Droom::Tagging"
+        has_many :tags, :through => :taggings, :class_name => "Droom::Tag"
+
+        class_eval {
+          extend Droom::Taggability::TaggedClassMethods
+          include Droom::Taggability::TaggedInstanceMethods
+        }
+      end
+    end
+
+    module TaggedClassMethods
+      def has_tags?
+        true
+      end
+    end
+  
+    module TaggedInstanceMethods
+      def add_tag(word=nil)
+        self.tags << Tag.for(word) if word && !word.blank?
+      end
+
+      def remove_tag(word=nil)
+        tag = Tag.find_by_title(word) if word && !word.blank?
+        self.tags.delete(tag) if tag
+      end
+    
+      def keywords
+        self.tags.map {|t| t.name}.join(', ')
+      end
+
+      def keywords_before_type_cast   # for form_helper
+        keywords
+      end
+
+      def keywords=(somewords="")
+        if somewords.blank?
+          self.tags.clear
+        else
+          self.tags = Tag.from_list(somewords)
+        end
+      end
+          
+    end
+  end
+
+end

data/lib/droom/title_case.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/env ruby
+
+# Ruby Title Case
+# A Ruby implementation of John Gruber's Title Case
+# http://daringfireball.net/2008/05/title_case
+#
+# Copyright (c) Paul Mucur (http://mucur.name), 2008.
+# Dual-licensed under the BSD (BSD-LICENSE.txt) and GPL (GPL-LICENSE.txt)
+# licenses.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+module TitleCase
+
+  # A regular expression to match small words that should not be
+  # titleized.
+  SMALL_WORDS_RE = /^(a|an|and|as|at|but|by|en|for|if|in|of|on|or|the|to|v\.?|via|vs\.?)$/
+
+  def titleize_if_appropriate(word)
+    if word
+      # If a word does not contain a full-stop within itself and it doesn't
+      # contain any capital letters apart from its first letter, titleize it.
+      if !word[/\w\.\w/] && !word[/^.+[A-Z]/]
+
+        # Capitalise the first *word* character (therefore avoiding problems
+        # where the first character is some punctuation).
+        word[/^\W*\w/] &&= word[/^\W*\w/].upcase
+      end
+
+      word
+    else
+      ""
+    end
+  end
+
+  def title_case
+
+    # Keep track when a colon has been used at the end of a word.
+    colon_preceding = false
+
+    # Split the string by any whitespace and then inspect each word
+    # at a time.
+    words = split(/\s+/).map do |word|
+      title_cased_word = if colon_preceding
+
+        # If there was a colon preceding this word then titleize
+        # it even if it is a small word.
+        colon_preceding = false
+        titleize_if_appropriate(word)
+      elsif word.downcase[SMALL_WORDS_RE]
+
+        # If this is a small word, make it lowercase.
+        word.downcase
+      else
+
+        # In all other cases, titleize the word.
+        titleize_if_appropriate(word)
+      end
+
+      # If this word ends in a colon, set the flag so that the
+      # following word can be titleized.
+      colon_preceding = true if word[/:$/]
+
+      title_cased_word
+    end
+
+    # Always capitalise the first and last words.
+    words[0]  = titleize_if_appropriate(words[0])
+    words[-1] = titleize_if_appropriate(words[-1])
+
+    words.join(" ")
+  end
+end
+
+if $0 == __FILE__
+
+  # If this file is being executed, read in from the command line
+  # and STDIN.
+  input = ARGV.first || STDIN.read
+
+  # ARGV.first is frozen and so cannot be extended by default.
+  input = input.dup if input.frozen?
+
+  if input.empty?
+
+    # If no input was given, print simple usage instructions
+    puts "usage: ruby title_case.rb [TEXT_TO_TITLE_CASE]"
+  else
+    input.extend(TitleCase)
+
+    puts input.title_case
+  end
+end

data/lib/droom/user_config.rb

@@ -0,0 +1,67 @@
+# This is a recursive hash that accepst keys in the form `key:subkey:subsubkey` and
+# populates nested hash objects accordingly. It allows both the standard []= and a more
+# convenient method-call notation.
+#
+# 
+#
+# Call new with an existing hash to populate the LazyHash with defaults.
+
+module Droom
+
+  class PreferencesHash < Hash
+    def get(path)
+      key, subkeys = split_path(path)
+      if subkeys.any?
+        self[key.to_sym].get(subkeys)
+      else
+        if self[key].is_a? Droom::Preference
+          self[key].value
+        else
+          self[key]
+        end
+      end
+    end
+    
+    def set(path, value)
+      key, subkeys = split_path(path)
+      if subkeys.any?
+        self[key] ||= LazyHash.new({})
+        self[key].set(subkeys, value)
+      else
+        if self[key].is_a? Droom::Preference
+          self[key].set(value)
+        else
+          self[key] = value
+        end
+      end
+    end
+  
+    def has_path?(path)
+      key, subkeys = split_path(path)
+      if subkeys.any?
+        self[key.to_sym].has_path?(subkeys)
+      else
+        self.has_key?(key.to_sym)
+      end
+    end
+
+    def split_path(key)
+      keys = path.is_a?(Array) ? path : path.to_s.split(':')
+      [keys.shift, keys]
+    end
+  
+    def method_missing(method_name, *args, &blk)
+      return self.get(method_name, &blk) if has_path?(method_name)
+      match = method_name.to_s.match(/(.*?)([?=]?)$/)
+      case match[2]
+      when "="
+        self.set(match[1], args.first)
+      when "?"
+        !!self[match[1]]
+      else
+        default(method_name, *args, &blk)
+      end
+    end
+  end
+
+end