active_mocker 1.3.2 → 1.4.1

data/lib/active_mocker/model_schema/generate.rb

@@ -0,0 +1,175 @@
+module ActiveMocker
+
+  class ModelSchema
+
+    class Generate
+
+      attr_reader :schema_file, :models_dir
+
+      def initialize(schema_file:nil, models_dir:nil, logger:nil)
+        @schema_file = schema_file
+        @models_dir  = models_dir
+        Logger.set(logger)
+      end
+
+      def tables
+        @tables ||= SchemaReader.new({schema_file: schema_file}).search(nil)
+      end
+
+      def get_table(model , model_name)
+        table_name = get_table_name(model.table_name, model_name)
+        selected_table = tables.select{|table| table.name == table_name}.first
+        if selected_table.nil?
+          Logger.error "The Implicit or defined table, `#{table_name}`, can not be found for model #{model_name.camelize}."
+        end
+        tables.delete(selected_table)
+        selected_table
+      end
+
+      # noinspection RubyArgCount
+      def run
+        model_schemas = models.map do |model_name|
+
+          model      = get_model(model_name)
+          next if model == false
+          table      = get_table(model, model_name)
+          attributes = build_attributes(table.fields, primary_key(table.fields, model))
+
+          ModelSchema.new(class_name:    model_name.camelize,
+                          table_name:    table.name,
+                          attributes:    attributes,
+                          methods:       build_methods(model),
+                          relationships: build_relationships(model),
+                          constants:     model.constants)
+        end
+
+        ModelSchemaCollection.new(model_schemas.compact)
+      end
+
+
+
+      # noinspection RubyArgCount
+      def build_attributes(attributes, primary_attribute)
+        attributes.map do |attr|
+          attribute = ModelSchema::Attributes
+                        .new(name:          attr.name,
+                             type:          attr.type,
+                             precision:     attr.precision,
+                             scale:         attr.scale,
+                             default_value: attr.default)
+          if primary_attribute == attr
+            attribute.primary_key = true
+          end
+          attribute
+        end
+      end
+
+      # noinspection RubyArgCount
+      def build_methods(model)
+        result = []
+        {instance: model.instance_methods_with_arguments,
+         class: model.class_methods_with_arguments}.each do |type,methods|
+          methods.map do |method|
+            method_name = method.keys.first.to_s
+            arguments = method.values.first
+
+            result.push(ModelSchema::Methods.new(name: method_name,arguments: arguments,type:type))
+          end
+        end
+        result
+      end
+
+      def build_relationships(model)
+        relations_by_type(model).map do |type, relations|
+          relations.map do |relation|
+            join_table = nil
+            join_table = find_join_table(relation, model) if type == :has_and_belongs_to_many
+            Relationships.new(name:        relation.name,
+                              class_name:  relation.class_name,
+                              type:        type,
+                              through:     relation.through,
+                              foreign_key: relation.foreign_key,
+                              join_table:  join_table)
+          end
+        end.flatten
+      end
+
+      def relations_by_type(model)
+        {belongs_to: model.belongs_to,
+         has_one: model.has_one,
+         has_many: model.has_many,
+         has_and_belongs_to_many: model.has_and_belongs_to_many
+
+        }
+      end
+
+      def find_join_table(relation, model)
+        return relation.join_table if relation.respond_to?(:join_table) && relation.join_table
+        tables.select do |table|
+          
+          "#{model.table_name}_#{relation.name}" == table.name.to_s || "#{relation.name}_#{model.table_name}" == table.name.to_s
+        end.first
+      end
+
+      def primary_key(attributes, model)
+        result = model_primary_key_attribute(attributes, model)
+        return result unless result.nil?
+
+        result = find_primary_key(attributes)
+        return result unless result.nil?
+
+        find_id_attribute(attributes)
+      end
+
+      private
+
+      def model_primary_key_attribute(attributes, model)
+        if model.respond_to?(:primary_key) && model.primary_key
+          attributes.select do |attr|
+            model.primary_key.to_s == attr.name.to_s
+          end.first
+        end
+      end
+
+      def find_primary_key(attributes)
+        attributes.select do |attr|
+          attr.try(:primary_key)
+        end.first
+      end
+
+      def find_id_attribute(attributes)
+        attributes.select do |attr|
+          attr.name.to_sym == :id
+        end.first
+      end
+
+      public
+
+      def models
+        Dir["#{models_dir}/*.rb"].map do |file|
+          Pathname.new(file).basename.to_s.sub('.rb', '')
+        end
+      end
+
+      def get_model(model_file_name)
+        ModelReader.new({model_dir: models_dir}).parse(model_file_name)
+      end
+
+      def get_table_name(model_table_name, model_name)
+        return model_name.tableize if model_table_name.nil?
+        return model_table_name
+      end
+
+      def table_to_model_file(table_name)
+        table_name.singularize
+      end
+
+      def table_to_class_name(table)
+        table.camelize.singularize
+      end
+
+    end
+
+  end
+
+end

data/lib/active_mocker/reparameterize.rb

