active_mocker 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a57ab19178452d40493f706844efc26d8381d0b1
+  data.tar.gz: 360196e9eccecb12fef06ca111e002bfdd1cb5a7
+SHA512:
+  metadata.gz: ff22e9d0e5bef978329f85385e6865dcce9803a10a703de790ce2682f7715efda58b017007a05b4ab4e0d3ac7d24a2fb9c6255d078d9a9e974ca04f0f3029f16
+  data.tar.gz: 6b94c9d8b9025619a45f8991cb7592a5c43dd44258822405726cbfcdffc4730eaddbd94687e02842cb5ed219c7f08d8136ad501dd771820c30748f6aa5e61c7e

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - "1.9.3"
+  - "2.0.0"
+  - "2.1.0"
+  - "2.1.1"

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in active_mocker.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dustin Zeisler
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# ActiveMocker
+[![Build Status](https://travis-ci.org/zeisler/active_mocker.png?branch=master)](https://travis-ci.org/zeisler/active_mocker)
+Create mocks from active record models without loading rails or running a datebase
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'active_mocker'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install active_mocker
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/active_mocker/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+
+task :default => 'specs'
+
+task :specs do
+  system 'rspec'
+end

data/active_mocker.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'active_mocker/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "active_mocker"
+  spec.version       = ActiveMocker::VERSION
+  spec.authors       = ["Dustin Zeisler"]
+  spec.email         = ["dustin@zive.me"]
+  spec.summary       = %q{Create mocks from active record models without loading rails or running a database}
+  spec.description   = %q{Create mocks from active record models without loading rails or running a database. The Mocks methods have the same arguments as the AR model and if they change you get a error in your test.}
+  spec.homepage      = "https://github.com/zeisler/active_mocker"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake", "~>10.1"
+  spec.add_development_dependency "rspec", "~>2.14"
+  spec.add_development_dependency "i18n", "~>0.6"
+  spec.add_development_dependency "activesupport", "~>4.0"
+
+  #spec.add_development_dependency "debase", "~>0.0"
+  #spec.add_development_dependency "ruby-debug-ide", "~>0.4"
+
+end

data/lib/active_mocker.rb

@@ -0,0 +1,5 @@
+require "active_mocker/version"
+
+module ActiveMocker
+  # Your code goes here...
+end

data/lib/active_mocker/active_record.rb

@@ -0,0 +1,12 @@
+$:.unshift File.expand_path('../../', __FILE__)
+require 'active_mocker/active_record/scope'
+require 'active_mocker/active_record/relationships'
+
+module ActiveMocker
+  module ActiveRecord
+    class Base
+      extend Scope
+      extend Relationships
+    end
+  end
+end

data/lib/active_mocker/active_record/relationships.rb

@@ -0,0 +1,34 @@
+require 'ostruct'
+
+module Relationships
+
+  def relationships
+    OpenStruct.new({has_many:   @has_many   ||= [],
+                    has_one:    @has_one    ||= [],
+                    belongs_to: @belongs_to ||= [],
+                    has_and_belongs_to_many: @has_and_belongs_to_many ||= []})
+  end
+
+  private
+
+  def has_many(*args)
+    @has_many ||= []
+    @has_many.push args
+  end
+
+  def has_one(*args)
+    @has_one ||= []
+    @has_one.push args
+  end
+
+  def belongs_to(*args)
+    @belongs_to ||= []
+    @belongs_to.push args
+  end
+
+  def has_and_belongs_to_many(*args)
+    @has_and_belongs_to_many ||= []
+    @has_and_belongs_to_many.push args
+  end
+
+end

data/lib/active_mocker/active_record/schema.rb

@@ -0,0 +1,81 @@
+module ActiveMocker
+  module ActiveRecord
+
+    class Schema
+
+      def self.define(version: version, &block)
+        search_result = search_cache(@table_search)
+        search_result unless search_result.nil?
+        schema = parse
+        schema.instance_eval(&block)
+        add_to_cache schema.tables.first
+        schema.tables.first
+      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
+      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 << ActiveMocker::Table.new(name, CreateTable.new.instance_eval(&block)) if name == table_search
+      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 << Field.new(name: args.shift, type: type, options: args)
+    end
+
+  end
+
+end
+
+

data/lib/active_mocker/active_record/scope.rb

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

data/lib/active_mocker/base.rb

@@ -0,0 +1,170 @@
+module ActiveMocker
+
+  #TODO DRY up method creation
+  #TODO have instance variable array for instance method
+  #TODO have class variable array for class method
+  #TODO enable support for active_hash as base class
+  #TODO work on options interface
+
+  class Base
+
+    attr_reader :model_name,
+                :model_options,
+                :options_schema,
+                :mass_assignment,
+                :model_relationships,
+                :schema_attributes,
+                :model_methods
+
+    def initialize(options={})
+      @schema_attributes   = options.fetch(:schema_attributes,   true)
+      @model_relationships = options.fetch(:model_relationships, true)
+      @model_methods       = options.fetch(:model_methods,       true)
+      @mass_assignment     = options.fetch(:mass_assignment,     true)
+      @model_options       = options[:model]
+      @options_schema      = options[:schema]
+    end
+
+    def mock(model_name)
+      @model_name = model_name
+      mock_class
+    end
+
+    def model_definition
+      return @model_definition unless @model_definition.nil?
+      @model_definition = ModelReader.new(model_options).parse(model_file_name)
+    end
+
+    def model_file_name
+      model_name.tableize.singularize
+    end
+
+    def table_definition
+      table_name = model_name.tableize
+      table = SchemaReader.new(options_schema).search(table_name)
+      raise "#{table_name} table not found." if table.nil?
+      return table
+    end
+
+    def mock_class
+      add_method_mock_of
+      add_instance_methods     if model_methods
+      add_mock_instance_method if model_methods
+      add_relationships        if model_relationships
+      add_class_methods        if model_methods
+      add_column_names_method  if schema_attributes
+      add_table_attributes     if schema_attributes
+      create_initializer       if mass_assignment
+      return @klass
+    end
+
+    def create_initializer
+      klass = create_klass
+      klass.instance_eval do
+        define_method('initialize') do |options={}|
+          options.each {|method, value| send("#{method}=", value)}
+        end
+      end
+    end
+
+    def add_relationships
+      klass = create_klass
+      model_definition.relationships.each do |m|
+        klass.instance_variable_set("@#{m}", nil)
+        klass.class_eval { attr_accessor m }
+      end
+    end
+
+    def add_method_mock_of
+      klass = create_klass
+      klass.class_variable_set(:@@model_name, model_name)
+      klass.instance_eval do
+        define_method(:mock_of) {klass.class_variable_get :@@model_name}
+      end
+    end
+
+    def add_table_attributes
+      klass = create_klass
+      table_definition.column_names.each do |m|
+        klass.instance_variable_set("@#{m}", nil)
+        klass.class_eval { attr_accessor m }
+      end
+    end
+
+    def add_instance_methods
+      klass = create_klass
+      model_definition.instance_methods_with_arguments.each do |method|
+        m = method.keys.first
+        params = Reparameterize.call(method.values.first)
+        params_pass = Reparameterize.call(method.values.first, true)
+        klass.instance_variable_set("@#{m}", eval_lambda(params, %Q[raise "##{m} is not Implemented for Class: #{klass.name}"]))
+        block = eval_lambda(params, %Q[ self.class.instance_variable_get("@#{m}").call(#{params_pass})])
+        klass.instance_eval do
+          define_method(m, block)
+        end
+      end
+    end
+
+    def eval_lambda(arguments, block)
+      eval(%Q[ ->(#{arguments}){ #{block} }])
+    end
+
+    def add_mock_instance_method
+      klass = create_klass
+      klass.singleton_class.class_eval do
+        define_method(:mock_instance_method) do |method, &block|
+          klass.instance_variable_set("@#{method.to_s}", block)
+        end
+      end
+    end
+
+    def add_class_methods
+      klass = create_klass
+      model_definition.class_methods.each do |m|
+        klass.singleton_class.class_eval do
+          define_method(m) do
+            raise "::#{m} is not Implemented for Class: #{klass.name}"
+          end
+        end
+      end
+    end
+
+    def add_column_names_method
+      klass = create_klass
+      table = table_definition
+      klass.singleton_class.class_eval do
+        define_method(:column_names) do
+          table.column_names
+        end
+      end
+    end
+
+    def create_klass
+      @klass ||= const_class
+    end
+
+    def const_class
+      remove_const(mock_class_name) if class_exists? mock_class_name
+      return Object.const_set(mock_class_name, Class.new) unless Object.const_defined?(mock_class_name)
+      return Object.const_get(mock_class_name, false)
+    end
+
+    def remove_const(class_name)
+      Object.send(:remove_const, class_name)
+    end
+
+    def class_exists?(class_name)
+      klass = Module.const_get(class_name)
+      return klass.is_a?(Class)
+      rescue NameError
+        return false
+    end
+
+    def mock_class_name
+      "#{model_name}Mock"
+    end
+
+  end
+
+end
+