rails3_assist 0.2.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,21 @@
+## MAC OS
+.DS_Store
+
+## TEXTMATE
+*.tmproj
+tmtags
+
+## EMACS
+*~
+\#*
+.\#*
+
+## VIM
+*.swp
+
+## PROJECT::GENERAL
+coverage
+rdoc
+pkg
+
+## PROJECT::SPECIFIC

data/.rspec

@@ -0,0 +1 @@
+--color --format nested

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Kristian Mandrup
+
+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.markdown

@@ -0,0 +1,63 @@
+# Rails3 Assistant
+
+Includes various helpers to assist operating on a Rails 3 application, including various Rails 3 artifacts, such as migrations etc.
+
+## Rails Artifacts
+
+Rails assist also includes various artifact libraries to help operate on different Rails 3 artifacts. 
+These assist libraries mainly contain some common CRUD (Create, Read, Update, Delete) operations. 
+The same API is shared in all the artifact assist libraries.
+The following is a list of the main API, including an alias for each method. 
+
+* create_[x] - new_[x])
+* insert_into_[x] - update_[x]
+* read_model - [x]_content
+* remove_[x] - delete_[x]
+* remove_[x]s - delete_[x]s
+
+Rails 3 artifacts that have a CRUD assistant:
+
+* controller
+* helper
+* mailer
+* migration (pending!)
+* model (insert bug!)
+* observer
+* view
+
+## Model
+
+* create_model (new_model)
+* insert_into_model (update_model)
+
+Create and insert for *model* operate according to the ORM currently used.
+The ORM used is specified by calling <code>use_orm :[orm]</code> fx <code>use_orm :active_record</code>
+
+### Usage
+
+Generators are often designed to create Rails 3 artifacts or update existing artifacts. It's often useful to include one or more Rails 3 artifact assisters along
+with a generator assister (see above). 
+This combination greatly facilitates your work in developing the generator, as much of the heavy lifting will be done for you in the assisters.
+To use a helper, simply call:
+
+*assist_with [list of helpers]*
+
+Example:
+
+<code>assist_with :app, :controller, :model, :view</code>
+
+Aliases: *use_helpers* and *use_helper*
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2010 Kristian Mandrup. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,21 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "rails3_assist"
+    gem.summary = %Q{Assist in operating on Rails 3 artifacts including migrations}
+    gem.description = %Q{Assist in operating on Rails 3 artifacts including migrations}
+    gem.email = "kmandrup@gmail.com"
+    gem.homepage = "http://github.com/kristianmandrup/rails3-assist"
+    gem.authors = ["Kristian Mandrup"]
+    gem.add_development_dependency "rspec",           ">= 2.0.0.beta.19"
+    # gem.add_development_dependency "generator-rspec", ">= 0.6.0"
+    gem.add_dependency "require_all",       ">= 1.1.0"
+    gem.add_dependency "migration_assist", ">= 0.1.2"
+
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+

data/VERSION

@@ -0,0 +1 @@
+0.2.2

data/lib/rails3_assist/app/file_names.rb

@@ -0,0 +1,34 @@
+module Rails::Assist
+  module View
+    module FileName    
+      def view_file_name folder, action=nil, type=nil
+        File.join(view_dir, folder.to_s, "#{get_action action}.#{get_type type}")
+      end        
+    end
+  end
+
+  module Migration
+    module FileName
+      def migration_file_name name, options={}
+        number = options[:number]      
+        number = next_migration_number(migration_dir) if !number      
+        File.join(migration_dir, "#{number}_#{name}.rb")      
+      end
+    end
+  end 
+  
+  (Rails::Assist.artifacts. - [:migration, :view]).each do |name|
+    class_eval %{
+      module #{name.to_s.camelize}
+        module FileName
+        
+          def #{name}_file_name name, options=nil
+            artifact_path name, :#{name}
+          end        
+        end
+        
+        include FileName
+      end
+    }
+  end
+end  

data/lib/rails3_assist/app/methods/crud.rb

