active_mocker 1.8.4 → 2.0.0.beta1

data/lib/active_mocker/active_record/schema.rb

@@ -1,81 +0,0 @@
-module ActiveMocker
-  module ActiveRecord
-
-    class Schema
-
-      def self.define(options, &block)
-        version = options[:version]
-        search_result = search_cache(@table_search)
-        search_result unless search_result.nil?
-        schema = parse
-        schema.instance_eval(&block)
-        schema
-      end
-
-      def self.parse
-        SchemaParser.new(@table_search)
-      end
-
-      def self.add_to_cache(table)
-        @tables_cache ||= []
-        @tables_cache << table unless table.nil?
-      end
-
-      def self.search_cache(table_name)
-        @tables_cache ||= []
-        @tables_cache.find do |h|
-          h.name == table_name
-        end
-      end
-
-      def self.clear_cache
-        @tables_cache = []
-      end
-
-      def self.search(table_name)
-        @table_search = table_name
-        search_cache(table_name)
-      end
-
-    end
-
-    class SchemaParser
-
-      attr_reader :tables, :table_search
-
-      def initialize(table_search)
-        @table_search = table_search
-        @tables = []
-      end
-
-      def create_table(name, options={}, &block)
-        tables << Table.new(name, options[:id], CreateTable.new.instance_eval(&block))
-      end
-
-      def method_missing(meth, *args)
-      end
-
-    end
-  end
-
-  class CreateTable
-
-    attr_reader :fields
-
-    def initialize
-      @fields = []
-    end
-
-    def method_missing(meth, *args)
-      base_field meth, args
-    end
-
-    def base_field(type, args)
-      fields << ActiveRecord::Field.new(args.shift, type, args)
-    end
-
-  end
-
-end
-
-

data/lib/active_mocker/active_record/scope.rb

@@ -1,22 +0,0 @@
-module ActiveMocker
-
-  module ActiveRecord
-
-    module Scope
-
-      def scope(method_name, proc)
-        get_named_scopes[method_name] = proc
-      end
-
-      def get_named_scopes
-        @scope_methods ||= {}
-      end
-
-    end
-
-  end
-
-end
-
-
-

data/lib/active_mocker/active_record/table.rb

@@ -1,26 +0,0 @@
-module ActiveMocker
-  module ActiveRecord
-  # @api private
-  class Table
-
-    attr_reader :name, :fields
-
-    def initialize(name, id=true, fields=[])
-      @name   = name
-      @fields = fields
-      fields.unshift Field.new('id', :integer, [{primary_key: true}]) if id.nil?
-    end
-
-    def to_h
-      {name: name, fields: fields.to_h}
-    end
-
-    alias_method :to_hash, :to_h
-
-    def column_names
-      fields.map { |f| f.name }
-    end
-
-  end
-  end
-end

data/lib/active_mocker/active_record/unknown_class_method.rb

@@ -1,17 +0,0 @@
-module ActiveMocker
-
-  module ActiveRecord
-
-    module UnknownClassMethod
-
-      def method_missing(meth, *args)
-        Config.logger.warn "#{meth} called from class #{self.name.demodulize}" +
-                         " is unknown and will not be available in mock.\n  #{caller.first}"
-      end
-
-    end
-
-  end
-
-end
-

data/lib/active_mocker/active_record/unknown_module.rb

@@ -1,30 +0,0 @@
-module ActiveMocker
-
-  module ActiveRecord
-
-    module UnknownModule
-
-      def include(_module)
-        try_and_log('include', _module, caller)
-      end
-
-      def extend(_module)
-        try_and_log('extend', _module, caller)
-      end
-
-      private
-
-      def try_and_log(method, name, _caller)
-        begin
-          super _module
-        rescue => e
-          Config.logger.debug "#{method} module #{name} from class #{self.name}.\n  #{_caller}\n  #{e}"
-        end
-      end
-
-    end
-
-  end
-
-
-end

data/lib/active_mocker/db_to_ruby_type.rb

