active_mocker 1.3.2 → 1.4.1

data/lib/active_mocker/loaded_mocks.rb

@@ -5,30 +5,70 @@ module ActiveMocker
       mocks.merge!({mocks_to_add.name => mocks_to_add})
     end
 
+    def self.add_subclass(subclass)
+      subclasses.merge!({subclass.mocked_class => subclass})
+    end
+
+    def self.subclasses
+      @subclasses ||= {}
+    end
+
+    def self.clear_subclasses
+      @subclasses = nil
+    end
+
+    def self.mocks
+      @mocks ||= {}
+    end
+
+    def self.find(klass)
+      class_name_to_mock[klass]
+    end
+
     def self.all
       mocks
     end
 
     def self.clear_all
-      mocks.each { |n, m| m.clear_mock }
+      action = -> (mocks){ mocks.each { |n, m| m.clear_mock } }
+      action.call(mocks)
+      action.call(subclasses)
+      clear_subclasses
     end
 
     def self.delete_all
-      mocks.each { |n, m| m.delete_all }
+      action = -> (mocks) { mocks.each { |n, m| m.delete_all } }
+      action.call(mocks)
+      action.call(subclasses)
     end
 
     def self.reload_all
-      mocks.each { |n, m| m.reload }
+      action = -> (mocks) { mocks.each { |n, m| m.send(:reload) } }
+      action.call(mocks)
+      action.call(subclasses)
     end
 
-    def self.mocks
-      @@mocks ||= {}
+    def self.undefine_all
+      action = -> (mocks) { mocks.each do |n, m|
+        Object.send(:remove_const, n) if Object.const_defined?(n)
+      end }
+      action.call(mocks)
+      action.call(subclasses)
     end
 
-    def self.undefine_all
-      mocks.each do |n, m|
-        Object.send(:remove_const, n) if Object.const_defined?(:n)
+    def self.class_name_to_mock
+      hash = {}
+      mocks.each do |mock_name, mock_constant|
+        hash[mock_constant.mocked_class] = mock_constant
       end
+      hash.merge(subclasses)
+    end
+
+    private
+
+    def self.internal_clear
+      clear_subclasses
+      @mocks = nil
     end
   end
 

data/lib/active_mocker/logger.rb

@@ -6,6 +6,8 @@ module ActiveMocker
     end
 
     def self.method_missing(meth, *args, &block)
+      @@logger ||= nil
+      return nil if @@logger.nil?
       return @@logger.send(meth, *args, &block)
     end
   end

data/lib/active_mocker/mock_template.erb

@@ -1,24 +1,49 @@
-require 'active_mocker/mock_requires'
-Object.send(:remove_const, "<%= class_name %>") if ActiveMocker.class_exists?("<%= class_name %>")
+require 'active_mocker/active_mock'
+Object.send(:remove_const, "<%= class_name + @mock_append_name %>") if Object.const_defined?("<%= class_name + @mock_append_name %>")
 
-class <%= class_name %> < ::ActiveHash::Base
-  include ActiveMocker::ActiveHash::ARApi
-  include ActiveMocker::MockInstanceMethods
-  extend  ActiveMocker::MockClassMethods
+class <%= class_name + @mock_append_name %> < ActiveMock::Base
+<% constants.each do |constant| %>
+  <%= constant.first %> = <%= constant.last.inspect %>
+<% end -%>
 
-  def initialize(attributes={}, &block)
-    @attributes = HashWithIndifferentAccess.new(<%= default_attributes %>)
-    @associations = HashWithIndifferentAccess.new(<%= associations %>)
-    super(attributes, &block)
-  end
+  class << self
 
+    def attributes
+      @attributes ||= HashWithIndifferentAccess.new(<%= attributes_with_defaults %>)
+    end
 
-  def self.column_names
-    <%= attribute_names %>
-  end
+    def types
+      @types ||= <%= types_hash %>
+    end
+
+    def associations
+      @associations ||= <%= associations %>
+    end
+
+    def model_instance_methods
+      @model_instance_methods ||= <%= instance_method_not_implemented %>
+    end
+
+    def model_class_methods
+      @model_class_methods ||= <%= class_method_not_implemented %>
+    end
+
+    def mocked_class
+      '<%= class_name %>'
+    end
+
+    def column_names
+      attribute_names
+    end
+
+    def attribute_names
+      @attribute_names ||= <%= attribute_names %>
+    end
+
+    def primary_key
+      <%= primary_key.name.inspect %>
+    end
 
-  def self.attribute_names
-    @attribute_names = <%= attribute_names %>
   end
 
   ##################################
@@ -26,75 +51,120 @@ class <%= class_name %> < ::ActiveHash::Base
   ##################################
 <% attributes.each do |meth| %>
   def <%= meth.name %>
