codestrap 0.1.0

data/lib/codestrap/server/version.rb

@@ -0,0 +1,5 @@
+module Codestrap
+  module Server
+    VERSION = '1.0'
+  end
+end

data/lib/codestrap/strap/abstract.rb

@@ -0,0 +1,135 @@
+require 'codestrap/mixin'
+require 'tmpdir'
+
+module Codestrap
+  module Strap
+    # @abstract
+    #
+    # Boilerplate renderer class
+    #
+    # Methods (aliased to #abstract) that require overriding
+    #
+    #   #pre
+    #
+    # Pre execution
+    #
+    #   #execute
+    #
+    # Render execution
+    #
+    # Methods that may be overridden
+    #
+    #   #post
+    #
+    class Abstract
+      include Codestrap::Mixin::Exceptions::Template
+
+      # Objects utilized in templates
+      # @!attribute [rw] objects
+      # @return [Codestrap::Object::Factory]
+      attr_accessor :objects
+
+      # List of files to ignore
+      # @!attribute [rw] ignore
+      # @return [Array]
+      attr_accessor :ignore
+
+      # List methods aliased to Codestrap::Template::Abstract#abstract
+      # @return [Array]
+      def self.abstract_methods
+        instance_methods.group_by { |m| instance_method(m) }.map(&:last).keep_if { |sym| sym.length > 1 }.map { |methods|
+          if methods.include?('abstract'.to_sym)
+            return methods.map { |method| method.to_s }.select { |method| method != 'abstract' }
+          end
+        }
+        []
+      end
+
+      # Path to project
+      # @!attribute [r] src
+      # @return [String]
+      attr_reader :src
+
+      # Path to destination file
+      # @!attribute [r] dst
+      # @return [String]
+      attr_reader :dst
+
+      # Allow overwrite of files
+      # @!attribute [rw] overwrite
+      # @return [true|false]
+      attr_accessor :overwrite
+
+      # Check overwrite attribute
+      # @return [true|false]
+      def overwrite?
+        !!@overwrite
+      end
+
+      # Set source project
+      #
+      # @param [String] src
+      #   Path to source directory
+      def src=(src)
+        raise Exception, %q[File doesn't exist] unless File.exist?(src)
+        @src = src
+      end
+
+      # Set destination project
+      #
+      # @param [String] dst
+      #   Path to destination directory
+      def dst=(dst)
+        if !overwrite? and File.exist? dst
+          Codestrap::Core.logger.error(:FILEEXISTS, dst)
+          exit 255
+        end
+        unless File.exist?(File.dirname(dst))
+          Codestrap::Core.logger.error(:NOPATH, dst)
+          exit 255
+        end
+        @dst = dst
+      end
+
+      # Abstract class. Raise error on instantiation
+      def initialize
+        raise RendererAbstractOnly, 'Abstract Class Requires implementation'
+      end
+
+      # @abstract
+      # Method(s) aliased to this method are considered abstract
+      # @raise [RendererRequiredMethod]
+      #   Raise an error if a method remains aliased to this method
+      def abstract
+        raise RendererRequiredMethod, "Method #{__method__.to_s} not implemented"
+      end
+
+      # Pre execution abstract method
+      alias :pre :abstract
+
+      # Execution abstract method
+      alias :execute :abstract
+
+      # Post execution method
+      def post
+      end
+
+      # Creates and returns path to working directory
+      #
+      # @return [Dir]
+      def working_dir
+        @working_dir ||= Dir.new(Dir.mktmpdir('strap'))
+      end
+
+      # Moves #working_dir contents to #dst
+      #
+      # @return [Integer]
+      #   Returns 0 on success
+      def to_disk
+        FileUtils.mv self.working_dir.path, self.dst
+      end
+
+      alias_method :file, :working_dir
+    end
+  end
+end

data/lib/codestrap/strap/factory.rb

@@ -0,0 +1,85 @@
+require 'codestrap/mixin'
+
+module Codestrap
+  module Strap
+    # Factory for instantiating classes from the Codestrap::Strap namespace
+    class Factory
+      include Codestrap::Mixin::Exceptions::Factory
+
+      attr_reader :klass
+
+      # Factory constructor for Codestrap::Template::* Classes
+      #
+      # @param [Class, Symbol, String] nklass
+      # @return [Codestrap::Stub::Factory]
+      def initialize(nklass)
+        self.klass = nklass
+        enforce_methods
+        ensure_required
+      end
+
+      # Constructor for Codestrap::Strap::* Classes
+      #
+      # @param [Array] args
+      #   Arguments to pass to constructor of child object
+      # @return [Object]
+      #   Return the object as specified Factory#klass.new(args)
+      def construct(*args)
+        self.klass.new(args)
+      end
+
+      # Dynamic Class creation.
+      # Looks for Classes in Codestrap::Strap::NKLASS
+      #
+      # @param [String|Symbol] nklass
+      #   Look for Codestrap::Template::nklass
+      # @raise [FactoryArgumentError]
+      #   Raised if nklass is not type String or type Symbol
+      # @return [Codestrap::Stub::KLASS]
+      #   Return class Codestrap::Template::KLASS
+      def to_class nklass
+        case
+          when nklass.is_a?(Symbol)
+            klass = nklass.to_s
+          when nklass.is_a?(String)
+            klass = nklass
+          else
+            raise ArgumentError, %Q(Could not find Class Codestrap::Strap::#{nklass.to_s})
+        end
+        @klass = ['Codestrap', 'Strap', klass].reduce(Module, :const_get)
+        @klass
+      end
+
+      alias :klass= :to_class
+
+      # Ensure self.klass has the following methods
+      #
+      #   klass.pre
+      #   klass.execute
+      #
+      # Inherited from Codestrap::Template::Factory
+      #   klass.file
+      #   klass.finalize
+      #
+      # @raise [FactoryMethodEnforcement]
+      #   Raised if a enforced method doesn't exist in the child
+      # @return [TrueClass, FalseClass]
+      def enforce_methods
+        [:pre, :execute, :overwrite, :overwrite=, :working_dir, :to_disk].each do |method|
+          next if @klass.method_defined? method
+          raise FactoryException, "Error missing method #{@klass.to_s}##{method}"
+        end
+      end
+
+      # Ensures any methods aliased to abstract_method are overridden
+      # @raise [FactoryAbstractMethod]
+      #   Raised if a abstract method (A method aliased to abstract_method), is not created in the child
+      def ensure_required
+        if @klass.abstract_methods.length > 0
+          methods = @klass.abstract_methods.map{ |method| "#{@klass.to_s}##{method}" }
+          raise FactoryException, "Abstract Method(s) #{methods.join(', ')} not overridden"
+        end
+      end
+    end
+  end
+end

data/lib/codestrap/strap/standard.rb

@@ -0,0 +1,95 @@
+require 'erb'
+require 'find'
+require 'fileutils'
+require 'ostruct'
+require 'codestrap/namespace'
+require 'codestrap/patch'
+require 'codestrap/strap/abstract'
+require 'ptools'
+require 'tmpdir'
+
+module Codestrap
+  module Strap
+    # Standard project renderer
+    #
+    class Standard < Abstract
+
+      def initialize(*args)
+        self.working_dir
+      end
+
+      def pre
+        @compiled ||= []
+
+        # Take ignored array from Codestrap.config
+        ignore_hash = {}
+        Array(self.ignore).each do |ignore|
+          ignore_hash[ignore] = true
+        end
+        Find.find(self.src) do |src|
+          # Ignore files
+          if ignore_hash.has_key? File.basename(src)
+            Find.prune
+          end
+
+          proj_path = String(src.gsub(/^#{Regexp.escape(self.src)}/, ''))
+
+          # Destination path substitutions
+          proj_path =~ /:(?:stub|strap):(.+?):/
+          object      = $1
+          replacement = proj_path.gsub(/:(?:stub|strap):.+?:/, "<%= #{object} %>")
+          if proj_path != replacement
+            # Regex replacement
+            ns        = Codestrap::Namespace.new(self.objects.objects)
+            erb       = ERB.new(replacement)
+            proj_path = erb.result(ns.get_binding)
+          end
+
+          dst = File.join(self.working_dir, proj_path)
+
+          # Directories
+          if File.directory? src
+            @compiled.push({file: proj_path, src: src, dst: dst, type: :dir})
+            next
+          end
+
+          # Files
+          file = Codestrap::Patch::File.new src
+          if file.stat.file?
+            # Read modeline
+            if not File.binary?(src) and file.has_mode_line?
+              # Templates
+              @compiled.push({file: proj_path, src: src, dst: dst, type: file.template})
+            else
+              # Files
+              @compiled.push({file: proj_path, src: src, dst: dst, type: :regular})
+            end
+            next
+          end
+        end
+      end
+
+      def execute
+        @compiled.each do |obj|
+          case obj[:type]
+            when :dir
+              FileUtils.mkpath obj[:dst]
+            when :regular
+              FileUtils.install obj[:src], obj[:dst]
+            when :erb
+              renderer         = Codestrap::Stub::Factory.new('Standard').construct
+              renderer.objects = self.objects
+              renderer.src     = obj[:src]
+              renderer.dst     = obj[:dst]
+              renderer.pre
+              renderer.execute
+              renderer.post
+              renderer.to_disk
+            else
+              raise Exception, "Unknown type: #{obj[:type].to_s}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/codestrap/stub/abstract.rb

@@ -0,0 +1,156 @@
+require 'singleton'
+require 'ostruct'
+require 'erb'
+require 'codestrap/mixin'
+require 'tempfile'
+
+module Codestrap
+  module Stub
+    # @abstract
+    #
+    # Template renderer class
+    #
+    # Methods (aliased to #abstract) that require overriding
+    #
+    #   #pre
+    #
+    # Pre execution
+    #
+    #   #execute
+    #
+    # Render execution
+    #
+    # Methods that may be overridden
+    #
+    #   #post
+    #
+    class Abstract
+      include Codestrap::Mixin::Exceptions::Template
+
+      # Objects utilized in templates
+      # @!attribute [rw] objects
+      # @return [Array<Codestrap::Object::Factory>]
+      attr_accessor :objects
+
+      # List methods aliased Codestrap::Template::Abstract#abstract
+      # @return [Array]
+      def self.abstract_methods
+        instance_methods.group_by { |m| instance_method(m) }.map(&:last).keep_if { |sym| sym.length > 1 }.map { |methods|
+          if methods.include?('abstract'.to_sym)
+            return methods.map { |method| method.to_s }.select { |method| method != 'abstract' }
+          end
+        }
+        []
+      end
+
+      # Set file object
+      # @!attribute [w] file
+      # @return [File]
+      attr_writer :file
+
+      # Path to template
+      # @!attribute [r] src
+      # @return [String]
+      attr_reader :src
+
+      # Path to destination project
+      # @!attribute [r] dst
+      # @return [String]
+      attr_reader :dst
+
+      # Allow overwriting of files
+      # @!attribute [rw] overwrite
+      # @return [true|false]
+      attr_accessor :overwrite
+
+      # Check overwrite attribute
+      # @return [true|false]
+      def overwrite?
+        !!@overwite
+      end
+
+      # Set source template
+      #
+      # @param [String] src
+      #   Path to source file
+      def src=(src)
+        raise Exception, %q[File doesn't exist] unless File.exist?(src)
+        @src = src
+      end
+
+      # Set destination file
+      #
+      # @param [String] dst
+      #   Path to destination file
+      def dst=(dst)
+        if !overwrite? and File.exist? dst
+          Codestrap::Core.logger.error(:FILEEXISTS, dst)
+          exit 255
+        end
+        unless File.exist?(File.dirname(dst))
+          Codestrap::Core.logger.error(:NOPATH, dst)
+          exit 255
+        end
+        @dst = dst
+      end
+
+      # Abstract class. Raise error on instantiation
+      def initialize()
+        raise RendererAbstractOnly, 'Abstract Class Requires implementation'
+      end
+
+      # @abstract
+      # Method(s) aliased to this method are considered abstract
+      # @raise [RendererRequiredMethod]
+      #   Raise an error if a method remains aliased to this method
+      def abstract
+        raise RendererRequiredMethod, "Method #{__method__.to_s} not implemented"
+      end
+
+      # Pre execution method
+      alias :pre :abstract
+
+      # Execution method
+      alias :execute :abstract
+
+      # Post execution method
+      def post
+      end
+
+      # Creates and returns Tempfile to working file
+      #
+      # @return [Tempfile]
+      #   Path to temporary file
+      def file
+        @file ||= Tempfile.new('codestrap')
+      end
+
+      # Moves #file contents to #dst
+      #
+      # @return [Integer]
+      #   Returns 0 on success
+      def to_disk
+        @file.close
+        tmp = open(@file.path)
+        final = Tempfile.new('codestrap')
+        strip_modeline(tmp, final)
+
+        tmp.close
+        File.unlink(@file.path)
+        final.close(unlink_now = false)
+
+        FileUtils.mv final.path, self.dst
+      end
+
+      private
+
+      def strip_modeline(src, dst, line_count=10)
+        i = 0
+        src.each_line do |line|
+          i += 1
+          dst.write(line) unless line =~ /(?:\b|^)(?:strap|stub):(?:erb|)(?:\b|$)/ and i <= line_count
+        end
+      end
+    end
+  end
+end