active_mocker 1.1.23 → 1.2.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 35394fa054b9991f64200432c22300c0338b5794
-  data.tar.gz: 439c5e2cb084947588d5e9be24e1adef3169103b
+  metadata.gz: bbba1fbd943d80b9a68d611991326685d86ed5c4
+  data.tar.gz: bc4c0d888da88e4b9a678f3a9581f35657b286af
 SHA512:
-  metadata.gz: b8116e203aefae67690da7552b188fbe3d36b9f8d40a4fa88a1a2deccacfaa7dcad891769795b8b61336c840be80fe819eb8540341c8ed5f9d03c6e8246f1455
-  data.tar.gz: d53d2aaec5da61ecc346ddae968166016543bbf91d431e53d7f665a2814cac4c039f066cc1a7d4803d39fba33586e25249b821b8bec07acdde316978f3728645
+  metadata.gz: 6507f76e5ad25d3817721c9cde6055ba8c559ab7bfd76154829222836793d13551ddd796dddef0a7f9603a355707f9f429392d07bba2cc4c29e72e522892eb15
+  data.tar.gz: 3d9ca4c2017bcc884a09f06d01e4916ddb770c7a322e1c280ee8bc90c541e4adebefb55a15d7d93580cfbb53a5037e3d7ad3b1c95cd040657439e4c4276b31ec

data/README.md

@@ -65,10 +65,10 @@ Or install it yourself as:
         => PersonMock
 
     PersonMock.column_names
-        => ["account_id", "first_name", "last_name", "address", "city"]
+        => ["id", "account_id", "first_name", "last_name", "address", "city"]
 
     person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler", account: ActiveMocker.mock('Account').new)
-        => #<PersonMock @first_name="Dustin", @last_name="Zeisler">
+        => "#<PersonMock id: nil, account_id: nil, first_name: \"Dustin\", last_name: \"Zeisler\", address: nil, city: nil>"
 
      person_mock.first_name
         => "Dustin"
@@ -89,18 +89,14 @@ Or install it yourself as:
 
      end
 
-     person_mock = PersonMock.new(first_name: "Dustin", last_name: "Zeisler", account: AccountMock.new)
-             => NoMethodError: undefined method `first_name=' for #<PersonMock:0x007f860abf6b10>
+     PersonMock.new(first_name: "Dustin", last_name: "Zeisler")
+             =>#<RuntimeError Rejected params: {"first_name"=>"Dustin", "last_name"=>"Zeisler"} for PersonMock>
 
 
 ### Mocking instance and class methods
 
-     person_mock.bar
-        => ArgumentError: wrong number of arguments (0 for 1..2)
-
      person_mock.bar('baz')
-        => RuntimeError: #bar is not Implemented for Class: PersonMock
-
+        => RuntimeError: ::bar is not Implemented for Class: PersonMock
 
      person_mock.mock_instance_method(:bar) do  |name, type=nil|
         "Now implemented with #{name} and #{type}"
@@ -109,7 +105,7 @@ Or install it yourself as:
      person_mock.new.bar('foo', 'type')
         => "Now implemented with foo and type"
 
-     person_mock.mock_class_method(:baz) do
+     person_mock.mock_class_method(:bar) do
        "Now implemented"
      end
 
@@ -144,12 +140,13 @@ Or install it yourself as:
     person_mock.mock_instance_method(:bar) do  |name, type=nil|
       "Now implemented with #{name} and #{type}"
     end
-      => NameError: undefined method `bar' for class `PersonMock'
+      => NoMethodError: undefined method `bar' for class `PersonMock'
 
 ### ActiveRecord supported methods
-**Class methods**
+**class methods**
   
-  * create/new
+* new
+  * create
   * column_names
   * find
   * find_by
@@ -162,21 +159,14 @@ Or install it yourself as:
   * count
   * first/last
 
-**Instance methods**
+**instance methods**
   
-  * attributes
+* attributes
   * update
   * save
   * write_attribute - (private)
   * read_attribute  - (private)
 
