social_framework 0.0.3 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 25e9b3a80977e4810fcaa7dd4e78b3a0513c2ade
-  data.tar.gz: dce5017aa56be031a52eda1a88edbd2ea7203c8c
+  metadata.gz: 6b68a8daea3ad1c3e49e41c401b8b6a1d52c0315
+  data.tar.gz: 95a801e3d44a12c5515580a96bc6eea370fbff8f
 SHA512:
-  metadata.gz: 84b5c510b4b6d3905f67d4f2c0a4dcfd6074ed5c63a1db06a300b4cc0edeb42db0e27a568791bffcd341b76cd2606c243556cab38f71d796783b9427b4a2d01d
-  data.tar.gz: b78e961350c45730a7db402daf40c4df76a2984e0e5132262c33a0707273cb91ffe6caf52400e6c108feed5091f10ad7b47b1e89b364929081bfbd80b10826c2
+  metadata.gz: 98ddf314dd490d392fca2165a2ecc9b18b5dd19dd5f58bb16b922870adb318a107d95a43f569ea2a52506fe2d8ab43c5bbac4b574579f2093897dcdc74799ba0
+  data.tar.gz: 813d11b7f320a82cea98618059d369f299fa5ebf9d9d8f9620b56fe7db2a37df713bb8e5910dd4cfb4d263feebd879664df354f7e376834ca2345a48374af0c8

data/README.md

@@ -16,7 +16,7 @@
 
 > SocialFramework is divided into three modules, which are: Users, Routes and Schedulers.
 In Users module the principal resources to users are provided, like authentication, register, relationships and searchs.
-In Routes the Framework provides resources to define routes to users in different situations and provides ways to work this.
+In Routes module the Framework provides resources to check the compatibility routes.
 And in Schedulers, provides resources to define schedules to users and attempts to relate this schedules.
 
 > Therefore, the SocialFramework can help build general or specifics social networks in a way faster and practical and without not worry with recurring problems in this type of system.
@@ -30,8 +30,7 @@ And in Schedulers, provides resources to define schedules to users and attempts
 gem 'social_framework'
 ```
 
-> The path described above should be changed to the path you did the clone.
-After adding gem in your Gemfile, intall it with the command:
+> After adding the gem in your Gemfile, intall it with the command:
 
 ```console
 bundle install
@@ -43,10 +42,10 @@ bundle install
 # Getting started
 
 > The SocialFramework is based on Devise, which is a flexible authentication solution for Rails. For a full documentation to Devise see: https://github.com/plataformatec/devise.
-The User class already is implemented in SocialFramework and some changes have been applied, like adding username attribute and the behaviors to relationships betweens users.
+The User class already is implemented in SocialFramework and some changes have been applied, like adding username attribute and the behaviors to relationships between users.
 The controllers and views of the Devise also has been changed to add new features.
 
-> Initially, some files should be added to app. These files represent the settings to SocialFramework and Devise with initializers, the i18n file to Devise, the routes and the views registrations and sessions to create and authenticate users.
+> Initially, some files should be added to app. These files represent the settings to SocialFramework and Devise as initializers, the i18n file to Devise, the routes and the views registrations and sessions to create and authenticate users.
 To this you should execute:
 
 ```console
@@ -147,7 +146,7 @@ devise_for :users, class_name: 'OtherUserClass',
 ## Configuring Migrations
 
 > The User class provides the default attributes username, email and password.
-To add or remove attributes to this or any other class you can add the Migrate in yor app.
+To add or remove attributes to this or any other class you can add the Migrate in your app.
 The SocialFramework provides a generator to do this, in this case you just need execute:
 
 ```console
@@ -194,7 +193,7 @@ All Devise controllers in SocialFramework have prefix Users.
 ## Configuring Routes
 
 > When you override some Devise controller you must be define that new controller in your routes.
-This can be done changing path to controller in deviser_for, like this:
+This can be done changing path to controller in devise_for, like this:
 
 ```ruby
 devise_for :users, class_name: 'SocialFramework::User',
@@ -203,7 +202,7 @@ devise_for :users, class_name: 'SocialFramework::User',
                 passwords: 'users/passwords'}
 ```
 
