active_mocker 1.3.2 → 1.4.1

data/lib/active_mocker/active_mock.rb

@@ -0,0 +1,26 @@
+require 'active_support'
+
+begin
+  require 'active_support/core_ext'
+rescue
+end
+
+begin
+  require 'active_model'
+  require 'active_model/naming'
+rescue LoadError
+end
+require 'active_mocker/logger'
+require 'active_mock/queries'
+require 'active_mock/collection'
+require 'active_mock/association'
+require 'active_mock/has_many'
+require 'active_mock/has_and_belongs_to_many'
+require 'active_mocker/loaded_mocks'
+require 'active_mock/do_nothing_active_record_methods'
+require 'active_mock/next_id'
+require 'active_mock/creators'
+require 'active_mock/records'
+require 'active_mock/base'
+require 'virtus'
+require 'active_mock/object_inspect'

data/lib/active_mocker/active_record.rb

@@ -14,6 +14,24 @@ module ActiveMocker
       extend UnknownModule
       extend ConstMissing
 
+      def self.table_name=(table_name)
+        @table_name = table_name
+      end
+
+      def self.table_name
+        @table_name ||= nil
+        @table_name
+      end
+
+      def self.primary_key=(primary_key)
+        @primary_key = primary_key
+      end
+
+      def self.primary_key
+        @primary_key ||= nil
+        @primary_key
+      end
+
       def self.const_missing(name)
         # Logger_.debug "ActiveMocker :: Can't can't find Constant #{name} from class #{}."
       end

data/lib/active_mocker/active_record/relationships.rb

@@ -1,5 +1,5 @@
 require 'ostruct'
-
+require 'active_support/core_ext/string'
 module Relationships
 
   def self.included(base)
@@ -25,26 +25,77 @@ module Relationships
     has_and_belongs_to_many + has_many
   end
 
-  private
+  class Relationship
+    attr_reader :name
+    def initialize(name, options={})
+      @name = name
+      @options = options.reduce(HashWithIndifferentAccess.new, :merge)
+    end
+
+    def options
+      @options.symbolize_keys
+    end
+
+    def through
+      options[:through]
+    end
+
+    def class_name
+      options[:class_name] || name.to_s.camelize.singularize
+    end
+
+    def foreign_key
+      options[:foreign_key] || name.to_s.foreign_key
+    end
+
+    def join_table
+      options[:join_table]
+    end
+  end
+
+  class HasMany < Relationship
+
+    attr_reader :klass_name
+
+    def initialize(name, klass_name, options={})
+      @klass_name = klass_name
+      super(name, options)
+    end
+
+    def foreign_key
+      options[:foreign_key] || klass_name.to_s.foreign_key
+    end
+
+  end
 
   def has_many(*args)
     @has_many ||= []
-    @has_many.push [args.first]
+    @has_many.push HasMany.new(args.shift, self.name, args)
+  end
+
+  class HasOne < Relationship
   end
 
   def has_one(*args)
     @has_one ||= []
-    @has_one.push [args.first]
+    @has_one.push HasOne.new(args.shift, args)
+  end
+
+  class BelongsTo < Relationship
   end
 
   def belongs_to(*args)
     @belongs_to ||= []
-    @belongs_to.push [args.first]
+    @belongs_to.push BelongsTo.new(args.shift, args)
+  end
+
+
+  class HasAndBelongsToMany < Relationship
   end
 
   def has_and_belongs_to_many(*args)
     @has_and_belongs_to_many ||= []
-    @has_and_belongs_to_many.push [args.first]
+    @has_and_belongs_to_many.push HasAndBelongsToMany.new(args.shift, args)
   end
 
 end

data/lib/active_mocker/active_record/schema.rb

@@ -49,7 +49,7 @@ module ActiveMocker
       end
 
       def create_table(name, options={}, &block)
-        tables << ActiveMocker::Table.new(name, CreateTable.new.instance_eval(&block))
+        tables << ActiveMocker::Table.new(name, options[:id], CreateTable.new.instance_eval(&block))
       end
 
       def method_missing(meth, *args)

data/lib/active_mocker/active_record/scope.rb

@@ -2,7 +2,7 @@ module Scope
 
   def scope(method_name, proc)
     singleton_class.class_eval do
-      params = Reparameterize.call(proc.parameters)
+      params = ActiveMocker::Reparameterize.call(proc.parameters)
       block = eval("lambda { |#{params}| }")
       define_method(method_name, block)
     end

data/lib/active_mocker/active_record/unknown_class_method.rb

@@ -3,7 +3,7 @@ module ActiveMocker
   module UnknownClassMethod
 
     def method_missing(meth, *args)
