inch 0.5.0.rc3 → 0.5.0.rc4

data/lib/inch/code_object/proxy/module_object.rb

@@ -1,8 +0,0 @@
-module Inch
-  module CodeObject
-    module Proxy
-      class ModuleObject < NamespaceObject
-      end
-    end
-  end
-end

data/lib/inch/code_object/proxy/namespace_object.rb

@@ -1,33 +0,0 @@
-module Inch
-  module CodeObject
-    module Proxy
-      # a namespace object can have methods and other namespace objects
-      # inside itself (e.g. classes and modules)
-      class NamespaceObject < Base
-        # The wording is a bit redundant, but this means the class and
-        # instance attributes of the namespace
-        def attributes
-          self[:attributes]
-        end
-
-        MANY_ATTRIBUTES_THRESHOLD = 5
-        def has_many_attributes?
-          attributes.size > MANY_ATTRIBUTES_THRESHOLD
-        end
-
-        MANY_CHILDREN_THRESHOLD = 20
-        def has_many_children?
-          children.size > MANY_CHILDREN_THRESHOLD
-        end
-
-        def has_methods?
-          children.any?(&:method?)
-        end
-
-        def pure_namespace?
-          children.all?(&:namespace?)
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/object_schema.rb

@@ -1,30 +0,0 @@
-module Inch
-  module Evaluation
-    # An ObjectSchema describes how important certain parts of the docs are
-    # for the associated Object
-    class ObjectSchema
-      extend Utils::ReadWriteMethods
-
-      rw_methods %w(
-        docstring
-        parameters
-        return_type
-        return_description
-        code_example_single
-        code_example_multi
-        unconsidered_tag
-        )
-
-      attr_reader :object
-
-      def initialize(&block)
-        @block = block
-      end
-
-      def evaluate(object)
-        @object = object
-        instance_eval(&@block)
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/base.rb

@@ -1,164 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      # @abstract
-      class Base
-        extend Forwardable
-
-        MIN_SCORE = 0
-        MAX_SCORE = 100
-
-        # @return [CodeObject::Proxy::Base]
-        attr_accessor :object
-
-        class << self
-          attr_reader :criteria_map
-
-          # Defines the weights during evaluation for different criteria
-          #
-          #   MethodObject.criteria do
-          #     docstring           0.5
-          #     parameters          0.4
-          #     return_type         0.1
-          #
-          #     if object.constructor?
-          #       parameters        0.5
-          #       return_type       0.0
-          #     end
-          #   end
-          #
-          # @return [void]
-          def criteria(&block)
-            @criteria_map ||= {}
-            @criteria_map[to_s] ||= ObjectSchema.new(&block)
-          end
-        end
-
-        # @param object [CodeObject::Proxy::Base]
-        def initialize(object)
-          self.object = object
-          @roles = []
-          evaluate
-        end
-
-        # Evaluates the objects and assigns roles
-        def evaluate
-          __evaluate(object, relevant_roles)
-        end
-
-        # @return [Float] the max score that is assignable to +object+
-        def max_score
-          @__max_score = __max_score
-        end
-
-        # @return [Float] the min score that is assignable to +object+
-        def min_score
-          @__min_score = __min_score
-        end
-
-        # @return [Fixnum] the final score for +object+
-        def score
-          @__score ||= __score
-        end
-
-        # @return [Fixnum] the priority for +object+
-        def priority
-          @__priority ||= __priority
-        end
-
-        # @return [Array<Evaluation::Role::Base>]
-        def roles
-          @roles
-        end
-
-        protected
-
-        def add_role(role)
-          @roles << role
-        end
-
-        def criteria
-          @criteria ||= begin
-            c = self.class.criteria_map[self.class.to_s]
-            c.evaluate(object)
-            c
-          end
-        end
-
-        def relevant_base_roles
-          {
-            Role::Object::InRoot => nil,
-            Role::Object::Public => nil,
-            Role::Object::Protected => nil,
-            Role::Object::Private => nil,
-            Role::Object::TaggedAsNodoc => nil,
-            Role::Object::WithDoc => score_for(:docstring),
-            Role::Object::WithoutDoc => score_for(:docstring),
-            Role::Object::WithCodeExample => score_for(:code_example_single),
-            Role::Object::WithMultipleCodeExamples => score_for(:code_example_multi),
-            Role::Object::WithoutCodeExample => score_for(:code_example_single),
-            Role::Object::Tagged => score_for_unconsidered_tags,
-            Role::Object::TaggedAsAPI => nil,
-            Role::Object::TaggedAsInternalAPI => nil,
-            Role::Object::TaggedAsPrivate => nil,
-            Role::Object::Alias => object.alias? ? object.aliased_object.score : nil,
-          }
-        end
-
-        def score_for_unconsidered_tags
-          count = object.unconsidered_tag_count
-          score_for(:unconsidered_tag) * count
-        end
-
-        # Returns a key-value pair of Role classes and potential scores for
-        # each role (can be nil)
-        #
-        # @return [Hash]
-        def relevant_roles
-          {}
-        end
-
-        def score_for(criteria_name)
-          criteria.send(criteria_name) * MAX_SCORE
-        end
-
-        def __evaluate(object, role_classes)
-          role_classes.each do |role_class, score|
-            if role_class.applicable?(object)
-              add_role role_class.new(object, score)
-            end
-          end
-        end
-
-        # @return [Float] the max score that is assignable to +object+
-        def __max_score
-          arr = @roles.map(&:max_score).compact
-          [MAX_SCORE].concat(arr).min
-        end
-
-        # @return [Float] the max score that is assignable to +object+
-        def __min_score
-          arr = @roles.map(&:min_score).compact
-          [MIN_SCORE].concat(arr).max
-        end
-
-        # @return [Float]
-        def __score
-          value = @roles.inject(0) { |sum,r| sum + r.score.to_f }.to_i
-          if value < min_score
-            min_score
-          elsif value > max_score
-            max_score
-          else
-            value
-          end
-        end
-
-        # @return [Fixnum]
-        def __priority
-          @roles.inject(0) { |sum,r| sum + r.priority.to_i }
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/class_object.rb

