netlinx-compile 1.0.0 → 3.1.2

data/lib/netlinx-compile.rb

@@ -1 +1,11 @@
-require 'netlinx/compiler'
+require 'netlinx/compiler'
+
+# :nodoc:
+module NetLinx
+  # :nodoc:
+  module Compile
+    # :nodoc:
+    module Extension
+    end
+  end
+end

data/lib/netlinx/compile/extension_discovery.rb

@@ -43,7 +43,7 @@ module NetLinx
             .select{|c| not c.nil?}
         end
         
-        # Returns an array of workspace file extensions.
+        # @return [Array<String>] workspace file extensions.
         def workspace_extensions
           @handlers
             .select{|h| h.is_a_workspace?}
@@ -51,7 +51,9 @@ module NetLinx
             .flatten
         end
         
-        # Get an ExtensionHandler for a given file or extension.
+        # @param filename [String] File or extension to find a
+        #   {NetLinx::Compile::ExtensionHandler} for.
+        # @return [ExtensionHandler]
         def get_handler(filename)
           @handlers.select{|h| h.include? filename}.first
         end

data/lib/netlinx/compile/extension_handler.rb

@@ -15,30 +15,28 @@ module NetLinx
       # in this ExtensionHandler.
       attr_reader :handler_class
       
-      # Parameters:
-      #   extensions: An array of file extensions (without the leading dot)
-      #               that this ExtensionHandler supports.
+      # @option kwargs [Array<String>] :extensions File extensions (without the
+      #   leading dot) that this ExtensionHandler supports.
       #
-      #   usurps:     Future.
-      #               Lets this ExtensionHandler take priority over other
-      #               ones. For example, most third-party handlers would
-      #               probably usurp the .apw NetLinx Studio workspace
-      #               extension.
+      # @option kwargs [Array<String>] :usurps Future.
+      #   Lets this ExtensionHandler take priority over other ones. For example,
+      #   most third-party handlers would probably usurp the .apw NetLinx Studio
+      #   workspace extension.
       #
-      #   is_a_workspace: Set to true if this ExtensionHandler is for
-      #               compiling a workspace. False by default. This
-      #               parameter assists with smart compiling, as
-      #               ExtensionDiscovery can return all workspace_handlers.
+      # @option kwargs [Boolean] :is_a_workspace Set to true if this
+      #   ExtensionHandler is for compiling a workspace. False by default. This
+      #   parameter assists with smart compiling, as {ExtensionDiscovery} can
+      #   return all workspace_handlers.
       #
-      #   handler_class: A reference to the class that should be instantiated
-      #               if this handler is selected. For example,
-      #               NetLinx::SourceFile is the class that handles files
-      #               with the .axs extension.
-      def initialize(**kvargs)
-        @extensions     = kvargs.fetch :extensions,     []
-        @usurps         = kvargs.fetch :usurps,         []
-        @is_a_workspace = kvargs.fetch :is_a_workspace, false
-        @handler_class  = kvargs.fetch :handler_class,  nil
+      # @option kwargs [Extension] :handler_class A reference to the class that
+      #   should be instantiated if this handler is selected. For example,
+      #   {NetLinx::SourceFile} is the class that handles files with the .axs
+      #   extension.
+      def initialize(**kwargs)
+        @extensions     = kwargs.fetch :extensions,     []
+        @usurps         = kwargs.fetch :usurps,         []
+        @is_a_workspace = kwargs.fetch :is_a_workspace, false
+        @handler_class  = kwargs.fetch :handler_class,  nil
       end
       
       # Alias to add a file extension.
@@ -46,8 +44,8 @@ module NetLinx
         @extensions << parse_extension(file_extension)
       end
       
-      # Returns true if the ExtensionHandler handles a workspace file
-      # (as opposed to a source code file).
+      # @return [Boolean] true if the {ExtensionHandler} handles a workspace file
+      #   (as opposed to a source code file).
       #
       # Workspace files are significant because they contain information
       # about a project, connection settings for a master, and possibly
@@ -59,7 +57,7 @@ module NetLinx
         @is_a_workspace
       end
       
-      # Returns true if this ExtensionHandler can handle the specified
+      # Returns true if this {ExtensionHandler} can handle the specified
       # file extension.
       def include?(file_extension)
         @extensions.include? parse_extension(file_extension)
@@ -69,7 +67,7 @@ module NetLinx
       
       # Parse a file extension from the given string.
       #
-      # Examples:
+      # @example
       #   apw
       #   .apw
       #   workspace.apw

