rapid-core 0.1

data/lib/rapid/skeleton/base.rb

@@ -0,0 +1,164 @@
+module Rapid
+  module Skeleton
+    
+    class Base
+      
+      include ActiveModel::Validations
+      
+      include Skeleton::Helpers::Directory
+      include Skeleton::Helpers::Gem
+      include Skeleton::Helpers::Migration
+      include Skeleton::Helpers::Route
+      include Skeleton::Helpers::Script
+      include Skeleton::Helpers::Template
+      include Skeleton::Helpers::View
+      
+      attr_reader :name, :settings, :project_path, :templates_path
+      
+      delegate :get_binding, :to => :settings
+      delegate :load_yaml,   :to => :settings
+      delegate :load_hash,   :to => :settings
+      delegate :to_yaml,     :to => :settings
+      delegate :to_hash,     :to => :settings
+      delegate :to_dot_hash, :to => :settings
+      delegate :[],          :to => :settings
+      delegate :[]=,         :to => :settings
+      delegate :set?,        :to => :settings
+      
+      validate :validate_settings
+      
+      def initialize settings = nil, options = {}
+        @settings = settings
+        @project_path = options[:project_path] || File.expand_path('.')
+        @templates_path = options[:templates_path] || discover_templates_path(options[:file])
+        @name = options[:name] || implied_name
+      end
+      
+      def settings= hash
+        settings.load_hash hash
+      end
+      
+      def push!
+        if push
+          true
+        else
+          raise Rapid::InvalidSkeletonError.new(errors.full_messages.join(', '))
+        end
+        
+        true
+      end
+      
+      def push
+        @pushing = true
+        is_valid = valid?
+        section(name) { bones } if is_valid
+        is_valid
+      ensure
+        @pushing = false
+      end
+      
+      def pull!
+        if pull
+          true
+        else
+          raise Rapid::InvalidSkeletonError.new(self.class.name)
+        end
+      end
+      
+      def pull
+        @pulling = true
+        !Rapid::Check.encounters_error? { section(name) { bones } }
+      ensure
+        @pulling = false
+      end
+      
+      protected
+      
+      def bones
+        raise NotImplementedError.new("subclass should implement bones")
+      end
+      
+      def section name, options = {}, &block
+        if Rapid::Check.current
+          Rapid::Check.current.with_section name do
+            run_section name, options, &block
+          end
+        else
+          run_section name, options, &block
+        end
+      end
+      
+      def pushing?
+        @pushing == true
+      end
+      
+      def pulling?
+        @pulling == true
+      end
+      
+      def ok file, message
+        log :ok, file, message
+      end
+      
+      def warning file, message
+        log :warning, file, message
+      end
+      
+      def error file, message
+        log :error, file, message
+      end
+      
+      def exception file, exception
+        log :exception, file, exception
+      end
+      
+      private
+      
+      def run_section name, options
+        if Kernel.block_given?
+          yield
+        else
+          method_name = options[:method] || name
+          send method_name
+        end
+      end
+      
+      def log type, file, message_or_exception
+        if Rapid::Check.current
+          Rapid::Check.current.send type, file, message_or_exception
+        else
+          raise "Rapid::Check.current is not set"
+        end
+        
+      end
+      
+      def validate_settings
+        if settings != nil && !settings.valid?
+          settings.errors.each do |attribute, errors|
+            errors.each {|error| self.errors.add attribute, error }
+          end
+        end
+        
+        true
+      end
+      
+      def discover_templates_path file_path
+         if file_path =~ /\/lib\//
+           path = File.join $`, 'templates'
+           return path if File.directory? path
+         end
+      end
+      
+      def implied_name
+        name = self.class.name
+        if name =~ /::Skeleton$/
+          $`
+        else
+          name
+        end
+      end
+      
+    end
+    
+  end
+end

data/lib/rapid/skeleton/helpers/directory.rb