@@ -1,8 +1,12 @@
+module ActiveMocker
 class Reparameterize
 
-  def self.call(params, list=false)
-    return params.map{|state, param| param }.join(", ") if list
+  def self.call(params, param_list:false)
+    return param_list(params) if param_list
+    method_arguments(params)
+  end
 
+  def self.method_arguments(params)
     params.map do |state, param|
       case state
         when :req
@@ -11,11 +15,27 @@ class Reparameterize
           "*#{param}"
         when :opt
           "#{param}=nil"
+        when :keyreq
+          "#{param}:"
+        when :key
+          "#{param}: nil"
         else
           param
       end
-    end.join(", ")
+    end.join(', ')
+
+  end
 
+  def self.param_list(params)
+    params.map do |state, param|
+      case state
+        when :key, :keyreq
+          "#{param}: #{param}"
+        else
+          param
+      end
+    end.join(', ')
   end
 
+end
 end

data/lib/active_mocker/table.rb

@@ -4,10 +4,10 @@ module ActiveMocker
 
     attr_reader :name, :fields
 
-    def initialize(name, fields=[])
+    def initialize(name, id=true, fields=[])
       @name   = name
       @fields = fields
-      fields.unshift Field.new('id', :integer, {})
+      fields.unshift Field.new('id', :integer, [{primary_key: true}]) if id.nil?
     end
 
     def to_h

data/lib/active_mocker/version.rb

@@ -1,3 +1,3 @@
 module ActiveMocker
-  VERSION = "1.3.2"
+  VERSION = "1.4.1"
 end

data/sample_app_rails_4/Gemfile

@@ -4,7 +4,7 @@ gem 'rails', '4.1'
 
 group :development, :test do
   gem 'sqlite3', '~>1.3'
-  gem 'rspec-rails', '~>2'
+  gem 'rspec-rails', '2.14.1'
 end
 
 group :test do

data/sample_app_rails_4/app/models/micropost.rb

@@ -1,12 +1,24 @@
 class Micropost < ActiveRecord::Base
   belongs_to :user
   default_scope -> { order('created_at DESC') }
+  MAGIC_ID_NUMBER = 90
+  MAGIC_ID_STRING = 'F-1'
 
+  module DoNotIncludeInMock
+
+  end
+  include DoNotIncludeInMock
+  # self.primary_key = :lol
+  # self.table_name = :posts
   # Returns microposts from the users being followed by the given user.
-  def self.from_users_followed_by(user)
+  def self.from_users_followed_by(user=nil)
     followed_user_ids = "SELECT followed_id FROM relationships
                          WHERE follower_id = :user_id"
     where("user_id IN (#{followed_user_ids}) OR user_id = :user_id",
           user_id: user.id)
   end
+
+  def display_name
+
+  end
 end

data/sample_app_rails_4/db/schema.rb

@@ -37,7 +37,7 @@ ActiveRecord::Schema.define(version: 20130315230445) do
   create_table "users", force: true do |t|
     t.string   "name"
     t.string   "email",    default: ""
-    t.decimal  "credits"
+    t.decimal  "credits",  precision: 19, scale: 6
     t.datetime "created_at"
     t.datetime "updated_at"
     t.string   "password_digest"

data/sample_app_rails_4/spec/compare_mocker_and_record_spec.rb

@@ -26,7 +26,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
   describe '::superclass' do
 
     it 'mock has super of active hash' do
-      expect(UserMock.superclass.name).to eq "ActiveHash::Base"
+      expect(UserMock.superclass.name).to eq "ActiveMock::Base"
     end
 
     it 'ar has super of ar' do
@@ -95,7 +95,9 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
   describe '#attributes' do
 
     let(:user_ar){User.new(attributes)}
-    let(:user_mock){UserMock.new(attributes)}
+    let(:user_mock){
+      UserMock.new(attributes)
+    }
 
     it 'mock' do
       expect(user_mock.attributes).to eq({"id" => nil, "name" => "Dustin Zeisler", "email" => "dustin@example.com", "credits" => nil, "created_at" => nil, "updated_at" => nil, "password_digest" => nil, "remember_token" => true, "admin" => false})
@@ -292,7 +294,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
       end
 
       it 'UserMock' do
-        where_no_options(UserMock, ActiveMocker::Collection::Queries::WhereNotChain)
+        where_no_options(UserMock, ActiveMock::Queries::WhereNotChain)
       end
 
     end
@@ -400,7 +402,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
       end
 
       it 'UserMock' do
