active_mocker 1.8.4 → 2.0.0.beta1

data/lib/active_mocker/mock/has_many.rb

@@ -32,12 +32,14 @@ module Mock
     def build(options={}, &block)
       new_record = relation_class.new(init_options.merge!(options), &block)
 
+      # @private
       def new_record._belongs_to(collection)
         @belongs_to_collection = collection
       end
 
       new_record._belongs_to(self)
 
+      # @private
       def new_record.save
         @belongs_to_collection << self
         super

data/lib/active_mocker/mock_creator.rb

@@ -0,0 +1,262 @@
+module ActiveMocker
+  class MockCreator
+    def initialize(file:,
+                   file_out:,
+                   schema_scrapper:,
+                   template_creator: nil,
+                   class_introspector: nil,
+                   enabled_partials: nil,
+                   klasses_to_be_mocked:,
+                   active_record_base_klass: ActiveRecord::Base)
+      @file                     = file
+      @file_out                 = file_out
+      @schema_scrapper          = schema_scrapper
+      @template_creator         = template_creator || template_creator_default(file_out)
+      @class_introspector       = class_introspector || class_introspector_default
+      @enabled_partials         = enabled_partials || self.class.enabled_partials_default
+      @klasses_to_be_mocked     = klasses_to_be_mocked
+      @active_record_base_klass = active_record_base_klass
+      @errors                   = []
+      @completed                = false
+    end
+
+    def create
+      verify_class
+      if errors.empty?
+        template_creator.render
+        file_out.close
+        @completed = true
+      end
+      self
+    end
+
+    def completed?
+      @completed
+    end
+
+    attr_reader :errors
+
+    private
+
+    attr_reader :file,
+                :file_out,
+                :schema_scrapper,
+                :template_creator,
+                :class_introspector,
+                :enabled_partials,
+                :klasses_to_be_mocked,
+                :active_record_base_klass
+
+    # -- Defaults -- #
+    private
+    def template_creator_default(file_out)
+      TemplateCreator.new(file_out:     file_out,
+                          erb_template: File.new(File.join(File.dirname(__FILE__), "mock_template.erb"), 'r'),
+                          binding:      binding)
+    end
+
+    def class_introspector_default
+      DissociatedIntrospection::Inspection.new(file: file)
+    end
+
+    class << self
+      def enabled_partials_default
+        [:modules_constants, :class_methods, :attributes, :scopes, :defined_methods, :associations]
+      end
+
+      public :enabled_partials_default
+    end
+
+    # -- END defaults -- #
+
+    def verify_class
+      v = ParentClass.new(parsed_source:        class_introspector.parsed_source,
+                          klasses_to_be_mocked: klasses_to_be_mocked,
+                          mock_append_name:     mock_append_name).call
+      errors << v.error if v.error
+      @parent_class = v.parent_mock_name
+    end
+
+    public
+
+    def partials
+      OpenStruct.new(enabled_partials.each_with_object({}) do |p, hash|
+        begin
+          file = File.new(File.join(File.dirname(__FILE__), "mock_template/_#{p}.erb"))
+          self.extend("ActiveMocker::MockCreator::#{p.to_s.camelize}".constantize)
+          hash[p] = ERB.new(file.read, nil, '-', "_sub#{p}").result(binding)
+        rescue => e
+          print "#{file.inspect}"
+          raise e
+        end
+      end)
+    end
+
+    def class_name
+      class_introspector.parsed_source.class_name
+    end
+
+    def mock_append_name
+      'Mock'
+    end
+
+    def parent_class
+      @parent_class
+    end
+
+    def primary_key
+      @primary_key ||= ActiveRecordSchemaScrapper::Attribute.new(name: 'id', type: :integer)
+    end
+
+    module ModulesConstants
+      def constants
+        const = {}
+        class_introspector.get_class.constants.each { |c| const[c] = class_introspector.get_class.const_get(c) }
+        const = const.reject do |c, v|
+          v.class == Module || v.class == Class
+        end
+        const
+      end
+
+      def modules
+        @modules ||= begin
+          {
+            included: reject_local_const(class_introspector.included_modules)
+                        .map(&:referenced_name),
+            extended: reject_local_const(class_introspector.extended_modules)
+                        .map(&:referenced_name)
+          }
+        end
+      end
+
+      private
+
+      def reject_local_const(source)
+        source.reject do |n|
+          class_introspector.locally_defined_constants.values.include?(n)
+        end
+      end
+    end
+
+    module Attributes
+      def attributes
+        @attribute ||= begin
+          a = schema_scrapper.attributes.to_a
+          unless a.any? { |aa| aa.name == "id" }
+            a << primary_key
+          end
+          a
+        end
+      end
+    end
+
+    module ClassMethods
+      include Attributes
+
+      def attributes_with_defaults
+        hash = {}
+        attributes.each do |attr|
+          hash[attr.name] = Virtus::Attribute.build(attr.type).coerce(attr.default)
+        end
+        hash
+      end
+
+      def types_hash
+        types = {}
+        attributes.each do |attr|
+          types[attr.name] = "#{attr.type}"
+        end
+
+        type_array = types.map do |name, type|
+          "#{name}: #{type}"
+        end
+        '{ ' + type_array.join(', ') + ' }'
+      end
+
+      def associations
+        @associations ||= schema_scrapper.associations.to_a.each_with_object({}) do |a, h|
+          h[a.name] = nil
+        end
+      end
+
+      def associations_by_class
+        schema_scrapper.associations.to_a.each_with_object({}) do |r, hash|
+          hash[r.class_name.to_s]         ||= {}
+          hash[r.class_name.to_s][r.type] ||= []
+          hash[r.class_name.to_s][r.type] << r.name
+        end
+      end
+
+      def attribute_names
+        attributes.map { |a| a.name }
+      end
+
+      def abstract_class
+        schema_scrapper.abstract_class?
+      end
+
+      def table_name
+        schema_scrapper.table_name
+      end
+    end
+
+    module Scopes
+      def scope_methods
+        class_introspector.class_macros.select { |h| h.keys.first == :scope }.map do |h|
+          a = h.values.first.first
+          OpenStruct.new(name: a[0], arguments: ReverseParameters.new(a[1]))
+        end
+      end
+    end
+
+    module DefinedMethods
+      def get_instance_methods
+        methods = class_introspector.get_class.public_instance_methods(false)
+        methods << class_introspector.get_class.superclass.public_instance_methods(false) if class_introspector.get_class.superclass != ActiveRecord::Base
+        methods.flatten
+      end
+
+      def instance_methods
+        get_instance_methods.map do |m|
+          OpenStruct.new(name: m, arguments: ReverseParameters.new(class_introspector.get_class.instance_method(m).parameters))
+        end
+      end
+
+      def get_class_methods
+        class_introspector.get_class.methods(false)
+      end
+
+      def class_methods
+        get_class_methods.map do |m|
+          OpenStruct.new(name: m, arguments: ReverseParameters.new(class_introspector.get_class.method(m).parameters))
+        end
+      end
+    end
+
+    module Associations
+      def has_many
+        association_collection.select { |a| a.type == :has_many }
+      end
+
+      def has_one
+        association_collection.select { |a| a.type == :has_one }
+      end
+
+      def belongs_to
+        association_collection.select { |a| a.type == :belongs_to }
+      end
+
+      def has_and_belongs_to_many
+        association_collection.select { |a| a.type == :has_and_belongs_to_many }
+      end
+
+      def relation_find(key, value)
+        association_collection.select { |r| r.send(key).to_sym == value }
+      end
+
+      def association_collection
+        @association_collection ||= schema_scrapper.associations.to_a
+      end
+    end
+  end
+end