@@ -0,0 +1,53 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Directory
+        
+        protected
+        
+        def directory path, options = {}
+          if pushing?
+            push_directory path, options
+          elsif pulling?
+            pull_directory path, options
+          end
+        end
+        
+        def push_directory path, options = {}
+          full_path = File.join project_path, path
+          
+          if_setting = options[:if]
+          return if if_setting && !set?(if_setting)
+          
+          FileUtils.mkdir_p full_path
+        end
+        
+        def pull_directory path, options = {}
+          full_path = File.join project_path, path
+          
+          if_setting = options[:if]
+          
+          if !File.exists?(full_path)
+            
+            if if_setting
+              self[if_setting] = false
+              ok path, "doesn't exist"
+            else
+              warning path, "doesn't exist"
+            end
+            
+          elsif !File.directory?(full_path)
+            error path, "isn't a directory"
+            
+          else
+            self[if_setting] = true if if_setting
+            ok path, "is good"
+          end
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/gem.rb

@@ -0,0 +1,133 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Gem
+        
+        def gemfile_path
+          File.join project_path, "Gemfile" if project_path
+        end
+        
+        protected
+        
+        def validate_gemfile_exists
+          path = gemfile_path
+          if path && !File.exists?(path)
+            errors.add :gem, "file does not exist"
+          end
+          
+          true
+        end
+        
+        def gem name, *args
+          if pushing?
+            push_gem name, *args
+          elsif pulling?
+            pull_gem name, *args
+          end
+        end
+        
+        def pull_gem gem_name, *args
+          options = Hash === args.last ? args.pop : {}
+          version = args.first
+          
+          path = gemfile_path
+          
+          if path.blank?
+            error gem_name, "Unknown Gemfile location"
+            return
+          end
+          
+          unless File.exists? path
+            error gem_name, "Gemfile doesn't exist"
+            return
+          end
+          
+          content = File.open(path) {|f| f.read }
+          
+          if_setting = options[:if]
+          
+          if has_gem? gem_name, content
+            ok gem_name, "is in your Gemfile"
+            self[if_setting] = true if if_setting
+            
+          elsif if_setting
+            ok gem_name, "isn't in your Gemfile"
+            self[if_setting] = false
+            
+          else
+            error gem_name, "isn't in your Gemfile"
+          end
+        end
+        
+        def push_gem name, *args
+          options = Hash === args.last ? args.pop : {}
+          version = args.first
+          
+          path = gemfile_path
+          return false unless path
+          
+          content = File.open(path) {|f| f.read }
+          
+          add_gem_to_content! [name, version, options], content
+          
+          File.open(path, 'w') {|f| f.write content }
+          true
+        end
+        
+        def add_gem_to_content! gem, content
+          gem_name = gem.first
+          gem_version = gem[1]
+          gem_options = gem[2]
+          
+          if_setting = gem_options.delete :if
+          return if if_setting && !set?(if_setting)
+          
+          return if has_gem? gem, content
+          
+          if gem_options[:group]
+            gem_group = gem_options[:group]
+            group_index = content.index %(group :#{gem_group} do)
+            
+          elsif gem_options[:groups]
+            groups = gem_options[:groups]
+            group_index = content.index %(group #{groups.collect {|g| g.to_sym.inspect}.join(", ")} do)
+          end
+          
+          if group_index
+            end_index = content.index("\nend", group_index)
+            rest = content[end_index+4..-1]
+            
+            gem_options.delete :group
+            gem_options.delete :groups
+            gem_method = gem_method_call gem_name, gem_version, gem_options
+            
+            content.sub! "\nend#{rest}", "\n  #{gem_method}\nend#{rest}"
+          else
+            gem_method = gem_method_call gem_name, gem_version, gem_options
+            content << "\n#{gem_method}"
+          end
+        end
+        
+        def has_gem? gem_name, content
+          content.index(%(gem "#{gem_name}")) != nil || content.index(%(gem '#{gem_name}')) != nil
+        end
+        
+        def gem_method_call gem_name, gem_version, gem_options
+          gem_options[:group] = gem_options[:group].to_sym if gem_options.key? :group
+          groups = gem_options.delete :groups
+          
+          gem_method = %(gem '#{gem_name}')
+          gem_method << ", '#{gem_version}'" unless gem_version.blank?
+          gem_method << ", #{gem_options.inspect[1..-2]}" unless gem_options.empty?
+          gem_method.gsub! "=>", " => "
+
+          gem_method << ", :groups => #{groups.collect {|g| g.to_sym}.inspect}" if groups
+          gem_method
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/migration.rb

@@ -0,0 +1,46 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Migration
+        
+        protected
+        
+        # def migration migration_path
+        #   if pushing?
+        #     push_migration path
+        #   elsif pulling?
+        #     pull_migration path
+        #   end
+        # end
+        # 
+        # def push_migration migration_path
+        #   
+        # end
+        # 
+        # def unique_prefix
+        #   if @timestamp
+        #     @timestamp + 1
+        #   else
+        #     @timestamp ||= Time.now.strftime("%Y%m%d%H%M%S").to_i
+        #   end
+        # end
+        # 
+        # def create_migration migration
+        #   if migration =~ /^[0-9]+_/
+        #     suffix = $'
+        #   else
+        #     suffix = migration
+        #   end
+        #   
+        #   template_path = File.join 'db', 'migrate', "#{migration}.rb"
+        #   output_path = File.join 'db', 'migrate', "#{unique_prefix}_#{suffix}.rb"
+        #   
+        #   push_template template_path, :to => output_path
+        # end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/route.rb

@@ -0,0 +1,115 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Route
+        
+        def routes_path
+          File.join project_path, "config", "routes.rb" if project_path
+        end
+        
+        protected
+        
+        def validate_routes_file_exists
+          path = routes_path
+          if path && !File.exists?(path)
+            errors.add :routes, "file does not exist"
+          end
+          
+          true
+        end
+        
+        def route type, path, options = {}
+          if pushing?
+            push_route type, path, options
+          elsif pulling?
+            pull_route type, path, options
+          end
+        end
+        
+        def pull_route type, path, options = {}
+          file_path = routes_path
+          
+          if file_path.blank?
+            error "config/routes.rb", "location is unknown"
+            return
+          end
+          
+          unless File.exists? file_path
+            error "config/routes.rb", "doesn't exist"
+            return
+          end
+          
+          content = File.open(file_path) {|f| f.read }
+          
+          if has_route? content, type, path
+            ok "#{type} '#{path}'", "exists"
+          else
+            error "#{type} '#{path}'", "doesn't exist"
+          end
+        end
+        
+        def push_route type, path, options = {}
+          file_path = routes_path
+          return false unless file_path
+          
+          content = File.open(file_path) {|f| f.read }
+          
+          add_route_to_content! content, type, path, options
+          
+          File.open(file_path, 'w') {|f| f.write content }
+          true
+        end
+        
+        def add_route_to_content! content, route_type, route_path, route_options
+          if route_options[:namespace]
+            add_route_to_namespace! content, route_type, route_path, route_options
+            
+          elsif !has_route?(content, route_type, route_path)
+            route_method = route_method_call route_type, route_path, route_options
+            content.sub! /\nend$/, "\n  #{route_method}\nend"
+          end
+        end
+        
+        def add_route_to_namespace! content, route_type, route_path, route_options
+          namespace = route_options.delete :namespace
+          route_method = route_method_call route_type, route_path, route_options
+          
+          namespace_index = content.index "\n  namespace :#{namespace} do"
+          if namespace_index
+            # append to existing
+            
+            end_index = content.index "\n  end", namespace_index
+            rest = content[end_index+6..-1]
+            
+            content.sub! "\n  end#{rest}", "\n    #{route_method}\n  end#{rest}"
+            
+          else
+            # append new to content
+            
+            namespace_method = "namespace :#{namespace} do\n    #{route_method}\n  end"
+            content.sub! /\nend$/, "\n  #{namespace_method}\nend"
+          end
+        end
+        
+        def has_route? content, route_type, route_path
+          content.index(%(\n  #{route_type} '#{route_path}')) != nil
+        end
+        
+        def route_method_call route_type, route_path, route_options
+          route_method = %(#{route_type} '#{route_path}')
+          
+          to_option = route_options[:to]
+          route_method += ", :to => '#{to_option}'" if to_option
+          
+          as_option = route_options[:as]
+          route_method += ", :as => :#{as_option}" if as_option
+          
+          route_method
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/script.rb

@@ -0,0 +1,33 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Script
+        
+        protected
+        
+        def script script_path, options = {}
+          if pushing?
+            push_script script_path, options
+          elsif pulling?
+            pull_script script_path, options
+          end
+        end
+        
+        def push_script script_path, options = {}
+          push_template script_path, options
+          
+          output_path = options[:to] || script_path
+          full_output_path = File.join project_path, output_path
+          File.chmod 0755, full_output_path
+        end
+        
+        def pull_script script_path, options = {}
+          pull_template script_path, options
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/template.rb

@@ -0,0 +1,73 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module Template
+        
+        protected
+        
+        def template template_path, options = {}
+          if pushing?
+            push_template template_path, options
+          elsif pulling?
+            pull_template template_path, options
+          end
+        end
+        
+        def push_template template_path, options = {}
+          if_setting = options[:if]
+          return false if if_setting && !set?(if_setting)
+          
+          full_template_path = File.join templates_path, template_path
+          template_content = File.open(full_template_path) { |f| f.read }
+          template = Rapid::Template::Base.new template_content, :filename => template_path
+          
+          output_path = options[:to] || template_path
+          full_output_path = File.join project_path, output_path
+          
+          output_content = template.push self
+          FileUtils.mkdir_p File.dirname(full_output_path)
+          File.open(full_output_path, 'w') { |f| f.write output_content }
+          
+          true
+          
+        rescue Errno::ENOENT => e
+          raise Rapid::TemplateNotFoundError.new(e.message)
+        end
+        
+        def pull_template template_path, options = {}
+          if_setting = options[:if]
+          
+          full_template_path = File.join templates_path, template_path
+          template_content = File.open(full_template_path) { |f| f.read }
+          template = Rapid::Template::Base.new template_content, :filename => template_path
+          
+          output_path = options[:to] || template_path
+          full_output_path = File.join project_path, output_path
+          
+          unless File.exists? full_output_path
+            if if_setting
+              self[if_setting] = false
+            else
+              error output_path, "doesn't exist"
+            end
+            return
+          end
+          
+          output_content = File.open(full_output_path) { |f| f.read }
+          begin
+            template.pull output_content
+          rescue Rapid::NotMatchingTemplateError => e
+            exception output_path, e
+            return
+          end
+          
+          self[if_setting] = true if if_setting
+          ok output_path, "is good"
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rapid/skeleton/helpers/view.rb

@@ -0,0 +1,35 @@
+module Rapid
+  module Skeleton
+    module Helpers
+      
+      module View
+        
+        protected
+        
+        def view view_path
+          if pushing?
+            push_view view_path
+          elsif pulling?
+            pull_view view_path
+          end
+        end
+        
+        def push_view view_path
+          template_path   = File.join 'app', 'views', view_path
+          rapid_view_path = File.join 'lib', 'rapid', 'views', view_path
+          
+          push_template template_path, :to => rapid_view_path
+        end
+        
+        def pull_view view_path
+          template_path   = File.join 'app', 'views', view_path
+          rapid_view_path = File.join 'lib', 'rapid', 'views', view_path
+          
+          pull_template template_path, :to => rapid_view_path
+        end
+        
+      end
+      
+    end
+  end
+end