rbdi 0.0.1

data/lib/rdi/dependency_graph_builder.rb

@@ -0,0 +1,50 @@
+require_relative 'graphs'
+
+module Rdi
+  module DependencyGraphBuilder
+
+    def self.build(context)
+      graph = Rdi::Graphs::DirectedGraph.new
+
+      context.beans.each do |bean_id, bean|
+        graph.add_vertex(bean_id)
+      end
+
+      context.beans.each do |bean_id, bean|
+        bean.constructor_args.each do |arg|
+          add_dependencies(bean_id, arg, graph)
+        end
+
+        bean.properties.each do |name, value|
+          add_dependencies(bean_id, value, graph)
+        end
+      end
+
+      graph
+    end
+
+    def self.add_dependencies(bean_id, value, graph)
+      if value.kind_of?(Rdi::Ref)
+        graph.add_edge(bean_id, value.bean_id)
+      elsif value.kind_of?(Hash)
+        add_dependencies_from_map(bean_id, value, graph)
+      elsif value.kind_of?(Array)
+        add_dependencies_from_collection(bean_id, value, graph)
+      end
+    end
+
+    def self.add_dependencies_from_collection(bean_id, collection, graph)
+      collection.each do |e|
+        add_dependencies(bean_id, e, graph)
+      end
+    end
+
+    def self.add_dependencies_from_map(bean_id, map, graph)
+      map.each do |key, value|
+        add_dependencies(bean_id, key, graph)
+        add_dependencies(bean_id, value, graph)
+      end
+    end
+
+  end
+end

data/lib/rdi/graphs.rb

@@ -0,0 +1,116 @@
+module Rdi
+  module Graphs
+
+    class DirectedGraph
+
+      attr_reader :vertices
+      attr_reader :adjacencies
+
+      def initialize
+        @vertices = {}
+        @adjacencies = {}
+      end
+
+      def add_vertex(label)
+        vertex = Vertex.new(label)
+        @vertices[label] = vertex
+        @adjacencies[vertex] = []
+      end
+
+      def add_edge(from, to)
+        @adjacencies[@vertices[from]] << @vertices[to]
+      end
+
+      def cycle?
+        cycle_vertices.any?
+      end
+
+
+      def path?(from, to)
+        _path?(Vertex.new(from), Vertex.new(to), @adjacencies.clone)
+      end
+
+      # Return the vertices that are part of a cycle.
+      #
+      # If there is no cycle, it returns an empty array.
+      #
+      # @return Array Vertices labels
+      def cycle_vertices
+        # Makes a copy of vertices and searches for ones with input grade of 0.
+        #
+        # Then it removes those vertices and searches again
+        #   until there are not vertices with input grade of 0.
+        #
+        # At this point, if there are some vertices it implies that a cycle exists.
+
+        vertices = @vertices
+        adjacencies = @adjacencies
+
+        while vertices.any?
+          leafs = in0(vertices, adjacencies)
+
+          if leafs.empty?
+            return vertices.keys
+          else
+            vertices = vertices.reject { |k, v| leafs.include?(v) }
+            adjacencies = adjacencies.reject { |k, v| leafs.include?(k) }
+          end
+        end
+
+        []
+      end
+
+      private
+      # Returns the vertices from adjacencies that have an input grade of 0.
+      #
+      # @param [Hash<Object, Vertex>] vertices
+      # @param [Hash<Vertext, Array<Vertext>>] adjacencies
+      #
+      # @return [Array<Vertext>]
+      def in0(vertices, adjacencies)
+        vertices.values.select { |vertex|
+          adjacencies.count { |v, adjacents|
+            adjacents.count { |adjacent_vertext|
+              adjacent_vertext == vertex
+            } != 0
+          } == 0
+        }
+      end
+
+      def _path?(from, to, adjacencies)
+        adjacents = adjacencies.delete(from) { [] }
+
+        adjacents.any? do |adjacent|
+          if adjacent == to
+            true
+          else
+            _path?(adjacent, to, adjacencies)
+          end
+        end
+      end
+
+
+    end
+
+    class Vertex
+      attr_reader :label
+
+      def initialize(label)
+        @label = label
+      end
+
+      def ==(other)
+        eql?(other)
+      end
+
+      def eql?(other)
+        label == other.label
+      end
+
+      def hash
+        label.hash
+      end
+    end
+
+  end
+end

