model_mill 0.1.0

data/spec/dummy/public/javascripts/rails.js

@@ -0,0 +1,175 @@
+(function() {
+  // Technique from Juriy Zaytsev
+  // http://thinkweb2.com/projects/prototype/detecting-event-support-without-browser-sniffing/
+  function isEventSupported(eventName) {
+    var el = document.createElement('div');
+    eventName = 'on' + eventName;
+    var isSupported = (eventName in el);
+    if (!isSupported) {
+      el.setAttribute(eventName, 'return;');
+      isSupported = typeof el[eventName] == 'function';
+    }
+    el = null;
+    return isSupported;
+  }
+
+  function isForm(element) {
+    return Object.isElement(element) && element.nodeName.toUpperCase() == 'FORM'
+  }
+
+  function isInput(element) {
+    if (Object.isElement(element)) {
+      var name = element.nodeName.toUpperCase()
+      return name == 'INPUT' || name == 'SELECT' || name == 'TEXTAREA'
+    }
+    else return false
+  }
+
+  var submitBubbles = isEventSupported('submit'),
+      changeBubbles = isEventSupported('change')
+
+  if (!submitBubbles || !changeBubbles) {
+    // augment the Event.Handler class to observe custom events when needed
+    Event.Handler.prototype.initialize = Event.Handler.prototype.initialize.wrap(
+      function(init, element, eventName, selector, callback) {
+        init(element, eventName, selector, callback)
+        // is the handler being attached to an element that doesn't support this event?
+        if ( (!submitBubbles && this.eventName == 'submit' && !isForm(this.element)) ||
+             (!changeBubbles && this.eventName == 'change' && !isInput(this.element)) ) {
+          // "submit" => "emulated:submit"
+          this.eventName = 'emulated:' + this.eventName
+        }
+      }
+    )
+  }
+
+  if (!submitBubbles) {
+    // discover forms on the page by observing focus events which always bubble
+    document.on('focusin', 'form', function(focusEvent, form) {
+      // special handler for the real "submit" event (one-time operation)
+      if (!form.retrieve('emulated:submit')) {
+        form.on('submit', function(submitEvent) {
+          var emulated = form.fire('emulated:submit', submitEvent, true)
+          // if custom event received preventDefault, cancel the real one too
+          if (emulated.returnValue === false) submitEvent.preventDefault()
+        })
+        form.store('emulated:submit', true)
+      }
+    })
+  }
+
+  if (!changeBubbles) {
+    // discover form inputs on the page
+    document.on('focusin', 'input, select, texarea', function(focusEvent, input) {
+      // special handler for real "change" events
+      if (!input.retrieve('emulated:change')) {
+        input.on('change', function(changeEvent) {
+          input.fire('emulated:change', changeEvent, true)
+        })
+        input.store('emulated:change', true)
+      }
+    })
+  }
+
+  function handleRemote(element) {
+    var method, url, params;
+
+    var event = element.fire("ajax:before");
+    if (event.stopped) return false;
+
+    if (element.tagName.toLowerCase() === 'form') {
+      method = element.readAttribute('method') || 'post';
+      url    = element.readAttribute('action');
+      params = element.serialize();
+    } else {
+      method = element.readAttribute('data-method') || 'get';
+      url    = element.readAttribute('href');
+      params = {};
+    }
+
+    new Ajax.Request(url, {
+      method: method,
+      parameters: params,
+      evalScripts: true,
+
+      onComplete:    function(request) { element.fire("ajax:complete", request); },
+      onSuccess:     function(request) { element.fire("ajax:success",  request); },
+      onFailure:     function(request) { element.fire("ajax:failure",  request); }
+    });
+
+    element.fire("ajax:after");
+  }
+
+  function handleMethod(element) {
+    var method = element.readAttribute('data-method'),
+        url = element.readAttribute('href'),
+        csrf_param = $$('meta[name=csrf-param]')[0],
+        csrf_token = $$('meta[name=csrf-token]')[0];
+
+    var form = new Element('form', { method: "POST", action: url, style: "display: none;" });
+    element.parentNode.insert(form);
+
+    if (method !== 'post') {
+      var field = new Element('input', { type: 'hidden', name: '_method', value: method });
+      form.insert(field);
+    }
+
+    if (csrf_param) {
+      var param = csrf_param.readAttribute('content'),
+          token = csrf_token.readAttribute('content'),
+          field = new Element('input', { type: 'hidden', name: param, value: token });
+      form.insert(field);
+    }
+
+    form.submit();
+  }
+
+
+  document.on("click", "*[data-confirm]", function(event, element) {
+    var message = element.readAttribute('data-confirm');
+    if (!confirm(message)) event.stop();
+  });
+
+  document.on("click", "a[data-remote]", function(event, element) {
+    if (event.stopped) return;
+    handleRemote(element);
+    event.stop();
+  });
+
+  document.on("click", "a[data-method]", function(event, element) {
+    if (event.stopped) return;
+    handleMethod(element);
+    event.stop();
+  });
+
+  document.on("submit", function(event) {
+    var element = event.findElement(),
+        message = element.readAttribute('data-confirm');
+    if (message && !confirm(message)) {
+      event.stop();
+      return false;
+    }
+
+    var inputs = element.select("input[type=submit][data-disable-with]");
+    inputs.each(function(input) {
+      input.disabled = true;
+      input.writeAttribute('data-original-value', input.value);
+      input.value = input.readAttribute('data-disable-with');
+    });
+
+    var element = event.findElement("form[data-remote]");
+    if (element) {
+      handleRemote(element);
+      event.stop();
+    }
+  });
+
+  document.on("ajax:after", "form", function(event, element) {
+    var inputs = element.select("input[type=submit][disabled=true][data-disable-with]");
+    inputs.each(function(input) {
+      input.value = input.readAttribute('data-original-value');
+      input.removeAttribute('data-original-value');
+      input.disabled = false;
+    });
+  });
+})();

