conventional_models 0.1.2 → 0.2.0

data/README.rdoc

@@ -48,11 +48,53 @@ Output:
     belongs_to_matcher {|column| column.name.end_with? "_id"}
     belongs_to_name {|column| column.name.gsub(/_id$/, "")}
     primary_key_name "id"
-    table_name {|name| name.pluralize}
     class_name {|table_name| table_name.singularize.camelize}
     ignore_tables "schema_migrations", "sqlite_sequence", "sysdiagrams"
   end
 
+== cmconsole command
+
+Starts an IRB session and configures activerecord for you based on what is in config/database.yml.
+
+=== Usage 
+  cmconsole [options]
+
+  For help use: cmconsole -h
+
+=== Options
+  -h, --help            Displays help message
+  -v, --version         Display the version, then exit
+  -e, --environment     Specify the database env to use, default to development
+  -c, --config          Where database.yml lives
+  -s, --skip-configure  Don't configure ConventionalModels automatically
+  -V, --verbose         Verbose
+
+== Rake
+
+You can use this from rake as follows:
+
+  # Confiigure active_record as you would normally
+  
+  task :console do
+    require 'irb'
+    require 'conventional_models'
+    ConventionalModels.configure do
+      primary_key_name "Id"
+    end
+    puts ConventionalModels.model_code
+    IRB.start
+  end
+  
+
+== Why?
+
+I use this for data migrations or quick scripting tasks on databases that don't follow rails 
+conventions.
+
+== TODO
+
+
+
 == Note on Patches/Pull Requests
  
 * Fork the project.

data/VERSION

@@ -1 +1 @@
-0.1.2
+0.2.0

data/bin/cmconsole

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+# == Synopsis 
+#   cmconsole starts an IRB session and configures activerecord for you 
+#   based on what is in config/database.yml.
+#
+# == Examples
+#   Default options when you run cmconsosole are:
+#     cmconsole --config config/database.yml -e development
+#
+#   Other examples:
+#     cmconsole --skip-configure
+#
+# == Usage 
+#   cmconsole [options]
+#
+#   For help use: cmconsole -h
+#
+# == Options
+#   -h, --help            Displays help message
+#   -v, --version         Display the version, then exit
+#   -e, --environment     Specify the database env to use
+#   -c, --config          Where database.yml lives
+#   -s, --skip-configure  Don't configure ConventionalModels automatically
+#   -V, --verbose         Verbose
+#
+# == Author
+#   Steve Hodgkiss
+#
+# == Copyright
+#   Copyright (c) 2007 Steve Hodgkiss. Licensed under the MIT License:
+#   http://www.opensource.org/licenses/mit-license.php
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+begin
+  require 'conventional_models'
+rescue LoadError
+  if File.symlink? __FILE__
+    require File.dirname(File.readlink(__FILE__)) + '/../lib/conventional_models'
+  else
+    require File.dirname(__FILE__) + '/../lib/conventional_models'
+  end
+end
+cli = ConventionalModels::CLI.new(ARGV)
+cli.run

data/conventional_models.gemspec

@@ -5,13 +5,15 @@
 
 Gem::Specification.new do |s|
   s.name = %q{conventional_models}
-  s.version = "0.1.2"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Steve Hodgkiss"]
-  s.date = %q{2010-04-10}
+  s.date = %q{2010-04-11}
+  s.default_executable = %q{cmconsole}
   s.description = %q{Generate ActiveRecord models automatically with basic relationships based on conventions.}
   s.email = %q{steve@hodgkiss.me.uk}
