inmake 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: c37126d894a3decaab96aee33fd26d3ee070ce37
+  data.tar.gz: ede65f7ae76d41696c33b3be97f0b3fdc53b12b2
+SHA512:
+  metadata.gz: bee4047a60a0f4e645fedc5554090fa9e46de37abb9a422413253f5b950aa5dc2bc86e237f6f404a6a872599053fb5073bea1209f1f4ff098cafd8e6e174f9a7
+  data.tar.gz: add2a6a9c6baaaf90f5901469657cc84d8ddaa7a2afb835bf76f22c3029664f698d94035fb3561713d454d83c11e74554adce77f1decdb0b884e554298cb724d

data/bin/inmake

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+
+require 'inmake'
+
+
+begin
+  # Generate a config from command-line arguments and resolve all files to 
+  # absolute paths
+  cfg = Inmake::Config.fromArguments
+  cfg = Inmake::Config.resolveFiles cfg
+
+  # Run inmake on all files found
+  runner = Inmake::Runner.new cfg
+
+  runner.run
+rescue Inmake::NoFilesGiven => e
+  abort e.message
+rescue Inmake::InvalidDirMode => e
+  abort e.message
+rescue Inmake::InvalidVarDefinition => e
+  abort e.message
+rescue Inmake::MultipleModeException => e
+  abort e.message
+rescue Inmake::CommandNotFound => e
+  abort e.message
+end

data/lib/inmake/config.rb

