active_mocker 1.8.4 → 2.0.0.beta1

data/lib/active_mocker/mock_template/_associations.erb

@@ -0,0 +1,82 @@
+# _associations.erb
+
+<%= '# 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
+
+  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 -%>

data/lib/active_mocker/mock_template/_attributes.erb

@@ -0,0 +1,11 @@
+# _attributes.erb
+<% attributes.each do |meth| -%>
+  def <%= meth.name %>
+    read_attribute(:<%= meth.name %>)
+  end
+
+
+  def <%= meth.name %>=(val)
+    write_attribute(:<%= meth.name %>, val)
+  end
+<% end -%>

data/lib/active_mocker/mock_template/_class_methods.erb

@@ -0,0 +1,41 @@
+#_class_methods.erb
+  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

data/lib/active_mocker/mock_template/_defined_methods.erb

@@ -0,0 +1,10 @@
+<% instance_methods.each do |method| -%>
+  def <%= method.name %><%= "(#{method.arguments.parameters})" unless method.arguments.parameters.to_a.empty? %>
+    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.arguments %>])
+  end
+<% end -%>
+<% class_methods.each do |method| -%>
+  def self.<%= method.name %><%= "(#{method.arguments.parameters})" unless method.arguments.parameters.to_a.empty? %>
+    call_mock_method(method: __method__, caller: Kernel.caller, arguments: [<%= method.arguments.arguments %>])
+  end
+<% end -%>

data/lib/active_mocker/mock_template/_modules_constants.erb

@@ -0,0 +1,10 @@
+# _modules_constants.erb
+<% 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 -%>

data/lib/active_mocker/mock_template/_scopes.erb

@@ -0,0 +1,23 @@
+# _scopes.erb
+  module Scopes
+    include <%= parent_class %>::Scopes
+
+  <% scope_methods.each do |method| -%>
+  def <%= method.name %><%= "(#{method.arguments.parameters})" unless method.arguments.parameters.to_a.empty? %>
+      ActiveMocker::LoadedMocks.find('<%= class_name %>').send(:call_mock_method, method: '<%= method.name %>', caller: Kernel.caller, arguments: [<%= method.arguments.arguments %>])
+    end
+
+  <% end -%>
+end
+
+  extend Scopes
+
+  class ScopeRelation < ActiveMocker::Mock::Association
+    include <%= class_name + mock_append_name %>::Scopes
+  end
+
+  def self.new_relation(collection)
+    <%= class_name + mock_append_name %>::ScopeRelation.new(collection)
+  end
+
+  private_class_method :new_relation

data/lib/active_mocker/null_progress.rb

@@ -0,0 +1,9 @@
+module ActiveMocker
+  class NullProgress
+    def initialize(*)
+
+    end
+    def increment
+    end
+  end
+end

data/lib/active_mocker/output_capture.rb

@@ -0,0 +1,32 @@
+module ActiveMocker
+  class OutputCapture
+    def self.capture(io, &block)
+      case io
+        when :stdout
+          capture_stdout(&block)
+        when :stderr
+          capture_stderr(&block)
+        else
+          raise "Unknown IO #{io}"
+      end
+    end
+
+    def self.capture_stdout(&block)
+      captured_stream     = StringIO.new
+      orginal_io, $stdout = $stdout, captured_stream
+      block.call
+      captured_stream.string
+    ensure
+      $stdout = orginal_io
+    end
+
+    def self.capture_stderr(&block)
+      captured_stream     = StringIO.new
+      orginal_io, $stderr = $stderr, captured_stream
+      block.call
+      captured_stream.string
+    ensure
+      $stderr = orginal_io
+    end
+  end
+end

data/lib/active_mocker/parent_class.rb

@@ -0,0 +1,64 @@
+module ActiveMocker
+  class ParentClass
+    def initialize(parsed_source:, klasses_to_be_mocked:, mock_append_name:, active_record_base_klass: ::ActiveRecord::Base)
+      @parsed_source            = parsed_source
+      @klasses_to_be_mocked     = klasses_to_be_mocked
+      @active_record_base_klass = active_record_base_klass
+      @mock_append_name         = mock_append_name
+    end
+
+    attr_reader :error
+
+    def call
+      if has_parent_class?
+        deal_with_parent
+      else
+        create_error("#{class_name} is missing a parent class.")
+      end
+      self
+    end
+
+    def parent_mock_name
+      if @parent_mock_name
+        "#{@parent_mock_name}#{mock_append_name}"
+      else
+        'ActiveMocker::Mock::Base'
+      end
+    end
+
+    private
+    attr_reader :parsed_source,
+                :klasses_to_be_mocked,
+                :active_record_base_klass,
+                :mock_append_name
+
+    def deal_with_parent
+      if parent_class <= active_record_base_klass
+        @parent_mock_name = parent_class_name if klasses_to_be_mocked.include?(parent_class_name)
+      else
+        create_error("#{class_name} does not inherit from ActiveRecord::Base")
+      end
+    end
+
+    def create_error(message)
+      @error = OpenStruct.new(class_name: class_name,
+                              message:    message)
+    end
+
+    def has_parent_class?
+      parsed_source.has_parent_class?
+    end
+
+    def parent_class_name
+      parsed_source.parent_class_name
+    end
+
+    def class_name
+      parsed_source.class_name
+    end
+
+    def parent_class
+      parent_class_name.constantize
+    end
+  end
+end

data/lib/active_mocker/progress.rb