data/lib/netlinx/compile/script.rb

@@ -10,9 +10,10 @@ module NetLinx
       
       class << self
         # Run the script.
-        def run(**kvargs)
-          # :argv is a convenience to override ARGV, like for testing.
-          args = kvargs.fetch :argv, ARGV
+        # @option kwargs [Array<String>] :argv A convenience to override ARGV,
+        #   like for testing.
+        def run(**kwargs)
+          args = kwargs.fetch :argv, ARGV
 
           # Command line options.
           @options = OpenStruct.new \

data/lib/netlinx/compiler.rb

@@ -2,38 +2,54 @@ require 'netlinx/compiler_result'
 
 module NetLinx
   # Raised when the NetLinx compiler (nlrc.exe) cannot be found on the system.
-  # See NetLinx::Compiler.
+  # @see NetLinx::Compiler
   class NoCompilerError < Exception; end
   
   # A wrapper class for the AMX NetLinx compiler executable (nlrc.exe).
   class Compiler
     
     # Checks for the AMX NetLinx compiler (third-party software, nlrc.exe) at the
-    # default installation path. This can be overridden by specifying :compiler_path.
-    def initialize(**kvargs)
-      @compiler_exe = 'nlrc.exe'
+    # default installation path.
+    # 
+    # @option kwargs [String] :compiler_exe ('nlrc.exe')
+    # @option kwargs [String] :compiler_path Recommend a directory to look for
+    #   the compiler_exe.
+    # @option kwargs [String] :use_wine (false) Set to true to force `wine` at
+    #   the front of the compiler command. This is automatic if nlrc.exe is
+    #   installed at Wine's default Program Files path.
+    # @raise [NetLinx::NoCompilerError] Compiler not found.
+    def initialize(**kwargs)
+      @compiler_exe = kwargs.fetch :compiler_exe, 'nlrc.exe'
+      user_specified_path = kwargs.fetch :compiler_path, nil
+      @use_wine = kwargs.fetch :use_wine, false
       
-      @compiler_path = kvargs.fetch :compiler_path,
-        File.expand_path('C:\Program Files (x86)\Common Files\AMXShare\COM') # 64-bit O/S path
-        
-      # Check for NetLinx compiler at :compiler_path or the 64-bit O/S path.
-      unless File.exists? File.expand_path('nlrc.exe', @compiler_path)
-        # Compiler not found. Try 32-bit O/S path.
-        @compiler_path = File.expand_path('C:\Program Files\Common Files\AMXShare\COM')
-        unless File.exists? File.expand_path('nlrc.exe', @compiler_path)
-          # ---------------------------------------------------------
-          # TODO: Check if the compiler was added to the system path.
-          #       Execute system('nlrc').
-          # ---------------------------------------------------------
-          
-          # Compiler not found.
-          raise NetLinx::NoCompilerError, 'The NetLinx compiler (nlrc.exe) could not be found on the system.'
+      default_paths = [
+        user_specified_path,
+        'C:\Program Files (x86)\Common Files\AMXShare\COM', # 64-bit O/S path
+        'C:\Program Files\Common Files\AMXShare\COM',       # 32-bit O/S path
+        '~/.wine/drive_c/Program Files/Common Files/AMXShare/COM', # Wine path
+      ].compact
+      
+      # Check for NetLinx compiler.
+      default_paths.each do |path|
+        if File.exists? File.expand_path(@compiler_exe, path)
+          @compiler_path = path
+          break
         end
       end
+      
+      # ---------------------------------------------------------
+      # TODO: Check if the compiler was added to the system path.
+      #       Execute system(@compiler_exe).
+      # ---------------------------------------------------------
+      
+      # Compiler not found.
+      raise NetLinx::NoCompilerError, "The NetLinx compiler (#{@compiler_exe}) could not be found on the system." \
+        unless @compiler_path
     end
     
     # Compile the specified object with the NetLinx compiler.
-    # See Test::NetLinx::Compilable.
+    # @see Test::NetLinx::Compilable.
     def compile(compilable)
       compiler = File.expand_path @compiler_exe, @compiler_path
       result   = []
@@ -50,7 +66,15 @@ module NetLinx
           compilable.compiler_library_paths.empty?
         
         # Run the NetLinx compiler.