@@ -0,0 +1,184 @@
+#!/usr/bin/env ruby
+# echo hi from Inmake::Config!
+require 'inmake/version'
+module Inmake
+
+  ##
+  # Stores inmake configuration options.
+  # 
+  class Config
+    attr_reader :dirMode, :searchMode, :searchArgument, :stripMatched, 
+                :variables, :files, :variablesDisabled, :ignoreNonmatches
+    attr_writer :variables, :files
+    def initialize opts
+      # How we treat directories that have been passed to the file list.
+      # Possible values are :acceptDirs, :ignoreDirs
+      # :acceptDirs => directories are accepted and recursed into
+      # :ignoreDirs => directories are ignored
+      @dirMode = opts[:dirMode]
+      # A list of all the files that inmake will act on.
+      # This may include directories or relative paths.
+      @files = opts[:files]
+      # How inmake looks for the build command inside the file. Possible values
+      # are :prefix, :suffix, :regex, :secondLine
+      # :prefix => search each line start for a prefix 
+      # :suffix => search each line ending for a suffix
+      # :regex  => search each line via an actual regex
+      # :secondLine => use the second line (or third if the second looks like an
+      #                encoding line like Python)
+      @searchMode = opts[:searchMode]
+      # An additional argument to specify the thing that the search mode uses
+      # to look for the build command. AKA, the actual prefix string or suffix
+      # string or the regex object.
+      @searchArgument = opts[:searchArgument]
+      # Do we strip all found parts of the regex from the build command?
+      @stripMatched = opts[:stripMatched]
+      # Hash of variables that can be replaced in the build command
+      @variables = opts[:variables]
+      # Are variables disabled overall? Even the builtins that is...
+      @variablesDisabled = opts[:variablesDisabled]
+      # Do we stop when a file didn't have a command inside?
+      @ignoreNonmatches = opts[:ignoreNonmatches]
+    end
+
+    def self.fromArguments
+      require 'optparse'
+      
+      opts = {}
+      opts[:files] = []
+      opts[:variables] = {}
+
+      # Parse special arguments
+      OptionParser.new do |parser|
+        parser.banner = INMAKE_BANNER
+
+        parser.on('-f', '--file FILENAME', 'Specify a target file.') do |filename|
+          opts[:files] << filename
+        end
+
+        parser.on('-p', '--prefix PREFIX', 'Find the build command by a prefix.') do |prefix|
+          unless opts[:searchMode]
+            opts[:searchMode] = :prefix
+            opts[:searchArgument] = prefix
+          else
+            raise MultipleModeException, "Multiple search mode definitions!"
+          end
+        end
+
+        parser.on('-s', '--suffix SUFFIX', 'Find the build command by a suffix.') do |suffix|
+          unless opts[:searchMode]
+            opts[:searchMode] = :suffix
+            opts[:searchArgument] = suffix
+          else
+            raise MultipleModeException, "Multiple search mode definitions!"
+          end
+        end
+
+        
+        okDirModes = [:acceptDirs, :ignoreDirs]
+        parser.on('-d', '--dir-mode MODE', "Define behavior when dealing with a directory. (default: acceptDirs) Accepted values are: #{okDirModes.join ', '}") do |dm|
+          dm = dm.to_sym
+          raise InvalidDirMode, "Not a valid directory mode: #{dm}" unless okDirModes.include? dm 
+          opts[:dirMode] = dm
+        end
+
+        parser.on('-x', '--regex REGEX', 'Specify a regular expression to match the build command.') do |rx|
+          unless opts[:searchMode]
+            re = Regexp.compile rx
+            opts[:searchMode] = :regex
+            opts[:searchArgument] = re
+          else
+            raise MultipleModeException, "Multiple search mode definitions!"
+          end
+        end
+
+        parser.on('--[no-]strip-matched', 'Strip all found matches on a regex search (default: false)') do |f|
+          opts[:stripMatched] = f
+        end
+
+        parser.on('--[no-]ignore-nonmatched', 'Silently continue if a file does not seem to have a build command (default: true)') do |f|
+          opts[:ignoreNonmatches] = f
+        end
+
+        parser.on('--no-vars', 'Disable all replacement variables, even the builtin ones (default: false)') do |v|
+          opts[:variablesDisabled] = v
+        end
+
+        parser.on('-a', '--add-var KEY=VALUE', 'Add a replacement from {{KEY}} (always allcaps!) to VALUE, much like a C preprocessor definition') do |var|
+          key, value = var.split '='
+          raise InvalidVarDefinition, "Invalid variable definition syntax: `#{var}`" unless key and value
+
+          opts[:variables][key.upcase] = value
+        end
+
+      end.parse!
+
+      # any arguments that weren't flags are just treated as file names
+      unless ARGV.empty?
+        opts[:files].concat ARGV
+      end
+
+      # The default search mode is to find the build command on the second line of 
+      # the source code.
+      opts[:searchMode] ||= :secondLine 
+
+      # The default file mode means that if a directory is encountered, we recurse
+      # on all its files.
+      opts[:dirMode] ||= :acceptDirs 
+
+      # Variables are enabled by default.
+      opts[:variablesDisabled] ||= false
+
+      # By default, we do not strip the matched string.
+      opts[:stripMatched] ||= false
+
+      opts[:ignoreNonmatched] = true unless defined? opts[:ignoreNonmatched]
+      
+      # Can't run without ANY files...
+      raise NoFilesGiven, "No input files specified! Use #{$0} --help for how to add input files." if opts[:files].empty?
+
+      # return a new Config object
+      return Config.new opts
+    end
+
+
+    def self.resolveFiles cfg
+      newFiles = []
+      cfg.files.each do |f|
+        if File.exist? f 
+          if File.file? f
+            newFiles << f
+          elsif File.directory? f and cfg.dirMode == :acceptDirs
+            newFiles.concat Dir[File.join(f, '**/*.*')].select {|x| File.file? x }
+          end
+        end
+      end
+
+      cfg.files = newFiles.map { |x| File.expand_path x }
+      cfg
+    end
+  end
+
+  ##
+  # Multiple search modes were defined when reading definitions from the
+  # command line (eg regex and prefix at the same time)
+  class MultipleModeException < StandardError; end
+  ##
+  # A variable was defined with wrong syntax when on the command line!
+  # (not something=something)
+  class InvalidVarDefinition < StandardError; end
+  ##
+  # No files added
+  class NoFilesGiven < StandardError; end
+  ## 
+  # The directory handling mode was invalid!
+  class InvalidDirMode < StandardError; end
+end
+
+INMAKE_BANNER = <<-EOF
+inmake v#{Inmake::VERSION} - the inline build command runner
+Runs commands directly embedded inside your source code. 
+Usage: #{$0} [options...] [files]
+Options:
+
+EOF