@@ -0,0 +1,13 @@
+module ActiveMocker
+  class Progress
+    def initialize(count)
+      @progress = ProgressBar.create(title:  'Generating Mocks',
+                                     total:  count,
+                                     format: '%t |%b>>%i| %p%%')
+    end
+
+    def increment
+      @progress.increment
+    end
+  end
+end

data/lib/active_mocker/public_methods.rb

@@ -1,39 +1,31 @@
 module ActiveMocker
-
   class << self
-
-    # Method will be deprecated in v2
-    def self.mock(model_name, options=nil)
-      require File.join(Config.mock_dir,
-                        "#{model_name.tableize.singularize}_mock.rb")
-      "#{model_name}Mock".constantize
-    end
-
     # Override default Configurations
     #
-    #  ActiveMocker.configure do |config|
-    #    config.schema_file = File.join(Rails.root, 'db/schema.rb')
-    #    config.model_dir   = File.join(Rails.root, 'app/models')
-    #    config.mock_dir    = File.join(Rails.root, 'spec/mocks')
-    #
-    #    # If a model has a base class that still behaves like ActiveRecord but doesn't directly inherit from it add it
-    #    # to the model_base_classes array
-    #    config.model_base_classes = %w[ ActiveRecord::Base ]
-    #
-    #    config.logger      = Rails.logger
+    #  ActiveMocker.configure do |c|
+    #    c.model_dir=          # Directory of ActiveRecord models
+    #    c.mock_dir=           # Directory to save mocks
+    #    c.single_model_path=  # Path to generate a single mock
+    #    c.progress_bar=       # False disables progress bar from sending to STDOUT
+    #                            or pass a class that takes a count in the initializer and responds to #increment.
+    #    c.error_verbosity=    # 0 = none, 1 = One line per error, 2 = More details
+    #    c.disable_modules_and_constants= # Modules are include/extend along with constant declarations.
+    #                                     # Default is false, to disable set to true.
     #  end
     #
+    # @param [block]
+    # @returns self
     def configure(&block)
       Config.set(&block)
+      self
     end
-
     alias_method :config, :configure
 
     # Generates Mocks file
+    # @returns self
     def create_mocks
-      Generate.new
+      Generate.new.call
+      self
     end
-
   end
-
 end

data/lib/active_mocker/rspec.rb

@@ -0,0 +1,16 @@
+module ActiveMocker
+  module Rspec
+
+    # @return ActiveMocker::LoadedMocks
+    def active_mocker
+      ActiveMocker::LoadedMocks
+    end
+
+    # @deprecated method, will be removed in version 2.1
+    # Use +active_mocker.mocks.find('ClassName')+ instead
+    def mock_class(*args)
+      active_mocker.mocks.find(*args)
+    end
+
+  end
+end

data/lib/active_mocker/rspec_helper.rb

@@ -1,20 +1,22 @@
 require 'active_mocker/loaded_mocks'
+require 'active_mocker/rspec'
 
 RSpec.configure do |config|
 
-  def mock_class(class_name)
-    return class_name.constantize if defined?(Rails) && !self.class.metadata[:active_mocker]
-    ActiveMocker::LoadedMocks.class_name_to_mock.select { |name, mock| name == class_name }.values.first
-  end
+  config.include ActiveMocker::Rspec
 
   config.before(:each, active_mocker: true) do
-    unless  ENV['RUN_WITH_RAILS'] && self.class.metadata[:rails_compatible]
-      ActiveMocker::LoadedMocks.class_name_to_mock.each { |class_name, mock| stub_const(class_name, mock) }
+    unless ENV['RUN_WITH_RAILS'] && self.class.metadata[:rails_compatible]
+      active_mocker.mocks.each { |class_name, mock| stub_const(class_name, mock) }
     end
   end
 
-  config.after(:all) do
-    ActiveMocker::LoadedMocks.clear_all if self.class.metadata[:active_mocker]
+  config.after(:all, active_mocker: true) do
+    ActiveMocker::LoadedMocks.delete_all
+  end
+
+  config.before(:all, active_mocker: true) do
+    ActiveMocker::LoadedMocks.delete_all
   end
 
 end

data/lib/active_mocker/task.rake

@@ -2,7 +2,12 @@ namespace :active_mocker do
 
   desc('Rebuild mocks.')
   task :build => :environment do
-    ActiveMocker::Generate.new
+    ActiveMocker.configure do |c|
+      c.single_model_path = ENV["MODEL"] if ENV["MODEL"]
+      c.progress_bar     = false if ENV["MUTE_PROGRESS_BAR"]
+      c.error_verbosity  = ENV["ERROR_VERBOSITY"].to_i if ENV["ERROR_VERBOSITY"]
+      c.disable_modules_and_constants = false
+    end.create_mocks
   end
 
   desc('Run all tests tagged   active_mocker')

data/lib/active_mocker/template_creator.rb

@@ -0,0 +1,22 @@
+require 'forwardable'
+
+module ActiveMocker
+  class TemplateCreator
+
+    def initialize(erb_template:, file_out: nil, binding:)
+      @erb_template = erb_template
+      @binding      = binding
+      @file_out     = file_out || Tempfile.new('TemplateModel')
+    end
+
+    def render
+      template = ERB.new(erb_template.read, nil, '>')
+      file_out.write template.result(binding).gsub(/\n{2,5}/, "\n\n")
+      file_out
+    end
+
+    private
+
+    attr_reader :erb_template, :binding, :file_out
+  end
+end