- **Collection Associations**
- 
-  * last/first
-  * sum(attribute)
-  * <<
-  * Enumerable methods
-
 ### Known Limitations
 
 * **::mock** model names and table names must follow the default ActiveRecord naming pattern.

data/active_mocker.gemspec

@@ -29,6 +29,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rspec", "~>2.14"
   # spec.add_development_dependency "i18n", "~>0.6"
   spec.add_development_dependency "sqlite3", "~>1.3"
+  spec.add_development_dependency "fuubar"
 
   if ENV['DEBUG'] == '1'
     spec.add_development_dependency "debase", "~>0.0"

data/lib/active_hash/init.rb

@@ -10,7 +10,7 @@ module ActiveHash
       def initialize(attributes = {})
         filter_associations(HashWithIndifferentAccess.new(attributes))
         @attributes.dup.merge(@associations.dup).each do |key, value|
-          send "#{key}=", value
+          send "#{key}=", value #maybe could just check if responds_to method? How AR works?
         end
       end
 

data/lib/active_mocker.rb

@@ -1,5 +1,9 @@
 require "active_mocker/version"
 $:.unshift File.expand_path('../../', __FILE__)
+
+require 'active_mocker/public_methods'
+require 'active_mocker/config'
+require 'active_mocker/generate'
 require 'singleton'
 require 'logger'
 require 'active_mocker/logger'
@@ -7,18 +11,13 @@ require 'active_support/all'
 require 'active_mocker/table'
 require 'active_mocker/field'
 require 'file_reader'
-require 'active_mocker/public_methods'
-require 'active_mocker/config'
 require 'active_mocker/reparameterize'
 require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/schema_reader'
 require 'active_mocker/active_record/schema'
 require 'active_mocker/collection_association'
-require 'active_mocker/base'
 require 'active_mocker/active_record'
 require 'active_mocker/model_reader'
 require 'active_mocker/reparameterize'
 require 'active_hash/ar_api'
-
-

data/lib/active_mocker/active_record/schema.rb

@@ -9,8 +9,7 @@ module ActiveMocker
         search_result unless search_result.nil?
         schema = parse
         schema.instance_eval(&block)
-        add_to_cache schema.tables.first
-        schema.tables.first
+        schema
       end
 
       def self.parse
@@ -47,11 +46,10 @@ module ActiveMocker
       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
+        tables << ActiveMocker::Table.new(name, CreateTable.new.instance_eval(&block))
       end
 
       def method_missing(meth, *args)

data/lib/active_mocker/config.rb

@@ -9,13 +9,14 @@ module ActiveMocker
                   :model_attributes,
                   :schema_file_reader,
                   :model_file_reader,
-                  :clear_cache
+                  :clear_cache,
+                  :migration_dir,
+                  :mock_dir
 
     def config
       @@first_load ||= reload_default
       yield self
       check_required_settings
-      require_active_hash
     end
 
     def reload_default
@@ -27,37 +28,20 @@ module ActiveMocker
       @clear_cache         = false
       @schema_file_reader  = nil
       @model_file_reader   = nil
+      @migration_dir       = nil
+      @mock_dir            = nil
     end
 
     def check_required_settings
       raise 'schema_file must be specified' if schema_file.nil?
       raise 'model_dir must be specified'   if model_dir.nil?
-    end
-
-    def require_active_hash
-      require 'active_hash'  if schema_attributes
+      raise 'mock_dir must be specified'    if mock_dir.nil?
     end
 
     def log_level=(level)
       Logger_.level = level
     end
 
-    def active_hash_as_base=(arg)
-      Logger_.warn('Deprecation Warning: config option `active_hash_as_base` is now model_attributes')
-    end
-
-    def model_relationships=(arg)
-      Logger_.warn('Deprecation Warning: config option `model_relationships` is now model_attributes')
-    end
-
-    def model_methods=(arg)
-      Logger_.warn('Deprecation Warning: config option `model_methods` is now model_attributes')
-    end
-
-    def mass_assignment=(arg)
-      Logger_.warn('Deprecation Warning: config option `mass_assignment` is now model_attributes')
-    end
-
   end
 
 end