-      Logger.debug "ActiveMocker :: #{meth} called from class #{self.name} is unknown and will not be available in mock."
+      Logger.debug "ActiveMocker :: DEBUG :: #{meth} called from class #{self.name} is unknown and will not be available in mock.\n"
     end
 
   end

data/lib/active_mocker/active_record/unknown_module.rb

@@ -3,20 +3,21 @@ module ActiveMocker
   module UnknownModule
 
     def include(_module)
-      begin
-        super _module
-      rescue => e
-        Logger.debug e
-        Logger.debug "ActiveMocker :: Can't include module #{_module} from class #{self.name}.\n #{caller}"
-
-      end
+      try_and_log('include', _module)
     end
 
     def extend(_module)
+      try_and_log('extend', _module)
+    end
+
+    private
+
+    def try_and_log(type, name)
       begin
         super _module
-      rescue
-        Logger.debug "ActiveMocker :: Can't extend module #{_module} from class #{self.name}..\n #{caller}"
+      rescue => e
+        Logger.debug "ActiveMocker :: Debug :: Can't #{type} module #{name} from class #{self.name}.\n\t\t\t\t\t\t\t\t#{caller}\n"
+        Logger.debug "\t\t\t\t\t\t\t\t#{e}"
       end
     end
 

data/lib/active_mocker/db_to_ruby_type.rb

@@ -0,0 +1,26 @@
+module ActiveMocker
+  class DBToRubyType
+
+    def self.call(type)
+      case type
+        when :integer
+          Fixnum
+        when :float
+          Float
+        when :decimal
+          BigDecimal
+        when :timestamp, :time
+          Time
+        when :datetime
+          DateTime
+        when :date
+          Date
+        when :text, :string, :binary
+          String
+        when :boolean
+          Axiom::Types::Boolean
+      end
+    end
+
+  end
+end

data/lib/active_mocker/field.rb

@@ -7,9 +7,12 @@ module ActiveMocker
     def initialize(name, type, options)
       @name    = name
       @type    = type
-      @options = {}
-      options.each{|hash| @options[hash.keys.first] = hash.values.first}
-      create_option_methods
+      @primary_key
+      @options = options.first || {}
+    end
+
+    def primary_key
+      @primary_key
     end
 
     def to_h
@@ -18,11 +21,16 @@ module ActiveMocker
 
     alias_method :to_hash, :to_h
 
-    def create_option_methods
-      options.each do |key, value|
-        self.instance_variable_set("@#{key}", value)
-        self.class.send(:attr_accessor, key)
-      end
+    def default
+      options[:default]
+    end
+
+    def precision
+      options[:precision]
+    end
+
+    def scale
+      options[:scale]
     end
 
   end

data/lib/active_mocker/generate.rb

@@ -31,192 +31,37 @@ class Generate
     "#{model_name}Mock".constantize
   end
 
-  def model_definition(table)
-    return @model_definition if @model_definition_table == table
-    @model_definition_table = table
-    @model_definition       = ModelReader.new({model_dir: model_dir, file_reader: model_file_reader}).parse(table_to_model_file(table))
-  end
-
-  def table_to_model_file(table)
-    table.singularize
-  end
-
-  def table_to_class_name(table)
-    table.camelize.singularize
-  end
-
-  def schema_reader
-    SchemaReader.new({schema_file: schema_file, file_reader: schema_file_reader}).search(nil)
-  end
-
-  def tables
-    schema_reader
+  def generate_model_schema
+    ActiveMocker::ModelSchema::Generate.new(schema_file: schema_file, models_dir: model_dir, logger: logger).run
   end
 
   def create_template
     mocks_created = 0
-    tables.each do |table|
-      begin
-      mock_template = MockTemplate.new
-      # Schema Attributes
-      mock_template.class_name      = mock_class_name(table.name)
-      mock_template.attribute_names = table.column_names
-      mock_template.attributes      = field_type_to_class(table.fields)
-      mock_template.default_attributes =default_attr_values(table.fields)
-
-      # Model associations
-      mock_template.single_associations     = model_definition(table.name).single_relationships
-      mock_template.collection_associations = model_definition(table.name).collections
-      mock_template.association_names       = [*model_definition(table.name).single_relationships, *model_definition(table.name).collections]
-      mock_template.associations            = associations(mock_template.association_names)
-
-      # Model Methods
-      mock_template.instance_methods       = instance_methods(table.name).methods
-      mock_template.model_instance_methods = instance_methods(table.name).model_instance_methods
-      mock_template.class_methods          = class_methods(table.name).methods
-      mock_template.model_class_methods    = class_methods(table.name).model_class_methods
-
-      klass_str = mock_template.render( File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read)
+    models = generate_model_schema
+    models.each do |model|
+      # begin
+        klass_str = ''
+        klass_str = model.render(File.open(File.join(File.expand_path('../', __FILE__), 'mock_template.erb')).read, mock_append_name)
       FileUtils::mkdir_p mock_dir unless File.directory? mock_dir