@@ -1,8 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      class ClassObject < NamespaceObject
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/class_variable_object.rb

@@ -1,19 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      class ClassVariableObject < Base
-        protected
-
-        def relevant_roles
-          {
-            Role::ClassVariable::WithDoc => score_for(:docstring),
-            Role::ClassVariable::WithoutDoc => score_for(:docstring),
-            Role::ClassVariable::TaggedAsNodoc => nil,
-            Role::ClassVariable::Public => nil,
-            Role::ClassVariable::Private => nil,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/constant_object.rb

@@ -1,19 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      class ConstantObject < Base
-        protected
-
-        def relevant_roles
-          {
-            Role::Constant::WithDoc => score_for(:docstring),
-            Role::Constant::WithoutDoc => score_for(:docstring),
-            Role::Constant::TaggedAsNodoc => nil,
-            Role::Constant::Public => nil,
-            Role::Constant::Private => nil,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/method_object.rb

@@ -1,65 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      class MethodObject < Base
-        def evaluate
-          super
-          evaluate_parameters
-        end
-
-        protected
-
-        def relevant_roles
-          relevant_base_roles.merge(relevant_method_roles)
-        end
-
-        private
-
-        def evaluate_parameters
-          params = object.parameters
-          per_param = score_for_single_parameter
-          params.each do |param|
-            role_classes = relevant_parameter_roles(param, per_param)
-            __evaluate(param, role_classes)
-          end
-        end
-
-        def relevant_method_roles
-          {
-            Role::Method::Constructor => nil,
-            Role::Method::Getter => nil,
-            Role::Method::Setter => nil,
-            Role::Method::Overridden => object.overridden? ? object.overridden_method.score : nil,
-            Role::Method::WithManyLines => nil,
-            Role::Method::WithBangName => nil,
-            Role::Method::WithQuestioningName => nil,
-            Role::Method::HasAlias => nil,
-            Role::Method::WithReturnType => score_for(:return_type),
-            Role::Method::WithoutReturnType => score_for(:return_type),
-            Role::Method::WithReturnDescription => score_for(:return_description),
-            Role::Method::WithoutReturnDescription => score_for(:return_description),
-            Role::Method::WithoutParameters => score_for(:parameters),
-            Role::Method::WithManyParameters => nil,
-          }
-        end
-
-        def relevant_parameter_roles(param, per_param)
-          {
-            Role::MethodParameter::WithWrongMention => -score_for(:parameters),
-            Role::MethodParameter::WithMention => per_param * 0.5,
-            Role::MethodParameter::WithoutMention => per_param * 0.5,
-            Role::MethodParameter::WithType => per_param * 0.5,
-            Role::MethodParameter::WithoutType => per_param * 0.5,
-            Role::MethodParameter::WithBadName => nil,
-            Role::MethodParameter::Block => nil,
-            Role::MethodParameter::Splat => nil,
-          }
-        end
-
-        def score_for_single_parameter
-          @param_score ||= score_for(:parameters) / object.parameters.size
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/module_object.rb

@@ -1,8 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      class ModuleObject < NamespaceObject
-      end
-    end
-  end
-end

data/lib/inch/evaluation/proxy/namespace_object.rb

@@ -1,27 +0,0 @@
-module Inch
-  module Evaluation
-    module Proxy
-      # a namespace object can have methods and other namespace objects
-      # inside itself (e.g. classes and modules)
-      class NamespaceObject < Base
-        protected
-
-        def relevant_roles
-          relevant_base_roles.merge(relevant_namespace_roles)
-        end
-
-        def relevant_namespace_roles
-          {
-            Role::Namespace::Core => nil,
-            Role::Namespace::WithManyAttributes => nil,
-            Role::Namespace::WithoutChildren => nil,
-            Role::Namespace::WithChildren => nil,
-            Role::Namespace::WithManyChildren => nil,
-            Role::Namespace::WithoutMethods => nil,
-            Role::Namespace::Pure => nil,
-          }
-        end
-      end
-    end
-  end
-end

data/lib/inch/evaluation/role/base.rb

@@ -1,92 +0,0 @@
-module Inch
-  module Evaluation
-    # Role objects are assigned to evaluations of code objects. They describe
-    # the object they are attached to.
-    module Role
-      # @abstract
-      class Base
-        attr_reader :object
-
-        class << self
-          def applicable_if(symbol = nil, &block)
-            @applicable_procs ||= {}
-            @applicable_procs[to_s] = block || symbol.to_proc
-          end
-
-          def applicable_unless(symbol = nil, &block)
-            @applicable_procs ||= {}
-            @applicable_procs[to_s] = proc do |object|
-              !(block || symbol.to_proc).call(object)
-            end
-          end
-
-          def applicable?(object)
-            @applicable_procs ||= {}
-            @applicable_procs[to_s].call(object)
-          end
-        end
-
-        def initialize(object, value = nil)
-          @object = object
-          @value = value
-        end
-
-        # Returns a maximal score for the object.
-        # The final score can not be higher than this.
-        # @note Override this method to that a max_score for the evaluation.
-        # @return [Float]
-        def max_score
-        end
-
-        # Returns a minimal score for the object.
-        # The final score can not be lower than this.
-        # @note Override this method to that a min_score for the evaluation.
-        # @return [Float]
-        def min_score
-        end
-
-        # Returns a score that will be added to the associated object's
-        # overall score.
-        #
-        # @note Override this method to assign a score for the role
-        # @return [Float]
-        def score
-          @value.to_f
-        end
-
-        # Returns a potential score that would be added to the overall score
-        # if the object had implemented the Role's subject.
-        #
-        # @see Role::Missing
-        # @note Override this method to assign a potential score for the role
-        # @return [Float]
-        def potential_score
-          nil
-        end
-
-        # Returns a priority that will be added to the associated object's
-        # overall priority.
-        #
-        # @note Override this method to assign a priority for the role
-        # @return [Fixnum]
-        def priority
-          0
-        end
-
-        # Returns a suggestion to achieve the potential score that would be
-        # added to the overall score if the object had implemented the Role's
-        # subject.
-        #
-        # @see Role::Missing
-        # @return [Float]
-        def suggestion
-          nil
-        end
-
-        def object_type
-          object.class.to_s.split('::').last.gsub(/Object$/, '').downcase
-        end
-      end
-    end
-  end
-end