data/lib/rdi/logger.rb

@@ -0,0 +1,7 @@
+module Rdi
+  module Logger
+    def self.log(msg)
+      STDERR.puts Time.now.strftime("%H:%M:%S: ") + " #{msg}"
+    end
+  end
+end

data/lib/rdi/object_builder.rb

@@ -0,0 +1,103 @@
+module Rdi
+  module ObjectBuilder
+
+    def self.create(bean, context)
+      args = bean.constructor_args.map do |arg|
+        if arg.kind_of?(Rdi::Ref)
+          context.get(arg.bean_id)
+        elsif arg.kind_of?(Rdi::Bean)
+          arg.evaluate
+
+        else
+          arg
+        end
+      end
+
+      obj = if bean.factory_method
+        bean.klass.send(bean.factory_method)
+      else
+        bean.klass.new(*args)
+      end
+
+      Rdi::ObjectBuilder.set_properties(obj, bean.properties, context)
+
+      if bean.init_method
+        obj.send bean.init_method
+      end
+
+      obj
+    end
+
+    def self.evaluate_collection(collection, context)
+      collection.map do |e|
+        if e.kind_of?(Rdi::Ref)
+          context.get(e.bean_id)
+
+        elsif e.kind_of?(Rdi::Bean)
+          e.evaluate
+
+        else
+          e
+        end
+      end
+    end
+
+    def self.evaluate_hash(hash, context)
+      value = {}
+
+      hash.each do |k, v|
+        if v.kind_of?(Rdi::Ref)
+          value[k] = context.get(v.bean_id)
+
+        elsif v.kind_of?(Rdi::Bean)
+          value[k] = v.evaluate
+
+        else
+          value[k] = v
+        end
+      end
+
+      value
+    end
+
+    def self.evaluate_proc(proc_, context)
+      params = proc_.parameters.map { |_, param| param }
+
+      values = params.map { |param| context.get(param) }
+
+      proc_.call(*values)
+    end
+
+    def self.set_properties(obj, properties, context)
+      properties.each do |name, value|
+        set_property(obj, name, value, context)
+      end
+    end
+
+    def self.set_property(obj, name, value, context)
+      value = evaluate(value, context)
+      obj.public_send "#{name}=", value
+    end
+
+    def self.evaluate(value, context)
+      if value.kind_of?(Rdi::Ref)
+        context.get(value.bean_id)
+
+      elsif value.kind_of?(Rdi::Bean)
+        value.evaluate
+
+      elsif value.kind_of?(Array) || value.kind_of?(Set)
+        evaluate_collection(value, context)
+
+      elsif value.kind_of?(Hash)
+        evaluate_hash(value, context)
+
+      elsif value.kind_of?(Proc) && !value.lambda?
+        p 'waa'
+        p evaluate_proc(value, context)
+      else
+        value
+      end
+    end
+  end
+end

data/lib/rdi/ref.rb

@@ -0,0 +1,23 @@
+module Rdi
+  class Ref
+
+    attr_reader :bean_id
+
+    def initialize(bean_id)
+      @bean_id = bean_id
+    end
+
+    def eql?(other)
+      if other.respond_to?(:bean_id)
+        bean_id.eql?(other.bean_id)
+      else
+        false
+      end
+    end
+
+    def hash
+      bean_id.hash
+    end
+
+  end
+end

data/lib/rdi/utils.rb