@@ -1,29 +0,0 @@
-module ActiveMocker
-  # @api private
-  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
-        when :hstore
-          Hash
-      end
-    end
-
-  end
-end

data/lib/active_mocker/file_reader.rb

@@ -1,11 +0,0 @@
-module ActiveMocker
-# @api private
-class FileReader
-
-  def self.read(file_and_path)
-    File.open(file_and_path).read
-  end
-
-end
-
-end

data/lib/active_mocker/model_reader.rb

@@ -1,191 +0,0 @@
-module ActiveMocker
-  # @api private
-
-  class ModelReader
-
-    attr_reader :model_name
-
-    def parse(model_name)
-      @model_name = model_name
-      return ParsedProperties.new(klass, parent_class, model_name) if klass
-      false
-    end
-
-    def klass
-      @klass ||= eval_file(sandbox_model, file_path)
-    end
-
-    def sandbox_model
-      source = RubyParse.new(read_file)
-      has_no_parent_class!(source)
-      get_non_active_record_parent_class(source)
-      source.modify_parent_class('ActiveMocker::ActiveRecord::Base')
-    end
-
-    def get_non_active_record_parent_class(source)
-      @parent_class = source.parent_class_name unless Config.model_base_classes.include?(source.parent_class_name)
-    end
-
-    def has_no_parent_class!(source)
-      raise ModelLoadError::HasNoParentClass.new("#{model_name}") unless source.has_parent_class?
-    end
-
-    def module_namespace
-      @module ||= Module.new
-    end
-
-    def eval_file(string, file_path)
-      failure = false
-      begin
-        module_namespace.module_eval(string, file_path)
-        _klass = module_namespace.const_get(module_namespace.constants.last)
-      rescue SyntaxError => e
-        log_loading_error(e, true)
-        failure = true
-      rescue Exception => e
-        log_loading_error(e, false)
-        failure = true
-      end
-      return false if failure
-      _klass
-    end
-
-    def log_loading_error(msg, print_to_stdout=false)
-      main = "Error loading Model: #{model_name} \n\t#{msg}\n"
-      file = "\t#{file_path}\n"
-      stack_trace = msg.backtrace_locations.map{|e| "\t#{e}"}.join("\n")
-      str = main + file + stack_trace
-      Config.logger.error str
-      print str if print_to_stdout
-    end
-
-    def parent_class
-      @parent_class
-    end
-
-    def read_file(m_name=model_name)
-      Config.file_reader.read(file_path(m_name))
-    end
-
-    def file_path(m_name=model_name)
-      "#{Config.model_dir}/#{m_name}.rb"
-    end
-
-    class ParsedProperties
-
-      attr_reader :klass, :parent_class, :model_name
-
-      def initialize(klass, parent_class, model_name)
-        @klass        = klass
-        @parent_class = parent_class
-        @model_name   = model_name
-      end
-
-      def rails_version
-        begin
-          @rails_version ||= model_name.camelize.constantize
-        rescue
-          raise ModelLoadError::LoadingModelInRails.new($!, model_name)
-        end
-      end
-
-      def abstract_class
-        rails_version.try(:abstract_class)
-      end
-
-      def select_only_current_class(type)
-        rails_version.reflect_on_all_associations(type).select do |a|
-          klass.relationships.send(type).map(&:name).include?(a.name)
-        end
-      end
-
-      def belongs_to
-        select_only_current_class(:belongs_to)
-      end
-
-      def has_one
-        select_only_current_class(:has_one)
-      end
-
-      def has_and_belongs_to_many
-        select_only_current_class(:has_and_belongs_to_many)
-      end
-
-      def has_many
-        select_only_current_class(:has_many)
-      end
-
-      def table_name
-        return rails_version.try(:table_name) if rails_version.try(:superclass).try(:name) == 'ActiveRecord::Base'
-        return nil if rails_version.superclass.try(:table_name) == rails_version.try(:table_name)
-        rails_version.try(:table_name)
-      end
-
-      def primary_key
-        rails_version.primary_key
-      end
-
-      def class_methods
-        klass.methods(false)
-      end
-
-      def scopes
-        klass.get_named_scopes
-      end
-
-      def scopes_with_arguments
-        scopes.map do |name, proc|
-          {name => proc.parameters, :proc => proc}
-        end
-      end
-
-      def class_methods_with_arguments
-        class_methods.map do |m|
-          {m => klass.method(m).parameters}
-        end
-      end
-
-      def instance_methods_with_arguments
-        instance_methods.map do |m|
-          {m => klass.instance_method(m).parameters}
-        end
-      end
-
-      def instance_methods
-        methods = klass.public_instance_methods(false)
-        methods << klass.superclass.public_instance_methods(false) if klass.superclass != ActiveRecord::Base
-        methods.flatten
-      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
-
-      def modules
-        {included: process_module_names(klass._included),
-         extended: process_module_names(klass._extended)}
-      end
-
-      def process_module_names(names)
-        names.reject { |m| /#{klass.inspect}/ =~ m.name }.map(&:inspect)
-      end
-
-    end
-
-  end
-
-end
-
-# Hack for CarrierWave error - undefined method `validate_integrity'
-module ActiveRecord
-  class Base
-    def self.mount_uploader(*args)
-      super unless ActiveMocker::Config.build_in_progress
-    end
-  end
-end

data/lib/active_mocker/model_schema.rb

@@ -1,285 +0,0 @@
-module ActiveMocker
-  # @api private
-  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
-
-  # @api private
-  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 < AttrPermit
-    attr_permit :class_name,
-                :table_name,
-                :attributes,
-                :relationships,
-                :_methods,
-                :modules,
-                :constants,
-                :parent_class,
-                :abstract_class
-
-    def abstract_class
-      !!call_method(:abstract_class)
-    end
-
-    def constants
-      call_method(: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 scope_methods
-      method_find(:scope)
-    end
-
-    def methods
-      call_method(:_methods) || []
-    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] = "#{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 associations_by_class
-      hash = {}
-      relationships.each do |r|
-        hash[r.class_name] ||= {}
-        hash[r.class_name][r.type] ||= []
-        hash[r.class_name][r.type] << r.name
-      end
-      hash
-    end
-
-    def mock_name(klass_name)
-      klass_name + "Mock"
-    end
-
-    def mockable_class_methods
-      class_methods.map(&:name).each_with_object({}) { |val, hash| hash[val] = nil }
-    end
-
-    def mockable_instance_methods
-      instance_methods.map(&:name).each_with_object({}) { |val, hash| hash[val] = nil }
-    end
-
-    def parent_class
-      return mock_name(call_method(:parent_class)) if call_method(:parent_class).present?
-      'ActiveMocker::Mock::Base'
-    end
-
-    def is_child_class?
-      call_method(:parent_class).present?
-    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)
-      call_method(: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, :source, :foreign_key, :join_table
-
-      def initialize(name:,
-          class_name:,
-          type:,
-          through:,
-          source:,
-          foreign_key:,
-          join_table:
-      )
-        @name        = name
-        @class_name  = class_name
-        @type        = type
-        @through     = through
-        @source      = source
-        @foreign_key = foreign_key
-        @join_table  = join_table
-      end
-
-    end
-
-    class Methods < AttrPermit
-
-      attr_permit :name, :arguments, :type
-
-      def arguments
-        Arguments.new(call_method(:arguments))
-      end
-
-      class Arguments
-
-        attr_reader :arguments
-
-        def initialize(arguments)
-          @arguments = arguments
-        end
-
-        def to_hash
-          @arguments
-        end
-
-        def empty?
-          @arguments.empty?
-        end
-
-        def to_s
-          Reparameterize.method_arguments(arguments)
-        end
-
-        def passable
-          Reparameterize.method_parameters(arguments)
-        end
-
-      end
-
-    end
-
-  end
-
-end