has_friends_ti2 0.0.22

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 097ffae0ab0f59a935d09428c7d045aeb4da24e8
+  data.tar.gz: 4ffde702a150b4dcef50079293719bb6c6f93450
+SHA512:
+  metadata.gz: d67263d8d8c742a9d6da53c9e7eac92875f57d313c6b00bb929ce97ec02351853d354bd6097a85f850a77f12039af57e83670a0dbc76b598c22b7692bb53cd92
+  data.tar.gz: 2203974ac10a80eb829d175565823c3aa61e13fc593ecb3d827de53b35a9129f0ff43d1b73fe8b1148df308e957987b85860d4447cf2a7f9ef27b7d78081c24f

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--require spec_helper
+--fail-fast
+--format documentation

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in has_friends.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Tiago D Cipriano
+
+MIT License
+
+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,168 @@
+# HasFriends
+
+**ATTENTION:** This is a new simpler implementation.
+
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'has_friends'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install has_friends
+
+## Usage
+
+Generate a migration with:
+```
+rails generate migration create_friendships
+```
+And add the following code:
+```
+class CreateFriendships < ActiveRecord::Migration
+  def self.up
+      create_table :friendships do |t|
+      t.references :user, :friend
+      t.datetime :requested_at, :accepted_at, :null => true, :default => nil
+      t.string :status
+   end
+
+    add_index :friendships, :user_id
+    add_index :friendships, :friend_id
+    add_index :friendships, :status
+  end
+
+  def self.down
+    drop_table :friendships
+  end
+end
+```
+Finally, run the migrations with
+```
+rake db:migrate
+```
+
+Usage
+-----
+
+Add the method call `has_friends` to your model.
+
+```
+class User < ActiveRecord::Base
+  has_friends
+end
+```
+
+```
+john = User.find_by_login 'john'
+mary = User.find_by_login 'mary'
+paul = User.find_by_login 'paul'
+```
+
+```
+# john wants to be friend with mary
+# always return a friendship object
+john.be_friends_with(mary)
+
+# are they friends?
+john.friends?(mary)
+
+# get the friendship object
+john.friendship_for(mary)
+
+# mary accepts john's request if it exists;
+# makes a friendship request otherwise.
+mary.be_friends_with(john)
+
+# check if paul is mary's friend
+mary.friends?(paul)
+
+# check if an user is the current user, so it can
+# be differently presented
+mary.friends.each {|friend| friend.is?(current_user) }
+
+# if you're dealing with a friendship object,
+# the following methods are available
+friendship.accept!
+
+# if you're using has_paginate plugin, you can use it:
+mary.friends.paginate(:page => 3, :limit => 10)
+
+# the be_friends_with method returns 2 params: friendship object and status.
+# the friendship object will be present only when the friendship is created
+# (that is, when is requested for the first time)
+# STATUS_ALREADY_FRIENDS		 # => users are already friends
+# STATUS_ALREADY_REQUESTED		 # => user has already requested friendship
+# STATUS_IS_YOU					 # => user is trying add himself as friend
+# STATUS_FRIEND_IS_REQUIRED      # => friend argument is missing
+# STATUS_FRIENDSHIP_ACCEPTED     # => friendship has been accepted
+# STATUS_REQUESTED				 # => friendship has been requested
+
+friendship, status = mary.be_friends_with(john)
+
+if status == Friends::STATUS_REQUESTED
+# the friendship has been requested
+Mailer.deliver_friendship_request(friendship)
+elsif status == Friends::STATUS_ALREADY_FRIENDS
+# they're already friends
+else
+# ...
+end
+
+NOTE: You should have a User model. You should also have a `friends_count` column
+on your model. Otherwise, this won't work! Create a new migration with `script/generate migration add_friends_count_to_user`:
+
+class AddFriendsCountToUser < ActiveRecord::Migration
+def self.up
+add_column :users, :friends_count, :integer, :default => 0, :null => false
+end
+
+def self.down
+remove_column :users, :friends_count
+end
+end
+
+```
+
+
+## Contributing
+
+1. Fork it ( https://github.com/TiagoTi/has_friends/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+
+
+LICENSE:
+--------
+
+(The MIT License)
+
+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/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/has_friends_ti2.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'has_friends_ti2/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "has_friends_ti2"
+  spec.version       = HasFriends::VERSION
+  spec.authors       = ["Tiago D Cipriano"]
+  spec.email         = ["tiago@ti2.net.br"]
+  spec.summary       = "Lib to implement friends"
+  #spec.description   = %q{TODO: Write a longer description. Optional.}
+  #spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  #spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  #spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  #spec.add_development_dependency "bundler", "~> 1.7"
+  #spec.add_development_dependency "rake", "~> 10.0"
+end

data/lib/has_friends_ti2/friendship.rb

@@ -0,0 +1,40 @@
+class Friendship < ActiveRecord::Base
+  # constants
+  STATUS_ALREADY_FRIENDS     = 1
+  STATUS_ALREADY_REQUESTED   = 2
+  STATUS_IS_YOU              = 3
+  STATUS_FRIEND_IS_REQUIRED  = 4
+  STATUS_FRIENDSHIP_ACCEPTED = 5
+  STATUS_REQUESTED           = 6
+  
+  # scopes
+  scope :pending, -> {where(:status => 'pending')}
+  scope :accepted, -> {where(:status => 'accepted')}
+  scope :requested, -> {where(:status => 'requested')}
+  
+  # associations
+  belongs_to :user
+  belongs_to :friend, :class_name => 'User', :foreign_key => 'friend_id'
+  
+  # callback
+  after_destroy do |f|
+    User.decrement_counter(:friends_count, f.user_id)
+  end
+  
+  def pending?
+    status == 'pending'
+  end
+  
+  def accepted?
+    status == 'accepted'
+  end
+  
+  def requested?
+    status == 'requested'
+  end
+
+  def accept!
+    User.increment_counter(:friends_count, user.id) unless accepted?
+    update_attribute(:status, 'accepted')
+  end
+end

data/lib/has_friends_ti2/has_friends.rb

@@ -0,0 +1,76 @@
+module HasFriends
+
+	module Friends
+		module ClassMethods
+			def has_friends
+				has_many :friendships
+        has_many :friends, :through => :friendships, :source => :friend#,-> { where( status: 'accepted')} #"friendships.status = 'accepted'"
+        after_destroy :destroy_all_friendships
+			end
+		end
+		
+		module InstanceMethods
+			def be_friends_with friend
+        # no user object
+        return nil, Friendship::STATUS_FRIEND_IS_REQUIRED unless friend
+
+        # should not create friendship if user is trying to add himself
+        return nil, Friendship::STATUS_IS_YOU if is?(friend)
+
+        # should not create friendship if users are already friends
+        return nil, Friendship::STATUS_ALREADY_FRIENDS if friends?(friend)
+
+        # retrieve the friendship request
+        friendship = self.friendship_for(friend)
+
+        # let's check if user has already a friendship request or have removed
+        request = friend.friendship_for(self)
+
+        # friendship has already been requested
+        return nil, Friendship::STATUS_ALREADY_REQUESTED if friendship && friendship.requested?
+
+        # friendship is pending so accept it
+        if friendship && friendship.pending?
+          friendship.accept!
+          request.accept!
+
+          return friendship, Friendship::STATUS_FRIENDSHIP_ACCEPTED
+        end
+
+        # we didn't find a friendship, so let's create one!
+        friendship = self.friendships.create(:friend_id => friend.id, :status => 'requested')
+
+        # we didn't find a friendship request, so let's create it!
+        request = friend.friendships.create(:friend_id => id, :status => 'pending')
+
+        return friendship, Friendship::STATUS_REQUESTED
+			end
+
+
+			def friends?(friend)
+        friendship = friendship_for(friend)
+        friendship && friendship.accepted?
+      end
+
+      def friendship_for(friend)
+        friendships.where(:friend_id => friend.id).first
+      end
+
+      def is?(friend)
+        self.id == friend.id
+      end
+
+      private
+      def destroy_all_friendships
+        Friendship.delete_all({:user_id => id})
+        Friendship.delete_all({:friend_id => id})
+      end
+		end
+		
+		def self.included(receiver)
+			receiver.extend         HasFriends::Friends::ClassMethods
+			receiver.send :include, HasFriends::Friends::InstanceMethods
+		end
+	end
+
+end

data/lib/has_friends_ti2/version.rb

@@ -0,0 +1,3 @@
+module HasFriends
+  VERSION = "0.0.22"
+end

data/lib/has_friends_ti2.rb

@@ -0,0 +1,4 @@
+require "has_friends_ti2/version"
+require "has_friends_ti2/has_friends"
+require "has_friends_ti2/friendship"
+ActiveRecord::Base.send(:include, HasFriends::Friends)

data/spec/has_friends_spec.rb

@@ -0,0 +1,176 @@
+require "spec_helper"
+
+# unset models used for testing purposes
+Object.unset_class('User')
+
+class User < ActiveRecord::Base
+	has_friends
+end
+
+describe 'has_friends' do
+
+	before do
+		User.delete_all
+
+		@vader = User.create(:login => "darth_vader")
+		@luke = User.create(:login => "luke_skywalker")
+		@leia = User.create(:login => "princess_leia")
+		@han_solo = User.create(:login => "han_solo")
+		@yoda = User.create(:login => "yoda")
+	end
+
+	describe 'methods' do
+		it "should respond to has_friends method" do
+			expect(User).to respond_to :has_friends
+		end
+
+		it "should respond to be_friends_with method" do
+			expect( @vader ).to respond_to :be_friends_with
+		end
+
+		it "should respond to friends? method" do
+			expect( @vader ).to respond_to :friends?
+		end
+	end
+
+	describe "friends" do
+		before(:each) do
+			create_friendship @vader, @luke
+			create_friendship @vader, @leia
+			create_friendship @luke, @leia
+			create_friendship @luke, @yoda
+			create_friendship @leia, @han_solo
+		end
+
+		it "should order vader's friends" do
+			# => princess_leia, luke_skywalker
+			expect(@vader.friends.all).to include( @leia, @luke )
+		end
+
+		it "should return luke's friends" do
+			expect(@luke.friends).to include(@vader, @leia, @yoda)
+		end
+
+		it "should return leia's frieds" do
+			expect(@leia.friends).to include(@vader, @luke, @han_solo)
+		end
+
+		it "should return yoda's friends" do
+			expect(@yoda.friends).to include @luke
+		end
+
+		it "should return solo's friends" do
+			expect(@han_solo.friends).to include @leia
+		end
+
+		it "should increment counter" do
+			@vader.reload
+			expect(@vader.friends_count).to eql 2
+		end
+
+		it "should decrement counter" do
+			friendship = @vader.friendship_for(@luke)
+			friendship.destroy
+
+			@vader.reload
+			expect(@vader.friends_count).to eql 1
+    end
+
+		it "should be @vader" do
+			expect(@vader.is?(@vader) ).to be_truthy
+		end
+
+		it "should not be @vader" do
+			expect( @vader.is?(@leia) ).to_not be_truthy
+		end		
+	end
+
+	describe "friendship request" do
+		it "should return nil and 'friend is required' status" do
+			friendship, status = @vader.be_friends_with(nil)
+
+			expect(friendship).to be_nil
+			expect(status).to eql Friendship::STATUS_FRIEND_IS_REQUIRED
+		end
+
+		it "should return nil and 'is you' status" do
+			friendship, status = @vader.be_friends_with(@vader)
+
+			expect(friendship).to be_nil
+			expect(status).to eql Friendship::STATUS_IS_YOU
+		end
+
+		it "should return nil and 'already friends status" do
+			@vader.be_friends_with(@luke)
+			@luke.be_friends_with(@vader)
+			friendship, status = @vader.be_friends_with(@luke)
+
+			expect(friendship).to be_nil
+			expect(status).to eql Friendship::STATUS_ALREADY_FRIENDS
+		end
+
+		it "should return nil and 'already requested' status" do
+			@vader.be_friends_with(@luke)
+			friendship, status = @vader.be_friends_with(@luke)
+
+			expect(friendship).to be_nil
+			expect(status).to eql Friendship::STATUS_ALREADY_REQUESTED
+		end
+
+		it "should return friendship and 'accepted friendship' status" do
+			@vader.be_friends_with(@luke)
+			friendship, status = @luke.be_friends_with(@vader)
+
+			expect(friendship).to be_kind_of Friendship
+			expect(status).to eql Friendship::STATUS_FRIENDSHIP_ACCEPTED
+			expect(@vader).to be_friends(@luke)
+			expect(@luke).to be_friends(@vader)
+		end
+
+		it "should create friendships" do
+      expect {
+        @vader.be_friends_with(@luke)
+        
+        expect(@vader.friendships.count).to eql 1
+        expect(@luke.friendships.count).to eql 1
+      }.to change(Friendship, :count).by(2)
+		end
+	end
+
+	describe Friendship do
+    it "should be pending status" do
+      @friendship = Friendship.new(:status => 'pending')
+      expect(@friendship).to be_pending
+    end
+
+    it "should be accepted status" do
+      @friendship = Friendship.new(:status => 'accepted')
+      expect(@friendship).to be_accepted
+    end
+
+    it "should be requested status" do
+      @friendship = Friendship.new(:status => 'requested')
+      expect(@friendship).to be_requested
+    end
+  end
+  
+  describe "pagination" do
+    before(:each) do
+      pending unless Object.const_defined?('Paginate')
+      
+      create_friendship @vader, @luke
+      create_friendship @vader, @leia
+      create_friendship @vader, @han_solo
+    end
+    
+    it "should paginate friends" do
+      #expect(@vader.friends.paginate(:limit => 1).to_a).to include(@luke, @leia)
+    end
+  end
+
+	private
+		def create_friendship(user1, user2)
+			user1.be_friends_with(user2)
+			user2.be_friends_with(user1)
+		end
+end

data/spec/schema.rb

@@ -0,0 +1,18 @@
+ActiveRecord::Schema.define(:version => 0) do
+  begin
+    drop_table :users
+    drop_table :friendships
+  rescue
+  end
+  
+  create_table :users do |t|
+    t.string :login
+    t.integer :friends_count, :default => 0, :null => false
+  end
+  
+  create_table :friendships do |t|
+    t.references :user, :friend
+    t.string :status
+    t.timestamps null:false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,113 @@
+require "active_record"
+#require "spec"
+require File.dirname(__FILE__) + "/../lib/has_friends_ti2"
+
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end
+
+  ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+
+  load("schema.rb")
+
+  class Object
+    def self.unset_class(*args)
+      class_eval do
+        args.each do |klass|
+          eval(klass) rescue nil
+          remove_const(klass) if const_defined?(klass)
+        end
+      end
+    end
+  end
+
+  alias :doing :lambda

metadata

@@ -0,0 +1,58 @@
+--- !ruby/object:Gem::Specification
+name: has_friends_ti2
+version: !ruby/object:Gem::Version
+  version: 0.0.22
+platform: ruby
+authors:
+- Tiago D Cipriano
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-05-11 00:00:00.000000000 Z
+dependencies: []
+description: 
+email:
+- tiago@ti2.net.br
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- has_friends_ti2.gemspec
+- lib/has_friends_ti2.rb
+- lib/has_friends_ti2/friendship.rb
+- lib/has_friends_ti2/has_friends.rb
+- lib/has_friends_ti2/version.rb
+- spec/has_friends_spec.rb
+- spec/schema.rb
+- spec/spec_helper.rb
+homepage: 
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Lib to implement friends
+test_files: []