adhonorem 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9f326114945fed6499e4985c361ccea8375f8116
+  data.tar.gz: c2b90be5a62154750813b7d03fad2406040ad3bd
+SHA512:
+  metadata.gz: 685fc34c29a634a9685728168c89344d63f6bf88b555f78fcdbea9460183ca1fb190e33096c76fa5800ca79dd209a647f526ce85d8b7b63ca7e8118e6085b079
+  data.tar.gz: d6e57fceb122c8e2557ce35b8c4bc5b32bcfa8897c0102f3b792d2bd252c95e071ed58add556b46cb3211df585612902bedccb64d79be84577e91a6bab080c80

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2016 Hugo Chevalier
+
+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,6 @@
+= AdHonorem
+
+1. Ensure you have a User model (name as you want)
+2. rails g adhonorem:initializer
+2. rails g adhonorem:migrations
+3. rake db:migrate

data/Rakefile

@@ -0,0 +1,30 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'StaticRecord'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path('../spec/test_app/Rakefile', __FILE__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+Bundler::GemHelper.install_tasks
+
+require 'rake'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.pattern = Dir.glob('../spec/**/*_spec.rb')
+end
+task default: :spec

data/app/assets/javascripts/adhonorem/application.js

@@ -0,0 +1,13 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .

data/app/assets/stylesheets/adhonorem/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any styles
+ * defined in the other CSS/SCSS files in this directory. It is generally better to create a new
+ * file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/adhonorem/application_controller.rb

@@ -0,0 +1,5 @@
+module AdHonorem
+  class ApplicationController < ActionController::Base # :nodoc:
+    protect_from_forgery with: :exception
+  end
+end

data/app/views/layouts/adhonorem/application.html.erb

@@ -0,0 +1,14 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>AdHonorem</title>
+  <%= stylesheet_link_tag    "adhonorem/application", media: "all" %>
+  <%= javascript_include_tag "adhonorem/application" %>
+  <%= csrf_meta_tags %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,2 @@
+AdHonorem::Engine.routes.draw do
+end

data/lib/adhonorem/engine.rb

@@ -0,0 +1,5 @@
+module AdHonorem
+  class Engine < ::Rails::Engine # :nodoc:
+    isolate_namespace AdHonorem
+  end
+end

data/lib/adhonorem/exceptions.rb

@@ -0,0 +1,6 @@
+module AdHonorem
+  class NoContext < RuntimeError; end
+  class ObjectiveNotFound < RuntimeError; end
+  class NotSuchProgressType < RuntimeError; end
+  class NotCompleted < RuntimeError; end
+end

data/lib/adhonorem/generators/adhonorem_generator.rb

@@ -0,0 +1,21 @@
+module Adhonorem
+  class MigrationsGenerator < Rails::Generators::Base # :nodoc:
+    source_root File.expand_path('../templates', __FILE__)
+
+    def copy_files
+      time = Time.zone.now.strftime('%Y%m%d%H%M')
+      template 'progress_migration.rb', "db/migrate/#{time}00_create_adhonorem_progress.rb"
+      template 'achievement_migration.rb', "db/migrate/#{time}01_create_adhonorem_achievement.rb"
+    end
+  end
+
+  class InitializerGenerator < Rails::Generators::Base # :nodoc:
+    source_root File.expand_path('../templates', __FILE__)
+
+    def copy_files
+      @model_name = ask('How is your user model called? [User]')
+      @model_name = 'User' if @model_name.blank?
+      template 'initializer.rb', 'config/initializers/adhonorem.rb', @model_name
+    end
+  end
+end

data/lib/adhonorem/generators/templates/achievement_migration.rb

@@ -0,0 +1,14 @@
+# AdHonorem::Achievement will let you know easily wich badges
+# have been unlocked by a user and when
+class CreateAdhonoremAchievement < ActiveRecord::Migration
+  def change
+    create_table :adhonorem_achievements do |t|
+      t.integer :user_id
+      t.integer :state, default: 0
+      t.datetime :unlocked_at
+
+      t.timestamps null: false
+    end
+    bind_static_record :adhonorem_achievements, :badge
+  end
+end

data/lib/adhonorem/generators/templates/initializer.rb

@@ -0,0 +1,3 @@
+AdHonorem.configure do |config|
+  config.user_class = '<%= @model_name %>'
+end

data/lib/adhonorem/generators/templates/progress_migration.rb

@@ -0,0 +1,11 @@
+# AdHonorem::Progress will save the progress of your users for every badge
+class CreateAdhonoremProgress < ActiveRecord::Migration
+  def change
+    create_table :adhonorem_progresses do |t|
+      t.integer :user_id
+      t.string :objective_slug
+      t.integer :numeric_progress, default: 0
+    end
+    bind_static_record :adhonorem_progresses, :badge
+  end
+end

data/lib/adhonorem/models/achievement.rb

@@ -0,0 +1,10 @@
+module AdHonorem
+  # Allows to get finished badges per user
+  class Achievement < ActiveRecord::Base
+    self.table_name = :adhonorem_achievements
+    has_static_record :badge, class_name: 'AdHonorem::Badge'
+    belongs_to :user, class_name: AdHonorem.configuration.user_class
+
+    enum state: [:started, :done]
+  end
+end

data/lib/adhonorem/models/badge.rb

@@ -0,0 +1,240 @@
+module AdHonorem
+  # AdHonorem core class, must be inherited from
+  class Badge < ::StaticRecord::Base
+    table       :badges
+    path        Rails.root.join('app', 'models', 'badges', '**', '*.rb')
+    primary_key :slug
+
+    attr_reader :objectives, :user
+
+    # After all badges loading, @@hooks will look like
+    # {
+    #   master_a_weapon: {
+    #     'ParameteredBadge' => [:checker_one, :checker_two],
+    #     'LegacyBadge' => [:a_checker],
+    #   },
+    #   other_event: {
+    #     'OtherBadgeResponder' => [:other_checker]
+    #   }
+    # }
+    @@hooks = {}
+
+    def initialize
+      super
+
+      @sub_badges = []
+      @rewards    = []
+      @objectives = {}
+    end
+
+    def set_context(user)
+      @user = user
+      self
+    end
+
+    def reload_context!
+      check_context
+      @user = AdHonorem.configuration.user_class.constantize.find(@user.id)
+      self
+    end
+
+    def add_reward; end
+
+    def add_objective(slug, name, description, amount_needed = 1)
+      # prevent crash when Badges are initialized before migrations were applied
+      return unless defined?(AdHonorem::Objective)
+      @objectives[slug] = AdHonorem::Objective.new(slug, name, description, amount_needed)
+    end
+
+    def objectives_count
+      objectives.keys.count
+    end
+
+    def progress(progress_type = :step)
+      check_context
+      return progress_meta(progress_type) if meta?
+
+      case progress_type
+      when :step
+        objectives.keys.map do |slug|
+          name = objectives[slug].name
+          "#{name} : #{get_progression_for(slug).progress(:stringified)}"
+        end
+      when :global
+        objectives.keys.map { |slug| get_progression_for(slug).progress(:percentage) }.sum / objectives_count
+      end
+    end
+
+    def legacy?
+      legacy || false
+    end
+
+    def self.dispatch(user, event, params = nil)
+      params ||= {}
+      result = {}
+
+      @@hooks[event] ||= {}
+      @@hooks[event].each do |responder, registered_checkers|
+        badge = find_by(klass: responder).set_context(user)
+        registered_checkers.each do |checker|
+          res = badge.trigger(checker, params)
+          result[res] ||= []
+          result[res] << "#{responder}##{checker}"
+        end
+      end
+
+      result
+    end
+
+    def trigger(objective_slug, params = nil)
+      return trigger_meta(objective_slug, params || {}) if meta?
+
+      return :already_done if complete?(objective_slug) || complete?
+      return :legacy_badge if legacy?
+
+      params ||= {}
+      proceed(objective_slug, params)
+    end
+
+    def complete?(objective = nil)
+      # Meta badges don't handle per-objective completion
+      return complete_meta? if meta?
+      check_context
+      selection = objectives.keys
+      selection.select! { |slug| slug == objective } if objective
+      selection.each do |slug|
+        objective = objectives[slug]
+        return false unless get_progression_for(objective).done?
+      end
+      true
+    end
+
+    def get_objective(objective_slug)
+      objective = objective_slug
+      unless objective.is_a?(AdHonorem::Objective)
+        objective = objectives[objective_slug]
+        raise ObjectiveNotFound, "Objective #{objective_slug} could not be found" unless objective
+      end
+
+      objective
+    end
+
+    def meta?
+      !@sub_badges.empty?
+    end
+
+    class << self
+      protected
+
+      def hook(event, params = nil)
+        params ||= {}
+        @@hooks[event] ||= {}
+        @@hooks[event][name] ||= []
+        @@hooks[event][name] += [params[:to] || []].flatten.uniq
+      end
+    end
+
+    protected
+
+    def add_sub_badge(badge_slug)
+      @sub_badges << badge_slug
+    end
+
+    private
+
+    def proceed(objective_slug, params)
+      objective = get_objective(objective_slug)
+      progression = get_progression_for(objective)
+      return :failed_check unless send(objective.slug, user, params[:data] || {})
+
+      progression.advance(params[:amount] || 1)
+      if complete?
+        unlock
+        reward
+        return :completed_badge
+      end
+
+      progression.done? ? :completed_step : :triggered
+    end
+
+    def get_progression_for(objective)
+      objective = get_objective(objective)
+
+      AdHonorem::Progress.find_or_initialize_by(
+        user: @user,
+        badge_static_record_type: self.class.name,
+        objective_slug: objective.slug.to_s
+      )
+    end
+
+    def related_achievement
+      AdHonorem::Achievement.find_or_initialize_by(
+        user: @user,
+        badge_static_record_type: self.class.name
+      )
+    end
+
+    def unlock
+      raise AdHonorem::NotCompleted unless complete?
+      achievement = related_achievement
+      achievement.done!
+    end
+
+    def trigger_meta(objective_slug, params)
+      @sub_badges.each do |sub_slug|
+        sub_badge = AdHonorem::Badge.find(sub_slug).set_context(@user)
+        next if sub_badge.complete? || !sub_badge.respond_to?(objective_slug)
+        sub_badge.trigger(objective_slug, params)
+      end
+    end
+
+    def complete_meta?
+      check_context
+      progress_meta(:global) == 100.0
+    end
+
+    def progress_meta(progress_type = :step)
+      check_context
+
+      case progress_type
+      when :step
+        @sub_badges.map { |sub_slug| AdHonorem::Badge.find(sub_slug).set_context(@user).progress(progress_type) }
+      when :global
+        res = @sub_badges.map do |sub_slug|
+          AdHonorem::Badge.find(sub_slug).set_context(@user).progress(progress_type)
+        end
+        res.sum / @sub_badges.size
+      end
+    end
+
+    def next_sub_badge
+      @sub_badges.each do |sub_slug|
+        sub = AdHonorem::Badge.find(sub_slug).set_context(@user)
+        return sub unless sub.complete?
+      end
+      last_sub_badge
+    end
+
+    def last_sub_badge
+      AdHonorem::Badge.find(@sub_badges.last).set_context(@user)
+    end
+
+    def reward
+      # @rewards.each do |reward|
+      # end
+    end
+
+    def check_context
+      raise AdHonorem::NoContext, 'No context User has been set' unless @user
+    end
+
+    columns slug:             :string,
+            name:             :string,
+            description:      :string,
+            category:         :string,
+            points:           :integer,
+            icon_locked:      :string,
+            icon_unlocked:    :string,
+            legacy:           :boolean
+  end
+end

data/lib/adhonorem/models/configuration.rb

@@ -0,0 +1,10 @@
+module AdHonorem
+  # Contains AdHonorem settings
+  class Configuration
+    attr_accessor :user_class
+
+    def initialize
+      @user_class = 'User'
+    end
+  end
+end

data/lib/adhonorem/models/objective.rb

@@ -0,0 +1,14 @@
+module AdHonorem
+  # Represent a badge objective
+  # Re-created on-the-fly at each badge instantiation
+  class Objective
+    attr_reader :slug, :name, :description, :amount_needed
+
+    def initialize(slug, name, description, amount_needed = 1)
+      @slug = slug
+      @name = name
+      @description = description
+      @amount_needed = amount_needed
+    end
+  end
+end

data/lib/adhonorem/models/progress.rb

@@ -0,0 +1,48 @@
+module AdHonorem
+  # Store users' progress in database for each badge triggered at least once
+  class Progress < ActiveRecord::Base
+    self.table_name = :adhonorem_progresses
+    has_static_record :badge, class_name: 'AdHonorem::Badge'
+    belongs_to :user, class_name: AdHonorem.configuration.user_class
+
+    PROGRESS_TYPES = {
+      numeric: :capped_numeric_progress,
+      percentage: :percentage_progress,
+      stringified: :stringified_progress
+    }.freeze
+
+    def advance(amount = 1)
+      return if done?
+      self.numeric_progress += amount
+      save
+    end
+
+    def objective
+      badge.objectives[objective_slug.to_sym]
+    end
+
+    def done?
+      numeric_progress >= objective.amount_needed
+    end
+
+    def progress(progress_type = :numeric)
+      raise AdHonorem::NotSuchProgressType unless PROGRESS_TYPES.keys.include?(progress_type)
+      send(PROGRESS_TYPES[progress_type])
+    end
+
+    private
+
+    def percentage_progress
+      return 100.0 if objective.amount_needed.zero?
+      capped_numeric_progress.to_f / objective.amount_needed * 100.0
+    end
+
+    def stringified_progress
+      "#{capped_numeric_progress}/#{objective.amount_needed}"
+    end
+
+    def capped_numeric_progress
+      [self.numeric_progress, objective.amount_needed].min
+    end
+  end
+end

data/lib/adhonorem/railtie.rb

@@ -0,0 +1,12 @@
+class Railtie < Rails::Railtie # :nodoc:
+  initializer 'adhonorem.load_static_record_dependent_files' do |_app|
+    ActiveSupport.on_load :static_record do
+      require 'adhonorem/models/objective'
+      require 'adhonorem/models/achievement'
+      require 'adhonorem/models/progress'
+      require 'adhonorem/models/badge'
+
+      ActiveSupport.run_load_hooks(:adhonorem, AdHonorem::Badge)
+    end
+  end
+end

data/lib/adhonorem/version.rb

@@ -0,0 +1,3 @@
+module AdHonorem
+  VERSION = '1.0.0'.freeze
+end

data/lib/adhonorem.rb

@@ -0,0 +1,32 @@
+require 'rails'
+
+require 'adhonorem/engine'
+require 'adhonorem/models/configuration'
+
+module AdHonorem # :nodoc:
+  class << self
+    attr_writer :configuration
+  end
+
+  def self.configuration
+    @configuration ||= AdHonorem::Configuration.new
+  end
+
+  def self.reset
+    @configuration = AdHonorem::Configuration.new
+  end
+
+  def self.configure
+    yield(configuration)
+  end
+end
+
+require 'rails/generators'
+require 'adhonorem/generators/adhonorem_generator'
+
+require 'adhonorem/exceptions'
+
+require 'active_record'
+require 'static_record'
+require 'adhonorem/railtie'
+ActiveSupport.run_load_hooks(:static_record, StaticRecord::Base)

data/lib/tasks/adhonorem_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :adhonorem do
+#   # Task goes here
+# end

data/spec/adhonorem_spec.rb

@@ -0,0 +1,5 @@
+RSpec.describe AdHonorem do
+  it 'is a module' do
+    expect(AdHonorem).to be_a(Module)
+  end
+end

data/spec/helpers/badge_instantiator.rb

@@ -0,0 +1,14 @@
+def instantiate_badges
+  name = (0...50).map { ('a'..'z').to_a[rand(26)] }.join
+  @user = User.create(name: name)
+
+  @normal_badge = AdHonorem::Badge.find('normal_badge').set_context(@user)
+
+  @two_objectives_badge = AdHonorem::Badge.find('two_objectives_badge').set_context(@user)
+
+  @conditionnal_badge = AdHonorem::Badge.find('conditionnal_badge').set_context(@user)
+
+  @legacy_badge = AdHonorem::Badge.find('legacy_badge').set_context(@user)
+
+  @parametered_badge = AdHonorem::Badge.find('parametered_badge').set_context(@user)
+end

data/spec/helpers/migration_has_been_run.rb

@@ -0,0 +1,28 @@
+def migration_has_been_run?(version)
+  table_name = ActiveRecord::Migrator.schema_migrations_table_name
+  query = "SELECT version FROM %s WHERE version = '%s'" % [table_name, version]
+  ActiveRecord::Base.connection.clear_query_cache
+  ActiveRecord::Base.connection.execute(query).any?
+end
+
+def test_migrate(migration_class, migration_number, way, reset_classes = nil)
+  reset_classes ||= []
+
+  verbosity = ActiveRecord::Migration.verbose
+  ActiveRecord::Migration.verbose = false
+
+  migration = migration_class.new
+  case way
+  when :up
+    migration.migrate(:up)# unless migration_has_been_run?(migration_number)
+  when :down
+    migration.migrate(:down)# if migration_has_been_run?(migration_number)
+  end
+
+  reset_classes.each do |klass|
+    klass.connection.schema_cache.clear!
+    klass.reset_column_information
+  end
+
+  ActiveRecord::Migration.verbose = verbosity
+end