data/lib/inmake/runner.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/env ruby
+# echo Hi from Inmake::Runner!
+module Inmake
+  ##  
+  # = Inmake Command Runner
+  # 
+  # Finds and runs the commands inside all of the files.
+  # The same search mode is used for every file.
+  class Runner
+
+    # Set up a runner with a configuration object defined earlier.
+    def initialize cfg
+      @config = cfg
+    end
+
+    # Run inmake on each of the files defined in the configuration
+    def run
+      @config.files.each do |x| 
+        begin 
+          dispatch x 
+        rescue CommandNotFound => e
+          raise unless @config.ignoreNonmatches
+        end
+      end
+    end
+    
+    # Find and run a command in a given file, depending on the search mode
+    def dispatch file
+      File.open(file) do |fd|
+        fd.flock File::LOCK_EX
+        if @config.searchMode == :prefix
+          runPrefix fd
+        elsif @config.searchMode == :suffix
+          runSuffix fd
+        elsif @config.searchMode == :regex
+          runRegex fd
+        elsif @config.searchMode == :secondLine
+          runSecondLine fd
+        end
+      end
+    end
+
+    # Apply variables and then run the found build command
+    def applyCommand cmd, fd
+      
+      unless @config.variablesDisabled
+        @config.variables.each do |k, v|
+          cmd.gsub! '{{'+k.to_s+'}}', v
+        end
+
+        cmd.gsub! '{{f}}', fd.path
+        cmd.gsub! '{{bn}}', File.basename(fd.path)
+        cmd.gsub! '{{bn1}}', File.basename(fd.path, '.*')
+        cmd.gsub! '{{ext}}', File.extname(fd.path)
+        cmd.gsub! '{{dn}}', File.dirname(fd.path)
+        st = fd.stat
+        cmd.gsub! '{{mode}}', st.mode.to_s
+        cmd.gsub! '{{mtime}}', st.mtime.to_i.to_s
+        cmd.gsub! '{{ctime}}', st.ctime.to_i.to_s
+        cmd.gsub! '{{size}}', st.size.to_s
+      end
+      fd.flock File::LOCK_UN
+      system cmd
+      puts cmd
+    end
+
+    # Find a given prefix in a file and apply the build command on match
+    def runPrefix fd
+      rx = /^\s*#{Regexp.escape @config.searchArgument}\s*/
+      command = fd.each_line.detect do |line|
+        rx.match line
+      end
+      raise CommandNotFound, "Did not find a prefixed command in file `#{fd.path}`" unless command
+      command.gsub!(rx, '')
+
+      applyCommand command, fd
+    end
+
+    # Find a given suffix in a file and apply the build command when matched
+    # Raises CommandNotFound if no command was found in a file
+    def runSuffix fd
+      rx = /#{Regexp.escape @config.searchArgument}\s*$/
+      command = fd.each_line.detect do |line|
+        rx.match line
+      end
+      raise CommandNotFound, "Did not find a suffixed command in file `#{fd.path}`" unless command
+      command.gsub!(rx, '') if @config.stripMatched
+
+      applyCommand command, fd
+    end
+
+    # Find a given regex in a file and apply the build command when matched
+    # Raises CommandNotFound if no command was found in a file
+    def runRegex fd
+      rx = @config.searchArgument
+      command = fd.each_line.detect do |line|
+        rx.match line
+      end
+      raise CommandNotFound, "Did not find a regex-ed command in file `#{fd.path}`" unless command
+      command.gsub!(rx, '') if @config.stripMatched
+
+      applyCommand command, fd
+    end
+
+    # Run the second line of code. This is the default option.
+    def runSecondLine fd
+      isEncodingLine = /coding[:=]\s*([-\w.]+)/
+      fd.gets
+      secondLine = fd.gets
+
+      raise CommandNotFound, "There wasn't enough data in the file `#{fd.path}` for two lines!" if $_.nil?
+
+      if isEncodingLine =~ secondLine
+        secondLine = fd.gets
+        raise CommandNotFound, "There wasn't enough data in the file `#{fd.path}` for three lines!" if $_.nil?
+      end
+
+      # Strip stuff until the first whitespace
+      command = secondLine[(secondLine =~ /\s/)...secondLine.length].strip
+
+      applyCommand command, fd
+    end
+  end
+  class CommandNotFound < StandardError; end
+end

data/lib/inmake.rb

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+# echo Hi from inmake.rb!
+require 'inmake/config'
+require 'inmake/runner'

metadata

@@ -0,0 +1,48 @@
+--- !ruby/object:Gem::Specification
+name: inmake
+version: !ruby/object:Gem::Version
+  version: 2.0.0
+platform: ruby
+authors:
+- boxmein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-07-06 00:00:00.000000000 Z
+dependencies: []
+description: Inline build command runner for any kind of projects.
+email: boxmein@boxmein.net
+executables:
+- inmake
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/inmake
+- lib/inmake.rb
+- lib/inmake/config.rb
+- lib/inmake/runner.rb
+homepage: https://github.com/boxmein/inmake
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.1
+signing_key: 
+specification_version: 4
+summary: Inline Build Commands
+test_files: []