@@ -0,0 +1,31 @@
+module Rails::Assist
+  artifacts.each do |name|
+    class_eval %{
+      module #{name.to_s.camelize}      
+        include Rails::Assist::BaseHelper
+        
+        def create_#{name} name, options={}, &block
+          create_artifact(name, set(options, :#{name}), &block)
+        end          
+      
+        def insert_into_#{name}(name, options={}, &block)
+          insert_content(name, set(options, :#{name}), &block)      
+        end
+        
+        def read_#{name}(name, options={}, &block)
+          read_artifact(name, set(options, :#{name}), &block)      
+        end
+
+        def remove_#{name} name
+          remove_artifact name, :#{name}
+        end
+    
+        def remove_#{name}s *names      
+          remove_artifacts :#{name}, *names
+        end              
+        
+        aliases_for :#{name}            
+      end
+    }    
+  end
+end

data/lib/rails3_assist/app/methods/new_content.rb

@@ -0,0 +1,11 @@
+module Rails::Assist
+  (artifacts - [:migration, :model]).each do |name|
+    class_eval %{
+      module #{name.to_s.camelize}
+        def new_#{name}_content name, content=nil, &block
+          new_artifact_content name, :#{name}, content, &block
+        end
+      end
+    }
+  end    
+end    

data/lib/rails3_assist/app/rails_dirs.rb

@@ -0,0 +1,105 @@
+module Rails::Assist
+  module App                               
+    class << self
+      attr_accessor :rails_root_dir
+    end      
+
+    module RailsDirs      
+      def self.root_directories
+        [:app, :config, :db, :public, :lib, :log, :doc, :test, :spec]      
+      end
+
+      def root_directories
+        Rails::Assist::App::RailsDirs.root_directories
+      end
+
+      def self.app_artifacts
+        [:controller, :mailer, :helper, :view, :model]
+      end
+    
+      def self.app_directories
+        app_artifacts.map {|a| a.to_s.singularize.to_sym}
+      end
+
+      def app_directories
+        Rails::Assist::App::RailsDirs.app_directories
+      end
+
+      def app_artifacts
+        Rails::Assist::App::RailsDirs.app_artifacts
+      end
+
+      def self.rails_containers
+        Rails::Assist::App::RailsDirs.instance_methods.grep(/_dir$/).map{|dir| dir.gsub(/^(.*)_dir/, '\1').to_sym }
+      end
+
+      def self.valid_container? type
+        rails_containers.include?(type)
+      end
+
+      def root_dir                                                                                    
+        dir = Rails::Assist::App.rails_root_dir
+        raise "You must set the Rails app root dir: Rails::Assist::App.root_dir = '/my/root/dir'" if !dir
+        dir
+      end    
+
+      def rails_dir_for type
+        raise ArgumentError, '#rails_dir_for takes a dir type argument' if !type
+        dir_method = "#{type}_dir"
+        self.send(dir_method) if respond_to?(dir_method)
+      end
+    
+      def migration_dir
+        File.join(db_dir, 'migrations')
+      end
+
+      def config_dir_for type
+        File.join(config_dir, type.to_s)
+      end      
+
+      def initializer_dir
+        config_dir_for type :initializers
+      end  
+
+      def locale_dir
+        config_dir_for type :locales
+      end
+
+      def public_dir_for type
+        File.join(public_dir, type.to_s)
+      end      
+
+      def stylesheet_dir
+        public_dir_for :stylesheets
+      end
+
+      def javascript_dir
+        public_dir_for :javascripts
+      end
+         
+      root_directories.each do |name|
+        class_eval %{
+          def #{name}_dir
+            File.join(root_dir, '#{name}')
+          end        
+        } 
+      end
+
+      app_artifacts.each do |name|
+        class_eval %{
+          def #{name}_dir      
+            File.join(app_dir, '#{name}')
+          end
+        } 
+      end    
+
+      def app_dir
+        File.join(root_dir, 'app')
+      end        
+
+      def observer_dir
+        model_dir
+      end
+    end # RailsDirs   
+  end # App
+end

data/lib/rails3_assist/app/rails_files.rb

@@ -0,0 +1,128 @@
+module Rails::Assist
+  module App
+    module RailsFiles
+    
+      def files_from expr, *types
+        types.inject([]) {|files, type| files + self.send(:"#{type}_files", expr)}
+      end
+
+      def all_files expr=nil
+        rails_files(root_dir).grep expr
+      end  
+
+      def app_files expr=nil
+        rails_app_files.grep expr
+      end  
+
+      def rails_files_for type, expr=nil, &block
+        files_method = "#{type}_files"
+        send files_method, expr, &block if respond_to?(files_method)
+      end
+
+      def self.rails_artifacts
+        @rails_artifacts ||= Rails::Assist::RailsDirs.instance_methods.grep(/_files$/).map{|dir| dir.gsub(/^(.*)_dir/, '\1').to_sym }      
+      end
+
+      def self.valid_artifact? type
+        rails_artifacts.include?(type)
+      end
+
+      [:model, :controller, :helper].each do |name|
+        class_eval %{
+          def #{name}_files expr=nil
+            files = rails_app_files(:#{name.to_s.pluralize}).grep expr
+            yield files if block_given?      
+          end          
+        }
+      end
+    
+      [:mailer, :observer].each do |name|
+        class_eval %{
+          def #{name}_files expr=nil
+            files = rails_app_files(:#{name.to_s.pluralize}, '**/*_#{name}.rb').grep expr
+            yield files if block_given?
+          end  
+        }
+      end
+
+      def view_files *args 
+        expr, model_name = get_view_args args
+        file_expr = model_name ? "#{model_name}/*.*" : '**/*.*'
+        files = rails_app_files(:views, file_expr).grep expr
+        yield files if block_given?          
+      end
+
+
+      [:erb, :haml].each do |name|
+        class_eval %{
+          def #{name}_view_files *args 
+            expr, model_name = get_view_args(args)
+            file_expr = model_name ? "\#{model_name}/*.\#{name}*" : '**/*.\#{name}*'
+            files = rails_app_files(:views, file_expr).grep expr
+            yield files if block_given?          
+          end
+        }
+      end
+
+      [:initializer, :db, :migration].each do |name|
+        class_eval %{
+          def #{name}_files expr=nil
+            files = rails_files(#{name}_dir).grep expr
+            yield files if block_given?          
+          end  
+        }
+      end
+
+      {:locale => :yml, :javascript => :js}.each_pair do |name, ext|
+        class_eval %{
+          def #{name}_files expr=nil
+            files = rails_files(#{name}_dir, '**/*.#{ext}').grep expr
+            yield files if block_given?                    
+          end
+        }
+      end
+
+      [:css, :sass].each do |ext|
+        class_eval %{
+          def #{ext}_files expr=nil
+            files = rails_files(stylesheet_dir, '**/*.#{ext}').grep expr
+            yield files if block_given?                    
+          end
+        }
+      end
+
+      protected
+   
+      RB_FILES = '**/*.rb'
+
+      def get_view_args args 
+        args = args.flatten
+        first_arg = args.first      
+        case first_arg
+        when Regexp
+          expr = first_arg
+        when String, Symbol
+          _model = first_arg
+        end
+        expr = args[1] if args > 1 && args1.kind_of?(Regexp)
+        [expr, _model]
+      end
+
+      def rails_files dir, type=nil, pattern=nil
+        path = case type
+        when nil
+          "#{dir}/#{RB_FILES}"
+        when String          
+          "#{dir}/#{type}"
+        when Symbol
+          pattern ? "#{dir}/#{type}/#{pattern}" : "#{dir}/#{type}"
+        end
+        FileList[path]
+      end
+
+      def rails_app_files type=nil, pattern='**/*.rb'
+        rails_files :app, type, pattern
+      end
+    end    
+  end # App                  
+end

data/lib/rails3_assist/app.rb

@@ -0,0 +1,47 @@
+module Rails::Assist  
+  def self.helper_list
+    self.artifacts + [:view]
+  end
+
+  module ArtifactPath
+    def artifact_path name, type, dir=nil
+      dir ||= send :"#{type}_dir"
+      File.join(dir, "#{name}#{type_postfix type}.rb")
+    end
+
+    def type_postfix type
+      "_#{type}" if ![:model].include?(type)
+    end
+  end
+  
+  module App
+    include ArtifactPath
+    
+    def create_empty_tmp *dir_types
+      dir_types.flatten.each do |dir_type|
+        dir = rails_dir_for(dir_type)
+        FileUtils.mkdir_p dir
+      end
+    end                              
+  end 
+  
+end
+
+# first load all base modules that the app helper will build upon
+require 'rails3_assist/base'
+
+# then load the app 'modules'
+require_all File.dirname(__FILE__) + '/app'
+
+# into App
+module Rails::Assist::App  
+  include RailsFiles       
+  include RailsDirs
+
+  # put all FileName modules into App
+  Rails::Assist.artifacts.each do |name|
+    class_eval %{
+      include Rails::Assist::#{name.to_s.camelize}::FileName
+    } 
+  end
+end                

data/lib/rails3_assist/artifact/markers.rb

@@ -0,0 +1,39 @@
+module Rails::Assist
+  module Controller
+    def controller_marker name, options=nil
+      "#{name.to_s.camelize}Controller < ActionController::Base"
+    end
+  end
+
+  module Helper
+    def helper_marker name, options=nil
+      "#{name.to_s.camelize}Helper"
+    end
+  end
+  
+  module Mailer
+    def mailer_marker name, options=nil
+      "#{name.to_s.camelize} < ActionMailer::Base"
+    end
+  end    
+
+  module Observer
+    def observer_marker name, options=nil
+      "#{name.to_s.camelize}Observer < ActiveRecord::Observer"
+    end
+  end
+  
+  module Model   
+    include Rails::Assist::BaseHelper    
+    
+    def model_marker name, options={}
+      return send :orm_marker_name, options if respond_to?(:orm_marker_name)
+      name.camelize      
+    end
+    
+    def orm_notify
+      ". You must specify an ORM with the macro use_orm, f.ex -- use_orm :active_record"
+    end    
+  end
+  
+end

data/lib/rails3_assist/artifact/migration.rb

@@ -0,0 +1,24 @@
+require 'migration_assist'
+
+Rails::Migration::Assist.rails_root_dir = Rails::Assist::App.rails_root_dir
+
+module Rails::Assist
+  module Migration
+    include Rails::Assist::BaseHelper    
+    include Rails::Migration::Assist::ClassMethods
+
+    include FileName
+    
+    def find_migration name, option=nil
+      migrations = Dir.glob("#{migration_dir}/[0-9]*_*.rb")
+      return nil if !migrations.empty?      
+      matching_migrations = migrations.grep(/\d+_#{name}\.rb$/)
+      return nil if matching_migrations.empty?
+      migration_file = (option == :last) ? matching_migrations.last : matching_migrations.first
+    end
+
+    def migration_marker name, options=nil
+      "#{name.to_s.camelize} < ActiveRecord::Migration"
+    end    
+  end
+end

data/lib/rails3_assist/artifact/orm.rb

@@ -0,0 +1,136 @@
+module Rails::Assist
+  module Orm
+    module Base
+      include Rails::Assist::Model 
+
+      protected
+
+      def orm_marker_name options = {:model_type => :document}
+        document_name options
+      end
+
+      def document_name options = {:model_type => :document} 
+        type_content = options[:model_type] == :embedded ?  "#{orm_name}::EmbeddedDocument" : "#{orm_name}::Document"
+      end
+
+      def clazz name
+        "class #{name.to_s.camelize}"
+      end
+
+      def file name, include_stmt, &block
+        %Q{#{clazz name}
+  #{include_stmt}
+  #{yield if block}
+end}
+      end
+
+      def file_w_include name, module_name, &block
+        file name, "include #{module_name}", &block 
+      end
+
+      def simple_file name, module_name, &block
+        %Q{#{clazz name}
+  #{yield if block}
+end}
+      end
+
+      def file_w_inherit name, module_name, &block
+        %Q{#{clazz name} < #{module_name}
+  #{yield if block}
+end}
+      end 
+      
+      def field name, type = nil
+        return "#{field_name} :#{name}, #{type}" if type
+        "#{field_name} :#{name}"
+      end      
+    end
+
+    module None
+      include Rails::Assist::Orm::Base
+
+      def orm_marker_name options=nil
+        @name
+      end
+
+      def new_model_content name, options={}, &block        
+        content = options[:content] || yield if block
+        @name = name
+        simple_file(name, orm_marker_name(options)) { content }
+      end
+    end
+
+    module ActiveRecord
+      include Rails::Assist::Orm::Base
+
+      def orm_marker_name options=nil
+        'ActiveRecord::Base'
+      end
+
+      def new_model_content name, options={}, &block        
+        content = options[:content] || yield if block
+        file_w_inherit(name, orm_marker_name(options)) { content }
+      end
+    end
+
+    module MongoMapper
+      include Rails::Assist::Orm::Base
+
+      def orm_name
+        'MongoMapper'
+      end      
+      
+      def new_model_content name, options={}, &block        
+        content = options[:content] || yield if block
+        file_w_include(name, orm_marker_name(options)) { content }
+      end
+
+      def field_name
+        'key'
+      end
+    end
+
+    module Mongoid
+      include Rails::Assist::Orm::Base
+
+      def orm_name
+        'Mongoid'
+      end
+
+      def field_name
+        'field'
+      end
+
+      def new_model_content name, options={}, &block        
+        content = options[:content] || yield if block
+        file_w_include(name, orm_marker_name(options)) { content }
+      end
+
+      def field name, type = nil
+        return "#{field_name} :#{name}, :type => #{type}" if type
+        "#{field_name} :#{name}"
+      end
+    end
+
+    module DataMapper
+      include Rails::Assist::Orm::Base
+
+      def orm_name
+        'DataMapper'
+      end
+
+      def orm_marker_name options=nil
+        "#{orm_name}::Resource"
+      end
+
+      def new_model_content name, options={}, &block        
+        content = options[:content] || yield if block
+        file_w_include(name, orm_marker_name(options)) { content }
+      end
+
+      def field_name
+        'property'
+      end
+    end
+  end
+end