-        io = IO.popen "\"#{compiler}\" \"#{target_file}\" \"#{include_paths}\" \"#{module_paths}\" \"#{library_paths}\""
+        # Note: NLRC.exe v2.1 freaks out if empty arguments ("") are in the command.
+        cmd  = ''
+        cmd += 'wine ' if @use_wine or compiler.include? '/.wine/'
+        cmd += "\"#{compiler}\" \"#{target_file}\""
+        cmd += " \"#{include_paths}\"" if include_paths
+        cmd += " \"#{module_paths}\""  if module_paths
+        cmd += " \"#{library_paths}\"" if library_paths
+        
+        io = IO.popen cmd
         stream = io.read
         io.close
         

data/lib/netlinx/compiler_result.rb

@@ -19,19 +19,18 @@ module NetLinx
     # See Compilable interface.
     attr_reader :compiler_library_paths
     
-    # Args:
-    #  stream -- The raw stream of text returned by the compiler.
-    #  compiler_target_files  -- See Compilable interface.
-    #  compiler_include_paths -- See Compilable interface.
-    #  compiler_module_paths  -- See Compilable interface.
-    #  compiler_library_paths -- See Compilable interface.
-    def initialize(**kvargs)
-      @stream   = kvargs.fetch :stream,   ''
+    # @option kwargs [String] :stream The raw stream of text returned by the compiler.
+    # @option kwargs [Array<String>] :compiler_target_files  See Compilable interface.
+    # @option kwargs [Array<String>] :compiler_include_paths See Compilable interface.
+    # @option kwargs [Array<String>] :compiler_module_paths  See Compilable interface.
+    # @option kwargs [Array<String>] :compiler_library_paths See Compilable interface.
+    def initialize(**kwargs)
+      @stream   = kwargs.fetch :stream, ''
       
-      @compiler_target_files  = kvargs.fetch :compiler_target_files,  []
-      @compiler_include_paths = kvargs.fetch :compiler_include_paths, []
-      @compiler_module_paths  = kvargs.fetch :compiler_module_paths,  []
-      @compiler_library_paths = kvargs.fetch :compiler_library_paths, []      
+      @compiler_target_files  = kwargs.fetch :compiler_target_files,  []
+      @compiler_include_paths = kwargs.fetch :compiler_include_paths, []
+      @compiler_module_paths  = kwargs.fetch :compiler_module_paths,  []
+      @compiler_library_paths = kwargs.fetch :compiler_library_paths, []      
       
       # Capture error and warning counts.
       @errors = nil
@@ -43,27 +42,27 @@ module NetLinx
       end
     end
     
-    # Alias of #stream.
+    # Alias of {#stream}.
     def to_s
       @stream
     end
     
-    # Returns the absolute path of the source code file that was compiled.
+    # @return [String] the absolute path of the source code file that was compiled.
     def target_file
       @compiler_target_files.first
     end
     
-    # Compile was successful?
+    # @return [Boolean] true if compile was successful.
     def success?
       @errors == 0 && @warnings == 0
     end
     
-    # An enumerable list of warnings.
+    # @return [Array<String>] a list of warnings.
     def warning_items
       @stream.scan(/(^WARNING: .*$)/).map {|i| i.first}
     end
     
-    # An enumerable list of errors.
+    # @return [Array<String>] a list of errors.
     def error_items
       @stream.scan(/(^ERROR: .*$)/).map {|i| i.first}
     end

data/lib/netlinx/rake/compile.rb

@@ -0,0 +1,4 @@
+
+require_relative 'compile/compile'
+
+NetLinx::Rake::Compile.new

data/lib/netlinx/rake/compile/compile.rb

@@ -0,0 +1,34 @@
+
+require 'rake'
+require 'rake/tasklib'
+
+require 'netlinx/compile/script'
+
+module NetLinx
+  module Rake
+    
+    # Compile to deployable code from the source code files in the given workspace.
+    class Compile < ::Rake::TaskLib
+      
+      attr_accessor :name
+      
+      def initialize name = :compile
+        @name = name
+        yield self if block_given?
+        
+        desc "Compile to deployable code from the source code files in the given workspace."
+        
+        task(name) do
+          workspace = Dir.glob("*.apw").first
+          
+          puts "\n\nLaunching NetLinx compiler...\n\n"
+          # TODO: Invoke compiler through API.
+          #       Just call the netlinx-compile rake task in rake/erb.
+          system "netlinx-compile --smart -s \"#{workspace}\""
+          # NetLinx::Compile::Script.run argv: ['--smart', '-s', "\"#{workspace}\""]
+        end
+        
+      end
+    end
+  end
+end

data/lib/netlinx/source_file.rb

@@ -1,21 +1,27 @@
 module NetLinx