-> To registrations controller was replaced with a new controller and that controller was added in routes.
+> The registrations controller was replaced with a new controller and that controller was added in routes.
 
 ----
 # Configuring Views
@@ -214,8 +213,6 @@ devise_for :users, class_name: 'SocialFramework::User',
 rails generate social_framework:views
 ```
 
-> This command will add all views to your app.
-
 > To add specific views you can use '-v' parameter and pass the views names, like this:
 
 ```console
@@ -229,12 +226,12 @@ Initially the SocialFramework add views registrations and sessions to your app p
 ----
 # SocialFramework's Modules
 
-> Currently the SocialFramework has one module to Users and Relationships, this module provides authentication, resgistrations, relationships between users and searchs in network mounted.
+> Currently the SocialFramework has modules Users, Schedules and Routes.
 
 ----
 ## Users Module
 
-> This module provides the principal logic to social networks, like create, confirm and remove relationships between users, beyond searchs, registers, updates and athentications.
+> This module provides the principal logic to social networks, like create, confirm and remove relationships between users, beyond searchs, registers, updates and authentications.
 
 > The relationships structure was built with a many to many association between Users through Edges. The Edges has user origin, user destiny, status can be active or inactive, if is bidirectional or not to specify relationships like two-way or one-way and label with the relationship name.
 May be exists multiple relationships between the same users. Each relationship is represent with an Edge.
@@ -274,10 +271,10 @@ The Graph can be accessed from the method 'graph' present in User class.
 In sign_in action the Graph is built with the User logged like root. The Graph is built until the depth specified in initializer 'social_framework.rb' in variable 'depth_to_build', the value default is three. The following is the method signature to build graph.
 
 ```ruby
-build(root, attributes = [:username, :email], relationships = "all")
+build(root, attributes = [:username, :email, :title], relationships = "all")
 ```
 
-> The attributes are user attributes thats will be mapped to vertices, for default contains 'username' and 'email', the attribute 'id' already is passed mandatorily. Relationships are the type of relationships to build the Graph, should be a string or an array, "all" is to build Graph with any relationships. In sign_in action the Graph is built with attributes 'username' and 'email', beyond 'id'.
+> The parameter root is a User that will be the root of graph, the attributes are user and event attributes thats will be mapped to vertices, for default contains 'username', 'email' and 'title'. Relationships are the type of relationships to build the Graph, should be a string or an array, "all" is to build Graph with any relationships. In sign_in action the Graph is built with attributes 'username', 'email' and 'title', beyond 'id'.
 
 > With the Graph built it's possible suggest relationships. To this it's analyzed the third level in graph finding common relationships with type specified in initializer 'social_framework.rb' in variable 'relationship_type_to_suggest', the value default is 'friend', the variable 'amount_relationship_to_suggest' specifies the value to use to suggest relationships, the default value is five. The following is the method signature.
 