data/lib/active_mocker/mock_template.erb

@@ -1,190 +1,13 @@
 require 'active_mocker/mock'
 
-class <%= class_name + @mock_append_name %> < <%= parent_class %>
-  created_with('<%= ActiveMocker::VERSION %>')
-<% constants.each do |constant| -%>
-  <%= constant.first %> = <%= constant.last.inspect %>
-<% end -%>
-<% modules[:included].each do |constant| -%>
-  prepend <%= constant %>
-<% end -%>
-<% modules[:extended].each do |constant| -%>
-  extend  <%= constant %>
-<% end -%>
-
-  class << self
-
-    def attributes
-      @attributes ||= HashWithIndifferentAccess.new(<%= attributes_with_defaults %>).merge(super)
-    end
-
-    def types
-      @types ||= ActiveMocker::Mock::HashProcess.new(<%= types_hash %>, method(:build_type)).merge(super)
-    end
-
-    def associations
-      @associations ||= <%= associations %>.merge(super)
-    end
-
-    def associations_by_class
-      @associations_by_class ||= <%= associations_by_class %>.merge(super)
-    end
-
-    def mocked_class
-      <%= class_name.inspect %>
-    end
-
-    private :mocked_class
-
-    def attribute_names
-      @attribute_names ||= <%= attribute_names %> | super
-    end
-
-    def primary_key
-      <%= primary_key.name.inspect %>
-    end
-
-    def abstract_class?
-      <%= abstract_class.inspect %>
-    end
-
-    def table_name
-      <%= table_name.inspect %> || super
-    end
-
-  end
-
-  ##################################
-  #   Attributes getter/setters    #
-  ##################################
-<% attributes.each do |meth| %>
-  def <%= meth.name %>
-    read_attribute(:<%= meth.name %>)
-  end
-
-  def <%= meth.name %>=(val)
-    write_attribute(:<%= meth.name %>, val)
-  end
-<% end %>
-  ##################################
-  #         Associations           #
-  ##################################
-
-<%= '# belongs_to' unless belongs_to.empty? -%>
-<% belongs_to.each do |meth| %>
-  def <%= meth.name %>
-<% association = relation_find(:name, meth.name).first -%>
-    read_association(:<%= meth.name %>) || write_association(:<%= meth.name %>, classes('<%= association.class_name %>').try{ |k| k.find_by(id: <%= association.foreign_key %>)})
-  end
-
-  def <%= meth.name %>=(val)
-    write_association(:<%= meth.name %>, val)
-    ActiveMocker::Mock::BelongsTo.new(val, child_self: self, foreign_key: :<%= meth.foreign_key %>).item
-  end
-
-  def build_<%= meth.name %>(attributes={}, &block)
-<% association = relation_find(:name, meth.name).first -%>
-<% if association -%>
-    association = classes('<%= association.class_name %>').try(:new, attributes, &block)
-    write_association(:<%= meth.name %>, association) unless association.nil?
-<% end -%>
-  end
+class <%= class_name + mock_append_name %> < <%= parent_class %>
 