+  s.executables = ["cmconsole"]
   s.extra_rdoc_files = [
     "LICENSE",
      "README.rdoc"
@@ -25,21 +27,30 @@ Gem::Specification.new do |s|
      "README.rdoc",
      "Rakefile",
      "VERSION",
+     "bin/cmconsole",
      "conventional_models.gemspec",
+     "features/cmconsole.feature",
      "features/conventional_models.feature",
      "features/output_model_code.feature",
+     "features/step_definitions/cmconsole_steps.rb",
      "features/step_definitions/conventional_models_steps.rb",
      "features/step_definitions/output_model_code_steps.rb",
      "features/support/env.rb",
      "lib/conventional_models.rb",
      "lib/conventional_models/active_record_base_model_for.rb",
+     "lib/conventional_models/cli.rb",
      "lib/conventional_models/column.rb",
      "lib/conventional_models/conventions.rb",
      "lib/conventional_models/database.rb",
+     "lib/conventional_models/option_parser.rb",
+     "lib/conventional_models/options.rb",
      "lib/conventional_models/table.rb",
      "lib/conventional_models/version.rb",
+     "spec/conventional_models/cli_spec.rb",
      "spec/conventional_models/conventions_spec.rb",
      "spec/conventional_models/database_spec.rb",
+     "spec/conventional_models/option_parser_spec.rb",
+     "spec/conventional_models/options_spec.rb",
      "spec/conventional_models/table_spec.rb",
      "spec/conventional_models_spec.rb",
      "spec/spec.opts",
@@ -51,8 +62,11 @@ Gem::Specification.new do |s|
   s.rubygems_version = %q{1.3.6}
   s.summary = %q{Generate ActiveRecord models. For lazy people.}
   s.test_files = [
-    "spec/conventional_models/conventions_spec.rb",
+    "spec/conventional_models/cli_spec.rb",
+     "spec/conventional_models/conventions_spec.rb",
      "spec/conventional_models/database_spec.rb",
+     "spec/conventional_models/option_parser_spec.rb",
+     "spec/conventional_models/options_spec.rb",
      "spec/conventional_models/table_spec.rb",
      "spec/conventional_models_spec.rb",
      "spec/spec_helper.rb"

data/features/cmconsole.feature

@@ -0,0 +1,34 @@
+@wip
+Feature: Cmconsole
+  In order to play with models generated against other projects with ease
+  As a user
+  I want a cmconsole command to find my database config, configure activerecord and start an IRB session for me
+  
+  Scenario: Typing cmconsole when a valid config/database.yml exists
+    Given a file named "config/database.yml" with:
+      """
+      development:
+        adapter: sqlite3
+        database: test.sqlite
+        pool: 5
+        timeout: 5000
+        
+      test:
+        adapter: sqlite3
+        database: test.sqlite
+        pool: 5
+        timeout: 5000
+        
+      production:
+        adapter: sqlite3
+        database: production.sqlite
+        pool: 5
+        timeout: 5000
+      """
+    And a table "pages"
+    When I run "../../bin/cmconsole"
+    Then I should see ">> "
+  
+  
+
+  

data/features/conventional_models.feature

@@ -10,7 +10,7 @@ Feature: ConventionalModels
       $:.unshift("../../lib")
       require 'rubygems'
       require 'active_record'
-      ActiveRecord::Base.establish_connection(:database => '../test.sqlite', :adapter => 'sqlite3')
+      ActiveRecord::Base.establish_connection(:database => 'test.sqlite', :adapter => 'sqlite3')
       require 'conventional_models'
       ConventionalModels.configure
       puts "Number of records: #{<model_name>.count}"
@@ -30,7 +30,7 @@ Feature: ConventionalModels
       $:.unshift("../../lib")
       require 'rubygems'
       require 'active_record'
-      ActiveRecord::Base.establish_connection(:database => '../test.sqlite', :adapter => 'sqlite3')
+      ActiveRecord::Base.establish_connection(:database => 'test.sqlite', :adapter => 'sqlite3')
       require 'conventional_models'
       ConventionalModels.configure
       puts "Number of records: #{<model_name>.count}"
@@ -58,7 +58,7 @@ Feature: ConventionalModels
       $:.unshift("../../lib")
       require 'rubygems'
       require 'active_record'
-      ActiveRecord::Base.establish_connection(:database => '../test.sqlite', :adapter => 'sqlite3')
+      ActiveRecord::Base.establish_connection(:database => 'test.sqlite', :adapter => 'sqlite3')
       require 'conventional_models'
       ConventionalModels.configure do
         primary_key_name "Id"

data/features/output_model_code.feature

@@ -18,7 +18,7 @@ Feature: Output model code
       $:.unshift("../../lib")
       require 'rubygems'
       require 'active_record'
-      ActiveRecord::Base.establish_connection(:database => '../test.sqlite', :adapter => 'sqlite3')
+      ActiveRecord::Base.establish_connection(:database => 'test.sqlite', :adapter => 'sqlite3')
       require 'conventional_models'
       ConventionalModels.configure do
         primary_key_name "Id"

data/features/support/env.rb

@@ -8,15 +8,16 @@ require 'active_record'
 
 Before do
   config = {
-    :development => {
-      :database => 'tmp/test.sqlite',
-      :adapter => 'sqlite3'
+    "development" => {
+      "database" => 'tmp/aruba/test.sqlite',
+      "adapter" => 'sqlite3'
     }
   }
   
   ActiveRecord::Base.configurations = config
   
   system "mkdir -p tmp"
-  system 'rm -f tmp/test.sqlite'
-  ActiveRecord::Base.establish_connection(config[:development])
+  system "mkdir -p tmp/aruba"
+  system 'rm -f tmp/aruba/test.sqlite'
+  ActiveRecord::Base.establish_connection(config["development"])
 end

data/lib/conventional_models.rb

@@ -7,12 +7,21 @@ require 'conventional_models/database'
 require 'conventional_models/table'
 require 'conventional_models/column'
 require 'conventional_models/active_record_base_model_for'
+require 'conventional_models/options'
+require 'conventional_models/option_parser'
+require 'conventional_models/cli'
+require 'irb';
+require 'irb/completion'
 
 module ConventionalModels
+  @@database = nil
+  
   def self.configure(&block)
     @@conventions = Conventions.new(&block)
-    @@database = Database.new(::ActiveRecord::Base.connection)
-    @@database.apply_conventions(@@conventions)
+    unless @@database.nil?
+      remove(@@database)
+    end
+    @@database = Database.new(@@conventions)
     run_code @@database.code
   end
   
@@ -27,4 +36,22 @@ module ConventionalModels
   def self.model_code_for(table)
     @@database.code_for(table)
   end
+  
+  def self.run_console!
+    configure_active_record
+    configure
+    IRB.start
+  end
+  
+  def self.configure_active_record(config='config/database.yml', environment='development')
+    config = YAML::load(IO.read(config))
+    ActiveRecord::Base.configurations = config
+    ActiveRecord::Base.establish_connection(config[environment])
+  end
+  
+  def self.remove(database)
+    database.tables.map{|t| t.class_name.to_sym}.each do |class_sym|
+      Object.send(:remove_const, class_sym)
+    end
+  end
 end

data/lib/conventional_models/cli.rb

@@ -0,0 +1,61 @@
+require 'optparse'
+require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+module ConventionalModels
+  class CLI
+    attr_reader :options
+
+    def initialize(arguments)
+      @arguments = arguments
+      @option_parser = OptionParser.new(arguments)
+      @options = @option_parser.options
+    end
+    
+    def run
+      if @option_parser.parsed_options?
+        return output_help if @options.output_help
+        return output_version if @options.output_version
+        output_options if @options.verbose
+        run_console
+      else
+        output_usage
+      end
+    end
+    
+    protected
+      
+      def run_console
+        unless File.exists?(@options.config)
+          puts "Config #{@options.config} doesn't exist!"
+          return
+        end
+        ConventionalModels.configure_active_record(@options.config, @options.environment)
+        ConventionalModels.configure unless @options.skip_configure
+        puts ConventionalModels.model_code
+        IRB.start
+      end
+      
+      def output_options
+        puts "Options:\n"
+      
+        @options.marshal_dump.each do |name, val|
+          puts "  #{name} = #{val}"
+        end
+      end
+    
+      def output_help
+        output_version
+        RDoc::usage()
+      end
+    
+      def output_usage
+        RDoc::usage('usage')
+      end
+    
+      def output_version
+        puts "ConventionalModels version #{ConventionalModels::VERSION::STRING}"
+      end
+  end
+end

data/lib/conventional_models/database.rb

@@ -4,27 +4,11 @@ module ConventionalModels
   class Database
     attr_accessor :tables
     
-    def initialize(connection)
-      @connection = connection
+    def initialize(conventions)
+      @connection = ::ActiveRecord::Base.connection
+      @conventions = conventions
       @tables = []
-    end
-    
-    def apply_conventions(conventions)
-      @connection.tables.select{|table| !conventions.ignored_tables.include? table}.each do |table|
-        @tables << Table.new(table, @connection.columns(table))
-      end
-      
-      @tables.each{|table| table.apply_conventions(conventions)}
-      
-      @tables.each do |table|
-        table.belongs_to_names.each do |belongs_to|
-          name = conventions.belongs_to_name.call(belongs_to)
-          has_many_table = @tables.select{|t| t.class_name == conventions.class_name.call(name)}.first
-          if has_many_table
-            has_many_table.lines << "has_many :#{table.name.tableize}, :class_name => '#{table.class_name}', :primary_key => '#{conventions.primary_key_name}', :foreign_key => '#{belongs_to.name}'"
-          end
-        end
-      end
+      apply_conventions
     end
     
     def code
@@ -39,5 +23,33 @@ module ConventionalModels
         "#{table_name} not found"
       end
     end
+    
+    protected
+      def apply_conventions
+        @connection.tables.select{|table| !@conventions.ignored_tables.include? table}.each do |table|
+          @tables << Table.new(table, @connection.columns(table), @conventions)
+        end
+
+        @tables.each do |table|
+          table.belongs_to_names.each do |belongs_to|
+            name = @conventions.belongs_to_name.call(belongs_to)
+            has_many_table = @tables.select{|t| t.class_name == @conventions.class_name.call(name)}.first
+            if has_many_table
+              unconventions = []
+              unless table.conventional_name?
+                unconventions << ":class_name => '#{table.class_name}'"
+                unconventions << ":foreign_key => '#{belongs_to.name}'"
+              end
+              unless @conventions.primary_key_name == "id"
+                unconventions << ":primary_key => '#{@conventions.primary_key_name}'"
+              end
+              
+              has_many_table.lines << ["has_many :#{table.name.tableize}", "#{unconventions.join(", ")}"].select do |convention|
+                !convention.empty?
+              end.join(", ")
+            end
+          end
+        end
+      end
   end
 end

data/lib/conventional_models/option_parser.rb

@@ -0,0 +1,50 @@
+require 'optparse'
+require 'rdoc/usage'
+require 'ostruct'
+require 'date'
+
+module ConventionalModels
+  class OptionParser
+  
+    attr_reader :options
+
+    def initialize(arguments)
+      @arguments = arguments
+      
+      @options = Options.new
+
+      @parsed_options = true
+      parse
+    end
+  
+    def parsed_options?
+      @parsed_options
+    end
+    
+    def parse
+      opts = ::OptionParser.new
+      opts.on('-v', '--version')    { @options.output_version = true }
+      opts.on('-h', '--help')       { @options.output_help = true }
+      opts.on('-s', '--skip-configure')    { @options.skip_configure = true }  
+      opts.on('-c', '--config FILE')      { |file| @options.config = file }
+      opts.on('-e', '--environment ENV')      { |env| @options.environment = env }
+      opts.on('-V', '--verbose')      { |env| @options.verbose = true }
+      
+      opts.parse!(@arguments) rescue @parsed_options = false
+    end
+      
+    protected
+      def output_help
+        output_version
+        RDoc::usage()
+      end
+    
+      def output_usage
+        RDoc::usage('usage')
+      end
+    
+      def output_version
+        puts "ConventionalModels version #{ConventionalModels::VERSION}"
+      end
+  end
+end

data/lib/conventional_models/options.rb

@@ -0,0 +1,16 @@
+module ConventionalModels
+  class Options
+    attr_accessor :skip_configure, :config, :environment, :verbose, :output_version, :output_help
+    
+    def initialize
+      @skip_configure = false
+      @config = "config/database.yml"
+      @environment = "development"
+      @verbose = false
+      @output_version = false
+      @output_help = false
+    end
+    
+    
+  end
+end

data/lib/conventional_models/table.rb

@@ -2,35 +2,44 @@ module ConventionalModels
   class Table
     attr_accessor :name, :columns, :lines, :belongs_to_names, :class_name
     
-    def initialize(name, columns)
+    def initialize(name, columns, conventions)
       @name = name
       @columns = columns
       @lines = []
       @belongs_to_names = []
+      @conventions = conventions
+      
+      apply_conventions
     end
     
     def ==(other)
       @name == other.name
     end
     
-    def apply_conventions(conventions)
-      @class_name = conventions.class_name.call(@name)
+    def code
+      "class ::#{@name.singularize.camelize} < ::ActiveRecord::Base\n#{@lines.map{|l| "  #{l}"}.join("\n")}\nend"
+    end
+    
+    def conventional_name?
+      @name.tableize == @name
+    end
+    
+    protected
+    
+      def apply_conventions
+        @class_name = @conventions.class_name.call(@name)
       
-      @lines << "set_primary_key \"#{conventions.primary_key_name}\""
+        @lines << "set_primary_key \"#{@conventions.primary_key_name}\"" unless @conventions.primary_key_name == "id"
       
-      @lines << "set_table_name \"#{@name}\""
+        @lines << "set_table_name \"#{@name}\"" unless @name.tableize == @name
       
-      @columns.each do |column|
-        if conventions.belongs_to_matcher.call(column)
-          name = conventions.belongs_to_name.call(column)
-          @belongs_to_names << column
-          @lines << "belongs_to :#{name.underscore}, :class_name => '#{conventions.class_name.call(name)}'"
+        @columns.each do |column|
+          if @conventions.belongs_to_matcher.call(column)
+            name = @conventions.belongs_to_name.call(column)
+            @belongs_to_names << column
+            @lines << "belongs_to :#{name.underscore}, :class_name => '#{@conventions.class_name.call(name)}'"
+          end
         end
       end
-    end
-    
-    def code
-      "class ::#{@name.singularize.camelize} < ::ActiveRecord::Base\n#{@lines.map{|l| "  #{l}"}.join("\n")}\nend"
-    end
   end
 end

data/lib/conventional_models/version.rb

@@ -1,8 +1,8 @@
 module ConventionalModels #:nodoc:
   module VERSION #:nodoc:
     MAJOR = 0
-    MINOR = 0
-    BUILD = 1
+    MINOR = 2
+    BUILD = 0
  
     STRING = [MAJOR, MINOR, BUILD].join('.')
   end

data/spec/conventional_models/cli_spec.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+module ConventionalModels
+  describe CLI do
+    before(:each) do
+      @args = []
+      @options = Options.new
+      @option_parser = mock(OptionParser, :options => @options)
+      OptionParser.stub(:new).and_return(@option_parser)
+      File.stub(:exists?).with(@options.config).and_return(true)
+    end
+    
+    it "should create a new option parser with args" do
+      OptionParser.should_receive(:new).with(@args)
+      CLI.new(@args)
+    end
+    
+    describe "run" do
+      before(:each) do
+        @stdout_orig = $stdout
+        $stdout = StringIO.new
+      end
+      after(:each) do
+        $stdout = @stdout_orig
+      end
+      
+      def run
+        @cli = CLI.new(@args)
+        @cli.run
+      end
+      
+      describe "with parsed options" do
+        before(:each) do
+          @option_parser.stub(:parsed_options?).and_return(true)
+          ConventionalModels.stub(:configure)
+          ConventionalModels.stub(:model_code)
+          ConventionalModels.stub(:configure_active_record)
+          IRB.stub(:start)
+        end
+        
+        it "configures activerecord with config and environment options" do
+          ConventionalModels.should_receive(:configure_active_record).with(@options.config, @options.environment)
+          run
+        end
+        
+        describe "when config doesnt exist" do
+          before(:each) do
+            File.stub(:exists?).with(@options.config).and_return(false)
+          end
+          
+          it "complains" do
+            run
+            $stdout.string.should include("doesn't exist")
+          end
+          
+          it "does not call configure_active_record" do
+            run
+            ConventionalModels.should_not_receive(:configure_active_record)
+          end
+        end
+        
+        it "calls configure" do
+          ConventionalModels.should_receive(:configure)
+          run
+        end
+        
+        it "puts the model code" do
+          ConventionalModels.should_receive(:model_code).and_return("TEST")
+          run
+          $stdout.string.should == "TEST\n"
+        end
+        
+        it "start IRB" do
+          IRB.should_receive(:start)
+          run
+        end
+        
+        describe "with skip-configure option" do
+          it "does not call configure" do
+            @options.skip_configure = true
+            ConventionalModels.should_not_receive(:configure)
+            run
+          end
+        end
+        
+        describe "with help option" do
+          it "outputs help" do
+            RDoc.should_receive(:usage)
+            @options.output_help = true
+            ConventionalModels.should_not_receive(:configure_active_record)
+            run
+          end
+        end
+        
+        describe "with output version option" do
+          it "outputs the version" do
+            @options.output_version = true
+            ConventionalModels.should_not_receive(:configure_active_record)
+            run
+            $stdout.string.should =~ /#{VERSION::STRING}/
+          end
+        end
+      end
+      
+      describe "with invalid options" do
+        it "prints usage" do
+          RDoc.should_receive(:usage).with('usage')
+          @option_parser.stub(:parsed_options?).and_return(false)
+          run
+        end
+      end
+    end
+  end
+end

data/spec/conventional_models/database_spec.rb

@@ -9,6 +9,8 @@ module ConventionalModels
       @connection = mock(::ActiveRecord::ConnectionAdapters::AbstractAdapter)
       @columns = [mock(Column)]
       
+      ::ActiveRecord::Base.stub(:connection).and_return(@connection)
+      
       @connection.stub(:tables).and_return(["Test"])
       @connection.stub(:columns).with("Test").and_return(@columns)
       
@@ -19,39 +21,57 @@ module ConventionalModels
       Table.stub(:new => @table)
     end
     
-    describe "#apply_conventions" do
-      before(:each) do
-        @database = Database.new(@connection)
-      end
-      
-      it "creates a table with the table name and the column definitions" do
-        Table.should_receive(:new).with("Test", @columns).and_return(@table)
-        @database.apply_conventions(@conventions)
+    describe ".new" do
+      it "creates a table with the table name, column definitions and conventions" do
+        Table.should_receive(:new).with("Test", @columns, @conventions).and_return(@table)
+        @database = Database.new(@conventions)
         @database.tables.first.should == @table
       end
       
-      it "applies conventions to each table" do
-        @table.should_receive(:apply_conventions).with(@conventions)
-        @database.apply_conventions(@conventions)
-      end
-      
       describe "has many relationships" do
-        before(:each) do
-          @connection.stub(:tables).and_return(["sites", "pages"])
+        
+        describe "conventional" do
+          before(:each) do
+            @connection.stub(:tables).and_return(["sites", "pages"])
+
+            Table.unstub!(:new)
+            @site_columns = [Column.new("name", nil, "string")]
+            @pages_columns = [Column.new("site_id", nil, "integer")]
+            @connection.stub(:columns).with("sites").and_return(@site_columns)
+            @connection.stub(:columns).with("pages").and_return(@pages_columns)
+            @database = Database.new(Conventions.new)
+          end
+
+          it "sets the table name" do
+            @database.tables.first.name.should == "sites"
+          end
           
-          Table.unstub!(:new)
-          @site_columns = [Column.new("name", nil, "string")]
-          @pages_columns = [Column.new("site_id", nil, "integer")]
+          it "sets site to have many pages" do
+            @database.tables.first.lines.last.should == "has_many :pages"
+            # , :class_name => 'Page', :primary_key => 'id', :foreign_key => 'site_id'
+          end
+        end
+
+        describe "unconventional" do
+          before(:each) do
+            @connection.stub(:tables).and_return(["Site", "Page"])
+            Table.unstub!(:new)
+            @site_columns = [Column.new("Name", nil, "string")]
+            @pages_columns = [Column.new("Site_id", nil, "integer")]
+            @connection.stub(:columns).with("Site").and_return(@site_columns)
+            @connection.stub(:columns).with("Page").and_return(@pages_columns)
+            @database = Database.new(Conventions.new{ primary_key_name "ID" })
+          end
+
+          it "sets the table name" do
+            @database.tables.first.name.should == "Site"
+          end
           
-          @connection.stub(:columns).with("sites").and_return(@site_columns)
-          @connection.stub(:columns).with("pages").and_return(@pages_columns)
+          it "sets site to have many pages" do
+            @database.tables.first.lines.last.should == "has_many :pages, :class_name => 'Page', :foreign_key => 'Site_id', :primary_key => 'ID'"
+          end
         end
         
-        it "sets site to have many pages" do
-          @database.apply_conventions(Conventions.new)
-          @database.tables.first.name.should == "sites"
-          @database.tables.first.lines.last.should == "has_many :pages, :class_name => 'Page', :primary_key => 'id', :foreign_key => 'site_id'"
-        end
       end
       
       it "ignores tables" do
@@ -59,19 +79,18 @@ module ConventionalModels
           ignore_tables "Test"
         end
         @table.should_not_receive(:apply_conventions)
-        @database.apply_conventions(@conventions)
+        @database = Database.new(@conventions)
       end
     end
 
     describe "code outputting" do
       before(:each) do
         @table.stub(:name).and_return("Test")
-        @database = Database.new(@connection)
-        @database.apply_conventions(@conventions)
       end
       describe "#code" do
         it "should return the code for each table" do
           @table.should_receive(:code).and_return("test")
+          @database = Database.new(@conventions)
           @database.code.should == "test"
         end
       end
@@ -79,9 +98,11 @@ module ConventionalModels
       describe "#code_for" do
         it "should return the model code for a specific table" do
           @table.should_receive(:code).and_return("test")
+          @database = Database.new(@conventions)
           @database.code_for("Test").should == "test"
         end
         it "should return not found for unknown tables" do
+        @database = Database.new(@conventions)
           @database.code_for("SomeTable").should == "SomeTable not found"
         end
       end

data/spec/conventional_models/option_parser_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module ConventionalModels
+  describe OptionParser do
+    def options_for(args)
+      @option_parser = OptionParser.new(args)
+      @option_parser.options
+    end
+    
+    describe "parsing" do
+      it "accepts a database config file" do
+        options_for(["-c", "config/db.yml"]).config.should == "config/db.yml"
+        options_for(["--config", "config/db.yml"]).config.should == "config/db.yml"
+      end
+      
+      it "accepts an environment flag" do
+        options_for(["-e", "production"]).environment.should == "production"
+        options_for(["--environment", "production"]).environment.should == "production"
+      end
+      
+      it "accepts a skip configure flag" do
+        options_for(["-s"]).skip_configure.should == true
+        options_for(["--skip-configure"]).skip_configure.should == true
+      end
+      
+      it "accepts an output version flag" do
+        options_for(["-v"]).output_version.should == true
+        options_for(["--version"]).output_version.should == true
+      end
+      
+      it "accepts an output help flag" do
+        options_for(["-h"]).output_help.should == true
+        options_for(["--help"]).output_help.should == true
+      end
+    end
+    
+    describe "invalid arguments" do
+      it "should set parsed_options? to false" do
+        options_for(["--boobs"])
+        @option_parser.parsed_options?.should == false
+      end
+    end
+  end
+end

data/spec/conventional_models/options_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module ConventionalModels
+  describe Options do
+    before(:each) do
+      @options = Options.new
+    end
+    
+    describe "default options" do
+      it "should use rails location for default database.yml" do
+        @options.config.should == "config/database.yml"
+      end
+
+      it "should configure" do
+        @options.skip_configure.should be_false
+      end
+      
+      it "should default to development environment" do
+        @options.environment.should == "development"
+      end
+      
+      it "should not be verbose" do
+        @options.verbose.should be_false
+      end
+      
+      it "should not output version" do
+        @options.output_version.should be_false
+      end
+      
+      it "should not output help" do
+        @options.output_help.should be_false
+      end
+    end
+  end
+end

data/spec/conventional_models/table_spec.rb

@@ -4,36 +4,66 @@ module ConventionalModels
   describe Table do
     before(:each) do
       @columns = [mock(Column, :name => "test")]
+      @conventions = Conventions.new
+    end
+    
+    def has_item?(array, expected)
+      @found = false
+      array.each do |line|
+        @found = true if line == expected
+      end
+      @found
     end
     
     describe ".new" do
       it "sets the name" do
-        Table.new("test", @columns).name.should == "test"
+        Table.new("test", @columns, @conventions).name.should == "test"
       end
       
       it "sets the columns" do
-        Table.new("test", @columns).columns.should == @columns
+        Table.new("test", @columns, @conventions).columns.should == @columns
       end
     end
     
     describe "#==" do
       it "is true for tables with the same name" do
-        Table.new("Page", @columns).should == Table.new("Page", @columns)
+        Table.new("Page", @columns, @conventions).should == Table.new("Page", @columns, @conventions)
       end
       
       it "is false for tables with different names" do
-        Table.new("Page", @columns).should_not == Table.new("Bar", @columns)
+        Table.new("Page", @columns, @conventions).should_not == Table.new("Bar", @columns, @conventions)
       end
     end
     
-    describe "#apply_conventions" do
+    describe "#conventional_name?" do
+      it "is true for tables that have a name that matches rails conventions" do
+        Table.new("Page", @columns, @conventions).conventional_name?.should be_false
+        Table.new("pages", @columns, @conventions).conventional_name?.should be_true
+      end
+    end
+    
+    describe ".new" do
       it "sets the primary key" do
         @conventions = Conventions.new do
           primary_key_name "ID"
         end
-        @table = Table.new("Page", @columns)
-        @table.apply_conventions(@conventions)
-        @table.lines[0].should == "set_primary_key \"ID\""
+        @table = Table.new("Page", @columns, @conventions)
+        has_item?(@table.lines, "set_primary_key \"ID\"").should be_true
+      end
+      
+      it "doesn't set the primary key when it is the rails default" do
+        @table = Table.new("Page", @columns, @conventions)
+        has_item?(@table.lines, "set_primary_key \"id\"").should_not == be_true
+      end
+      
+      it "sets the table name" do
+        @table = Table.new("Page", @columns, @conventions)
+        has_item?(@table.lines, "set_table_name \"Page\"").should be_true
+      end
+      
+      it "doesn't set the table name if it is the rails default" do
+        @table = Table.new("pages", @columns, @conventions)
+        has_item?(@table.lines, "set_table_name \"pages\"").should be_false
       end
       
       it "sets the class name" do
@@ -42,17 +72,15 @@ module ConventionalModels
             "BOO"
           end
         end
-        @table = Table.new("Page", @columns)
-        @table.apply_conventions(@conventions)
+        @table = Table.new("Page", @columns, @conventions)
         @table.class_name.should == "BOO"
       end
       
       it "sets belongs to columns" do
         @conventions = Conventions.new
         @columns = [Column.new("Site_id", nil, "integer")]
-        @table = Table.new("Page", @columns)
-        @table.apply_conventions(@conventions)
-        @table.lines[2].should == "belongs_to :site, :class_name => 'Site'"
+        @table = Table.new("Page", @columns, @conventions)
+        has_item?(@table.lines, "belongs_to :site, :class_name => 'Site'").should be_true
         @table.belongs_to_names.first.name.should == "Site_id"
       end
       
@@ -60,18 +88,18 @@ module ConventionalModels
     
     describe "#code" do
       before(:each) do
-        @table = Table.new("pages", @columns)
+        @table = Table.new("pages", @columns, @conventions)
       end
       
-      it "returns an empty activerecord class with no columns" do
+      it "returns an activerecord class" do
         @model_code = @table.code
-        @model_code.should == %Q{class ::Page < ::ActiveRecord::Base\n\nend}
+        @model_code.starts_with?(%Q{class ::Page < ::ActiveRecord::Base}).should be_true
       end
       
       it "returns lines in the model definition" do
         @table.lines << "test"
         @model_code = @table.code
-        @model_code.split("\n")[1].should == "  test"
+        has_item?(@model_code.split("\n"), "  test").should be_true
       end
     end
   end

data/spec/conventional_models_spec.rb

@@ -8,24 +8,18 @@ module ConventionalModels
       
       ConventionalModels.stub(:run_code)
       
-      @connection = mock(Column)
-      ::ActiveRecord::Base.stub(:connection).and_return(@connection)
-      
       @generated_code = mock(String)
       @database = mock(Database, :code => @generated_code)
       @database.stub(:apply_conventions).with(@conventions)
       Database.stub(:new => @database)
+
+      ConventionalModels.stub(:remove)
     end
     
     describe ".configure" do
-      describe "with no args" do        
-        it "creates a database object with the connection and conventions" do
-          Database.should_receive(:new).with(@connection).and_return(@database)
-          ConventionalModels.configure
-        end
-        
-        it "called apply_conventions on the database object" do
-          @database.should_receive(:apply_conventions).with(@conventions)
+      describe "with no args" do
+        it "creates a database object with the conventions" do
+          Database.should_receive(:new).with(@conventions).and_return(@database)
           ConventionalModels.configure
         end
       
@@ -34,6 +28,13 @@ module ConventionalModels
           ConventionalModels.configure
         end
       end
+      describe "second call" do
+        it "should call remove if a database has already been configured" do
+          ConventionalModels.should_receive(:remove).with(@database)
+          ConventionalModels.configure
+          ConventionalModels.configure
+        end
+      end
     end
     
     describe ".run_code" do
@@ -58,5 +59,27 @@ module ConventionalModels
         ConventionalModels.model_code_for("Test").should == "test"
       end
     end
+    
+    describe ".run_console!" do
+      it "starts an IRB session" do
+        IRB.should_receive(:start)
+        ConventionalModels.should_receive(:configure_active_record)
+        ConventionalModels.should_receive(:configure)
+        ConventionalModels.run_console!
+      end
+    end
+    
+    describe ".remove" do
+      before(:each) do
+        ConventionalModels.unstub(:remove)
+        table = mock(Table, :class_name => "TestTable")
+        @database.should_receive(:tables).and_return([table])
+        Object.should_receive(:send).with(:remove_const, :TestTable)
+      end
+      
+      it "removes the table constants from the environment" do
+        ConventionalModels.remove(@database)
+      end
+    end
   end  
 end

data/spec/spec_helper.rb

@@ -9,5 +9,4 @@ require 'spec'
 require 'spec/autorun'
 
 Spec::Runner.configure do |config|
-  
 end

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 1
   - 2
-  version: 0.1.2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Steve Hodgkiss
@@ -14,8 +14,8 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-04-10 00:00:00 +01:00
-default_executable: 
+date: 2010-04-11 00:00:00 +01:00
+default_executable: cmconsole
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rspec
@@ -75,8 +75,8 @@ dependencies:
   requirement: *id004
 description: Generate ActiveRecord models automatically with basic relationships based on conventions.
 email: steve@hodgkiss.me.uk
-executables: []
-
+executables: 
+- cmconsole
 extensions: []
 
 extra_rdoc_files: 
@@ -91,21 +91,30 @@ files:
 - README.rdoc
 - Rakefile
 - VERSION
+- bin/cmconsole
 - conventional_models.gemspec
+- features/cmconsole.feature
 - features/conventional_models.feature
 - features/output_model_code.feature
+- features/step_definitions/cmconsole_steps.rb
 - features/step_definitions/conventional_models_steps.rb
 - features/step_definitions/output_model_code_steps.rb
 - features/support/env.rb
 - lib/conventional_models.rb
 - lib/conventional_models/active_record_base_model_for.rb
+- lib/conventional_models/cli.rb
 - lib/conventional_models/column.rb
 - lib/conventional_models/conventions.rb
 - lib/conventional_models/database.rb
+- lib/conventional_models/option_parser.rb
+- lib/conventional_models/options.rb
 - lib/conventional_models/table.rb
 - lib/conventional_models/version.rb
+- spec/conventional_models/cli_spec.rb
 - spec/conventional_models/conventions_spec.rb
 - spec/conventional_models/database_spec.rb
+- spec/conventional_models/option_parser_spec.rb
+- spec/conventional_models/options_spec.rb
 - spec/conventional_models/table_spec.rb
 - spec/conventional_models_spec.rb
 - spec/spec.opts
@@ -141,8 +150,11 @@ signing_key:
 specification_version: 3
 summary: Generate ActiveRecord models. For lazy people.
 test_files: 
+- spec/conventional_models/cli_spec.rb
 - spec/conventional_models/conventions_spec.rb
 - spec/conventional_models/database_spec.rb
+- spec/conventional_models/option_parser_spec.rb
+- spec/conventional_models/options_spec.rb
 - spec/conventional_models/table_spec.rb
 - spec/conventional_models_spec.rb
 - spec/spec_helper.rb