ruby-lint 0.0.3 → 0.0.4

data/lib/ruby-lint/definition_builder/base.rb

@@ -0,0 +1,43 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Base definition builder that provides common methods for individual
+    # builder classes.
+    #
+    # @!attribute [r] node
+    #  @return [RubyLint::AST::Node]
+    # @!attribute [r] definitions
+    #  @return [RubyLint::Definition::RubyObject]
+    #
+    class Base
+      include Helper::ConstantPaths
+
+      attr_reader :definitions, :node, :options
+
+      ##
+      # @param [RubyLint::AST::Node] node
+      # @param [RubyLint::Definition::RubyObject] definitions
+      # @param [Hash] options
+      #
+      def initialize(node, definitions, options = {})
+        @node        = node
+        @definitions = definitions
+        @options     = options
+
+        after_initialize if respond_to?(:after_initialize)
+      end
+
+      protected
+
+      ##
+      # Returns the name of a constant node as a String.
+      #
+      # @param [RubyLint::AST::Node] node
+      # @return [String]
+      #
+      def constant_name(node)
+        return node.children[1].to_s
+      end
+    end # Base
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/primitive.rb

@@ -0,0 +1,39 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder used for building primitive Ruby types such as
+    # integers and strings.
+    #
+    class Primitive < Base
+      ##
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def build
+        parents = [definition_for_node(node)]
+        opts    = {
+          :type          => node.type,
+          :value         => node.children[0],
+          :instance_type => :instance,
+          :parents       => parents
+        }.merge(options)
+
+        return Definition::RubyObject.new(opts)
+      end
+
+      ##
+      # Returns a definition for a given node type.
+      #
+      # @param [RubyLint::AST::Node] node
+      # @return [RubyLint::Definition::RubyObject]
+      # @raise ArgumentError Raised when an invalid type was specified.
+      #
+      def definition_for_node(node)
+        ruby_class = node.ruby_class
+
+        raise(ArgumentError, "The type #{type} is invalid") unless ruby_class
+
+        return RubyLint::VirtualMachine.global_constant(ruby_class)
+      end
+    end # Primitive
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_array.rb

@@ -0,0 +1,77 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder for building Ruby arrays.
+    #
+    class RubyArray < Base
+      ##
+      # Builds the definition for the array and assigns the values as members.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def build
+        definition = create_container
+
+        values.each_with_index do |value, index|
+          member = create_member(index.to_s, value)
+
+          definition.add_definition(member)
+        end
+
+        return definition
+      end
+
+      private
+
+      ##
+      # @return [Array]
+      #
+      def values
+        return options[:values] || []
+      end
+
+      ##
+      # @return [Array]
+      #
+      def parents
+        return [RubyLint::VirtualMachine.global_constant('Array')]
+      end
+
+      ##
+      # Creates an empty data container for the members.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def create_container
+        return Definition::RubyObject.new(
+          :type             => container_type,
+          :instance_type    => :instance,
+          :parents          => parents,
+          :members_as_value => true
+        )
+      end
+
+      ##
+      # @return [Symbol]
+      #
+      def container_type
+        return :array
+      end
+
+      ##
+      # Creates a new array member definition.
+      #
+      # @param [String] name
+      # @param [RubyLint::Definition::RubyObject] value
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def create_member(name, value)
+        return Definition::RubyObject.new(
+          :type  => :member,
+          :name  => name,
+          :value => value
+        )
+      end
+    end # RubyArray
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_block.rb

@@ -0,0 +1,34 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder for building Ruby blocks.
+    #
+    class RubyBlock < Base
+      ##
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def build
+        definition = new_definition([definitions])
+
+        definitions.list(:lvar).each do |variable|
+          definition.add_definition(variable)
+        end
+
+        return definition
+      end
+
+      ##
+      # @param [Array] parents
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def new_definition(parents)
+        return Definition::RubyObject.new(
+          :name           => 'block',
+          :type           => :block,
+          :parents        => parents,
+          :update_parents => [:lvar, :ivar, :cvar, :gvar]
+        )
+      end
+    end # RubyBlock
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_class.rb

