rails3_assist 0.2.4 → 0.2.5

data/lib/rails3_assist/app/file_names.rb

@@ -1,97 +0,0 @@
-require 'migration_assist'
-
-module Rails::Assist
-  module View
-    module FileName
-      DEFAULT_TEMPLATE_LANG = 'html.erb'
-      DEFAULT_REST_ACTION = 'show'
-          
-      def view_file_name folder, *args
-        action, type, args = get_view_args(args)
-        File.expand_path File.join(view_dir, folder.to_s, "#{action}.#{type}")
-      end 
-      
-      def get_view_args args 
-        args = args.flatten
-        action  = DEFAULT_REST_ACTION
-        type    = DEFAULT_TEMPLATE_LANG
-        case args.first
-        when Hash
-          action = args.first.delete(:action)
-          type = args.first.delete(:type)
-        when String, Symbol     
-          action = args.delete_at(0)
-        end
-        case args.first
-        when String, Symbol        
-          type = args.delete_at(0)
-        end      
-        [action, type, args]
-      end
-    end 
-    
-    include FileName
-  end
-
-  module Migration
-    module FileName   
-      include Rails::Migration::Assist::ClassMethods      
-
-      class FindError
-        attr_accessor :find_expr
-        
-        def initialize find_expr
-          self.find_expr = find_expr
-        end
-      end
-      
-      def migration_file_name name, options={}
-        number = options[:number]      
-        
-        migration_dir_name = File.expand_path(migration_dir options[:root_path])
-                
-        number = next_migration_number(migration_dir_name) if !number      
-        File.join(migration_dir, "#{number}_#{name}.rb")      
-      end
-            
-      def find_migration name, options={}
-        root_path = options[:root_path]        
-             
-        migration_dir_name = File.expand_path(migration_dir options[:root_path])
-
-        migration_find_expr = "#{migration_dir_name}/[0-9]*_*.rb"
-        migrations = Dir.glob(migration_find_expr)
-        
-        find_err = FindError.new migration_find_expr
-        
-        return find_err if migrations.empty?  
-        
-        migration_find_expr = /\d+_#{name}\.rb$/
-        find_err.find_expr = migration_find_expr
-            
-        matching_migrations = migrations.grep(migration_find_expr)
-
-        return find_err if matching_migrations.empty?
-
-        migration_file = (options[:last]) ? matching_migrations.last : matching_migrations.first
-      end      
-    end
-    
-    include FileName 
-  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}, options
-          end        
-        end
-        
-        include FileName
-      end
-    }
-  end
-end  

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

@@ -1,31 +0,0 @@
-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