-  def create_<%= meth.name %>(attributes={}, &block)
-<% association = relation_find(:name, meth.name).first -%>
-<% if association -%>
-    association = classes('<%= association.class_name %>').try(:create,attributes, &block)
-    write_association(:<%= meth.name %>, association) unless association.nil?
-<% end -%>
-  end
-  alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
-<% end -%>
-<%= '# has_one' unless has_one.empty? -%>
-<% has_one.each do |meth| %>
-  def <%= meth.name %>
-    read_association(:<%= meth.name %>)
-  end
-
-  def <%= meth.name %>=(val)
-    write_association(:<%= meth.name %>, val)
-    ActiveMocker::Mock::HasOne.new(val, child_self: self, foreign_key: '<%= meth.foreign_key %>').item
-  end
-
-  def build_<%= meth.name %>(attributes={}, &block)
-<% association = relation_find(:name, meth.name).first -%>
-<% if association -%>
-    write_association(:<%= meth.name %>, classes('<%= association.class_name %>').new(attributes, &block)) if classes('<%= association.class_name %>')
-<% end -%>
-  end
-
-  def create_<%= meth.name %>(attributes={}, &block)
-<% association = relation_find(:name, meth.name).first -%>
-<% if association -%>
-    write_association(:<%= meth.name %>, classes('<%= association.class_name %>').new(attributes, &block)) if classes('<%= association.class_name %>')
-<% end -%>
-  end
-  alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
-<% end -%>
-
-<%= '# has_many' unless has_many.empty? -%>
-<% has_many.each do |meth| %>
-  def <%= meth.name %>
-    read_association(:<%= meth.name %>, -> { ActiveMocker::Mock::HasMany.new([],foreign_key: '<%= meth.foreign_key %>', foreign_id: self.id, relation_class: classes('<%= meth.class_name %>'), source: '<%= meth.source %>') })
-  end
-
-  def <%= meth.name %>=(val)
-    write_association(:<%= meth.name %>, ActiveMocker::Mock::HasMany.new(val, foreign_key: '<%= meth.foreign_key %>', foreign_id: self.id, relation_class: classes('<%= meth.class_name %>'), source: '<%= meth.source %>'))
-  end
-<% end -%>
-<%= '# has_and_belongs_to_many' unless has_and_belongs_to_many.empty? -%>
-<% has_and_belongs_to_many.each do |meth| %>
-  def <%= meth.name %>
-    read_association(:<%= meth.name %>, ->{ ActiveMocker::Mock::HasAndBelongsToMany.new([]) })
-  end
-
-  def <%= meth.name %>=(val)
-    write_association(:<%= meth.name %>, ActiveMocker::Mock::HasAndBelongsToMany.new(val))
-  end
-<% end -%>
-
-  module Scopes
-    include <%= parent_class %>::Scopes
-
-<% scope_methods.each do |method| -%>
-    def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-      ActiveMocker::LoadedMocks.find('<%= class_name %>').send(:call_mock_method, method: '<%= method.name %>', caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
-    end
-
-<% end -%>
-  end
-
-  extend Scopes
-
-  class ScopeRelation < ActiveMocker::Mock::Association
-    include <%= class_name + @mock_append_name %>::Scopes
-  end
-
-  private
-
-  def self.new_relation(collection)
-    <%= class_name + @mock_append_name %>::ScopeRelation.new(collection)
-  end
-
-  public
-
-  ##################################
-  #        Model Methods           #
-  ##################################
-
-<% instance_methods.each do |method| %>
-  def <%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
-  end
-<% end -%>
-<% class_methods.each do |method| %>
-  def self.<%= method.name %><%= "(#{method.arguments})" unless method.arguments.empty? %>
-    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.passable %>])
-  end
-<% end -%>
+  created_with('<%= ActiveMocker::VERSION %>')
 
-end
+<%= partials.modules_constants %>
+<%= partials.class_methods %>
+<%= partials.attributes %>
+<%= partials.associations %>
+<%= partials.scopes %>
+<%= partials.defined_methods %>
+end