completeness-fu 0.5.0

data/VERSION.yml

@@ -0,0 +1,4 @@
+---
+:major: 0
+:minor: 5
+:patch: 0

data/init.rb

@@ -0,0 +1 @@
+require 'completeness-fu'

data/lib/completeness-fu.rb

@@ -0,0 +1,20 @@
+require 'completeness-fu/active_record_additions'
+require 'completeness-fu/scoring_builder'
+
+module ActiveRecord
+  Base.class_eval do
+    include CompletenessFu::ActiveRecordAdditions
+  end
+end
+
+
+CompletenessFu.common_weightings  = { :low => 20, :medium => 40, :high => 60 }
+
+CompletenessFu.default_weightings = 40
+
+CompletenessFu.default_i18n_namespace = [:completeness_scoring, :models]
+
+CompletenessFu.default_grading    = { :poor => 0..24, 
+                                      :low =>  25..49, 
+                                      :medium => 50..79, 
+                                      :high => 80..100 }

data/lib/completeness-fu/active_record_additions.rb

@@ -0,0 +1,112 @@
+module CompletenessFu
+  
+  class << self
+    attr_accessor :common_weightings
+    attr_accessor :default_weightings
+    attr_accessor :default_i18n_namespace
+    attr_accessor :default_grading
+  end
+    
+  
+  module ActiveRecordAdditions
+    
+    def self.included(base)
+      base.class_eval do
+        def self.define_completeness_scoring(&checks_block)
+          class_inheritable_array :completeness_checks
+          cattr_accessor :default_weighting
+          cattr_accessor :model_weightings
+          
+          self.send :extend, ClassMethods
+          self.send :include, InstanceMethods
+          
+          checks_results = CompletenessFu::ScoringBuilder.generate(self, &checks_block)
+          
+          self.default_weighting   = checks_results[:default_weighting]
+          self.completeness_checks = checks_results[:completeness_checks]
+          self.model_weightings    = checks_results[:model_weightings]
+          self.before_validation checks_results[:cache_score_details] if checks_results[:cache_score_details]
+        end
+      end
+    end
+    
+    
+    module ClassMethods
+      def max_completeness_score
+        self.completeness_checks.inject(0) { |score, check| score += check[:weighting] }
+      end
+    end
+    
+    
+    module InstanceMethods
+      # returns an array of hashes with the translated name, description + weighting
+      def failed_checks
+        self.completeness_checks.inject([]) do |failures, check| 
+          failures << translate_check_details(check) if not check[:check].call(self)
+          failures
+        end
+      end
+      
+      # returns an array of hashes with the translated name, description + weighting
+      def passed_checks
+        self.completeness_checks.inject([]) do |passed, check| 
+          case check[:check]
+          when Proc
+            passed << translate_check_details(check) if check[:check].call(self)
+          when Symbol
+            passed << translate_check_details(check) if self.send check[:check]
+          end
+          
+          passed
+        end
+      end
+      
+      # returns the absolute complete score
+      def completeness_score
+        sum_score = 0
+        passed_checks.each { |check| sum_score += check[:weighting] }
+        sum_score
+      end
+      
+      # returns the percentage of completeness (relative score)
+      def percent_complete
+        self.completeness_score.to_f / self.class.max_completeness_score.to_f  * 100
+      end
+      
+      # returns a basic 'grading' based on percent_complete, defaults are :high, :medium, :low, and :poor
+      def completeness_grade
+        CompletenessFu.default_grading.each do |grading| 
+          return grading.first if grading.last.include?(self.percent_complete) 
+        end
+      end
+      
+      
+      private 
+      
+        def translate_check_details(full_check)
+          namespace = CompletenessFu.default_i18n_namespace + [self.class.name.downcase.to_sym, full_check[:name]]
+          
+          translations = [:title, :description, :extra].inject({}) do |list, field|
+                           list[field] = I18n.t(field.to_sym, :scope => namespace)
+                           list
+                         end
+          
+          full_check.merge(translations)
+        end
+        
+        def cache_completeness_score(score_type)
+          score = case score_type
+                  when :relative
+                    self.percent_complete
+                  when :absolute
+                    self.completeness_score
+                  else
+                    raise ArgumentException, 'completeness scoring type not recognized'
+                  end
+          self.cached_completeness_score = score.round
+        end
+    end
+    
+  end
+  
+end

data/lib/completeness-fu/scoring_builder.rb