+  # A NetLinx source code file.
+  # Typically .axs or .axi.
   class SourceFile
     
-    # Parameters:
-    #   file: Name or path of the file to compile.
-    #   compiler_include_paths: Array of additional paths for the compiler to find include files.
-    #   compiler_module_paths: Array of additional paths for the compiler to find module files.
-    #     NOTE: SourceFile already searches the body of the source file to automatically determine
-    #           include and module paths.
-    def initialize(**kvargs)
-      @compiler_target_files  = [ (kvargs.fetch :file, nil) ]
-      @compiler_include_paths = kvargs.fetch :compiler_include_paths, []
-      @compiler_module_paths  = kvargs.fetch :compiler_module_paths,  []
+    # NOTE: SourceFile searches the body of the source file to automatically
+    # determine include and module paths.
+    # 
+    # @option kwargs [String] :file Name or path of the file to compile.
+    # @option kwargs [Array<String>] :compiler_include_paths Additional paths for the compiler to find include files.
+    # @option kwargs [Array<String>] :compiler_module_paths Additional paths for the compiler to find module files.
+    def initialize(**kwargs)
+      @compiler_target_files  = [ kwargs.fetch(:file, nil) ]
+      @compiler_include_paths = kwargs.fetch :compiler_include_paths, []
+      @compiler_module_paths  = kwargs.fetch :compiler_module_paths,  []
       
       return unless @compiler_target_files.first
       
       source_code = File.open(@compiler_target_files.first).read
       
+      unless source_code.valid_encoding?
+        source_code.force_encoding Encoding::ASCII_8BIT
+      end
+      
       # Scan file for additional include paths.
       includes = source_code.scan(/(?i)^\s*(?:\#include)\s+'([\w\-]+)'/)
       
@@ -47,22 +53,22 @@ module NetLinx
       @compiler_module_paths.uniq!
     end
     
-    # See Test::NetLinx::Compilable interface.
+    # @see _ lib/test/netlinx/compilable.rb interface.
     def compiler_target_files
       @compiler_target_files
     end
     
-    # See Test::NetLinx::Compilable interface.
+    # @see _ lib/test/netlinx/compilable.rb interface.
     def compiler_include_paths
       @compiler_include_paths
     end
     
-    # See Test::NetLinx::Compilable interface.
+    # @see _ lib/test/netlinx/compilable.rb interface.
     def compiler_module_paths
       @compiler_module_paths
     end
     
-    # See Test::NetLinx::Compilable interface.
+    # @see _ lib/test/netlinx/compilable.rb interface.
     def compiler_library_paths
       []
     end

data/lib/test/netlinx/compilable.rb

@@ -1,48 +1,13 @@
-module Test
-  module NetLinx
-    # Interface tests for an object that can be compiled with NetLinx::Compiler.
-    module Compilable
-      
-      # :nodoc:
-      def test_responds_to_compiler_target_files
-        assert_respond_to @object, :compiler_target_files
-      end
-      
-      # :nodoc:
-      def test_responds_to_compiler_include_paths
-        assert_respond_to @object, :compiler_include_paths
-      end
-      
-      # :nodoc:
-      def test_responds_to_compiler_library_paths
-        assert_respond_to @object, :compiler_library_paths
-      end
-      
-      # :nodoc:
-      def test_responds_to_compiler_module_paths
-        assert_respond_to @object, :compiler_module_paths
-      end
-      
-      # :nodoc:
-      def test_compiler_target_files_is_an_array
-        assert @object.compiler_target_files.is_a? Array
-      end
-      
-      # :nodoc:
-      def test_compiler_include_paths_is_an_array
-        assert @object.compiler_include_paths.is_a? Array
-      end
-      
-      # :nodoc:  
-      def test_compiler_library_paths_is_an_array
-        assert @object.compiler_library_paths.is_a? Array
-      end
-      
-      # :nodoc:
-      def test_compiler_module_paths_is_an_array
-        assert @object.compiler_module_paths.is_a? Array
-      end
-      
-    end
-  end
-end
+shared_examples "compilable" do
+  
+  it { should respond_to :compiler_target_files  }
+  it { should respond_to :compiler_include_paths }
+  it { should respond_to :compiler_library_paths }
+  it { should respond_to :compiler_module_paths  }
+  
+  its(:compiler_target_files)  { should be_an Array }
+  its(:compiler_include_paths) { should be_an Array }
+  its(:compiler_library_paths) { should be_an Array }
+  its(:compiler_module_paths)  { should be_an Array }
+  
+end