@@ -0,0 +1,24 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder used for building Ruby classes.
+    #
+    class RubyClass < RubyModule
+      ##
+      # Called after creating a new instance of the class.
+      #
+      def after_initialize
+        options[:parent] ||= RubyLint::VirtualMachine.global_constant('Object')
+      end
+
+      ##
+      # Builds the definition for a Ruby class.
+      #
+      # @see RubyLint::DefinitionBuilder::RubyModule#build
+      #
+      def build
+        return new_definition([options[:parent], definitions])
+      end
+    end # RubyClass
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_hash.rb

@@ -0,0 +1,37 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder for building Ruby hashes.
+    #
+    class RubyHash < RubyArray
+      ##
+      # Builds the definition for the Hash and assigns the members.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def build
+        definition = create_container
+
+        values.each do |pair|
+          definition.add_definition(pair)
+        end
+
+        return definition
+      end
+
+      ##
+      # @see RubyLint::DefinitionBuilder::RubyArray#parents
+      #
+      def parents
+        return [RubyLint::VirtualMachine.global_constant('Hash')]
+      end
+
+      ##
+      # @return [Symbol]
+      #
+      def container_type
+        return :hash
+      end
+    end # RubyHash
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_method.rb

@@ -0,0 +1,84 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder for building method definitions. Receivers should be
+    # set from the outside (= the VM).
+    #
+    class RubyMethod < Base
+      ##
+      # Called after a new instance has been created.
+      #
+      def after_initialize
+        @options[:type] ||= :instance_method
+      end
+
+      ##
+      # Builds the definition for the method definition.
+      #
+      # @see #new_definition
+      # @return [RubyLint::Definition::RubyMethod]
+      #
+      def build
+        return new_definition([scope])
+      end
+
+      ##
+      # Returns the scope to define the method in.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def scope
+        scope = definitions
+
+        if has_receiver? and options[:receiver]
+          scope = options[:receiver]
+        end
+
+        return scope
+      end
+
+      private
+
+      ##
+      # @return [String]
+      #
+      def method_name
+        return node.children[name_index].to_s
+      end
+
+      ##
+      # @param [Array] parents The parent definitions.
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def new_definition(parents)
+        type = options[:type]
+
+        if has_receiver?
+          type = :method if options[:receiver].class?
+        end
+
+        return Definition::RubyMethod.new(
+          :name          => method_name,
+          :parents       => parents,
+          :type          => type,
+          :instance_type => :instance,
+          :visibility    => options[:visibility]
+        )
+      end
+
+      ##
+      # @return [TrueClass|FalseClass]
+      #
+      def has_receiver?
+        return node.type == :defs
+      end
+
+      ##
+      # @return [Numeric]
+      #
+      def name_index
+        return has_receiver? ? 1 : 0
+      end
+    end # RubyMethod
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_builder/ruby_module.rb

@@ -0,0 +1,68 @@
+module RubyLint
+  module DefinitionBuilder
+    ##
+    # Definition builder used for building Ruby modules as well as providing
+    # the groundwork for building Ruby classes.
+    #
+    class RubyModule < Base
+      ##
+      # Creates a new module definition.
+      #
+      # @see #new_definition
+      #
+      def build
+        return new_definition([definitions])
+      end
+
+      ##
+      # Determines the scope to define the module in.
+      #
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def scope
+        scope       = definitions
+        name_prefix = node.children[0].children[0]
+
+        # name_prefix contains the constant path leading up to the name. For
+        # example, if the name is `A::B::C` this node would contain `A::B`.
+        if name_prefix
+          found = resolve_constant_path(name_prefix)
+          scope = found if found
+        end
+
+        return scope
+      end
+
+      protected
+
+      ##
+      # Returns the name of the module.
+      #
+      # @see #constant_name
+      #
+      def module_name
+        return constant_name(node.children[0])
+      end
+
+      ##
+      # Creates a new RubyObject definition with the specified parent
+      # definitions.
+      #
+      # @param [Array] parents
+      # @return [RubyLint::Definition::RubyObject]
+      #
+      def new_definition(parents)
+        definition = Definition::RubyObject.new(
+          :name             => module_name,
+          :parents          => parents,
+          :reference_amount => 1,
+          :type             => :const
+        )
+
+        definition.add(:keyword, 'self', definition)
+
+        return definition
+      end
+    end # RubyModule
+  end # DefinitionBuilder
+end # RubyLint