-    @attributes['<%= meth.name %>']
+    read_attribute(:<%= meth.name %>)
   end
 
   def <%= meth.name %>=(val)
-    type = (types[:<%= meth.name %>] ||= Virtus::Attribute.build(<%= meth.type %>))
-    @attributes['<%= meth.name %>'] = type.coerce(val)
+<% association = belongs_to_foreign_key(meth.name)  -%>
+    write_attribute(:<%= meth.name %>, val)
+<% if association -%>
+    association = classes('<%= association.class_name %>').try(:find, <%= meth.name  %>)
+    write_association(:<%= association.name %>,association) unless association.nil?
+<% end -%>
   end
 <% end %>
   ##################################
-  #   Association getter/setters   #
+  #         Associations           #
   ##################################
 
-  def self.association_names
-    @association_names = <%= association_names.map { |a| a.to_sym } %>
+<%= '# belongs_to' unless belongs_to.empty? -%>
+<% belongs_to.each do |meth| %>
+  def <%= meth.name %>
+    @associations[:<%= meth.name %>]
   end
-<% single_associations.each do |meth| %>
-  def <%= meth %>
-    associations['<%= meth %>']
+
+  def <%= meth.name %>=(val)
+    @associations[:<%= meth.name %>] = val
+    write_attribute(:<%= meth.foreign_key %>, val.id) if val.respond_to?(:persisted?) && val.persisted?
+  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 <%= meth %>=(val)
-    associations['<%= meth %>'] = val
+  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 %>, nil) unless association.nil?
+<% end -%>
   end
+  alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
 <% end -%>
-<% collection_associations.each do |meth| %>
-  def <%= meth %>
-    associations['<%= meth %>'] ||= ActiveMocker::Collection::Association.new
+<%= '# has_one' unless has_one.empty? -%>
+<% has_one.each do |meth| %>
+  def <%= meth.name %>
+    @associations['<%= meth.name %>']
   end
 
-  def <%= meth %>=(val)
-    associations['<%= meth %>'] = ActiveMocker::Collection::Association.new(val)
+  def <%= meth.name %>=(val)
+    @associations['<%= meth.name %>'] = val
   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
 
-  ##################################
-  #  Model Methods getter/setters  #
-  ##################################
+  def create_<%= meth.name %>(attributes={}, &block)
+<% association = relation_find(:name, meth.name).first -%>
+<% if association -%>
+    write_association(:<%= meth.name %>,classes('<%= association.class_name %>').create(attributes, &block)) if classes('<%= association.class_name %>')
+<% end -%>
+  end
+  alias_method :create_<%= meth.name %>!, :create_<%= meth.name %>
+<% end -%>
 