-        supported_array_methods(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+        supported_array_methods(UserMock, MicropostMock, ActiveMock::HasMany)
       end
 
     end
@@ -420,7 +422,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
         end
 
         it 'UserMock' do
-          collection_find(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+          collection_find(UserMock, MicropostMock, ActiveMock::Association)
         end
 
       end
@@ -438,7 +440,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
         end
 
         it 'UserMock' do
-          collection_finds(UserMock, MicropostMock, ActiveMocker::Collection::Association)
+          collection_finds(UserMock, MicropostMock, ActiveMock::Association)
         end
 
       end
@@ -822,7 +824,7 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
       end
 
       it 'UserMock' do
-        find_by_exception(UserMock, ActiveMocker::RecordNotFound)
+        find_by_exception(UserMock, ActiveMock::RecordNotFound)
       end
 
     end
@@ -846,6 +848,191 @@ describe 'Comparing ActiveMocker Api to ActiveRecord Api' do
 
   end
 
+  describe '::transaction' do
 
+    context 'will run code in block' do
+
+      def transaction(user_class)
+        user_class.transaction do
+          user_class.create(email: '1')
+          user_class.create(email: '2')
+        end
+
+        expect(user_class.count).to eq 2
+      end
+
+      it 'User' do
+        transaction(User)
+      end
+
+      it 'UserMock' do
+        transaction(UserMock)
+      end
+
+    end
+
+  end
+
+  describe 'belongs_to association' do
+
+    describe 'when setting association by object it will set id if object is persisted' do
+
+      def id_set_by_object(post_class, user_class)
+        user = user_class.create
+        post = post_class.create(user: user)
+        expect(post.user_id).to eq user.id
+      end
+
+      it 'User' do
+        id_set_by_object(Micropost, User)
+      end
+
+      it 'UserMock' do
+        id_set_by_object(MicropostMock, UserMock)
+      end
+
+    end
+
+    describe 'when setting association by object it will set the child association', pending:true do
+
+      def set_by_object(post_class, user_class)
+        user = user_class.create
+        post = post_class.create(user: user)
+        expect(user.microposts).to eq [post]
+      end
+
+      it 'User' do
+        set_by_object(Micropost, User)
+      end
+
+      it 'UserMock' do
+        set_by_object(MicropostMock, UserMock)
+      end
+
+    end
+
+    describe 'when setting association by id it will set the object on the parent' do
+
+      def object_set_by_id(post_class, user_class)
+        user = user_class.create
+        post = post_class.create(user_id: user.id)
+        expect(post.user).to eq user
+      end
+
+      it 'User' do
+        object_set_by_id(Micropost, User)
+      end
+
+      it 'UserMock' do
+        object_set_by_id(MicropostMock, UserMock)
+      end
+
+    end
+
+    describe 'when setting association by object it will not set id if object is not persisted' do
+
+      def id_set_by_object(post_class, user_class)
+        user = user_class.new
+        post = post_class.new(user: user)
+        expect(post.user_id).to eq nil
+      end
+
+      it 'User' do
+        id_set_by_object(Micropost, User)
+      end
+
+      it 'UserMock' do
+        id_set_by_object(MicropostMock, UserMock)
+      end
+
+    end
+
+    describe 'can build' do
+
+      def build_belong_to(post_class, user_class)
+        post = post_class.new
+        user = post.build_user
+        expect(user.class).to eq user_class
+        expect(post.user).to eq user
+      end
+
+      it 'User' do
+        build_belong_to(Micropost, User)
+      end
+
+      it 'UserMock' do
+        build_belong_to(MicropostMock, UserMock)
+      end
+
+    end
+
+  end
+
+  describe 'has_many association' do
+
+    describe 'when passing in collection all item in collection will set its foreign key to the parent', pending: true do
+
+      def id_set_to_children(user_class, post_class)
+        posts = [post_class.create, post_class.create, post_class.create]
+        user = user_class.create(microposts: posts)
+        expect(user.microposts.map(&:user_id)).to eq posts.map(&:user_id)
+        expect(posts.map(&:user_id)).to eq [user.id, user.id, user.id]
+      end
+
+      it 'User' do
+        id_set_to_children(User, Micropost)
+      end
+
+      it 'UserMock' do
+        id_set_to_children(UserMock, MicropostMock)
+      end
+
+    end
+
+  end
+
+  describe 'can build new object from collection' do
+
+    def new_record_on_collection(user_class, post_class)
+      user = user_class.create
+      new_post = user.microposts.build
+      expect(new_post.class).to eq(post_class)
+      expect(new_post.attributes).to eq({"id" => nil, "content" => nil, "user_id" => 1, "up_votes" => nil, "created_at" => nil, "updated_at" => nil})
+      expect(user.microposts.count).to eq 0
+      new_post.save
+      expect(user.microposts.count).to eq(1)
+      expect(user.microposts.first).to eq(new_post)
+    end
+
+    it 'User' do
+      new_record_on_collection(User, Micropost)
+    end
+
+    it 'UserMock' do
+      new_record_on_collection(UserMock, MicropostMock)
+    end
+
+  end
+
+  describe 'can create new object from collection' do
+
+    def create_record_on_collection(user_class, post_class)
+      user = user_class.create
+      new_post = user.microposts.create
+      expect(new_post.class).to eq(post_class)
+      expect(new_post.user_id).to eq(1)
+      expect(user.microposts.count).to eq 1
+      expect(user.microposts.first).to eq(new_post)
+    end
+
+    it 'User' do
+      create_record_on_collection(User, Micropost)
+    end
+
+    it 'UserMock' do
+      create_record_on_collection(UserMock, MicropostMock)
+    end
+
+  end
 
 end