@@ -0,0 +1,46 @@
+module CompletenessFu
+  
+  # A simple clean room for setting up the completeness check information
+  class ScoringBuilder
+
+    attr_accessor :completeness_checks, :model_weightings, :cache_score_details, :default_weighting
+    
+    def self.generate(model, &block)
+      sb = ScoringBuilder.new
+      
+      sb.completeness_checks = []
+      sb.default_weighting   = CompletenessFu.default_weightings
+      sb.model_weightings    = CompletenessFu.common_weightings
+      
+      sb.instance_eval(&block)
+      
+      { :completeness_checks => sb.completeness_checks,
+        :model_weightings    => sb.model_weightings,
+        :cache_score_details => sb.cache_score_details,
+        :default_weighting   => sb.default_weighting }     
+    end
+
+
+    private
+    
+      def check(name, check, weighting = nil)
+        weighting ||= self.default_weighting
+        weighting = self.model_weightings[weighting] if weighting.is_a?(Symbol)
+        self.completeness_checks << { :name => name, :check => check, :weighting => weighting}
+      end
+
+      def weightings(custom_weighting_opts)
+        use_common = custom_weighting_opts.delete(:merge_with_common)
+        if use_common
+          self.model_weightings.merge!(custom_weights)
+        else
+          self.model_weightings = custom_weighting_opts
+        end
+      end
+
+      def cache_score(score_type = :relative)
+        self.cache_score_details = lambda { |instance| instance.send :cache_completeness_score, score_type }
+      end
+  end
+  
+end

data/test/debug.log

@@ -0,0 +1 @@
+# Logfile created on Wed Sep 23 14:40:19 +0200 2009 by logger.rb/22285

data/test/en.yml

@@ -0,0 +1,8 @@
+en:
+  completeness_scoring:
+    models:
+      scoringtest:
+        title:
+          title: 'Title'
+          description: 'The Scoring Test Description'
+          extra: 'Just give it a title'

data/test/helper.rb

@@ -0,0 +1,56 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+
+require 'active_record'
+require 'action_controller'
+
+begin
+  require 'ruby-debug'
+rescue LoadError
+  puts "ruby-debug not loaded"
+end
+
+ROOT       = File.join(File.dirname(__FILE__), '..')
+
+$LOAD_PATH << File.join(ROOT, 'lib')
+$LOAD_PATH << File.join(ROOT, 'lib', 'completeness-fu')
+
+require File.join(ROOT, 'lib', 'completeness-fu.rb')
+
+
+TEST_DATABASE_FILE = File.join(ROOT, 'test', 'test.sqlite3')
+
+File.unlink(TEST_DATABASE_FILE) if File.exist?(TEST_DATABASE_FILE)
+ActiveRecord::Base.establish_connection(
+  "adapter" => "sqlite3", "database" => TEST_DATABASE_FILE
+)
+
+RAILS_DEFAULT_LOGGER = Logger.new(File.join(File.dirname(__FILE__), "debug.log"))
+
+load(File.dirname(__FILE__) + '/schema.rb')
+
+
+I18n.load_path << File.join(ROOT, 'test', 'en.yml')
+
+
+def rebuild_class options = {}
+  ActiveRecord::Base.send(:include, CompletenessFu::ActiveRecordAdditions)
+  Object.send(:remove_const, "ScoringTest") rescue nil
+  Object.const_set("ScoringTest", Class.new(ActiveRecord::Base))
+  ScoringTest.class_eval do
+    include CompletenessFu::ActiveRecordAdditions
+    define_completeness_scoring do
+      check :title, lambda { |test| test.title.present? }, 20
+    end
+  end
+end
+
+def reset_class class_name
+  ActiveRecord::Base.send(:include, CompletenessFu::ActiveRecordAdditions)
+  Object.send(:remove_const, class_name) rescue nil
+  klass = Object.const_set(class_name, Class.new(ActiveRecord::Base))
+  klass.class_eval{ include CompletenessFu::ActiveRecordAdditions }
+  klass
+end

data/test/schema.rb

@@ -0,0 +1,6 @@
+ActiveRecord::Schema.define :version => 0 do
+  create_table "scoring_tests", :force => true do |t|
+    t.string :title
+    t.string :cached_completeness_score
+  end
+end

data/test/scoring_test.rb