data/lib/ruby-lint/definition_generator.rb

@@ -1,6 +1,7 @@
 require 'fileutils'
 require 'erb'
 require_relative 'template/scope'
+require_relative 'generated_constant'
 
 module RubyLint
   ##
@@ -17,10 +18,13 @@ module RubyLint
   #
   # @!attribute [r] directory
   #  @return [String] The directory to store the generated definitions in.
+  #
   # @!attribute [r] options
   #  @return [Hash]
-  # @!attribute [String] template
-  #  @return [String] The filepath to the ERB template to use.
+  #
+  # @!attribute [r] template
+  #  @return [String] The ERB template to use.
+  #
   # @!attribute [r] inspector
   #  @return [RubyLint::Inspector]
   #
@@ -48,8 +52,8 @@ module RubyLint
       constants = inspector.inspect_constants.sort - options[:ignore]
 
       group_constants(constants).each do |root, names|
-        filepath    = File.join(directory, "#{root.snake_case}.rb")
-        definitions = []
+        filepath  = File.join(directory, "#{root.snake_case}.rb")
+        constants = []
 
         if File.file?(filepath) and !options[:overwrite]
           next
@@ -58,21 +62,26 @@ module RubyLint
         names.each do |name|
           current_inspector = Inspector.new(name)
           inspected_methods = inspect_methods(current_inspector)
-          variables         = {
-            :methods       => method_information(inspected_methods),
-            :constant      => current_inspector.constant,
-            :constant_name => current_inspector.constant_name,
-            :superclass    => (current_inspector.constant.superclass rescue nil)
-          }
+          superclass        = nil
 
-          scope = Template::Scope.new(variables)
-          erb   = ERB.new(template, nil, '-').result(scope.get_binding)
+          if current_inspector.inspect_superclass
+            superclass = current_inspector.inspect_superclass.to_s
+          end
 
-          definitions << erb
+          constant = GeneratedConstant.new(
+            :name       => current_inspector.constant_name,
+            :constant   => current_inspector.constant,
+            :methods    => method_information(inspected_methods),
+            :superclass => superclass
+          )
+
+          constants << constant
         end
 
+        erb = render_template(template, :constants => constants)
+
         File.open(filepath, 'w') do |handle|
-          handle.write(definitions.join("\n").strip)
+          handle.write(erb)
         end
       end
     end
@@ -130,7 +139,7 @@ module RubyLint
           args = []
 
           method.parameters.each do |arg|
-            args << {:method => arg_mapping[arg[0]], :name => arg[1]}
+            args << {:type => arg_mapping[arg[0]], :name => arg[1]}
           end
 
           info[type][method.name] = args
@@ -151,5 +160,22 @@ module RubyLint
         :block => :block_argument
       }
     end
+
+    ##
+    # @param [String] template
+    # @param [Hash] variables
+    #
+    def render_template(template, variables = {})
+      scope = Template::Scope.new(variables)
+      erb   = ERB.new(template, nil, '-').result(scope.get_binding)
+
+      # Trim excessive newlines.
+      erb.gsub!(/\n{3,}/, "\n\n")
+
+      # Get rid of the occasional empty newline before `end` tokens.
+      erb.gsub!(/\n{2,}end/, "\nend")
+
+      return erb
+    end
   end # DefinitionGenerator
 end # RubyLint