data/spec/dummy/script/rails

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+APP_PATH = File.expand_path('../../config/application',  __FILE__)
+require File.expand_path('../../config/boot',  __FILE__)
+require 'rails/commands'

data/spec/generator_spec_helper.rb

@@ -0,0 +1,149 @@
+# Grabbed from here: https://github.com/kristianmandrup/canable/blob/master/spec/generator_spec_helper.rb
+
+require 'rubygems'
+require 'test/unit'
+require 'rails/all'
+require 'rails/generators'
+require 'rails/generators/test_case'
+
+require 'rails_spec_helper'
+
+# Call configure to load the settings from
+# Rails.application.config.generators to Rails::Generators
+
+Rails::Generators.configure!
+
+# require the generators
+def require_generators generator_list
+  generator_list.each do |name, generators|
+    generators.each do |generator_name|
+      require File.join('generators', name.to_s, generator_name.to_s, "#{generator_name}_generator")
+    end
+  end
+end
+
+module RSpec
+  module Generators
+    class TestCase < ::Rails::Generators::TestCase
+      setup :prepare_destination
+      # setup :copy_routes
+      destination File.join(::Rails.root)
+
+      def initialize(test_method_name)
+        @method_name = test_method_name
+        @test_passed = true
+        @interrupted = false
+        #copy_routes
+      end
+
+      protected
+
+      def copy_routes
+        routes_file = File.join(File.dirname(__FILE__), 'fixtures', 'routes.rb')
+        # puts "routes_file: #{routes_file}"
+        routes = File.expand_path(routes_file)
+        destination = File.join(::Rails.root, "config")
+        FileUtils.mkdir_p(destination)
+        FileUtils.cp File.expand_path(routes), destination
+      end
+
+    end
+  end
+end
+
+
+module GeneratorSpec
+  class << self
+    attr_accessor :generator, :test_method_name
+
+    def clean!
+      if generator
+        generator.class.generator_class = nil
+      end
+      @generator = nil
+    end
+
+    def get_generator test_method_name=nil
+      @generator ||= RSpec::Generators::TestCase.new(test_method_name + '_spec')
+    end
+
+    def run_generator *args, &block
+      generator.run_generator *args
+      if block
+        block.arity < 1 ? generator.instance_eval(&block) : block.call(generator, self)
+      end
+    end
+
+    def check(&block)
+      if block
+        block.arity < 1 ? self.instance_eval(&block) : block.call(self)
+      end
+    end
+
+    def with(generator, &block)
+      if block
+        block.arity < 1 ? generator.instance_eval(&block) : block.call(generator) #, self, generator.class)
+      end
+    end
+
+    def with_generator &block
+      with(get_generator, &block)
+    end
+
+    def setup_generator test_method_name=nil, &block
+      clean! if test_method_name
+      generator = get_generator(test_method_name)
+      if block
+        block.arity < 1 ? generator.class.instance_eval(&block) : block.call(generator.class)
+      end
+    end
+
+
+    def check_methods methods
+      methods.each do |method_name|
+        content.should_match /def #{method_name}_by?(user)/
+      end
+    end
+    alias_method :methods, :check_methods
+
+    def check_matchings matchings
+      matchings.each do |matching|
+        content.should_match /#{Regexp.escape(matching)}/
+      end
+    end
+    alias_method :matchings, :check_matchings
+
+    def check_file file
+      generator.should generate_file file
+    end
+    alias_method :file, :check_file
+
+    def check_class_methods methods
+      methods.each do |method_name|
+        content.should_match /def self.#{method_name}_by?(user)/
+      end
+    end
+    alias_method :class_methods, :check_class_methods
+
+    def check_view(folder, file_name, strings)
+      generator.should generate_file("app/views/#{folder}/#{filename}") do |file_content|
+        strings.each do |str|
+          content.should_match /#{Regexp.escape(str)}/
+        end
+      end
+    end
+    alias_method :view, :check_view
+
+    def check_model(name, clazz, options = {})
+      generator.should generate_file("app/models/#{name.underscore}.rb") do |file_content|
+        file_content.should have_class user.camelize do |content|
+          check_matchings options[:matchings]
+          check_methods(options[:methods])
+          check_class_methods(options[:class_methods])
+        end
+      end
+    end
+    alias_method :model, :check_model
+  end # class self
+end
+