@@ -0,0 +1,198 @@
+# encoding: utf-8
+require 'test/helper'
+
+
+class ScoringTest < Test::Unit::TestCase
+  
+  context "An ActiveRecord child class" do
+    should "have a define_completeness_scoring mixed in" do
+      reset_class 'ScoringTest'
+      assert ScoringTest.methods.include?('define_completeness_scoring')
+    end
+  end
+  
+  
+  context "A class with scoring defined" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          check :title, lambda { |test| test.title.present? }, 20
+        end
+      end
+    end
+    
+    should "have one scoring check" do
+      assert_equal 1, ScoringTest.completeness_checks.size
+    end
+  
+    should "have one failed check" do
+      st = ScoringTest.new
+      assert_equal 1, st.failed_checks.size
+    end
+  
+  
+    context "and with one complete check" do
+      setup do
+        @st = ScoringTest.new
+        @st.title = 'I have a title'
+      end
+      
+      should "have an absolute completeness score of 20" do
+        assert_equal 20, @st.completeness_score
+      end
+    
+      should "have a relative completeness score of 0 (percent complete)" do
+        assert_equal 100, @st.percent_complete
+      end
+      
+      should "have a description" do
+        assert_equal "The Scoring Test Description", @st.passed_checks.first[:description]
+      end
+    end
+  end
+  
+  
+  context "A class with scoring defined with no weighting" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          check :title, lambda { |test| test.title.present? }
+        end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have the default scoring used" do
+      assert_equal 40, @st.completeness_score
+    end
+  end
+
+
+  context "A class with scoring defined with a symbol weighting" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          check :title, lambda { |test| test.title.present? }, :high
+        end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have a scoring from the common_weightings hash used used" do
+      assert_equal ScoringTest.model_weightings[:high], @st.completeness_score
+    end
+  end
+  
+  
+  context "A class with scoring defined with a custom weighting" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          weightings :super_high => 80
+          check :title, lambda { |test| test.title.present? }, :super_high
+        end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have a scoring from the common_weightings hash used used" do
+      assert_equal ScoringTest.model_weightings[:super_high], @st.completeness_score
+    end
+  end
+  
+  
+  context "A class with scoring defined with a custom weighting and no common weightings" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          weightings :super_high => 80 , :merge_with_common => false
+          check :title, lambda { |test| test.title.present? }, :super_high
+        end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have a scoring from the common_weightings hash used used" do
+      assert_equal nil, ScoringTest.model_weightings[:high]
+      assert_equal ScoringTest.model_weightings[:super_high], @st.completeness_score
+    end
+  end
+  
+  
+  context "A class with scoring defined with a check using a symbol to a private method" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          check :title, :title_present?, :high
+        end
+        
+        private
+          def title_present?
+            self.title.present?
+          end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have a scoring from the common_weightings hash used used" do
+      assert_equal 1, @st.passed_checks.size
+      assert_equal 60, @st.completeness_score
+    end
+  end
+  
+  
+  context "A class with scoring defined and cache to field directive" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          cache_score :absolute
+          check :title, :title_present?, :high
+        end
+        
+        private
+          def title_present?
+            self.title.present?
+          end
+      end
+      @st = ScoringTest.new
+      @st.title = 'I have a title'
+    end
+    
+    should "have a before filter added, and save the defined calculation to the default field" do
+      assert_equal nil, @st.cached_completeness_score
+      @st.valid?
+      assert_equal @st.completeness_score, @st.cached_completeness_score
+    end
+  end
+  
+  
+  context "A class with scoring" do
+    setup do
+      reset_class 'ScoringTest'
+      ScoringTest.class_eval do
+        define_completeness_scoring do
+          check :title, lambda { |test| test.title.present? }, :high
+        end
+      end
+      @st = ScoringTest.new
+    end
+    
+    should "have a grade of :high" do
+      assert_equal :poor, @st.completeness_grade
+      @st.title = 'I have a title'
+      assert_equal :high, @st.completeness_grade
+    end
+  end
+end

metadata

@@ -0,0 +1,73 @@
+--- !ruby/object:Gem::Specification 
+name: completeness-fu
+version: !ruby/object:Gem::Version 
+  version: 0.5.0
+platform: ruby
+authors: 
+- Josh Kalderimis
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-03 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.3
+    version: 
+description: 
+email: josh.kalderimis@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- VERSION.yml
+- init.rb
+- lib/completeness-fu.rb
+- lib/completeness-fu/active_record_additions.rb
+- lib/completeness-fu/scoring_builder.rb
+has_rdoc: true
+homepage: http://github.com/joshk/completeness-fu
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Simple dsl for defining how to calculate how complete a model instance is (similar to LinkedIn profile completeness)
+test_files: 
+- test/debug.log
+- test/en.yml
+- test/helper.rb
+- test/schema.rb
+- test/scoring_test.rb
+- test/test.sqlite3