rails_assist 0.4.0

data/lib/rails_assist/artifact/files.rb

@@ -0,0 +1,95 @@
+require 'sugar-high/regexp'
+
+module RailsAssist::Artifact
+  module Files  
+    module Methods  
+      [:model].each do |name|
+        class_eval %{
+          def #{name}_filepaths expr=nil
+            files = RailsAssist::Files.rails_app_files(:#{name.to_s.pluralize}).grep_it expr
+            yield files if block_given?
+            files
+          end          
+
+          def #{name}_files expr=nil
+            files = #{name}_filepaths(expr).to_files
+            yield files if block_given?
+            files
+          end          
+        }
+      end
+
+      [:initializer, :locale].each do |name|
+        class_eval %{
+          def #{name}_filepaths expr=nil
+            files = RailsAssist::Files.rails_app_files(:#{name.to_s.pluralize}).grep_it expr
+            yield files if block_given?
+            files
+          end          
+        }
+      end
+
+      # artifact files using xxx_[artifact].rb convention, i.e postfixing with type of artifact
+      [:mailer, :observer, :permit, :license, :controller, :helper, :validator].each do |name|
+        class_eval %{
+          def #{name}_filepaths expr=nil
+            files = RailsAssist::Files.rails_app_files(:#{name.to_s.pluralize}, :pattern => '**/*_#{name}.rb').grep_it expr
+            yield files if block_given?
+            files
+          end  
+
+          def #{name}_files expr=nil
+            files = #{name}_filepaths(expr).to_files
+            yield files if block_given?
+            files
+          end  
+        }
+      end   
+
+      def view_filepaths *args 
+        expr, model_name = Helper.get_view_args args
+        ext = last_option(args)[:template_language] || 'erb'
+        pattern = model_name ? "#{model_name.to_s.pluralize}/*.#{ext}*" : "**/*.#{ext}*"
+        files = RailsAssist::Files.rails_app_files(:views, :pattern => pattern).grep_it expr
+        yield files if block_given?
+        files          
+      end
+
+      def view_files *args
+        files = view_filepaths(args).to_files
+        yield files if block_given?
+        files
+      end  
+
+
+      [:erb, :haml, :slim].each do |name|
+        class_eval %{
+          def #{name}_view_filepaths *args 
+            view_files args, :template_language => :#{name}
+          end
+
+          def #{name}_view_files *args 
+            view_filepaths(args).to_files
+          end
+        }
+      end
+    end
+    extend Methods
+    include Methods
+
+    module Helper    
+      def self.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.size > 1 && args[1].kind_of?(Regexp)
+        [expr, _model]
+      end        
+    end
+  end
+end

data/lib/rails_assist/artifact/path.rb

@@ -0,0 +1,16 @@
+module RailsAssist::Artifact
+  module Path
+    include RailsAssist::Artifact::Directory    
+    
+    def artifact_path name, type, options={}
+      dir = send :"#{type}_dir", options
+      File.join(dir, "#{name}#{type_postfix type}.rb")
+    end
+
+    protected
+
+    def type_postfix type
+      "_#{type}" if ![:model].include?(type)
+    end
+  end
+end

data/lib/rails_assist/directory.rb

@@ -0,0 +1,64 @@
+require_all File.dirname(__FILE__) + '/directory'
+require 'rails_assist/artifact'
+
+module RailsAssist
+  module Directory      
+    class << self
+      attr_accessor :rails_root
+      
+      def method_missing(sym, *args, &block)
+        RailsAssist::Artifact::Directory.send sym
+      end
+    end    
+
+    include Root
+    extend Root
+
+    include App
+    extend App
+
+    include Container    
+    extend Container
+        
+    # dir_for helpers
+    # -------------------
+
+    module Methods   
+      DIR = RailsAssist::Artifact::Directory      
+      
+      # :app, :config, :db, :public, :lib, :log, :doc, :test, :spec
+      #
+      # app_dir, config_dir ...
+      RailsAssist::Directory::Root.root_directories.each do |name|
+        class_eval %{
+          def #{name}_dir options={}
+            ::File.join(RailsAssist::Directory::Root.root_dir(options), '#{name}')
+          end        
+        } 
+      end      
+      
+      def rails_dir_for type, options={}
+        raise ArgumentError, '#rails_dir_for takes a dir type argument' if !type
+        dir_method = "#{type}_dir"
+        return send(dir_method, options) if respond_to?(dir_method)
+        DIR.send(dir_method, options) if DIR.respond_to?(dir_method)
+      end
+
+      def app_dir_for type, options={}
+        ::File.join(app_dir(options), type.to_s.pluralize)
+      end      
+
+      def config_dir_for type, options={}
+        ::File.join(config_dir(options), type.to_s.pluralize)
+      end      
+
+      def public_dir_for type, options={}
+        ::File.join(public_dir(options), type.to_s.pluralize)
+      end                
+    end
+    
+    include Methods
+    extend Methods
+    
+  end # Directories   
+end

data/lib/rails_assist/directory/app.rb

@@ -0,0 +1,21 @@
+module RailsAssist::Directory
+  module App  
+    module Methods
+      def app_directories
+        RailsAssist::Artifact::app_artifacts.map {|a| a.to_s.pluralize.to_sym}
+      end
+
+      def app_dirpath options={}
+        rails_root_dir = RailsAssist::Directory::Root.root_dir(options)
+        [rails_root_dir, 'app'].file_join
+      end
+
+      def app_dir options={}
+        app_dirpath(options).dir
+      end
+    end
+    
+    include Methods
+    extend Methods
+  end
+end

data/lib/rails_assist/directory/container.rb

@@ -0,0 +1,24 @@
+module RailsAssist::Directory      
+  module Container  
+
+    # return list of symbols for all kinds of supported Rails 3 containers 
+    # (those that have a [container]_dir method)
+    
+    module Methods    
+      def rails_containers
+        app_methods       = RailsAssist::Directory.instance_methods
+        artifact_methods  = RailsAssist::Artifact::Directory.instance_methods
+        all_methods = app_methods + artifact_methods
+    
+        all_methods.grep(/_dir$/).map{|dir| dir.to_s.gsub(/^(.*)_dir/, '\1').to_sym }
+      end
+
+      def valid_container? type
+        rails_containers.include?(type)
+      end
+    end
+    
+    include Methods
+    extend Methods
+  end
+end

data/lib/rails_assist/directory/root.rb

@@ -0,0 +1,24 @@
+module RailsAssist::Directory
+  module Root
+    module Methods
+      def root_directories
+        [:app, :config, :db, :public, :lib, :log, :doc, :test, :spec]      
+      end
+
+      def root_dirpath options={}
+        raise ArgumentError, "options argument to root_dir must be a hash, was: #{options.inspect}" if options && !options.kind_of?(Hash)
+        dir = options[:root_path] if options 
+        dir ||= RailsAssist::Directory.rails_root || Rails.root
+        raise "You must set the Rails app root dir: RailsAssist::App.root_dir = '/my/root/dir'" if !dir
+        dir.path
+      end
+      
+      def root_dir options={}    
+        root_dirpath(options).dir
+      end      
+    end    
+    
+    include Methods
+    extend Methods
+  end
+end

data/lib/rails_assist/file.rb

@@ -0,0 +1,91 @@
+require_all File.dirname(__FILE__) + '/file'
+# require 'sugar-high/file'
+
+module RailsAssist
+  module File
+    module Methods
+      {:initializer => 'rb', :db => 'rb', :migration => 'rb', :locale => 'yml', :javascript => 'js', :stylesheet => 'css', :config => '.rb', :db => '.rb'}.each_pair do |name, ext|
+        plural_name = name.to_s.pluralize
+        pure_ext = ext.gsub /^\./, ''
+        class_eval %{      
+          def #{name}_file? name
+            name = name.as_filename
+            name = (name =~ /.rb$/) ? name : "\#{name}.#{pure_ext}"            
+            #{name}_file(name)
+          end            
+          alias_method :has_#{name}_file?, :#{name}_file?
+
+          def #{name}_files? *names
+            names.to_filenames.each do |name|
+              return false if !#{name}_file?(name)
+            end
+            true
+          end            
+          
+          def #{name}_filepath name
+            name = name.as_filename
+            name = (name =~ /.rb$/) ? name : "\#{name}.#{pure_ext}"
+            [RailsAssist::Artifact::Directory.#{name}_dir, name].file_join
+          end  
+
+          def #{name}_file name
+            name = name.as_filename            
+            #{name}_filepath(name).new_file
+          end  
+
+          def create_#{name} name, &block
+            name = name.as_filename            
+
+            # create dir for artifact if it doesn't exist
+            RailsAssist::App.create_empty_tmp :#{name} if !RailsAssist::Artifact::Directory.#{name}_dir
+
+            #{name}_file(name).overwrite do
+              yield
+            end
+          end
+
+          def read_#{name} name 
+            name = name.as_filename            
+            #{name}_file(name).read_content
+          end
+          alias_method :read_#{name}_file, :read_#{name}
+
+          def replace_#{name}_content name, args = {}, &block
+            name = name.as_filename            
+            if !(args.kind_of?(Hash) && args[:where])
+              raise ArgumentError, "#replace_#{name}_content Must take a hash argument with a :where option that is the content to be matched and replaced" 
+            end            
+
+            replace_content = block ? yield : args[:with]
+            if !replace_content            
+              raise ArgumentError, "#replace_#{name}_content Must take a block or a :with hash option that is the content to replace with" 
+            end
+
+            #{name}_file(name).replace_content :where => args[:where], :with => replace_content
+          end
+
+          def remove_all_#{plural_name}
+            return if !(RailsAssist::Artifact::Directory.#{name}_dir.path.directory?)
+            #{name}_files.delete_all!
+          end
+
+          def remove_#{plural_name} *names
+            return remove_all_#{plural_name} if names.empty? 
+            names.to_filenames.each do |name|
+              name = (name =~ /.rb$/) ? name : "\#{name}.#{pure_ext}"
+              #{name}_file(name).delete!
+            end
+          end
+          alias_method :remove_#{name}, :remove_#{plural_name} 
+        }
+      end
+    end
+
+    include Special
+    extend Special
+    
+    include Methods
+    extend Methods
+  end
+end   
+

data/lib/rails_assist/file/application.rb

@@ -0,0 +1,15 @@
+require 'sugar-high/file'
+require 'sugar-high/file_mutate'
+
+module RailsAssist::File
+  module Application
+    module Methods
+      def insert_application_config statement=nil, &block
+        statement = block ? yield : "config.#{statement}"
+        application_file.insert statement, :after => 'Rails::Application'
+      end  
+    end
+    include Methods
+    extend Methods
+  end
+end

data/lib/rails_assist/file/environment.rb

@@ -0,0 +1,16 @@
+module RailsAssist::File
+  module Environment
+    def insert_before_application_init content=nil, &block
+      insert_application_init :before, content, &block
+    end
+
+    def insert_after_application_init content=nil, &block
+      insert_application_init :after, content, &block
+    end
+
+    def insert_application_init place, statement=nil, &block
+      statement = block ? yield : statement  
+      environment_file.insert statement, place => /\w+#{Regexp.escape('::Application.initialize!')}/
+    end    
+  end
+end

data/lib/rails_assist/file/gem_file.rb

@@ -0,0 +1,32 @@
+module RailsAssist::File
+  module Gemfile
+    def has_gem? name
+      read_gem_file =~ /gem\s+('|")#{name}\1/
+    end
+
+    def has_gem_version? name, version = nil
+      read_gem_file =~ /gem\s+('|")#{name}\1,\s*('|")#{version}\2/
+    end
+
+    def clean_gemfile
+      clean_gemfile_content = read_gem_file.gsub(/('|"|end)\s*gem/m, "\\1\ngem")
+      read_gem_file.overwrite clean_gemfile_content
+    end
+
+    def gem_filepath
+      [RailsAssist::Directory.rails_root.path, 'Gemfile'].file_join
+    end
+    
+    def gem_file
+      raise "No Gemfile found at #{gem_filepath}" if !File.exist? gem_filepath
+      gem_filepath.new_file
+    end
+
+    # def with_gem_file command = nil
+    #   return send :"#{command}_gem_file" if command.valid_file_command?
+    # 
+    #   raise "No Gemfile found at #{gem_filepath}" if gem_filepath.exists?
+    #   gem_filepath.new_file
+    # end
+  end
+end

data/lib/rails_assist/file/routes_file.rb

@@ -0,0 +1,13 @@
+module RailsAssist::File
+  module Routes
+    def insert_into_routes route_stmt=nil, &block
+      statement = block ? yield : route_stmt
+      routes_file.insert statement, :after => 'routes.draw do'
+    end
+
+    def insert_last_in_routes route_stmt=nil, &block
+      statement = block ? yield : route_stmt
+      routes_file.insert statement, :before_last => 'end'
+    end
+  end
+end

data/lib/rails_assist/file/special.rb

@@ -0,0 +1,78 @@
+require_all File.dirname(__FILE__)
+
+module RailsAssist::File
+  module Special          
+    module Methods
+      # application_file, environment_file
+      [:application, :environment, :routes, :boot].each do |name|
+        class_eval %{
+          def #{name}_filepath
+            [RailsAssist::Directory.config_dir.path, '#{name}.rb'].file_join
+          end
+
+          def #{name}_file
+            #{name}_filepath.file
+          end
+        }
+      end  
+
+      def database_filepath
+        [RailsAssist::Directory.config_dir.path, 'database.yml'].file_join
+      end
+
+      def database_file
+        raise "No Database file found at #{database_filepath}" if File.file? database_filepath
+        File.new(database_filepath) 
+      end
+
+      def seed_filepath
+        [RailsAssist::Directory.db_dir.path, 'seeds.rb'].file_join
+      end
+
+      def seed_file
+        raise "No Seed file found at #{seed_filepath}" if !File.exist? seed_filepath
+        seed_filepath.new_file
+      end
+          
+      # read_application_file
+      # append_to_application_file
+      [:application, :environment, :seed, :gem, :routes, :boot, :database].each do |name|
+        class_eval %{      
+          def read_#{name}_file
+            #{name}_file.read_content
+          end
+
+          def remove_#{name}_file
+            #{name}_file.delete!
+          end
+
+          def append_to_#{name}_file content=nil, &block
+            #{name}_file.append content, &block
+          end
+
+          def replace_in_#{name}_file options = {}, &block
+            #{name}_file.replace_content options, &block
+          end
+
+          def remove_from_#{name}_file content=nil, &block
+            #{name}_file.remove_content content, &block
+          end
+        }
+      end
+    end
+    
+    include Methods
+    extend Methods
+    
+    include RailsAssist::File::Application
+    include RailsAssist::File::Environment
+    include RailsAssist::File::Gemfile
+    include RailsAssist::File::Routes    
+
+    extend RailsAssist::File::Application
+    extend RailsAssist::File::Environment
+    extend RailsAssist::File::Gemfile
+    extend RailsAssist::File::Routes    
+
+  end
+end