data/lib/active_mocker/field.rb

@@ -15,11 +15,13 @@ module ActiveMocker
       {name: name, type: type, options: options}
     end
 
+    alias_method :to_hash, :to_h
+
     def create_option_methods
       options.each do |opt|
         key, value = opt.first
         self.instance_variable_set("@#{key}", value)
-        define_singleton_method(key) {instance_variable_get("@#{key}")}
+        self.class.send(:attr_accessor, key)
       end
     end
 

data/lib/active_mocker/generate.rb

@@ -0,0 +1,161 @@
+module ActiveMocker
+class Generate
+  extend Config
+  extend Forwardable
+
+  @@_self = self
+  def_delegators :@@_self,
+                 :schema_attributes,
+                 :model_attributes,
+                 :model_dir,
+                 :schema_file,
+                 :model_file_reader,
+                 :schema_file_reader,
+                 :mock_dir
+
+  def initialize
+    create_template
+  end
+
+  def self.configure(&block)
+    config(&block)
+  end
+
+  def self.mock(model_name)
+    load_mock(model_name)
+  end
+
+  def self.load_mock(model_name)
+    load File.join(mock_dir, "#{model_name.tableize.singularize}_mock.rb")
+    "#{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
+  end
+
+  def create_template
+    tables.each do |table|
+      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      = table.column_names
+
+      # 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]
+
+      # 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)
+      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)
+    end
+
+  end
+
+
+
+
+  def mock_class_name(table_name)
+    "#{table_to_class_name(table_name)}Mock"
+  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
+      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
+    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
+      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
+    class_methods
+  end
+
+  class Method
+    attr_accessor :method, :params, :params_pass
+  end
+
+  class Methods
+    attr_accessor :methods, :model_class_methods, :model_instance_methods
+  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
+
+    def render(template)
+      ERB.new(template,nil,true).result(binding)
+    end
+  end
+
+
+end
+end
+
+

data/lib/active_mocker/mock_class_methods.rb

@@ -0,0 +1,82 @@
+module ActiveMocker
+module MockClassMethods
+
+  def mock_instance_method(method, &block)
+    model_instance_methods[method] = block
+  end
+
+  def mock_class_method(method, &block)
+    model_class_methods[method] = block
+  end
+
+  def column_names
+    schema_attributes_template
+  end
+
+  private
+
+  def delegate_to_model_instance(method, *args)
+    model_class_instance.send(method, *args)
+  end
+
+  def delegate_to_model_class(method, *args)
+    model_class.send(method, *args)
+  end
+
+  def model_class_methods
+    @model_class_methods ||= HashWithIndifferentAccess.new
+  end
+
+  def model_methods_template
+    @model_methods_template ||= HashWithIndifferentAccess.new
+  end
+
+  def schema_attributes_template
+    @schema_attributes_template ||= HashWithIndifferentAccess.new
+  end
+
+  def model_class
+    @model_class
+  end
+
+  def model_class_instance
+    @model_class_instance ||= model_class.new
+  end
+
+  def attribute_names
+    @attribute_names
+  end
+
+  def attribute_names=(attributes)
+    @attribute_names = attributes.map{|a| a.to_sym}
+  end
+
+  def attribute_template
+    return @attribute_template unless @attribute_template.nil?
+    @attribute_template = HashWithIndifferentAccess.new
+    attribute_names.each {|a| @attribute_template[a] = nil}
+    return @attribute_template
+  end
+
+  def association_names
+    @association_names
+  end
+
+  def association_names=(associations)
+    @association_names = associations.map{|a| a.to_sym}
+  end
+
+  def association_template
+    return @association_template unless @association_template.nil?
+    @association_template = HashWithIndifferentAccess.new
+    association_names.each {|a| @association_template[a] = nil}
+    return @association_template
+  end
+
+  public
+  def is_implemented(val, method)
+    raise "#{method} is not Implemented for Class: #{name}" if val == :not_implemented
+  end
+
+end
+end