data/spec/generators/model_generator_spec.rb

@@ -0,0 +1,87 @@
+require 'rake'
+require 'ap'
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'generators/model_mill/models/models_generator'
+
+RSpec::Matchers.define :generate_file do |expected|
+  match do |actual|
+    expected_path = File.expand_path(expected, Rails.application.root)
+    File.exists?(expected_path)
+  end
+
+  failure_message_for_should do |actual|
+    "expected a file at #{expected}"
+  end
+
+  failure_message_for_should_not do |actual|
+    "expected there to be no file at #{expected}"
+  end
+
+  description do
+    "generate the file at #{expected}"
+  end
+end
+
+def file_contents path
+  File.read(File.expand_path(path, ::Rails.root))
+end
+
+describe 'models_generator' do
+  context 'with namespace option' do
+    before :each do
+      GeneratorSpec.setup_generator 'model_generator' do
+        tests ModelMill::Generators::ModelsGenerator
+      end
+      @namespace = 'legacy'
+      @tables = %w(users widgets)
+    end
+
+    after :each do
+      FileUtils.rm_r File.expand_path("app/models/#{@namespace}", ::Rails.root)
+    end
+
+    it "generates a base model for the namespace" do
+      GeneratorSpec.with_generator do |g|
+        g.run_generator @namespace
+        g.should generate_file("app/models/#{@namespace}")
+        g.should generate_file("app/models/#{@namespace}/base.rb")
+        file_contents("app/models/#{@namespace}/base.rb").should match(/class #{@namespace.camelize}::Base < ActiveRecord::Base/)
+      end
+    end
+
+    it "generates a model for each table" do
+      GeneratorSpec.with_generator do |g|
+        g.run_generator @namespace
+        @tables.each do |tn|
+          g.should generate_file("app/models/#{@namespace}/#{tn.singularize.underscore}.rb")
+        end
+      end
+    end
+  end
+
+  context 'without namespace option' do
+    before :each do
+      GeneratorSpec.setup_generator 'model_generator' do
+        tests ModelMill::Generators::ModelsGenerator
+      end
+      @tables = %w(users widgets)
+    end
+
+    after :each do
+      @tables.each do |tn|
+        FileUtils.rm_r File.expand_path("app/models/#{tn.singularize.underscore}.rb", ::Rails.root)
+      end
+    end
+
+    it "generates a model for each table" do
+      GeneratorSpec.with_generator do |g|
+        g.run_generator
+        @tables.each do |tn|
+          g.should generate_file("app/models/#{tn.singularize.underscore}.rb")
+          file_contents("app/models/#{tn.singularize.underscore}.rb").should match(/class #{tn.singularize.camelize} < ActiveRecord::Base/)
+        end
+      end
+    end
+  end
+end
+

data/spec/integration/navigation_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe "Navigation" do
+  include Capybara
+  
+  it "should be a valid app" do
+    ::Rails.application.should be_a(Dummy::Application)
+  end
+end

data/spec/matchers/all.rb

@@ -0,0 +1,9 @@
+module RSpec
+  module Rails
+  end
+end
+
+require 'matchers/generate_file'
+require 'matchers/generate_migration'
+require 'matchers/have_class_method'
+require 'matchers/have_method'

data/spec/matchers/generate_file.rb

@@ -0,0 +1,42 @@
+# Asserts a given file exists. You need to supply an absolute path or a path relative
+# to the configured destination:
+#
+#   generator.should have_generated_file "app/controller/products_controller.rb" 
+#            
+
+module RSpec::Rails
+  module GeneratorMatchers
+    class GenerateFile
+
+      def initialize(relative)
+        @relative = relative      
+      end
+
+      # actual is the generator
+      def matches?(generator, &block)              
+        @expected = File.expand_path(@relative, generator.class.destination_root)
+        ex = File.exists?(@expected)
+        if block && ex
+          read = File.read(@expected)
+          yield read
+        else
+          ex
+        end        
+      end          
+    
+      def failure_message
+        "Expected file #{@relative} to have been generated, but it was not"
+      end
+
+      def negative_failure_message
+        "Did not expected file #{@relative} to have been generated, but it was"
+      end
+    end
+
+    def generate_file(relative)
+      GenerateFile.new(relative)
+    end
+    alias_method :generate_directory, :generate_file  
+
+  end
+end

data/spec/matchers/generate_migration.rb

@@ -0,0 +1,44 @@
+# This method manipulates the given path and tries to find any migration which
+# matches the migration name. For example, the call above is converted to:
+#
+#   generator.should generate_migration "db/migrate/003_create_products.rb"
+#
+# Consequently it accepts the same arguments as the matcher have_file.
+
+module RSpec::Rails
+  module GeneratorMatchers
+    class GenerateMigration
+
+      def initialize(relative)
+        @relative = relative      
+      end
+
+      # actual is the generator
+      def matches?(generator)      
+        migration_file_name(relative, generator)        
+      end          
+    
+      def failure_message
+        "Expected migration #{relative} to have been generated, but it was not"
+      end
+
+      def negative_failure_message
+        "Did not expect migration #{relative} to have been generated, but it was"
+      end
+      
+      protected
+      
+      def migration_file_name(relative, generator) #:nodoc:
+        absolute = File.expand_path(relative, generator.class.destination_root)
+        dirname, file_name = File.dirname(absolute), File.basename(absolute).sub(/\.rb$/, '')
+        Dir.glob("#{dirname}/[0-9]*_*.rb").grep(/\d+_#{file_name}.rb$/).first
+      end
+      
+    end
+  
+    def generate_migration(relative)
+      GenerateMigration.new(relative)
+    end
+
+  end   
+end

data/spec/matchers/have_class_method.rb

@@ -0,0 +1,42 @@
+# This method manipulates the given path and tries to find any migration which
+# matches the migration name. For example, the call above is converted to:
+#
+#   generator.should generate_migration "db/migrate/003_create_products.rb"
+#
+# Consequently it accepts the same arguments as the matcher have_file.
+
+module RSpec::Rails
+  module GeneratorMatchers
+    class HaveClassMethod
+
+      def initialize(content)
+        begin
+          @content = File.open(content).read
+        rescue
+          @content = content      
+        end
+      end
+
+      # actual is the generator
+      def matches?(method)      
+        @method = method
+        @content =~ /def\s+self.#{method}\s*(\(.+\))?(.*?)\n/m
+      end          
+    
+      def failure_message
+        "Expected there to be the class method #{method}, but there wasn't"
+      end
+
+      def negative_failure_message
+        "Did not expect there to be the class method #{method}, but there was"
+      end
+            
+    end
+
+    def have_class_method(method)
+      HaveClassMethod.new(method)
+    end    
+  end  
+end
+
+

data/spec/matchers/have_method.rb

@@ -0,0 +1,46 @@
+# This method tries to see if a specific method is contained in the generated file.
+# It can operate (should) on either a file name or the raw content 
+#
+#   generated_file_name.should have_method "hello" # 'my/path/say_hello.rb'.should have_method "hello"
+#
+#   say_hello_file_content.should have_method "hello"
+#
+
+
+module RSpec::Rails
+  module GeneratorMatchers
+    class HaveMethod
+
+      def initialize(content)
+        begin
+          @content = File.open(content).read
+        rescue
+          @content = content      
+        end
+      end
+
+      # actual is the generator
+      def matches?(method)      
+        @method = method
+        @content =~ /def\s+#{method}\s*(\(.+\))?(.*?)\n/m
+      end          
+    
+      def failure_message
+        "Expected there to be the method #{method}, but there wasn't"
+      end 
+      
+      def negative_failure_message
+        "Did not expect there to be the method #{method}, but there was"
+      end
+                 
+    end
+    
+    def have_method(method)
+      HaveMethod.new(method)
+    end
+    alias_method :have_instance_method, :have_method 
+    
+  end  
+end
+
+

data/spec/model_mill_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe ModelMill do
+  it "should be valid" do
+    ModelMill.should be_a(Module)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,35 @@
+# Configure Rails Envinronment
+ENV["RAILS_ENV"] = "test"
+
+require File.expand_path("../dummy/config/environment.rb",  __FILE__)
+require "rails/test_help"
+require "rspec/rails"
+
+ActionMailer::Base.delivery_method = :test
+ActionMailer::Base.perform_deliveries = true
+ActionMailer::Base.default_url_options[:host] = "test.com"
+
+Rails.backtrace_cleaner.remove_silencers!
+
+# Configure capybara for integration testing
+require "capybara/rails"
+Capybara.default_driver   = :rack_test
+Capybara.default_selector = :css
+
+# Run any available migration
+ActiveRecord::Migrator.migrate File.expand_path("../dummy/db/migrate/", __FILE__)
+
+# Load support files
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+require 'generator_spec_helper'
+
+RSpec.configure do |config|
+  # Remove this line if you don't want RSpec's should and should_not
+  # methods or matchers
+  require 'rspec/expectations'
+  config.include RSpec::Matchers
+
+  # == Mock Framework
+  config.mock_with :rspec
+end