-      File.open(File.join(mock_dir,"#{table.name.singularize}_mock.rb"), 'w').write(klass_str)
-      logger.info "saving mock #{table_to_model_file(table.name)} to #{mock_dir}"
-
-      rescue Exception => exception
-        logger.debug $!.backtrace
-        logger.debug exception
-        logger.info "failed to load #{table_to_model_file(table.name)} model"
-        next
-      end
+      File.open(File.join(mock_dir,"#{model.table_name.singularize}_mock.rb"), 'w').write(klass_str)
+      logger.info "saving mock #{model.class_name} to #{mock_dir}"
+
+      # rescue Exception => exception
+      #   logger.debug $!.backtrace
+      #   logger.debug exception
+      #   logger.info "failed to load #{model} model"
+      #   next
+      # end
       mocks_created += 1
 
     end
-    logger.info "Generated #{mocks_created} of #{tables.count} mocks"
-  end
-
-  def field_type_to_class(fields)
-    fields.map do |field|
-      field.type = case field.type
-         when :integer then
-           Fixnum
-         when :float then
-           Float
-         when :decimal then
-           BigDecimal
-         when :timestamp, :time then
-           Time
-         when :datetime then
-           DateTime
-         when :date then
-           Date
-         when :text, :string, :binary then
-           String
-         when :boolean then
-           ::Virtus::Attribute::Boolean
-       end
-      field
-    end
-
-  end
-
-  def mock_class_name(table_name)
-    "#{table_to_class_name(table_name)}Mock"
-  end
-
-  def associations(names)
-    hash = {}
-    names.each do |name|
-      hash[name] = nil
-    end
-    hash
-  end
-
-  def default_attr_values(fields)
-    attributes = {}
-    fields.each do |f|
-      if f.options[:default].nil?
-        attributes[f.name] = nil
-      else
-        value = f.default.class == String ? f.default : f.default
-        attributes[f.name] = value
-      end
-    end
-    attributes
-  end
-
-  def instance_methods(table_name)
-    model_instance_methods = []
-    instance_methods = Methods.new
-    instance_methods.methods = model_definition(table_name).instance_methods_with_arguments.map do |method|
-      m = method.keys.first.to_s
-      if m == :attributes
-        logger.warn "ActiveMocker Depends on the #attributes method. It will not be redefined for the model."
-        next
-      end
-      params      = Reparameterize.call(method.values.first)
-      params_pass = Reparameterize.call(method.values.first, true)
-
-      instance_method = Method.new
-      instance_method.method = m
-      instance_method.params = params
-
-      instance_method.params_pass = params_pass
-      model_instance_methods << m
-      instance_method
-    end
-    instance_methods.model_instance_methods = {}
-    model_instance_methods.each{|meth| instance_methods.model_instance_methods[meth] = :not_implemented }
-    instance_methods
-  end
-
-  def class_methods(table_name)
-    model_class_methods = []
-    class_methods = Methods.new
-    class_methods.methods = model_definition(table_name).class_methods_with_arguments.map do |method|
-      m = method.keys.first.to_s
-      params      = Reparameterize.call(method.values.first)
-      params_pass = Reparameterize.call(method.values.first, true)
-
-      class_method = Method.new
-      class_method.method = m
-      class_method.params = params
-      class_method.params_pass = params_pass
-      model_class_methods << m
-      class_method
-    end
-    class_methods.model_class_methods = {}
-    model_class_methods.each { |meth| class_methods.model_class_methods[meth] = :not_implemented }
-    class_methods
-  end
-
-  class Method
-    attr_accessor :method, :params, :params_pass
+    logger.info "Generated #{mocks_created} of #{models.count} mocks"
   end
 
-  class Methods
-    attr_accessor :methods, :model_class_methods, :model_instance_methods
+  def mock_append_name
+    'Mock'
   end
 
-  class MockTemplate
-    attr_accessor :attributes,
-                  :single_associations,
-                  :collection_associations,
-                  :class_name,
-                  :association_names,
-                  :attribute_names,
-                  :column_names,
-                  :instance_methods,
-                  :class_methods,
-                  :model_instance_methods,
-                  :model_class_methods,
-                  :default_attributes,
-                  :associations
-
-    def render(template)
-      ERB.new(template, nil, '-').result(binding)
-    end
-  end
-
-
 end
 end