incodesert 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5ad6be7bdf06c9cba44bfad3b572459fd801874a
+  data.tar.gz: dc69f1f2234bdfb51e85d8468701c2f8fc70f0dc
+SHA512:
+  metadata.gz: 687a44dcbfcca68c7a8749008fc64e749b25363f26e8d4fbd9c45b9e62c4b0e0438f636d74e1b2f146d371004629525d3bce626648dbece53be921d3cc9208bd
+  data.tar.gz: 11ca8ea225c4a98d84185373ffb70e1f80577694675c1695172f0a72d13341efc8f460462c41d4eb6baa295b765c5167cda95c58f7b5a71b00508c9555d900a7

data/bin/incodesert

@@ -0,0 +1,131 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+require 'incodesert'
+
+def usage
+  puts <<EOF
+incodesert [flags] <source-file> <dest-file> [extractions-file]
+  incodesert inserts the code snippets found in the source file delimited 
+  by special comment blocks and replaces matching comment blocks in the 
+  destination file.  If the optional extractions-file is supplied, that 
+  file will contain the snippets of code removed from the destination 
+  file (useful for later reverting the dest file).
+  
+  Flag:
+    --help
+      Displays this message
+    --verbose
+      Provides diagnostics on stdout
+    --no-warn
+      By default, the replaced blocks in the destination will contain a 
+      warning comment that the code there was auto-inserted by incodesert.  
+      This flag suppresses that warning comment (most likely you would use 
+      this when reverting from an extractions file).
+    --no-bak
+      By default, a backup of the destination file is produced with a .bak 
+      suffix, just in case something goes horribly wrong.  This flag 
+      cleans up that file upon completion.
+    --classname <name>
+      By default, any occurance of the token __CLASSNAME__ in the source 
+      file is replaced with the camel cased version of the destination
+      filename (sans path and suffix).  If you want to override this 
+      behavior with an explicit classname, supply it here.
+EOF
+
+  abort
+end
+
+# Monkeypatch String to do camel casing.
+class String
+  def camel_case
+    return self if self !~ /_/ && self =~ /[A-Z]+.*/ 
+    split('_').map{|e| e.capitalize}.join
+  end
+end
+
+
+verbose = false
+no_warn = false
+no_bak = false
+classname = nil
+
+if ARGV.length < 1
+  usage
+end
+
+while ARGV[0] =~ /^--/
+  arg = ARGV.shift
+  if arg == "--help"
+    usage
+  elsif arg == "--verbose"
+    verbose = true
+  elsif arg == "--no-warn"
+    no_warn = true
+  elsif arg == "--no-bak"
+    no_bak = true
+  elsif arg == "--classname"
+    classname = ARGV.shift
+  else
+    warn "Unrecognized flag: #{arg}"
+    usage
+  end
+end
+
+if ARGV.length < 2 and ARGV.length > 3
+  usage
+end
+
+source_name = ARGV.shift
+dest_name = ARGV.shift
+extractions_name = ARGV.shift if ARGV.any?
+bak_name = dest_name + ".bak"
+
+unless classname
+  # Deduce the classname represented by the dest file
+  # First strip off the path before the filename
+  classname = dest_name.sub(/\.\w+$/, "")
+  # Then strip off the suffix
+  classname = classname.sub(/^.*\//, "")
+
+  classname = classname.camel_case
+end
+
+source = File.open(source_name).read
+# Protect against goofy carriage returns on non-unix systems
+source.gsub!(/\r\n?/, "\n")
+
+FileUtils.cp(dest_name, bak_name)
+destination = File.open(bak_name).read
+# Protect against goofy carriage returns on non-unix systems
+destination.gsub!(/\r\n?/, "\n")
+
+documents = Incodesert::Documents.new(source, destination)
+documents.verbose = verbose
+documents.no_warn = no_warn
+documents.source_name = source_name
+
+documents.replacements["CLASSNAME"] = classname
+
+# Enough setup, let's light this candle!
+documents.perform_insertions!
+
+# Spew any warnings that came up (usually mismatched token names)
+warn documents.warnings
+
+File.open(dest_name, "w") do |file|
+  file.print documents.destination
+end
+
+if extractions_name
+  File.open(extractions_name, "w") do |file|
+    file.print documents.extractions
+  end
+end
+
+if no_bak
+  FileUtils.rm(bak_name)
+end
+
+# All done!
+

data/lib/incodesert.rb

@@ -0,0 +1,5 @@
+module Incodesert
+  VERSION = "0.1.0"
+end
+
+require 'incodesert/documents'

data/lib/incodesert/documents.rb

@@ -0,0 +1,216 @@
+module Incodesert
+  
+  # Documents holds all three documents involved in an incodesert insertion.
+  # Those three documents are:
+  # * The source:  A String holding the blocks to be inserted delimited by special 
+  #   comments.
+  # * The destination:  A String to receive the insertions that contains insertion 
+  #   points delimited by the same comments as appear in the source.
+  # * The extractions:  A String of all the blocks that were removed in the destination
+  #   in order to be replaced by the source.  This can be useful to revert the changes.
+  #
+  # Documents also performs the insertion upon calling +perform_insertions!+
+  # 
+  # Author:: Kirk Bowers (mailto:kirkbowers@yahoo.com)
+  # Copyright:: Copyright (c) 2015 Kirk Bowers
+  # License:: MIT License
+  class Documents
+    
+    attr_accessor :source
+    attr_accessor :destination
+    attr_reader   :extractions
+    attr_reader   :warnings
+    
+    attr_accessor :replacements
+        
+    attr_accessor :verbose
+    attr_accessor :no_warn
+    attr_accessor :source_name
+
+    def initialize(source = "", destination = "")
+      @source = source
+      @destination = destination
+      @extractions = []
+      @warnings = []
+
+      @replacements = {}      
+      
+      @verbose = false
+      @no_warn = false
+      @source_name = nil
+    end
+    
+    # Shadow global warn function
+    def warn(message)
+      @warnings.push message
+    end
+    
+    def perform_insertions!
+      process_source
+      
+      process_destination
+      
+      @destination = @destination.join("\n")
+      @extractions = @extractions.join("\n")
+      # Add an extra newline to extractions so it doesn't end without one if non-empty
+      @extractions += "\n" if @extractions != ""
+      
+      @warnings = @warnings.join("\n")
+      @warnings += "\n" if @warnings != ""
+    end
+    
+    #-----------------------------------------------------------
+    private
+    
+    def process_source
+      @blocks = {}
+      @current_block_name = ""
+      
+      # The "-1" is an unintuitive way of saying don't trim off trailing newlines.
+      # We want to preserve the source exactly.
+      lines = @source.split("\n", -1)
+      
+      lines.each do |line|
+        # If we match either a C-style or script style comment, exactly 3 < (in) chars,
+        # one or more spaces, then anything as a token (even including spaces)
+        # that opens a source block
+        if line =~ /^(\s*(\/{2}|#))\s+<{3}\s+(.+)/
+          open_source_block(line, $1, $3)
+        # Similarly, match a comment, exactly 3 > (out) chars, and a token,
+        # close the block
+        elsif line =~ /^\s*(\/{2}|#)\s+>{3}\s+(.+)/
+          close_source_block(line, $2)
+        # If we are in a current block, remember this line
+        elsif @current_block_name != ""
+          @current_block.push(line)
+        end
+      end
+    end
+      
+    def open_source_block(line, comment, name)
+      name = name.rstrip
+      puts "Source:  open block: #{name}" if @verbose
+      @current_block_name = name
+      @current_block = [line]
+      unless @no_warn
+        @current_block.push("#{comment}")
+        @current_block.push("#{comment} WARNING!!! This code auto-inserted by incodesert")
+        @current_block.push("#{comment} Do not edit this block!")
+        if @source_name
+          @current_block.push("#{comment} If you need to make changes, edit the source: #{@source_name}")
+        end
+      end
+    end
+    
+    def close_source_block(line, name)
+      name = name.rstrip
+      puts "Source: close block: #{name}" if @verbose
+      if name == @current_block_name
+        @current_block.push(line)
+        @blocks[name] = @current_block
+      else
+        warn "In source: open and close blocks do not match!!"
+        warn "Opened with #{@current_block_name}"
+        warn "Closed with #{name}"
+      end
+
+      # Either way, we've attempted to close a block, so clear the current block name
+      # to signify we are not currently in a block at all.
+      @current_block_name = ""
+    end
+    
+    
+    def process_destination  
+      @current_block_name = ""
+      @extractions = []
+      
+      lines = @destination.split("\n", -1)
+
+      # We're going to rebuild the destination from scratch now
+      @destination = []
+      
+      lines.each do |line|
+        if line =~ /^\s*(\/{2}|#)\s+<{3}\s+(.+)/
+          open_destination_block(line, $2)
+        elsif line =~ /^\s*(\/{2}|#)\s+>{3}\s+(.+)/
+          close_destination_block(line, $2)
+        elsif @current_block_name != ""
+          @current_block.push(line)
+        else
+          @destination.push(line)
+        end
+      end      
+    end
+    
+    def open_destination_block(line, name)
+      name = name.rstrip
+      puts "Destination:  open block: #{name}" if @verbose
+      @current_block_name = name
+      @current_block = [line]
+    end
+    
+    def close_destination_block(in_line, name)
+      name = name.rstrip
+      puts "Destination: close block: #{name}" if @verbose
+
+      @current_block.push(in_line)
+
+      if name == @current_block_name
+        lines_to_insert = @blocks[name]
+        
+        if lines_to_insert.nil?
+          # There was no such block in the source
+          # We need to leave this block as is in the destination
+          @destination.concat(@current_block)
+        else
+          puts "Destination: matched block from source, replacing" if @verbose
+          lines_to_insert.each do |line|
+            result = ""
+            # This nasty bit of logic lets us scan through each line to insert and
+            # see if have any __ delimited tokens to possibly replace.
+            # Some languages, like ruby and python, do have variables with names that
+            # match this pattern.  Our tokens here are all caps, so there's very little
+            # chance of a clash.  Any __ surrounded thing we see but don't recognize
+            # should be left as is.  Otherwise we replace.
+            while line.length > 0
+              match = /(__(\w+)__)/.match(line)
+              if match
+                replacement = @replacements[match[2]]
+                if replacement
+                  result += match.pre_match + replacement
+                else
+                  # There's probably a cleaner way to do this, but it works.
+                  result += match.pre_match + match[1]
+                end
+                # Advance the part of the line we're looking at
+                line = match.post_match
+              else
+                # No match, consume all that's left
+                result += line
+                line = ""
+              end
+            end
+            
+            @destination.push(result)
+          end
+          
+          # Preserve the replaced block
+          @extractions.concat(@current_block)
+        end
+      
+      else
+        # Pass the current block through unmodified
+        @destination.concat(@current_block)
+      
+        warn "In Destination: open and close blocks do not match!!"
+        warn "Opened with #{@current_block_name}"
+        warn "Closed with #{name}"
+      end
+
+      # Either way, we've attempted to close a block, so clear the current block name
+      # to signify we are not currently in a block at all.
+      @current_block_name = ""      
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,85 @@
+--- !ruby/object:Gem::Specification
+name: incodesert
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Kirk Bowers
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: hoe
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.13'
+description: "code insert\n    code in      sert\n         in code sert\n         incodesert\n\n+incodesert+
+  (pronounced \"in code sert\", not \"inco desert\") \nis a utility for inserting
+  code snippets from one file into another.\nIt was originally intended to facilitate
+  autogenerating code and interlacing that\nautogened code with hand written code.
+  \ It is also useful for performing\nPre-rolled Blackbox Testing."
+email:
+- kirkbowers@yahoo.com
+executables:
+- incodesert
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gemtest"
+- bin/incodesert
+- lib/incodesert.rb
+- lib/incodesert/documents.rb
+homepage: https://github.com/kirkbowers/incodesert
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--main"
+- README.txt
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: code insert code in      sert in code sert incodesert  +incodesert+ (pronounced
+  "in code sert", not "inco desert")  is a utility for inserting code snippets from
+  one file into another
+test_files: []