@@ -1,11 +0,0 @@
-module Rails::Assist
-  (artifacts - [: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

@@ -1,106 +0,0 @@
-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 options={}                                                                                    
-        dir = options[:root_path] if options
-        dir ||= Rails::Assist::App.rails_root_dir || Rails.root
-        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, options={}
-        raise ArgumentError, '#rails_dir_for takes a dir type argument' if !type
-        dir_method = "#{type}_dir"
-        self.send(dir_method, options) if respond_to?(dir_method)
-      end
-    
-      def migration_dir options={}
-        File.join(db_dir(options), 'migrations')
-      end
-
-      def config_dir_for type, options={}
-        File.join(config_dir(options), type.to_s)
-      end      
-
-      def initializer_dir options={}
-        config_dir_for type :initializers, options
-      end  
-
-      def locale_dir options={}
-        config_dir_for type :locales, options
-      end
-
-      def public_dir_for type, options={}
-        File.join(public_dir(options), type.to_s)
-      end      
-
-      def stylesheet_dir options={}
-        public_dir_for :stylesheets, options
-      end
-
-      def javascript_dir options={}
-        public_dir_for :javascripts, options
-      end
-         
-      root_directories.each do |name|
-        class_eval %{
-          def #{name}_dir options={}
-            File.join(root_dir(options), '#{name}')
-          end        
-        } 
-      end
-
-      app_artifacts.each do |name|
-        class_eval %{
-          def #{name}_dir options={}
-            File.join(app_dir(options), '#{name}')
-          end
-        } 
-      end    
-
-      def app_dir options={}
-        File.join(root_dir(options), 'app')
-      end        
-
-      def observer_dir options={}
-        model_dir options
-      end
-    end # RailsDirs   
-  end # App
-end

data/lib/rails3_assist/app/rails_files.rb

@@ -1,128 +0,0 @@
-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/artifact/markers.rb

@@ -1,45 +0,0 @@
-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 Migration
-    def migration_marker name, options=nil
-      "#{name.to_s.camelize} < ActiveRecord::Migration"
-    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

@@ -1,10 +0,0 @@
-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
-  end
-end

data/lib/rails3_assist/artifact/orm.rb

@@ -1,136 +0,0 @@
-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

data/lib/rails3_assist/artifact/view.rb

@@ -1,70 +0,0 @@
-module Rails::Assist
-  module View
-    include Rails::Assist::BaseHelper
-    
-    # CREATE
-    def create_view name, *args, &block
-      file_name = view_file_name(name, args)      
-      dir = File.dirname(file_name)
-      FileUtils.mkdir_p dir if !File.directory?(dir)
-
-      content = get_content(args) || yield if block
-      
-      # abort if no content given
-      debug "Warning: Content must be passed in either as a :content hash or a block" if !content
-      return nil if !content
-
-      debug "Writing view file: #{file_name}"
-      # write file content of view
-      File.open(file_name, 'w') do |f|  
-        f.puts content 
-      end
-    end  
-
-    # READ
-    def read_view(name, *args, &block)
-      file_name = view_file_name(name, args)
-      debug "reading from: #{file_name}"
-      file = File.new(file_name)
-      raise "The view file: #{file} could not be found" if !file
-      begin
-        content = file.read
-        debug "read content: #{content}"
-        yield content if block
-        content
-      rescue
-        nil
-      end
-    end
-    
-    # UPDATE
-    def insert_into_view(name, *args, &block)
-      arguments = args.clone  
-      action, type, args = get_view_args(args)            
-      file_name = view_file_name(name, arguments)
-      debug "file insertion (view): #{file_name}"
-
-      options = args.first.kind_of?(Hash) ? args.first : {}            
-      marker = options[:before] || options[:after]
-
-      raise ArgumentError, ":before or :after option must be specified for insertion" if !marker      
-      file_insertion(file_name, marker, options, &block)
-    end
-
-    # DELETE
-    def remove_view name, action=nil, type=nil
-      file = view_file_name(name, action, type)
-      FileUtils.rm_f(file) if File.exist?(file)
-    end
-
-    def get_content args
-      args = args.flatten
-      case args.first
-      when Hash
-        args.first[:content]
-      end
-    end    
-
-    aliases_for :view 
-  end
-end

data/lib/rails3_assist/base/class_methods.rb

@@ -1,11 +0,0 @@
-module Rails::Assist
-  module BaseHelper
-    module ClassMethods
-      def aliases_for name
-        multi_alias name, 
-                    :create => :new, :insert_into => [:inject_into, :update], :read => :X_content, :remove => :delete, 
-                    :options => :after
-      end
-    end
-  end
-end

data/lib/rails3_assist/base/create.rb

@@ -1,48 +0,0 @@
-module Rails::Assist
-  module BaseHelper
-    def new_artifact_content name, type, content=nil, &block
-      content ||= yield if block
-      %Q{class #{marker(name, type)}
-  #{content}
-end}
-    end    
-             
-    # CREATE
-    def create_artifact name, options={}, &block
-      type = get_type(options)
-
-      file = make_file_name name, type
-      return if File.exist?(file)
-
-      debug "create #{type}: #{name}, opt: #{options}"
-      debug "file: #{file}"
-
-      # make dir        
-      dir = File.dirname(file)
-      FileUtils.mkdir_p dir if !File.directory?(dir)
-
-      content = options[:content]
-      content ||= yield if block
-
-      content_method = :"new_#{type}_content"
-      debug "inner content: #{content}, to inject using ##{content_method}"
-
-      raise "Content method #{content_method} not found #{orm_notify}" if !respond_to?(content_method)
-
-      insert_content = if type == :model        
-        send content_method, name, options.merge(:content => content), &block
-      else
-        send content_method, name, content, &block
-      end
-      
-      debug "content to insert: #{insert_content}"
-
-      return if insert_content.blank?
-
-      File.open(file, 'w') do |f|  
-        f.puts insert_content
-      end
-      debug "file created and content inserted"
-    end
-  end
-end