@@ -0,0 +1,116 @@
+module Rdi
+  module Utils
+
+    # Extracts values from a given array
+    #
+    #
+    # Suppose there is a method named 'm'
+    #
+    #   def m(id, name, options); end
+    #
+    # Which is expected to be called as:
+    #
+    #   m(1, 'foo', :x => true, :y => true)
+    #
+    # and also:
+    #
+    #   m('foo')
+    #
+    # In the second case, 'foo' is expected to be pased as the 'name' parameter,
+    #   and id parameter is expected to be nil
+    #
+    # It would be good to define m as:
+    #
+    #  def m(id = nil, name, options = {})
+    #
+    # So, we start to implement m as:
+    #
+    #   def m(*args)
+    #
+    #     id = 0
+    #     name = nil
+    #     options = {}
+    #
+    #     if args.empty?
+    #       raise ArgumentError, 'wrong number of arguments (0 for 1..3)'
+    #     end
+    #
+    #     if args.length == 1
+    #       name = args[0]
+    #     elsif args.length == 2
+    #       id = args[0]
+    #       name = args[1]
+    #     elsif args.length == 3
+    #       id = args[0]
+    #       name = args[1]
+    #       options = args[3]
+    #     else
+    #       raise ArgumentError, "wrong number of arguments (#{args.length} for 1..3)"
+    #     end
+    #
+    #     # ...
+    #   end
+    #
+    # By using extract_args, the above code could be refactored as follows:
+    #
+    #   def m(*args)
+    #     id, name, options = extract_args(args, 3, {:0 => nil, :2 => {}})
+    #
+    #     // ...
+    #   end
+    #
+    # @param [Array] args Arguments passed
+    # @param [Integer] args_number Maximum number of expected arguments
+    # @param [Hash<Integer, Object>] Default argument values.
+    #   keys => index of the argument
+    #   values => argument value
+    #
+    # @return [Array] Extracted arguments
+    #
+    # @raise [ArgumentError] if less params than expected are passed
+    def self.extract_args(args, args_number, defaults = {})
+      min_args_number = args_number - defaults.length
+
+      if args.length < min_args_number
+        raise ArgumentError, "wrong number of arguments (#{args.length} for #{min_args_number}..#{args_number}"
+      elsif args.length > args_number
+        raise ArgumentError, "wrong number of arguments (#{args.length} for #{min_args_number}..#{args_number}"
+      end
+
+      # extracted args are put here
+      values = Array.new(args_number)
+
+      default_indexes = defaults.keys.sort
+      non_default_indexes = (0...args_number).to_a - default_indexes
+
+      defaults.each do |index, default|
+        values[index] = default
+      end
+
+      # number of args that will override default args
+      extra_args = args.length - (args_number - defaults.length)
+
+      # TODO: make this more legible
+      args.each_with_index do |arg, index|
+        if extra_args > 0
+          possible_default_index = default_indexes.first || (args_number + 1)
+          possible_non_default_index = non_default_indexes.first || (args_number + 1)
+          if possible_default_index < possible_non_default_index
+            values[possible_default_index] = arg
+            default_indexes.delete_at(0)
+            extra_args -= 1
+          else
+            values[possible_non_default_index] = arg
+            non_default_indexes.delete_at(0)
+          end
+        else
+          possible_non_default_index = non_default_indexes.delete_at(0)
+          values[possible_non_default_index] = arg
+        end
+      end
+
+      values
+    end
+
+  end
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rbdi
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gianfranco Zas
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.10.0
+description: Based on spring core.
+email: snmgian@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rdi/utils.rb
+- lib/rdi/object_builder.rb
+- lib/rdi/ref.rb
+- lib/rdi/context_builder.rb
+- lib/rdi/graphs.rb
+- lib/rdi/context.rb
+- lib/rdi/chain.rb
+- lib/rdi/logger.rb
+- lib/rdi/bean.rb
+- lib/rdi/dependency_graph_builder.rb
+- lib/rdi.rb
+- COPYING
+- COPYING.LESSER
+- README.md
+homepage: http://rubygems.org/gems/rbdi
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Brings dependency injection to ruby.
+test_files: []
+has_rdoc: