inch 0.5.0.rc3 → 0.5.0.rc4

data/lib/inch/code_object.rb

@@ -3,6 +3,6 @@ module Inch
   end
 end
 
-require 'inch/code_object/converter'
-require 'inch/code_object/provider'
-require 'inch/code_object/proxy'
+require "inch/code_object/converter"
+require "inch/code_object/provider"
+require "inch/code_object/proxy"

data/lib/inch/code_object/converter.rb

@@ -52,7 +52,7 @@ module Inch
         unconsidered_tag_count
         undocumented?
         visibility
-        ).map(&:to_sym)
+      ).map(&:to_sym)
 
       PARAMETER_ATTRIBUTES = %w(
         name
@@ -62,7 +62,7 @@ module Inch
         splat?
         typed?
         wrongly_mentioned?
-        ).map(&:to_sym)
+      ).map(&:to_sym)
 
       # Returns an attributes Hash for a given code object
       #
@@ -71,16 +71,14 @@ module Inch
       def self.to_hash(o)
         attributes = {}
         OBJECT_ATTRIBUTES.each do |name|
-          if o.respond_to?(name)
-            attributes[name] = o.public_send(name)
-          end
+          next unless o.respond_to?(name)
+          attributes[name] = o.public_send(name)
         end
         attributes[:parameters] = o.parameters.map do |parameter|
           hash = {}
           PARAMETER_ATTRIBUTES.each do |pname|
-            if parameter.respond_to?(pname)
-              hash[pname] = parameter.public_send(pname)
-            end
+            next unless parameter.respond_to?(pname)
+            hash[pname] = parameter.public_send(pname)
           end
           hash
         end

data/lib/inch/code_object/provider.rb

@@ -9,7 +9,7 @@ module Inch
     # YARD's SourceParser returns ::YARD::CodeObject objects, which are
     # cast to Provider::YARD::Object::Base objects that can ensure naming
     # conventions et al. follow certain rules. These objects are then again
-    # converted into CodeObject::Proxy::Base objects that form the codebase:
+    # converted into CodeObject::Proxy objects that form the codebase:
     #
     #                        ::YARD::CodeObject
     #                               ↓
@@ -17,20 +17,20 @@ module Inch
     #                               ↓
     #                             (Hash)
     #                               ↓
-    #                   ::Inch::CodeObject::Proxy::Base
+    #                   ::Inch::CodeObject::Proxy
     #
     #
     module Provider
-      def self.parse(dir, config = Inch::Config.codebase, type = :YARD)
-        provider_for(type).parse(dir, config)
-      end
-
-      # @return [Module]
-      def self.provider_for(type)
-        const_get(type)
+      # Parses a codebase to provide objects
+      #
+      # @param dir [String] the directory to parse
+      # @param config [Inch::Config::Codebase]
+      # @return [#objects]
+      def self.parse(dir, config = Inch::Config.codebase)
+        Config.namespace(config.language, :Provider)
+          .const_get(config.object_provider)
+          .parse(dir, config)
       end
     end
   end
 end
-
-require 'inch/code_object/provider/yard'

data/lib/inch/code_object/proxy.rb

@@ -3,37 +3,68 @@ module Inch
     # CodeObject::Proxy object represent code objects in the analaysed
     # codebase.
     #
-    module Proxy
-      class << self
-        # Returns a Proxy object for the given +code_object+
-        #
-        # @param code_object [YARD::Object::Base]
-        # @return [CodeObject::Proxy::Base]
-        def for(code_object)
-          attributes = Converter.to_hash(code_object)
-          proxy_object = class_for(code_object).new(attributes)
-        end
-
-        private
-
-        # Returns a Proxy class for the given +code_object+
-        #
-        # @param code_object [YARD::CodeObject]
-        # @return [Class]
-        def class_for(code_object)
-          class_name = code_object.class.to_s.split('::').last
-          const_get(class_name)
-        end
+    class Proxy
+      # Returns a Proxy object for the given +code_object+
+      #
+      # @param language [String,Symbol]
+      # @param code_object [YARD::Object::Base]
+      # @param object_lookup [Codebase::Objects]
+      # @return [CodeObject::Proxy]
+      def self.for(language, code_object, object_lookup)
+        attributes = Converter.to_hash(code_object)
+        class_for(language, code_object).new(attributes, object_lookup)
+      end
+
+      extend Forwardable
+
+      # @return [#find]
+      #  an object that responds to #find to look up objects by their
+      #  full name
+      attr_accessor :object_lookup
+
+      # @param object_lookup [Codebase::Objects]
+      def initialize(attributes = {}, object_lookup = nil)
+        @attributes = attributes
+        @object_lookup = object_lookup
+      end
+
+      # Returns the attribute for the given +key+
+      #
+      # @param key [Symbol]
+      def [](key)
+        @attributes[key]
+      end
+
+      # @return [Symbol] the programming language of the code object
+      def language
+        raise NotImplementedError
+      end
+
+      # Used to persist the code object
+      def marshal_dump
+        @attributes
+      end
+
+      # Used to load a persisted code object
+      def marshal_load(attributes)
+        @attributes = attributes
+      end
+
+      def inspect
+        "#<#{self.class}: #{fullname}>"
+      end
+
+      private
+
+      # Returns a Proxy class for the given +code_object+
+      #
+      # @param language [String,Symbol]
+      # @param code_object [YARD::CodeObject]
+      # @return [Class]
+      def self.class_for(language, code_object)
+        class_name = code_object.class.to_s.split("::").last
+        Config.namespace(language, :CodeObject).const_get(class_name)
       end
     end
   end
 end
-
-require 'inch/code_object/proxy/base'
-require 'inch/code_object/proxy/namespace_object'
-require 'inch/code_object/proxy/class_object'
-require 'inch/code_object/proxy/class_variable_object'
-require 'inch/code_object/proxy/constant_object'
-require 'inch/code_object/proxy/method_object'
-require 'inch/code_object/proxy/method_parameter_object'
-require 'inch/code_object/proxy/module_object'

data/lib/inch/codebase.rb

@@ -5,18 +5,17 @@ module Inch
     # Parses a codebase
     #
     # @param dir [String]
-    # @param config [Inch::Config::Codebase,nil]
+    # @param config [Inch::Config::Codebase]
     # @return [Codebase::Proxy]
-    def self.parse(dir, config = nil)
-      config ||= Config.codebase.clone
+    def self.parse(dir, config)
       config.update_via_yaml(dir)
       Proxy.parse(dir, config)
     end
   end
 end
 
-require 'inch/codebase/proxy'
-require 'inch/codebase/objects'
-require 'inch/codebase/objects_filter'
-require 'inch/codebase/serializer'
-
+require "inch/codebase/proxy"
+require "inch/codebase/object"
+require "inch/codebase/objects"
+require "inch/codebase/objects_filter"
+require "inch/codebase/serializer"

data/lib/inch/codebase/object.rb

@@ -0,0 +1,60 @@
+require 'inch/code_object/converter'
+
+module Inch
+  module Codebase
+    # An object that holds a code_object as well as it's evaluation
+    # and exposes shortcut methods to the commonly asked members of
+    # both.
+    class Object
+      extend Forwardable
+
+      attr_reader :code_object
+
+      # @return [String]
+      attr_reader :language
+
+      # @return [Grade]
+      #   when objects are assigned to GradeLists, this grade is set to
+      #   enable easier querying for objects of a certain grade
+      attr_writer :grade
+
+      # convenient shortcuts to evalution object
+      def_delegators :evaluation, :score, :roles, :priority
+
+      # convenient shortcuts to code object
+      def_delegators :code_object, :object_lookup=
+
+      # @param language [String,Symbol]
+      # @param code_object [YARD::Object::Base]
+      # @param object_lookup [Codebase::Objects]
+      def initialize(language, code_object, object_lookup)
+        @language = language
+        @code_object = CodeObject::Proxy.for(language, code_object, object_lookup)
+      end
+
+      def evaluation
+        @evaluation ||= Evaluation::Proxy.for(@language, self)
+      end
+
+      # @return [Grade]
+      def grade
+        @grade ||= Evaluation.new_grade_lists.find do |range|
+          range.scores.include?(score)
+        end.grade
+      end
+
+      def method_missing(name, *args, &block)
+        if code_object.respond_to?(name)
+          self.class.class_eval <<-RUBY
+            def #{name}(*args, &block)
+              code_object.#{name}(*args, &block)
+            end
+          RUBY
+          code_object.send(name, *args, &block)
+        else
+          super
+        end
+      end
+    end
+  end
+end

data/lib/inch/codebase/objects.rb

@@ -6,19 +6,17 @@ module Inch
 
       def_delegators :@list, :each, :empty?, :size
 
-      # @param objects [Array<CodeObject::Proxy::Base>]
-      # @return [Array<CodeObject::Proxy::Base>]
+      # @param objects [Array<CodeObject::Proxy>]
+      # @return [Array<CodeObject::Proxy>]
       def self.sort_by_priority(objects)
         objects.sort_by do |o|
           [o.priority, o.score, o.fullname.size]
         end.reverse
       end
 
-      def initialize(objects)
-        list = objects.map do |o|
-          proxy = CodeObject::Proxy.for(o)
-          proxy.object_lookup = self
-          proxy
+      def initialize(language, objects)
+        list = objects.map do |code_object|
+          Codebase::Object.new(language, code_object, self)
         end
         @list = list
         index_by_fullname
@@ -31,7 +29,7 @@ module Inch
       # Returns all parsed objects as code object proxies
       #
       # @see CodeObject::Proxy.for
-      # @return [Array<CodeObject::Proxy::Base>]
+      # @return [Array<CodeObject::Proxy>]
       def all
         @list
       end
@@ -44,7 +42,7 @@ module Inch
       #   # => returns the code object proxy for Foo#bar
       #
       # @param fullname [String] partial fullname/name of an object
-      # @return [CodeObject::Proxy::Base]
+      # @return [CodeObject::Proxy]
       def find(fullname)
         @by_fullname[fullname]
       end
@@ -58,7 +56,7 @@ module Inch
       #   # => returns the code object proxies for all instance methods of Foo
       #
       # @param partial_name [String] partial name of an object
-      # @return [Array<CodeObject::Proxy::Base>]
+      # @return [Array<CodeObject::Proxy>]
       def starting_with(partial_name)
         all.select { |o| o.fullname.start_with?(partial_name) }
       end

data/lib/inch/codebase/objects_filter.rb

@@ -1,16 +1,20 @@
 module Inch
   module Codebase
-    # ObjectsFilter can be used to filter a list of objects by given a set of
+    # ObjectsFilter can be used to filter a list of objects by a given set of
     # given +options+
     class ObjectsFilter
+      # @return [API::Options::Base] the filter options
       attr_reader :options
 
+      # @param list [Array<CodeObject::Proxy>] the unfiltered list
+      # @param options [API::Options::Base] the filter options
       def initialize(list, options)
         @list = list
         @options = options
         filter
       end
 
+      # @return [Array<CodeObject::Proxy>] the filtered list
       def objects
         @list
       end
@@ -41,16 +45,14 @@ module Inch
       end
 
       def filter_depth
-        if options.depth
-          @list = @list.select { |o| o.depth <= options.depth }
-        end
+        @list = @list.select { |o| o.depth <= options.depth } if options.depth
       end
 
       def filter_visibility
         @list = @list.select do |o|
           options.visibility.include?(o.visibility)
         end
-        if !options.visibility.include?(:private)
+        unless options.visibility.include?(:private)
           @list = @list.reject do |o|
             o.tagged_as_private?
           end

data/lib/inch/codebase/proxy.rb

@@ -3,8 +3,8 @@ module Inch
     class Proxy
       attr_reader :objects
 
-      def initialize(provider)
-        @objects = Codebase::Objects.new(provider.objects)
+      def initialize(language, provider)
+        @objects = Codebase::Objects.new(language, provider.objects)
       end
 
       def grade_lists
@@ -16,9 +16,9 @@ module Inch
         lists
       end
 
-      def self.parse(dir = Dir.pwd, config = Inch::Config.codebase)
+      def self.parse(dir, config)
         provider = CodeObject::Provider.parse(dir, config)
-        new(provider)
+        new(config.language, provider)
       end
     end
   end

data/lib/inch/codebase/serializer.rb

@@ -9,12 +9,12 @@ module Inch
 
       def self.save(codebase, filename)
         content = Marshal.dump(codebase)
-        FileUtils.mkdir_p( File.dirname(filename) )
-        File.open(filename, 'wb') { |file| file.write(content) }
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename, "wb") { |file| file.write(content) }
       end
 
       def self.load(filename)
-        codebase = Marshal.load( File.binread(filename) )
+        codebase = Marshal.load(File.binread(filename))
         codebase.objects.each do |object|
           object.object_lookup = codebase.objects
         end

data/lib/inch/config.rb

@@ -1,24 +1,55 @@
 module Inch
   # Stores the configuration for Inch
   #
-  # @see config/defaults.rb
+  # @see config/base.rb
   class Config
     class << self
-      attr_accessor :instance
+      def instance(language = :ruby)
+        if block = @blocks[language.to_s]
+          config = Config::Base.new(language)
+          config = config.update(&block)
+          config
+        else
+          raise "Language not registered: #{language}"
+        end
+      end
+
+      # Registers a configuration block for a given language.
+      #
+      # @return [void]
+      def register(language, &block)
+        @blocks ||= {}
+        @blocks[language.to_s] = block
+      end
+
+      def codebase(language = :ruby)
+        instance(language).codebase
+      end
+
+      def base(&block)
+        Config::Base.new(:__base__).update(&block)
+      end
 
-      def codebase
-        self.instance ||= Config::Base.new
-        instance.codebase
+      # Returns the Config object for a given +language+.
+      # Optionally parses a given +path+ for inch.yml
+      #
+      # @return [Config::Base]
+      def for(language, path = nil)
+        config = instance(language)
+        config.codebase.update_via_yaml(path) if path
+        config
       end
 
-      def run(&block)
-        self.instance ||= Config::Base.new
-        instance.update(&block)
-        instance
+      def namespace(language, submodule = nil)
+        name = language.to_s.split('_').collect { |w| w.capitalize }.join
+        const = ::Inch::Language.const_get(name)
+        const = const.const_get(submodule) unless submodule.nil?
+        const
       end
     end
   end
 end
 
-require 'inch/config/base'
-require 'inch/config/codebase'
+require "inch/config/base"
+require "inch/config/evaluation"
+require "inch/config/codebase"