-  def self.model_instance_methods
-    @model_instance_methods ||= <%= model_instance_methods %>
+<%= '# has_many' unless has_many.empty? -%>
+<% has_many.each do |meth| %>
+  def <%= meth.name %>
+    @associations[:<%= meth.name %>] ||= ActiveMock::HasMany.new([],'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
   end
 
-  def self.model_class_methods
-    @model_class_methods ||= <%= model_class_methods %>
+  def <%= meth.name %>=(val)
+    @associations[:<%= meth.name %>] ||= ActiveMock::HasMany.new(val,'<%= meth.foreign_key %>', @attributes['id'], classes('<%= meth.class_name %>'))
+  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 %>
+    @associations[:<%= meth.name %>] ||= ActiveMock::HasAndBelongsToMany.new
   end
 
-  def self.clear_mock
-    @model_class_methods, @model_instance_methods = nil, nil
-    delete_all
+  def <%= meth.name %>=(val)
+    @associations[:<%= meth.name %>] = ActiveMock::HasAndBelongsToMany.new(val)
   end
+<% end -%>
+
+  ##################################
+  #  Model Methods getter/setters  #
+  ##################################
+
 <% instance_methods.each do |method| %>
-  def <%= method.method %>(<%= method.params %>)
-    block =  model_instance_methods['<%= method.method %>']
-    self.class.is_implemented(block, '#<%= method.method %>')
-    instance_exec(*[<%= method.params_pass %>], &block)
+  def <%= method.name %>(<%= method.arguments %>)
+    block =  model_instance_methods['<%= method.name %>']
+    self.class.is_implemented(block, '#<%= method.name %>')
+    instance_exec(*[<%= method.arguments.passable %>], &block)
   end
 <% end -%>
 <% class_methods.each do |method| %>
-  def self.<%= method.method %>(<%= method.params %>)
-    block =  model_class_methods['<%= method.method %>']
-    is_implemented(block, '::<%= method.method %>')
-    instance_exec(*[<%= method.params_pass %>], &block)
+  def self.<%= method.name %>(<%= method.arguments %>)
+    block =  model_class_methods['<%= method.name %>']
+    is_implemented(block, '::<%= method.name %>')
+    instance_exec(*[<%= method.arguments.passable %>], &block)
   end
 <% end -%>
 
+  private
+
   def self.reload
     load __FILE__
   end
 
-end
-
-ActiveMocker::LoadedMocks.add(<%= class_name %>)
+end

data/lib/active_mocker/model_reader.rb

@@ -12,7 +12,8 @@ module ActiveMocker
     def parse(model_name)
       @model_name = model_name
       klass
-      self
+      return self unless @klass == false
+      return false
     end
 
     def klass
@@ -20,22 +21,17 @@ module ActiveMocker
     end
 
     def eval_file
-      failure = true
-      while failure
+      failure = false
         begin
           m = Module.new
           m.module_eval(read_file, file_path)
-        rescue NameError => e
-          raise e
-          result = e.to_s.scan /::(\w*)$/ # gets the Constant name from error
-          const_name = result.flatten.first
-          Logger_.debug "ActiveMocker :: Can't can't find Constant #{const_name} from class #{model_name}..\n #{caller}"
-          next
+        rescue Exception => e
+          Logger.error "ActiveMocker :: Error loading Model: #{model_name} \n \t\t\t\t\t\t\t\t`#{e}` \n"
+          Logger.error "\t\t\t\t\t\t\t\t #{file_path}\n"
+          failure = true
         end
-        failure = false
-        model = m.const_get m.constants.first
-      end
-      model
+      return m.const_get m.constants.first unless failure
+      return false
     end
 
     def read_file
@@ -82,6 +78,39 @@ module ActiveMocker
       klass.single_relationships.flatten.compact
     end
 
+    def belongs_to
+      klass.relationships.belongs_to
+    end
+
+    def has_one
+      klass.relationships.has_one
+    end
+
+    def has_and_belongs_to_many
+      klass.relationships.has_and_belongs_to_many
+    end
+
+    def has_many
+      klass.relationships.has_many
+    end
+
+    def table_name
+      klass.table_name
+    end
+
+    def primary_key
+      klass.primary_key
+    end
+
+    def constants
+      const = {}
+      klass.constants.each {|c| const[c] = klass.const_get(c)}
+      const = const.reject do |c, v|
+        v.class == Module || v.class == Class
+      end
+      const
+    end
+
   end
 
 end

data/lib/active_mocker/model_schema.rb

@@ -0,0 +1,279 @@
+module ActiveMocker
+
+  module LoggerToJson
+
+    def initialize(*args)
+      super(args)
+      UnitLogger.unit.info "#{caller_locations[1]}\n"
+      obj = JSON.parse(self.to_hash.to_json)
+      UnitLogger.unit.info "#{self.class.name}: #{JSON.pretty_unparse(obj)}\n"
+      puts "#{self.class.name}: #{JSON.pretty_unparse(obj)}\n"
+    end
+
+  end
+
+  class ModelSchemaCollection
+
+    include Enumerable
+
+    attr_accessor :collection
+
+    def initialize(collection)
+      @collection = collection
+    end
+
+    def each(&block)
+      collection.each do |item|
+        block.call(item)
+      end
+    end
+
+    def find_by(options={})
+      collection.select{|c| c.send(options.keys.first) == options.values.first}.first
+    end
+
+    def find_by_in_relationships(options={})
+      result = nil
+      collection.each do |item|
+        result = item.relationships.select do |attr|
+          attr.send(options.keys.first) == options.values.first
+        end
+      end
+      result
+    end
+
+
+    def [](val)
+      collection[val]
+    end
+
+  end
+
+  class ModelSchema
+
+    include LoggerToJson
+
+    attr_reader :class_name, :table_name, :attributes, :relationships, :methods
+
+    def initialize( class_name:    nil,
+                    table_name:    nil,
+                    attributes:    nil,
+                    relationships: nil,
+                    methods:       nil,
+                    constants:     nil,
+                    is_join_table: nil,
+                    join_table_members: nil
+                    )
+      @class_name    = class_name
+      @table_name    = table_name
+      @attributes    = attributes    unless attributes.nil?
+      @relationships = relationships unless relationships.nil?
+      @methods       = methods       unless (methods || []).empty?
+      @constants     = constants     unless (constants || []).empty?
+      @is_join_table = is_join_table unless is_join_table.nil?
+      @join_table_members = join_table_members unless join_table_members.nil?
+
+      # UnitLogger.unit.info "#{caller_locations[1]}\n"
+      # obj = ::JSON.parse(self.to_json)
+      # UnitLogger.unit.info "#{self.class.name}: #{JSON.pretty_unparse(obj)}\n"
+      # puts "#{self.class.name}: #{JSON.pretty_unparse(obj)}\n"
+    end
+
+    def constants
+      @constants || []
+    end
+
+    def has_many
+      relation_find(:type, :has_many)
+    end
+
+    def has_one
+      relation_find(:type, :has_one)
+    end
+
+    def belongs_to
+      relation_find(:type, :belongs_to)
+    end
+
+    def has_and_belongs_to_many
+      relation_find(:type, :has_and_belongs_to_many)
+    end
+
+    def belongs_to_foreign_key(foreign_key)
+      belongs_to.select { |r| r.foreign_key.to_sym == foreign_key.to_sym }.first
+    end
+
+    def relation_find(key, value)
+      relationships.select { |r| r.send(key).to_sym == value }
+    end
+
+    def instance_methods
+      method_find(:instance)
+    end
+
+    def class_methods
+      method_find(:class)
+    end
+
+    def method_find(type)
+      return [] if methods.nil?
+      methods.select { |r| r.type.to_sym == type }
+    end
+
+    def attribute_names
+      attributes.map(&:name)
+    end
+
+    def types_hash
+      types = {}
+      attributes.each do |attr|
+        types[attr.name] = "build_type(#{attr.ruby_type})"
+      end
+
+      type_array = types.map do |name, type|
+        "#{name}: #{type}"
+      end
+      '{ ' + type_array.join(', ') + ' }'
+    end
+
+    def attributes_with_defaults
+      hash = {}
+      attributes.each do |attr|
+        hash[attr.name] = attr.default_value
+      end
+      hash
+    end
+
+    def associations
+      hash = {}
+      relationships.each do |r|
+        hash[r.name] = nil
+      end
+      hash
+    end
+
+    def mock_name(klass_name)
+      klass_name + "Mock"
+    end
+
+    def class_method_not_implemented
+      not_implemented(class_methods)
+    end
+
+    def instance_method_not_implemented
+      not_implemented(instance_methods)
+    end
+
+    def not_implemented(collection)
+      hash = {}
+      collection.each do |meth|
+        hash[meth.name.to_s] = :not_implemented
+      end
+      hash
+    end
+
+    def render(template, mock_append_name)
+      @mock_append_name = mock_append_name
+      ERB.new(template, nil, '-').result(binding)
+    end
+
+    private :relation_find
+
+    def primary_key
+      key_attribute = attributes.select { |attr| attr.primary_key }.first
+      return key_attribute if key_attribute
+      default_primary_key
+    end
+
+    def default_primary_key
+      default_id = Attributes.new(name: 'id', primary_key: true, type: :integer)
+      attributes.unshift(default_id)
+      default_id
+    end
+
+    class Attributes
+
+      attr_reader :name, :type, :precision, :scale, :default_value, :primary_key
+      attr_writer :primary_key
+      def initialize(name:,
+                     type:,
+                     precision:     nil,
+                     scale:         nil,
+                     default_value: nil,
+                     primary_key:   nil
+      )
+        @name          = name
+        @type          = type
+        @precision     = precision     unless precision.nil?
+        @scale         = scale         unless scale.nil?
+        @default_value = default_value unless default_value.nil?
+        @primary_key   = primary_key   unless primary_key.nil?
+      end
+
+      def ruby_type
+        ActiveMocker::DBToRubyType.call(type)
+      end
+
+    end
+
+    class Relationships
+
+      attr_reader :name, :class_name, :type, :through, :foreign_key, :join_table
+
+      def initialize(name:,
+          class_name:,
+          type:,
+          through:,
+          foreign_key:,
+          join_table:
+      )
+        @name        = name
+        @class_name  = class_name
+        @type        = type
+        @through     = through     unless through.nil?
+        @foreign_key = foreign_key unless foreign_key.nil?
+        @join_table  = join_table  unless join_table.nil?
+      end
+
+    end
+
+    class Methods
+
+      attr_reader :name, :arguments, :type
+
+      def initialize( name:,
+                      arguments:,
+                      type:
+                    )
+        @name      = name
+        @arguments = Arguments.new(arguments)
+        @type      = type
+      end
+
+      class Arguments
+
+        attr_reader :arguments
+
+        def initialize(arguments)
+          @arguments = arguments
+        end
+
+        def to_hash
+          @arguments
+        end
+
+        def to_s
+          Reparameterize.call(arguments)
+        end
+
+        def passable
+          Reparameterize.call(arguments, param_list: true)
+        end
+
+      end
+
+    end
+
+  end
+
+end