@@ -294,14 +291,14 @@ suggest_relationships(type_relationships = SocialFramework.relationship_type_to_
 search(map, search_in_progress = false, elements_number = SocialFramework.elements_number_to_search)
 ```
 
-> It's passed a map to be used in search, this map represent keys and values to compare vertices, for example, the map '{username: 'user', email: 'user'}' will cause an search with any vertice thats contains the string 'user' in username or email.
-The param 'search_in_progress' is used to continue a search finding more results, to do this pass true. And, the param 'elements_number' define the quantity of users to return, this value is specified in initializer 'social_framework.rb' in variable 'elements_number_to_search', the value default is five.
+> It's passed a map to be used in search, this map represent keys and values to compare vertices, for example, the map '{username: 'user', email: 'user', title: 'event'}' will cause an search with any vertice thats contains the string 'user' in username or email or thats contains the string 'event' in title.
+The param 'search_in_progress' is used to continue a search finding more results, to do this pass true. And, the param 'elements_number' define the quantity of results to return, this value is specified in initializer 'social_framework.rb' in variable 'elements_number_to_search', the value default is five.
 
 > An example to continue searchs is shown below. For default, when you continue a search the 'elements_number' param is used to increase the maximum size to results found.
-In this case the first call returns the first five users found in graph, the second call returns more ten users and the final array has size fifteen.
+In this case the first call returns the first five elements found in graph, the second call returns more ten elements and the final size is fifteen. The return is a hash with two keys, the first is 'users' and its value is found array of users and the second is 'events' and its value is an array of events found.
 
 ```ruby
-map = {username: 'user', email: 'user'}
+map = {username: 'user', email: 'user', title: 'event'}
 graph.search(map)
 graph.search(map, true, 10)
 ```
@@ -309,21 +306,21 @@ graph.search(map, true, 10)
 > You can change the default behavior to continue searchs passing a block to method, this block will indicate how the 'elements_number' must be increased. For example:
 
 ```ruby
-map = {username: 'user', email: 'user'}
+map = {username: 'user', email: 'user', title: 'event'}
 graph.search(map, false, 1)
 graph.search(map, true) { |elements_number| elements_number *= 2 }
 ```
 
-> In that case the 'elements_number' will double every call search method with this block. Therefore, the first call returns one user due to the value passed, the second two, the third four, and so on.
+> In that case the 'elements_number' will double every call search method with this block. Therefore, the first call returns one element due to the value passed, the second two, the third four, and so on.
 
-> When the search reaches the end of the Graph and not yet found all required users an search in database is done to complete the array.
+> When the search reaches the end of the Graph and not yet found all required elements an search in database is done to complete the hash.
 
 ----
 ## Schedules Module
 
 > This module provides the logic to work with the schedule of social network users, how to create, enter, invite, confirm, exit and remove events.
 
-> The struct of relationships was built as follow: An Schedule belongs to a user and have a many to many association with Event through a Participant_Event, which has a confirmed attribute indicating whether the user has confirmed the event or is pending. Beyond an event be able to be present in various schedules, an event have a title, a description, a date and start time, a date and finish time, can or can not have an associated route and if the evente is particular an another user will only be able participate in the event if it is invited, if not particular any user can enter the event.
+> The struct of relationships was built as follow: An Schedule belongs to a user and have a many to many association with Event through a Participant_Event, which has a confirmed attribute indicating whether the user has confirmed the event or is pending. Beyond an event be able to be present in various schedules, an event have a title, a description, a date and start time, a date and finish time, can or can not have an associated route and if the event is particular an another user will only be able participate in the event if it is invited, if not particular any user can enter the event.
 
 > To create a new event uses the method 'create_event', defined in Schedule Class. The following is the method signature.
 
@@ -381,7 +378,7 @@ invite(inviting, guest, relationship = SocialFramework.relationship_type_to_invi
 
 > It is necessary to pass as a parameter the user inviting and the user guest, if not passed the type of the relationship between the users will be used the type defined in the configuration file. To invite an user to an event the inviting should be confirmed in event, have the permition to 'invite' and have the guest into your circle of relationships with the specificed type of relationship, should use the type 'all' to any type of relationship.
 
-> To change the role of a participant in an event should invoke the method 'change_participant_role', defined in Schedule Class. The following is the method signature.
+> To change the role of a participant in an event should invoke the method 'change_participant_role', defined in Schedule Class. The following is the method signature:
 
 ```ruby
 change_participant_role(maker, participant, action)
@@ -397,7 +394,7 @@ remove_participant(remover, participant)
 
 > It is necessary to pass as a parameter the remover will remove an user and the participant will be removed from the event. To the removal is performed successfully the remover must have permission to execute the action.
 
-> To add a route in an event should invoke the method 'add_route', defined in Schedule Class. The following is the method signature.
+> To add a route in an event should invoke the method 'add_route', defined in Event Class. The following is the method signature.
 
 ```ruby
 add_route(user, route)
@@ -405,7 +402,15 @@ add_route(user, route)
 
 > It is necessary to pass as a parameter the user will add a route in an event and the route will be added. To the addition is performed successfully the user must have permission to ':add_route'.
 
-> The Schedules Module uses a graph to provide slotes time ordered considering the greater amount of weight slotes. This functionality is present in the 'ScheduleHelper', which includes the Vertex and Edge classes and implements the Graph class.
+> To see all users in event confirmed or no it's necessarily call the method 'users' in event class, with the following signature:
+
+```ruby
+users(confirmed = true, role = "all")
+```
+
+> The param 'confirmed' is used to specify is users returned are confirmed in event or no. The param 'role' is used to specify users role, the value "all" define all papers.
+
+> The Schedules Module uses a graph to provide slotes time ordered considering the greater amount of weight slotes. This functionality is present in the 'ScheduleHelper', which includes the class 'ScheduleContext' responssible to invoke the schedule module methods.
 
 > In this graph the vertices with the user type only have connection with the vertices with the slot type, and the vertices with the slote type only have connection with the vertices with the user type, thus forming a bipartite graph.
 
@@ -433,7 +438,7 @@ build(users, start_day, finish_day, start_hour = Time.parse("00:00"), finish_hou
 > Currently, it's available to users create routes. That can be done with the following method, present in User class:
 
 ```ruby
-create_route(title, distance, locations, mode_of_travel = "driving")
+create_route(title, distance, locations, mode_of_travel = "driving", accepted_deviation = 0)
 ```
 
 > The params are route title, route distance, locations is a array with all points of latitude and longitude to build route, must be passed like this:
@@ -443,19 +448,15 @@ locations = [{latitude: -15.792740000000002, longitude: -47.876360000000005},
          {latitude: -15.792520000000001, longitude: -47.876900000000006}]
 ```
 
-> And mode_of_travel represents the type to build route, can be 'driving', 'bycicling', 'walking' or 'transit', the value default is 'driving' to travels with car.
+> And mode_of_travel represents the type to build route, can be 'driving', 'bycicling', 'walking' or 'transit', the value default is 'driving' to travels with car. The param accepted_deviation has zero like default value and, represent the maximum accepted deviation to some route.
 
 > That module also provides a feature to verify the compatibility between two routes. To do this call the method 'compare_routes' present in 'route_helper.rb'.
 
 ```ruby
-compare_routes(principal_route, secondary_route,
-          principal_deviation = SocialFramework.principal_deviation,
-          secondary_deviation = SocialFramework.secondary_deviation)
+compare_routes(principal_route, secondary_route)
 ```
 
-> This method is used to verify if two routes can be connected in just one route. The param principal_route represent the route that will be updated to auxliar the secondary_route if possible, when the principal_route can not be updated the on tries to update the secondary_route to achieve the goal.
-The others params principal_deviation and secondary_deviation represent a map with mode_of_travel and maximum deviation to routes, the maximum deviation is the distance that a route can be diverted to achieve the goal.
-The default values to principal_deviation and secondary_deviation are present in initializer 'social_framework.rb' and can be updated.
+> This method is used to verify if two routes can be connected in just one route. The param principal_route represent the route that will be updated to auxliar the secondary_route if possible, when the principal_route can not be updated the on tries to update the secondary_route to achieve the goal. The method uses the attribute `accepted_deviation' in routes to verify if routes can be updated.
 
 > It's returned a map with the compatibility information, like this:
 

data/app/helpers/social_framework/network_helper.rb

@@ -20,23 +20,17 @@ module SocialFramework
       # ====== Params:
       # +id+:: +Integer+ Id of the user logged
       # +elements_factory+:: +String+ Represent the factory class name to build
-      # Returns Graph object
+      # Returns NotImplementedError
       def self.get_instance(id, elements_factory)
-        @@instances ||= {}
-        
-        if @@instances[id].nil?
-          @@instances[id] = GraphStrategyDefault.new elements_factory
-        end
-
-        return @@instances[id]
+        raise 'Must implement method in subclass'
       end
 
       # Destroy graph instance with id passed
       # ====== Params:
       # +id+:: +Integer+ Id of the user logged
-      # Returns Graph instance removed
+      # Returns NotImplementedError
       def destroy(id)
-        @@instances.delete(id)
+        raise 'Must implement method in subclass'
       end
 
       # Mount a graph from an user
@@ -83,6 +77,29 @@ module SocialFramework
 
     # Represent the network on a Graph, with Vertices and Edges
     class GraphStrategyDefault < GraphStrategy
+      # Get graph instance to user logged
+      # ====== Params:
+      # +id+:: +Integer+ Id of the user logged
+      # +elements_factory+:: +String+ Represent the factory class name to build
+      # Returns Graph object
+      def self.get_instance(id, elements_factory)
+        @@instances ||= {}
+        
+        if @@instances[id].nil?
+          @@instances[id] = GraphStrategyDefault.new elements_factory
+        end
+
+        return @@instances[id]
+      end
+
+      # Destroy graph instance with id passed
+      # ====== Params:
+      # +id+:: +Integer+ Id of the user logged
+      # Returns Graph instance removed
+      def destroy(id)
+        @@instances.delete(id)
+      end
+
       # Mount a graph from an user
       # ====== Params:
       # +root+:: +User+ Root user to mount graph
@@ -125,7 +142,7 @@ module SocialFramework
       # +map+:: +Hash+ with keys and values to compare
       # +search_in_progress+:: +Boolean+ to continue if true or start a new search
       # +elements_number+:: +Integer+ to limit max search result
-      # Returns Set with users found
+      # Returns Hash with users and events found
       def search(map, search_in_progress = false, elements_number = SocialFramework.elements_number_to_search)
         return {users: @users_found, events: @events_found} if @finished_search and search_in_progress == true
 
@@ -150,7 +167,7 @@ module SocialFramework
       # ====== Params:
       # +type_relationships+:: +Array+ labels to find relationships, can be multiple in array or just one in a simple String
       # +amount_relationships+:: +Integer+ quantity of relationships to suggest a new relationship
-      # Returns +Array+ with the vertices to suggestions
+      # Returns +Array+ with users to suggestions
       def suggest_relationships(type_relationships = SocialFramework.relationship_type_to_suggest,
         amount_relationships = SocialFramework.amount_relationship_to_suggest)
 
@@ -440,7 +457,7 @@ module SocialFramework
       # +map+:: +Hash+ with keys and values to compare
       # +search_in_progress+:: +Boolean+ to continue if true or start a new search
       # +elements_number+:: +Integer+ to limit max search result
-      # Returns Set with users found
+      # Returns Hash with users and events found
       def search(map, search_in_progress = false, elements_number = SocialFramework.elements_number_to_search)
         @graph.search(map, search_in_progress, elements_number)
       end
@@ -449,7 +466,7 @@ module SocialFramework
       # ====== Params:
       # +type_relationships+:: +Array+ labels to find relationships, can be multiple in array or just one in a simple String
       # +amount_relationships+:: +Integer+ quantity of relationships to suggest a new relationship
-      # Returns +Array+ with the vertices to suggestions
+      # Returns +Array+ with users to suggestions
       def suggest_relationships(type_relationships = SocialFramework.relationship_type_to_suggest,
         amount_relationships = SocialFramework.amount_relationship_to_suggest)
         @graph.suggest_relationships(type_relationships, amount_relationships)

data/app/helpers/social_framework/route_helper.rb

@@ -9,10 +9,8 @@ module SocialFramework
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +principal_deviation+:: +Hash+ with maximum deviation and mode of travel to principal route
-      # +secondary_deviation+:: +Hash+ with maximum deviation and mode of travel to secondary route
       # Returns NotImplementedError
-      def compare_routes(principal_route, secondary_route, principal_deviation, secondary_deviation)
+      def compare_routes(principal_route, secondary_route)
         raise 'Must implement method in subclass'
       end
     end
@@ -20,19 +18,16 @@ module SocialFramework
     # Contains the methods to match routes
     class RouteStrategyDefault < RouteStrategy
 
+      RATIO_OF_EARTH = 6500000
+      
       # Compare the routes to verify if are compatible
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +principal_deviation+:: +Hash+ with maximum deviation and mode of travel to principal route
-      # +secondary_deviation+:: +Hash+ with maximum deviation and mode of travel to secondary route
       # Returns Hash with information of compatibility and necessary distances
-      def compare_routes(principal_route, secondary_route,
-          principal_deviation = SocialFramework.principal_deviation,
-          secondary_deviation = SocialFramework.secondary_deviation)
+      def compare_routes(principal_route, secondary_route)
 
-        principal_accepted = principal_accepted_deviation(principal_route, secondary_route,
-          principal_deviation[:deviation], principal_deviation[:mode])
+        principal_accepted = principal_accepted_deviation(principal_route, secondary_route)
 
         result = {compatible: false, principal_route: {deviation: :none,
             distance: 0}, secondary_route: {deviation: :none, distance: 0}}
@@ -42,23 +37,18 @@ module SocialFramework
           result[:principal_route][:deviation] = :both
           result[:principal_route][:distance] = principal_accepted[:distance]
         else
-          secondary_origin, secondary_destiny, secondary_accepted = condictions_secondary_deviation(principal_route,
-            secondary_route, principal_accepted, secondary_deviation)
+          secondary_origin, secondary_destiny, secondary_accepted =
+                condictions_secondary_deviation(principal_route, secondary_route, principal_accepted)
 
           if(secondary_origin)
-            result[:compatible] = true
-            result[:principal_route][:deviation] = :destiny
-            result[:principal_route][:distance] = principal_accepted[:distance_destiny]
-            result[:secondary_route][:deviation] = :origin
-            result[:secondary_route][:distance] = secondary_accepted[:distance_origin]
+            build_result(result, true, :destiny, principal_accepted[:distance_destiny],
+                                  :origin, secondary_accepted[:distance_origin])
           elsif(secondary_destiny)
-            result[:compatible] = true
-            result[:principal_route][:deviation] = :origin
-            result[:principal_route][:distance] = principal_accepted[:distance_origin]
-            result[:secondary_route][:deviation] = :destiny
-            result[:secondary_route][:distance] = secondary_accepted[:distance_destiny]
+            build_result(result, true, :origin, principal_accepted[:distance_origin],
+                                  :destiny, secondary_accepted[:distance_destiny])
           end
         end
+
         return result
       end
 
@@ -69,60 +59,63 @@ module SocialFramework
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
       # +principal_accepted_deviation+:: +Hash+ with point and smallest deviation
-      # +secondary_deviation+:: +Hash+ with maximum deviation and mode of travel to secondary route
       # Returns If the secondary can change origin, If the secondary can change destiny and A Hash with point and smallest deviation
-      def condictions_secondary_deviation(principal_route, secondary_route, principal_accepted_deviation, secondary_deviation)
-        secondary_accepted = secondary_accepted_deviation(principal_route, secondary_route,
-            secondary_deviation[:deviation], secondary_deviation[:mode])
+      def condictions_secondary_deviation(principal_route, secondary_route, principal_accepted_deviation)
+        secondary_accepted = secondary_accepted_deviation(principal_route, secondary_route)
 
-          principal_destiny = (principal_accepted_deviation[:accept] == :any or principal_accepted_deviation[:accept] == :destiny) 
-          principal_origin = (principal_accepted_deviation[:accept] == :any or principal_accepted_deviation[:accept] == :origin)
+        principal_destiny = (principal_accepted_deviation[:accept] == :any or
+          principal_accepted_deviation[:accept] == :destiny) 
+        
+        principal_origin = (principal_accepted_deviation[:accept] == :any or
+          principal_accepted_deviation[:accept] == :origin)
 
-          secondary_any = (secondary_accepted[:accept] == :both or secondary_accepted[:accept] == :any)
+        secondary_any = (secondary_accepted[:accept] == :both or secondary_accepted[:accept] == :any)
 
-          origin_lower_than_destiny = (secondary_any and (secondary_accepted[:distance_origin] < secondary_accepted[:distance_destiny]))
-          
-          secondary_origin = ((principal_destiny and secondary_accepted[:accept] == :origin) or
-            (secondary_any and principal_destiny))
+        origin_lower_than_destiny = (secondary_any and (secondary_accepted[:distance_origin] < secondary_accepted[:distance_destiny]))
+        
+        secondary_origin = ((principal_destiny and secondary_accepted[:accept] == :origin) or
+          (secondary_any and principal_destiny))
 
-          secondary_destiny = ((principal_origin and secondary_accepted[:accept] == :destiny) or
-            (secondary_any and principal_origin))
+        secondary_destiny = ((principal_origin and secondary_accepted[:accept] == :destiny) or
+          (secondary_any and principal_origin))
 
-          if secondary_origin and secondary_destiny
-            secondary_origin = origin_lower_than_destiny
-            secondary_destiny = (not origin_lower_than_destiny)
-          end
+        if secondary_origin and secondary_destiny
+          secondary_origin = origin_lower_than_destiny
+          secondary_destiny = (not origin_lower_than_destiny)
+        end
 
-          return secondary_origin, secondary_destiny, secondary_accepted
+        return secondary_origin, secondary_destiny, secondary_accepted
       end
 
       # Verify the deviations which can be made on principal route
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +deviation+:: +Integer+ maximum deviation accepeted to principal route
-      # +mode_of_travel+:: +String+ specify mode of travel
       # Returns Hash with point and smallest deviation
-      def principal_accepted_deviation(principal_route, secondary_route, deviation, mode_of_travel)
+      def principal_accepted_deviation(principal_route, secondary_route)
         distance_with_both = get_distance_with_waypoints(principal_route.locations.first,
           principal_route.locations.last, [secondary_route.locations.first, secondary_route.locations.last],
-          mode_of_travel)
+          principal_route.mode_of_travel)
 
-        if((not distance_with_both.nil?) and distance_with_both <= (principal_route.distance + deviation))
+        if((not distance_with_both.nil?) and
+          distance_with_both <= (principal_route.distance + principal_route.accepted_deviation))
           return {accept: :both, distance: distance_with_both}
         else
           distance_with_origin = get_distance_with_waypoints(principal_route.locations.first,
-            principal_route.locations.last, [secondary_route.locations.first], mode_of_travel)
+            principal_route.locations.last, [secondary_route.locations.first], principal_route.mode_of_travel)
 
           distance_with_destiny = get_distance_with_waypoints(principal_route.locations.first,
-            principal_route.locations.last, [secondary_route.locations.last], mode_of_travel)
+            principal_route.locations.last, [secondary_route.locations.last], principal_route.mode_of_travel)
 
-          if((not distance_with_origin.nil?) and distance_with_origin <= (principal_route.distance + deviation) and
-            distance_with_destiny <= (principal_route.distance + deviation))
+          if((not distance_with_origin.nil?) and
+            distance_with_origin <= (principal_route.distance + principal_route.accepted_deviation) and
+            distance_with_destiny <= (principal_route.distance + principal_route.accepted_deviation))
             return {accept: :any, distance_origin: distance_with_origin, distance_destiny: distance_with_destiny}
-          elsif((not distance_with_origin.nil?) and distance_with_origin <= (principal_route.distance + deviation))
+          elsif((not distance_with_origin.nil?) and
+            distance_with_origin <= (principal_route.distance + principal_route.accepted_deviation))
             return {accept: :origin, distance_origin: distance_with_origin}
-          elsif((not distance_with_destiny.nil?) and distance_with_destiny <= (principal_route.distance + deviation))
+          elsif((not distance_with_destiny.nil?) and
+            distance_with_destiny <= (principal_route.distance + principal_route.accepted_deviation))
             return {accept: :destiny, distance_destiny: distance_with_destiny}
           else
             return {accept: :none}
@@ -134,21 +127,22 @@ module SocialFramework
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +deviation+:: +Integer+ maximum deviation accepeted to secondary route
-      # +mode_of_travel+:: +String+ specify mode of travel
       # Returns Hash with point and smallest deviation
-      def secondary_accepted_deviation(principal_route, secondary_route, deviation, mode_of_travel)
-        points = near_points(principal_route, secondary_route, deviation)
-        origin_deviation = smallest_distance(points[:origins], secondary_route.locations.first, mode_of_travel)
-        destiny_deviation = smallest_distance(points[:destinations], secondary_route.locations.last, mode_of_travel)
+      def secondary_accepted_deviation(principal_route, secondary_route)
+        points = near_points(principal_route, secondary_route)
+        origin_deviation = smallest_distance(points[:origins], secondary_route.locations.first,
+          secondary_route.mode_of_travel)
+        destiny_deviation = smallest_distance(points[:destinations], secondary_route.locations.last,
+          secondary_route.mode_of_travel)
         
-        if(deviation >= origin_deviation[:deviation] + destiny_deviation[:deviation])
+        if(secondary_route.accepted_deviation >= origin_deviation[:deviation] + destiny_deviation[:deviation])
           return {accept: :both, distance_origin: origin_deviation[:deviation], distance_destiny: destiny_deviation[:deviation]}
-        elsif(deviation >= origin_deviation[:deviation] and deviation >= destiny_deviation[:deviation])
+        elsif(secondary_route.accepted_deviation >= origin_deviation[:deviation] and
+          secondary_route.accepted_deviation >= destiny_deviation[:deviation])
           return {accept: :any, distance_origin: origin_deviation[:deviation], distance_destiny: destiny_deviation[:deviation]}
-        elsif(deviation >= origin_deviation[:deviation])
+        elsif(secondary_route.accepted_deviation >= origin_deviation[:deviation])
           return {accept: :origin, distance_origin: origin_deviation[:deviation]}
-        elsif(deviation >= destiny_deviation[:deviation])
+        elsif(secondary_route.accepted_deviation >= destiny_deviation[:deviation])
           return {accept: :destiny, distance_destiny: destiny_deviation[:deviation]}
         end
         return {accept: :none}
@@ -161,12 +155,12 @@ module SocialFramework
       # +mode_of_travel+:: +String+ specify mode of travel
       # Returns Hash with point and smallest deviation
       def smallest_distance(origin_points, destiny, mode_of_travel)
-        smallest_distance = nil
+        smallest_distance = RATIO_OF_EARTH
         origin_point = nil
 
         origin_points.each do |origin|
           distance = get_distance(origin, destiny, mode_of_travel)
-          if smallest_distance.nil? or distance < smallest_distance
+          if distance < smallest_distance
             origin_point = origin
             smallest_distance = distance
           end
@@ -278,9 +272,8 @@ module SocialFramework
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +secondary_maximum_deviation+:: +Integer+ maximum deviation to who hitchhike
       # Returns Hash with origins and destinations points
-      def near_points(principal_route, secondary_route, secondary_maximum_deviation)
+      def near_points(principal_route, secondary_route)
         origin = secondary_route.locations.first
         destiny = secondary_route.locations.last
 
@@ -291,12 +284,31 @@ module SocialFramework
           distance_origin = haversine_distance(location, origin)
           distance_destiny = haversine_distance(location, destiny)
 
-          origins << location if (not distance_origin.nil?) and distance_origin <= secondary_maximum_deviation
-          destinations << location if (not distance_destiny.nil?) and distance_destiny <= secondary_maximum_deviation
+          origins << location if (not distance_origin.nil?) and
+            distance_origin <= secondary_route.accepted_deviation
+          destinations << location if (not distance_destiny.nil?) and
+            distance_destiny <= secondary_route.accepted_deviation
         end
 
         return {origins: origins, destinations: destinations}
       end
+
+      # Build results do compare routes
+      # ====== Params:
+      # +result+:: +Hash+ with all results to compare routes
+      # +compatible+:: +Boolean+ result compare routes
+      # +first_deviation+:: +Symbol+ specify where the first route is devious
+      # +first_distance+:: +Integer+ distance total to first route
+      # +second_deviation+:: +Symbol+ specify where the last route is devious
+      # +second_distance+:: +Integer+ distance total to last route
+      # Returns Hash with origins and destinations points
+      def build_result(result, compatible, first_deviation, first_distance, second_deviation, second_distance)
+        result[:compatible] = compatible
+        result[:principal_route][:deviation] = first_deviation
+        result[:principal_route][:distance] = first_distance
+        result[:secondary_route][:deviation] = second_deviation
+        result[:secondary_route][:distance] = second_distance
+      end
     end
 
     # Used to define the RouteStrategy class
@@ -311,14 +323,9 @@ module SocialFramework
       # ====== Params:
       # +principal_route+:: +Route+ who gives a lift
       # +secondary_route+:: +Route+ who hitchhike
-      # +principal_deviation+:: +Hash+ with maximum deviation and mode of travel to principal route
-      # +secondary_deviation+:: +Hash+ with maximum deviation and mode of travel to secondary route
       # Returns Hash with information of compatibility and necessary distances
-      def compare_routes(principal_route, secondary_route,
-          principal_deviation = SocialFramework.principal_deviation,
-          secondary_deviation = SocialFramework.secondary_deviation)
-
-        @route.compare_routes(principal_route, secondary_route, principal_deviation, secondary_deviation)
+      def compare_routes(principal_route, secondary_route)
+        @route.compare_routes(principal_route, secondary_route)
       end
     end
   end