gioco 1.0.1 → 1.1.1

data/lib/generators/gioco/generator_instructions.rb

@@ -8,15 +8,15 @@ module GeneratorInstructions
 Gioco successfully installed.
 
 Now you are able to add Badges using:
-  rake gioco:add_badge[BADGE_NAME#{",POINTS" if options[:points]}#{",TYPE_NAME" if options[:types]},DEFAULT]
+  rake gioco:add_badge[BADGE_NAME#{",POINTS" if options[:points]}#{",KIND_NAME" if options[:kinds]},DEFAULT]
 
 To remove Badges using:
-  rake gioco:remove_badge[BADGE_NAME#{",TYPE_NAME" if options[:types]}]
+  rake gioco:remove_badge[BADGE_NAME#{",KIND_NAME" if options[:kinds]}]
 
 #{
-  if options[:types]
-"And to remove Types using:
-  rake gioco:remove_type[TYPE_NAME]"
+  if options[:kinds]
+"And to remove Kinds using:
+  rake gioco:remove_kind[KIND_NAME]"
   end
 }
 

data/lib/generators/gioco/model_generator.rb

@@ -1,10 +1,10 @@
 module ModelGenerator
   def generate_models
     generate("model", "level badge_id:integer #{@model_name}_id:integer")
-    if options[:types]
-      generate("model", "point user_id:integer type_id:integer value:integer")
-      generate("model", "type name:string") 
-      generate("model", "badge name:string type_id:integer  #{(options[:points]) ? "points:integer" : ""} default:boolean")
+    if options[:kinds]
+      generate("model", "point user_id:integer kind_id:integer value:integer")
+      generate("model", "kind name:string")
+      generate("model", "badge name:string kind_id:integer  #{(options[:points]) ? "points:integer" : ""} default:boolean")
     else
       generate("migration", "add_points_to_#{@model_name.pluralize} points:integer") if options[:points]
       generate("model", "badge name:string #{(options[:points]) ? "points:integer" : ""} default:boolean")
@@ -13,7 +13,7 @@ module ModelGenerator
 
   def creating_templates
     @points = (options[:points] ) ? true : false
-    @types = (options[:types] ) ? true : false
+    @kinds = (options[:kinds] ) ? true : false
     template "gioco.rb", "config/initializers/gioco.rb"
   end
 
@@ -34,19 +34,19 @@ module ModelGenerator
     add_relationship("level", @model_name, "belongs_to")
     add_relationship("level", "badge", "belongs_to")
 
-    if options[:types]
+    if options[:kinds]
       add_relationship(@model_name, "points", "has_many")
-      add_relationship("type", "points", "has_many")
-      add_relationship("type", "badges", "has_many")
-      add_relationship("badge", "type", "belongs_to")
+      add_relationship("kind", "points", "has_many")
+      add_relationship("kind", "badges", "has_many")
+      add_relationship("badge", "kind", "belongs_to")
       add_relationship("point", @model_name, "belongs_to")
-      add_relationship("point", "type", "belongs_to")
+      add_relationship("point", "kind", "belongs_to")
     end
   end
 
   def add_validations
     add_validation("badge", "name", [["presence", "true"]])
-    add_validation("type", "name", [["uniqueness", "true"], ["presence", "true"]]) if options[:types]
+    add_validation("kind", "name", [["uniqueness", "true"], ["presence", "true"]]) if options[:kinds]
   end
 
   private

data/lib/generators/gioco/rakes_generator.rb

@@ -7,19 +7,19 @@ namespace :gioco do
   
   desc "Used to add a new badge at Gioco scheme"
   
-  task :add_badge, [:name, #{":points, " if options[:points]}#{":type, " if options[:types]}:default] => :environment do |t, args|
+  task :add_badge, [:name, #{":points, " if options[:points]}#{":kind, " if options[:kinds]}:default] => :environment do |t, args|
     arg_default = ( args.default ) ? eval(args.default) : false
 
 
-    if !args.name #{"|| !args.points" if options[:points]}#{" || !args.type" if options[:types]}
+    if !args.name #{"|| !args.points" if options[:points]}#{" || !args.kind" if options[:kinds]}
       raise "There are missing some arguments"
     else
-      badge_string = "#{options[:types] ? 'type = Type.find_or_create_by_name(\'#{args.type}\')\n' : ''}"
+      badge_string = "#{options[:kinds] ? 'kind = Kind.find_or_create_by(name: \'#{args.kind}\')\n' : ''}"
 
       badge_string = badge_string + "badge = Badge.create({ 
                       :name => \'\#\{args.name\}\', 
                       #{":points => \'\#\{args.points\}\'," if options[:points]}
-                      #{":type_id  => type.id," if options[:types]}
+                      #{":kind_id  => kind.id," if options[:kinds]}
                       :default => \'\#\{arg_default\}\'
                     })\n"
 
@@ -27,8 +27,8 @@ namespace :gioco do
         badge_string = badge_string + 'resources = #{@model_name.capitalize}.find(:all)\n'
         badge_string = badge_string + "resources.each do |r|
         #{
-        if options[:points] && options[:types]
-            "r.points  << Point.create({ :type_id => type.id, :value => \'\#\{args.points\}\'})"
+        if options[:points] && options[:kinds]
+            "r.points  << Point.create({ :kind_id => kinds.id, :value => \'\#\{args.points\}\'})"
         elsif options[:points]
           "r.points = \'\#\{args.points\}\'"
         end
@@ -42,7 +42,7 @@ namespace :gioco do
 
       eval badge_string
       
-      file_path = "/db/gioco/create_badge_\#\{args.name\}#{"_\#\{args.type\}" if options[:types]}.rb"
+      file_path = "/db/gioco/create_badge_\#\{args.name\}#{"_\#\{args.kind\}" if options[:kinds]}.rb"
       File.open("\#\{Rails.root\}\#\{file_path\}", 'w') { |f| f.write badge_string }
       File.open("\#\{Rails.root\}/db/gioco/db.rb", 'a') { |f| f.write "require \\"\\#\\{Rails.root\\}\#\{file_path\}\\"\n" }
 
@@ -52,12 +52,12 @@ namespace :gioco do
 
   desc "Used to remove an old badge at Gioco scheme"
 
-  task :remove_badge, [:name#{", :type" if options[:types]}] => :environment do |t, args|
-    if !args.name#{" || !args.type" if options[:types]}
+  task :remove_badge, [:name#{", :kind" if options[:kinds]}] => :environment do |t, args|
+    if !args.name#{" || !args.kind" if options[:kinds]}
       raise "There are missing some arguments"
     else
-      badge_string = "#{"type = Type.find_by_name('\#\{args.type\}')" if options[:types]}
-      badge = Badge.where( :name => '\#\{args.name\}'#{", :type_id => type.id" if options[:types]} ).first
+      badge_string = "#{"kind = Kind.find_by_name('\#\{args.kind\}')" if options[:kinds]}
+      badge = Badge.where( :name => '\#\{args.name\}'#{", :kind_id => kind.id" if options[:kinds]} ).first
       badge.destroy\n"
     end
 
@@ -70,25 +70,25 @@ namespace :gioco do
     File.open("\#\{Rails.root\}/db/gioco/db.rb", 'a') { |f| f.write "require \\"\\#\\{Rails.root\\}\#\{file_path\}\\"\n" }
   end
 #{
-if options[:types]
+if options[:kinds]
   '
-  desc "Removes a given type"
-  task :remove_type, [:name] => :environment do |t, args|
+  desc "Removes a given kind"
+  task :remove_kind, [:name] => :environment do |t, args|
     if !args.name
       raise "There are missing some arguments"
     else
-      type_string = "type = Type.find_by_name( \'#{args.name}\' )\n"
-      type_string = type_string + "if type.badges.empty?
-        type.destroy
+      kind_string = "kind = Kind.find_by_name( \'#{args.name}\' )\n"
+      kind_string = kind_string + "if kind.badges.empty?
+        kind.destroy
       else
-        raise \'Aborted! There are badges related with this type.\'
+        raise \'Aborted! There are badges related with this kind.\'
       end\n"
     end
-    type_string = type_string + "puts \'> Type successfully removed\'"
-    eval type_string
+    kind_string = kind_string + "puts \'> Kind successfully removed\'"
+    eval kind_string
     
-    file_path = "/db/gioco/remove_type_#{args.name}.rb"
-    File.open("#{Rails.root}#{file_path}", "w") { |f| f.write type_string }
+    file_path = "/db/gioco/remove_kind_#{args.name}.rb"
+    File.open("#{Rails.root}#{file_path}", "w") { |f| f.write kind_string }
     File.open("#{Rails.root}/db/gioco/db.rb", "a") { |f| f.write "require \\"\\#\\{Rails.root\\}#{file_path}\\"\n" }
   end
   '

data/lib/generators/gioco/setup_generator.rb

@@ -13,8 +13,8 @@ class Gioco
     source_root File.expand_path("../../templates", __FILE__)
     
     desc "Setup Gioco for some resource"
-    class_option :points, :type => :boolean, :default => false, :desc => "Setup gioco with points-system based"
-    class_option :types, :type => :boolean, :default => false, :desc => "Setup gioco with multiples types(categories) of badges."
+    class_option :points, :kind => :boolean, :default => false, :desc => "Setup gioco with points-system based"
+    class_option :kinds, :kind => :boolean, :default => false, :desc => "Setup gioco with multiples kinds(categories) of badges."
 
 
     def execute

data/lib/generators/templates/badge.rb

@@ -2,8 +2,8 @@ def add(resource_id)
   resource = Gioco::Core.get_resource(resource_id)
 
   if Gioco::Core::POINTS && !resource.badges.include?(self)
-    if Gioco::Core::TYPES
-      Gioco::Core.sync_resource_by_points(resource, self.points, self.type)
+    if Gioco::Core::KINDS
+      Gioco::Core.sync_resource_by_points(resource, self.points, self.kind)
     else
       Gioco::Core.sync_resource_by_points(resource, self.points)
     end
@@ -17,10 +17,10 @@ def remove(resource_id)
   resource = Gioco::Core.get_resource(resource_id)
 
   if Gioco::Core::POINTS && resource.badges.include?(self)
-    if Gioco::Core::TYPES
-      type       = self.type
-      badges_gap = Badge.where( "points < #{self.points} AND type_id = #{type.id}" ).order('points DESC')[0]
-      Gioco::Core.sync_resource_by_points( resource, ( badges_gap.nil? ) ? 0 : badges_gap.points, type)
+    if Gioco::Core::KINDS
+      kind       = self.kind
+      badges_gap = Badge.where( "points < #{self.points} AND kind_id = #{kind.id}" ).order('points DESC')[0]
+      Gioco::Core.sync_resource_by_points( resource, ( badges_gap.nil? ) ? 0 : badges_gap.points, kind)
     else
       badges_gap = Badge.where( "points < #{self.points}" ).order('points DESC')[0]
       Gioco::Core.sync_resource_by_points( resource, ( badges_gap.nil? ) ? 0 : badges_gap.points)

data/lib/generators/templates/gioco.rb

@@ -1,3 +1,3 @@
 Gioco::Core::RESOURCE_NAME  = "<%= @model_name %>"
 Gioco::Core::POINTS         = <%= @points %>
-Gioco::Core::TYPES          = <%= @types %>
+Gioco::Core::KINDS          = <%= @kinds %>

data/lib/generators/templates/resource.rb

@@ -1,29 +1,28 @@
 def change_points(options)
-  if Gioco::Core::TYPES
-    type_id = options[:type]
-    points  = options[:points]
+  if Gioco::Core::KINDS
+    points = options[:points]
+    kind   = Kind.find(options[:kind])
   else
-    points  = options
+    points = options
+    kind   = false
   end
-  type      = (type_id) ? Type.find(type_id) : false
 
-  if Gioco::Core::TYPES
-    raise "Missing Type Identifier argument" if !type_id
-    old_pontuation  = self.points.where(:type_id => type_id).sum(:value)
+  if Gioco::Core::KINDS
+    raise "Missing Kind Identifier argument" if !kind
+    old_pontuation = self.points.where(:kind_id => kind.id).sum(:value)
   else
-    old_pontuation  = self.points.to_i
+    old_pontuation = self.points.to_i
   end
-  new_pontuation    = old_pontuation + points
-  Gioco::Core.sync_resource_by_points(self, new_pontuation, type)
+  new_pontuation = old_pontuation + points
+  Gioco::Core.sync_resource_by_points(self, new_pontuation, kind)
 end
 
-def next_badge?(type_id = false)
-  type              = (type_id) ? Type.find(type_id) : false
-  if Gioco::Core::TYPES
-    raise "Missing Type Identifier argument" if !type_id
-    old_pontuation  = self.points.where(:type_id => type_id).sum(:value)
+def next_badge?(kind_id = false)
+  if Gioco::Core::KINDS
+    raise "Missing Kind Identifier argument" if !kind_id
+    old_pontuation = self.points.where(:kind_id => kind_id).sum(:value)
   else
-    old_pontuation  = self.points.to_i
+    old_pontuation = self.points.to_i
   end
   next_badge       = Badge.where("points > #{old_pontuation}").order("points ASC").first
   last_badge_point = self.badges.last.try('points')
@@ -32,7 +31,7 @@ def next_badge?(type_id = false)
   if next_badge
     percentage      = (old_pontuation - last_badge_point)*100/(next_badge.points - last_badge_point)
     points          = next_badge.points - old_pontuation
-    next_badge_info = { 
+    next_badge_info = {
                         :badge      => next_badge,
                         :points     => points,
                         :percentage => percentage

data/lib/gioco/core.rb

@@ -4,28 +4,36 @@ class Gioco
       RESOURCE_NAME.capitalize.constantize.find(rid)
     end
 
-    def self.sync_resource_by_points(resource, points, type = false)
-
-      badges = {}
-      if TYPES && type
-        old_pontuation  = resource.points.where(:type_id => type.id).sum(:value)
-        related_badges  = Badge.where(((old_pontuation < points) ? "points <= #{points}" : "points > #{points} AND points <= #{old_pontuation}") + " AND type_id = #{type.id}")
+    def self.related_info(resource, points, kind)
+      if KINDS && kind
+        old_pontuation  = resource.points.where(:kind_id => kind.id).sum(:value)
+        related_badges  = Badge.where(((old_pontuation < points) ? "points <= #{points}" : "points > #{points} AND points <= #{old_pontuation}") + " AND kind_id = #{kind.id}")
       else
         old_pontuation  = resource.points.to_i
         related_badges  = Badge.where((old_pontuation < points) ? "points <= #{points}" : "points > #{points} AND points <= #{old_pontuation}")
       end
-      
       new_pontuation    = ( old_pontuation < points ) ? points - old_pontuation : - (old_pontuation - points)
 
+      { old_pontuation: old_pontuation, related_badges: related_badges, new_pontuation: new_pontuation }
+    end
+
+    def self.sync_resource_by_points(resource, points, kind = false)
+
+      badges         = {}
+      info           = self.related_info(resource, points, kind)
+      old_pontuation = info[:old_pontuation]
+      related_badges = info[:related_badges]
+      new_pontuation = info[:new_pontuation]
+
       Badge.transaction do
-        if TYPES && type
-          resource.points << Point.create({ :type_id => type.id, :value => new_pontuation })
+          if KINDS && kind
+          resource.points << Point.create({ :kind_id => kind.id, :value => new_pontuation })
         elsif POINTS
           resource.update_attribute( :points, points )
         end
         related_badges.each do |badge|
           if old_pontuation < points
-            if !resource.badges.include?(badge)
+            unless resource.badges.include?(badge)
               resource.badges << badge
               badges[:added] = [] if badges[:added].nil?
               badges[:added] << badge
@@ -39,6 +47,5 @@ class Gioco
         badges
       end
     end
-    
   end
 end

data/lib/gioco/rankings.rb

@@ -1,36 +1,40 @@
 class Gioco
   class Ranking < Core
 
-     def self.generate
+    def self.with_kind_and_points
       ranking = []
-      
-      if POINTS && TYPES
-        Type.find(:all).each do |t|
-          data = RESOURCE_NAME.capitalize.constantize
-                  .select("#{RESOURCE_NAME.capitalize.constantize.table_name}.*, 
-                           points.type_id, SUM(points.value) AS type_points")
-                  .where("points.type_id = #{t.id}")
-                  .joins(:points)
-                  .group("type_id, #{RESOURCE_NAME}_id")
-                  .order("type_points DESC")
+      Kind.all.each do |t|
+        data = RESOURCE_NAME.capitalize.constantize
+                .select("#{RESOURCE_NAME.capitalize.constantize.table_name}.*, 
+                         points.kind_id, SUM(points.value) AS kind_points")
+                .where("points.kind_id = #{t.id}")
+                .joins(:points)
+                .group("kind_id, #{RESOURCE_NAME}_id")
+                .order("kind_points DESC")
 
-          ranking << { :type => t, :ranking => data }
-        
-        end
-
-      elsif POINTS && !TYPES
-        ranking = RESOURCE_NAME.capitalize.constantize.order("points DESC")
+        ranking << { :kind => t, :ranking => data }
+      end
+      ranking
+    end
 
-      elsif !POINTS && !TYPES
-        ranking = RESOURCE_NAME.capitalize.constantize
-                    .select("#{RESOURCE_NAME.capitalize.constantize.table_name}.*,
-                             COUNT(levels.badge_id) AS number_of_levels")
-                    .joins(:levels)
-                    .group("#{RESOURCE_NAME}_id")
-                    .order("number_of_levels DESC")
+    def self.without_kind_and_points
+      ranking = RESOURCE_NAME.capitalize.constantize
+                  .select("#{RESOURCE_NAME.capitalize.constantize.table_name}.*,
+                           COUNT(levels.badge_id) AS number_of_levels")
+                  .joins(:levels)
+                  .group("#{RESOURCE_NAME}_id")
+                  .order("number_of_levels DESC")
+    end
 
+    def self.generate
+      ranking = []
+      if POINTS && KINDS
+        ranking = self.with_kind_and_points
+      elsif POINTS && !KINDS
+        ranking = RESOURCE_NAME.capitalize.constantize.order("points DESC")
+      elsif !POINTS && !KINDS
+        ranking = without_kind_and_points
       end
-
       ranking
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gioco
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-15 00:00:00.000000000Z
+date: 2013-09-13 00:00:00.000000000 Z
 dependencies: []
 description: Gioco is a easy to implement gamification gem based on plug and play
   concept. Doesn't matter if you already have a full and functional database, Gioco
@@ -51,7 +51,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.18
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: A gamification gem to Ruby on Rails applications.