make_watchable 0.0.2

data/.gitignore

@@ -0,0 +1,7 @@
+Gemfile.lock
+pkg/*
+doc/*
+*.gem
+*.log
+*.sqlite3
+.bundle

data/Gemfile

@@ -0,0 +1,4 @@
+source :gemcutter
+
+# Specify your gem's dependencies in make_flaggable.gemspec
+gemspec

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010-2011 by Kai Schlamp
+
+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.rdoc

@@ -0,0 +1,78 @@
+= MakeWatchable
+
+MakeWatchable is an extension for building a user-centric watching system for Rails 3 applications.
+It currently supports ActiveRecord models.
+
+== Installation
+
+add MakeWatchable to your Gemfile
+
+  gem 'make_watchable'
+
+afterwards execute
+
+  bundle install
+
+generate the required migration file
+
+  rails generate make_watchable
+
+migrate the database
+
+  rake db:migrate
+
+== Usage
+
+  # Specify a model that can be watched.
+  class Repository < ActiveRecord::Base
+    make_watchable
+  end
+
+  # Specify a model that can watch a watchable.
+  class User < ActiveRecord::Base
+    make_watcher
+  end
+
+  # The user can now watch the watchable.
+  # If the user is already watching the watchable then an AlreadyWatchingError is raised.
+  user.watch!(repository)
+
+  # The method without bang(!) does not raise the AlreadyWatchingError, but just return
+  # false when the watcher tries to watch an already watching watchable.
+  user.watch(repository)
+
+  # The user may unwatch a watched watchable.
+  # If the watch was never watching the watchable then an NotWatchingError is raised.
+  user.unwatch!(repository)
+
+  # The method without bang(!) does not raise the NotFlaggedError, but just returns false
+  # if the watcher is not watching the watchable.
+  user.unwatch(repository)
+
+  # Get all watchings of a watchable.
+  repository.watchings
+
+  # Get the watcher of the watching.
+  watching = repository.watchings.first
+  user = watching.watcher
+
+  # Watchings can also be accessed by its watcher.
+  user.watchings
+
+  # Check if the watcher watches a watchable
+  user.watches?(repository)
+
+  # Check if a watchable is watched by a watcher
+  repository.watched_by?(user)
+
+== Testing
+
+MakeWatchable uses RSpec for testing and has a rake task for executing the provided specs
+
+  rake spec
+
+or simply
+
+  rake
+
+Copyright © 2010-2011 Kai Schlamp (http://www.medihack.org), released under the MIT license

data/Rakefile

@@ -0,0 +1,7 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/generators/make_watchable/make_watchable_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+
+class MakeWatchableGenerator < Rails::Generators::Base
+  include Rails::Generators::Migration
+
+  desc "Generates a migration for the watching model"
+
+  def self.source_root
+    @source_root ||= File.dirname(__FILE__) + '/templates'
+  end
+
+  def self.next_migration_number(path)
+    ActiveRecord::Generators::Base.next_migration_number(path)
+  end
+
+  def generate_migration
+    migration_template 'migration.rb', 'db/migrate/create_make_watchable_tables'
+  end
+end

data/lib/generators/make_watchable/templates/migration.rb

@@ -0,0 +1,22 @@
+class CreateMakeWatchableTables < ActiveRecord::Migration
+   def self.up
+     create_table :watchings do |t|
+       t.string :watchable_type
+       t.integer :watchable_id
+       t.string :watcher_type
+       t.integer :watcher_id
+
+       t.timestamps
+    end
+
+    add_index :watchings, [:watchable_type, :watchable_id]
+    add_index :watchings, [:watcher_type, :watcher_id, :watchable_type, :watchable_id], :name => "access_watchings"
+  end
+
+  def self.down
+    remove_index :watchings, :column => [:watchable_type, :watchable_id]
+    remove_index :watchings, :name => "access_watchings"
+    
+    drop_table :watchings
+  end
+end

data/lib/make_watchable/exceptions.rb

@@ -0,0 +1,21 @@
+module MakeWatchable
+  module Exceptions
+    class AlreadyWatchingError < StandardError
+      def initialize
+        super "The watcher is already watching this watchable."
+      end
+    end
+
+    class NotWatchingError < StandardError
+      def initialize
+        super "The watcher is not watching the watchable."
+      end
+    end
+
+    class InvalidWatchableError < StandardError
+      def initialize
+        super "Invalid watchable."
+      end
+    end
+  end
+end

data/lib/make_watchable/version.rb

@@ -0,0 +1,3 @@
+module MakeWatchable
+  VERSION = "0.0.2"
+end

data/lib/make_watchable/watchable.rb

@@ -0,0 +1,19 @@
+module MakeWatchable
+  module Watchable
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :watchings, :class_name => "MakeWatchable::Watching", :as => :watchable
+    end
+
+    module ClassMethods
+      def watchable?
+        true
+      end
+    end
+
+    def watched_by?(watcher)
+      watcher.watches?(self)
+    end
+  end
+end

data/lib/make_watchable/watcher.rb

@@ -0,0 +1,89 @@
+module MakeWatchable
+  module Watcher
+    extend ActiveSupport::Concern
+
+    included do
+      has_many :watchings, :class_name => "MakeWatchable::Watching", :as => :watcher
+    end
+
+    module ClassMethods
+      def watcher?
+        true
+      end
+    end
+
+    # Watch a +watchable+.
+    # Raises an +AlreadyWatchingError+ if the watcher already is watching the watchable.
+    # Raises an +InvalidWatchableError+ if the watchable is not a valid watchable.
+    def watch!(watchable)
+      check_watchable(watchable)
+
+      if watches?(watchable)
+        raise Exceptions::AlreadyWatchingError.new
+      end
+
+      Watching.create(:watchable => watchable, :watcher => self)
+
+      true
+    end
+
+    # Watch a +watchable+, but don't raise an error if the watcher is already watching the
+    # watchable. Instead simply return false then and ignore the watch request.
+    # Raises an +InvalidWatchableError+ if the watchable is not a valid watchable.
+    def watch(watchable)
+      begin
+        watch!(watchable)
+        success = true
+      rescue Exceptions::AlreadyWatchingError
+        success = false
+      end
+      success
+    end
+
+    # Unwatch a +watchable+.
+    # Raises an +NotWatchingError if the watcher is not watching the watchable.
+    # Raises an +InvalidWatchableError+ if the watchable is not a valid watchable.
+    def unwatch!(watchable)
+      check_watchable(watchable)
+
+      watching = fetch_watching(watchable)
+
+      raise Exceptions::NotWatchingError unless watching
+
+      watching.destroy
+
+      true
+    end
+
+    # Unwatch a +watchable+, but don't raise an error if the watcher is not watching
+    # the watchable. Instead returns false.
+    # Raises an +InvalidWatchableError+ if the watchable is not a valid watchable.
+    def unwatch(watchable)
+      begin
+        unwatch!(watchable)
+        success = true
+      rescue Exceptions::NotWatchingError
+        success = false
+      end
+      success
+    end
+
+    # Check if the watcher watches a watchable.
+    def watches?(watchable)
+      fetch_watching(watchable) ? true : false
+    end
+
+    private
+
+    def fetch_watching(watchable)
+      watchings.where({
+        :watchable_type => watchable.class.to_s,
+        :watchable_id => watchable.id
+      }).try(:first)
+    end
+
+    def check_watchable(watchable)
+      raise Exceptions::InvalidWatchableError unless watchable.class.watchable?
+    end
+  end
+end

data/lib/make_watchable/watching.rb

@@ -0,0 +1,6 @@
+module MakeWatchable
+  class Watching < ActiveRecord::Base
+    belongs_to :watchable, :polymorphic => true
+    belongs_to :watcher, :polymorphic => true
+  end
+end

data/lib/make_watchable.rb

@@ -0,0 +1,36 @@
+require 'make_watchable/watching'
+require 'make_watchable/watchable'
+require 'make_watchable/watcher'
+require 'make_watchable/exceptions'
+
+module MakeWatchable
+  def watchable?
+    false
+  end
+
+  def watcher?
+    false
+  end
+
+  # Specify a model as watchable.
+  #
+  # Example:
+  # class Repository < ActiveRecord::Base
+  #   make_watchable
+  # end
+  def make_watchable
+    include Watchable
+  end
+
+  # Specify a model as watcher.
+  #
+  # Example:
+  # class User < ActiveRecord::Base
+  #   make_watcher
+  # end
+  def make_watcher(options = {})
+    include Watcher
+  end
+end
+
+ActiveRecord::Base.extend MakeWatchable

data/make_watchable.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path("../lib/make_watchable/version", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "make_watchable"
+  s.version     = MakeWatchable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Kai Schlamp"]
+  s.email       = ["schlamp@gmx.de"]
+  s.homepage    = "http://github.com/medihack/make_watchable"
+  s.summary     = "Rails 3 flagging extension"
+  s.description = "A user-centric watching extension for Rails 3 applications."
+
+  s.required_rubygems_version = ">= 1.3.6"
+  s.rubyforge_project         = "make_watchable"
+
+  s.add_dependency "activerecord", "~> 3.0.0"
+  s.add_development_dependency "bundler", "~> 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.5.0"
+  s.add_development_dependency "database_cleaner", "0.6.7.RC"
+  s.add_development_dependency "sqlite3-ruby", "~> 1.3.0"
+  s.add_development_dependency "generator_spec", "~> 0.8.2"
+
+  s.files        = `git ls-files`.split("\n")
+  s.executables  = `git ls-files`.split("\n").map{|f| f =~ /^bin\/(.*)/ ? $1 : nil}.compact
+  s.require_path = 'lib'
+end

data/spec/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: make_watchable.sqlite3

data/spec/database.yml.sample

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: make_watchable.sqlite3

data/spec/generators/make_watchable_generator_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'action_controller'
+require 'generator_spec/test_case'
+require 'generators/make_watchable/make_watchable_generator'
+
+describe MakeWatchableGenerator do
+  include GeneratorSpec::TestCase
+  destination File.expand_path("/tmp", __FILE__)
+  tests MakeWatchableGenerator
+
+  before do
+    prepare_destination
+    run_generator
+  end
+
+  specify do
+    destination_root.should have_structure {
+      directory "db" do
+        directory "migrate" do
+          migration "create_make_watchable_tables" do
+            contains "class CreateMakeWatchableTables"
+            contains "create_table :watchings"
+          end
+        end
+      end
+    }
+  end
+end

data/spec/lib/make_watchable_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../../spec_helper', __FILE__)
+
+describe "Make Watchable" do
+  before(:each) do
+    @watchable = WatchableModel.create(:name => "Watchable 1")
+    @watcher = WatcherModel.create(:name => "Watcher 1")
+  end
+
+  it "should create a watchable instance" do
+    @watchable.class.should == WatchableModel
+    @watchable.class.watchable?.should == true
+  end
+
+  it "should create a watcher instance" do
+    @watcher.class.should == WatcherModel
+    @watcher.class.watcher?.should == true
+  end
+
+  describe "watcher" do
+    describe "watch" do
+      it "should create a watching" do
+        @watchable.watchings.length.should == 0
+        @watcher.watch!(@watchable).should == true
+        @watchable.watchings.reload.length.should == 1
+      end
+
+      it "should only allow to watch a watchable per watcher once with rasing an error" do
+        @watcher.watch!(@watchable)
+        lambda { @watcher.watch!(@watchable) }.should raise_error(MakeWatchable::Exceptions::AlreadyWatchingError)
+        @watchable.watchings.count.should == 1
+      end
+
+      it "should only allow to watch a watchable per watcher once without rasing an error" do
+        @watcher.watch(@watchable)
+        lambda {
+          @watcher.flag(@watchable).should == false
+        }.should_not raise_error(MakeWatchable::Exceptions::AlreadyWatchingError)
+        @watchable.watchings.count.should == 1
+      end
+    end
+
+    describe "unwatch" do
+      it "should remove a watching" do
+        @watcher.watch!(@watchable)
+        @watcher.watchings.length.should == 1
+        @watcher.unwatch!(@watchable).should == true
+        @watcher.watchings.reload.length.should == 0
+      end
+
+      it "normal method should return true when successfully unflagged" do
+        @watcher.watch(@watchable)
+        @watcher.unwatch(@watchable).should == true
+      end
+
+      it "should raise error if watcher not watching the watchable with bang method" do
+        lambda { @watcher.unwatch!(@watchable) }.should raise_error(MakeWatchable::Exceptions::NotWatchingError)
+      end
+
+      it "should not raise error if watcher not watching the watchable with normal method" do
+        lambda {
+          @watcher.unwatch(@watchable).should == false
+        }.should_not raise_error(MakeWatchable::Exceptions::NotWatchingError)
+      end
+    end
+
+    it "should check if watcher is watches the watchable" do
+      @watcher.watches?(@watchable).should == false
+      @watcher.watch!(@watchable)
+      @watcher.watches?(@watchable).should == true
+      @watcher.unwatch!(@watchable)
+      @watcher.watches?(@watchable).should == false
+    end
+  end
+
+  describe "watchable" do
+    it "should have watchings" do
+      @watchable.watchings.length.should == 0
+      @watcher.watch!(@watchable)
+      @watchable.watchings.reload.length.should == 1
+    end
+
+    it "should check if watchable is watched by watcher" do
+      @watchable.watched_by?(@watcher).should == false
+      @watcher.watch!(@watchable)
+      @watchable.watched_by?(@watcher).should == true
+      @watcher.unwatch!(@watchable)
+      @watchable.watched_by?(@watcher).should == false
+    end
+  end
+end

data/spec/models.rb

@@ -0,0 +1,10 @@
+class WatchableModel < ActiveRecord::Base
+  make_watchable
+end
+
+class WatcherModel < ActiveRecord::Base
+  make_watcher
+end
+
+class InvalidWatchableModel < ActiveRecord::Base
+end

data/spec/schema.rb

@@ -0,0 +1,25 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table :watchable_models, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :watcher_models, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :invalid_watchable_models, :force => true do |t|
+    t.string :name
+  end
+
+  create_table :watchings, :force => true do |t|
+     t.string :watchable_type
+     t.integer :watchable_id
+     t.string :watcher_type
+     t.integer :watcher_id
+
+     t.timestamps
+  end
+
+  add_index :watchings, [:watchable_type, :watchable_id]
+  add_index :watchings, [:watcher_type, :watcher_id, :watchable_type, :watchable_id], :name => "access_watchings"
+end

data/spec/spec_helper.rb

@@ -0,0 +1,37 @@
+require 'rubygems'
+require 'bundler'
+require 'logger'
+require 'rspec'
+require 'active_record'
+require 'database_cleaner'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+require 'make_watchable'
+
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/debug.log')
+ActiveRecord::Base.configurations = YAML::load_file(File.dirname(__FILE__) + '/database.yml')
+ActiveRecord::Base.establish_connection(ENV['DB'] || 'sqlite3')
+
+ActiveRecord::Base.silence do
+  ActiveRecord::Migration.verbose = false
+
+  load(File.dirname(__FILE__) + '/schema.rb')
+  load(File.dirname(__FILE__) + '/models.rb')
+end
+
+RSpec.configure do |config|
+  config.filter_run :focus => true
+  config.run_all_when_everything_filtered = true
+  config.filter_run_excluding :exclude => true
+
+  config.mock_with :rspec
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :truncation
+    DatabaseCleaner.clean
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification 
+name: make_watchable
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.2
+platform: ruby
+authors: 
+- Kai Schlamp
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-06-18 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 3.0.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.0.0
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 2.5.0
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: database_cleaner
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 0.6.7.RC
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: sqlite3-ruby
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 1.3.0
+  type: :development
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: generator_spec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: 0.8.2
+  type: :development
+  version_requirements: *id006
+description: A user-centric watching extension for Rails 3 applications.
+email: 
+- schlamp@gmx.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README.rdoc
+- Rakefile
+- lib/generators/make_watchable/make_watchable_generator.rb
+- lib/generators/make_watchable/templates/migration.rb
+- lib/make_watchable.rb
+- lib/make_watchable/exceptions.rb
+- lib/make_watchable/version.rb
+- lib/make_watchable/watchable.rb
+- lib/make_watchable/watcher.rb
+- lib/make_watchable/watching.rb
+- make_watchable.gemspec
+- spec/database.yml
+- spec/database.yml.sample
+- spec/generators/make_watchable_generator_spec.rb
+- spec/lib/make_watchable_spec.rb
+- spec/models.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/medihack/make_watchable
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: 1.3.6
+requirements: []
+
+rubyforge_project: make_watchable
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: Rails 3 flagging extension
+test_files: []
+