opal 0.6.3 → 0.7.0.beta1

data/lib/opal/builder_processors.rb

@@ -0,0 +1,165 @@
+require 'opal/compiler'
+require 'opal/erb'
+require 'source_map'
+
+module Opal
+  module BuilderProcessors
+    DEFAULT_PROCESSORS = []
+
+    class Processor
+      def self.inherited(processor)
+        DEFAULT_PROCESSORS << processor
+      end
+
+      def initialize(source, filename, options = {})
+        @source, @filename, @options = source, filename, options
+        @requires = []
+        @required_trees = []
+      end
+      attr_reader :source, :filename, :options, :requires, :required_trees
+
+      def to_s
+        source.to_s
+      end
+
+      def self.handles(*extensions)
+        @extensions = extensions
+        matches = extensions.join('|')
+        matches = "(#{matches})" if extensions.size == 1
+
+        @match_regexp = Regexp.new "\\.#{matches}$"
+      end
+
+      def self.extensions
+        @extensions
+      end
+
+      def self.match? other
+        (other.is_a?(String) and other.match(match_regexp))
+      end
+
+      def self.match_regexp
+        @match_regexp or raise NotImplementedError
+      end
+
+      def source_map
+        @source_map ||= begin
+          mappings = []
+          source_file = filename+'.js'
+          line = source.count("\n")
+          column = source.scan("\n[^\n]*$").size
+          offset = ::SourceMap::Offset.new(line, column)
+          mappings << ::SourceMap::Mapping.new(source_file, offset, offset)
+
+          # Ensure mappings isn't empty: https://github.com/maccman/sourcemap/issues/11
+          unless mappings.any?
+            zero_offset = ::SourceMap::Offset.new(0,0)
+            mappings = [::SourceMap::Mapping.new(source_file,zero_offset,zero_offset)]
+          end
+
+          ::SourceMap::Map.new(mappings)
+        end
+      end
+
+      def mark_as_required(filename)
+        "Opal.mark_as_loaded(Opal.normalize_loadable_path(#{filename.to_s.inspect}));"
+      end
+    end
+
+    class JsProcessor < Processor
+      handles :js
+
+      def source
+        @source.to_s + mark_as_required(@filename)
+      end
+    end
+
+    class RubyProcessor < Processor
+      handles :rb, :opal
+
+      def source
+        compiled.result
+      end
+
+      def source_map
+        compiled.source_map.map
+      end
+
+      def compiled
+        @compiled ||= begin
+          compiler = compiler_for(@source, file: @filename)
+          compiler.compile
+          compiler
+        end
+      end
+
+      def compiler_for(source, options = {})
+        compiler_class.new(source, @options.merge(options))
+      end
+
+      def requires
+        compiled.requires
+      end
+
+      def required_trees
+        compiled.required_trees
+      end
+
+      def compiler_class
+        ::Opal::Compiler
+      end
+    end
+
+    class ERBProcessor < RubyProcessor
+      handles :opalerb
+
+      def initialize(*args)
+        super
+        @source = prepare(@source, @filename)
+      end
+
+      def requires
+        ['erb']+super
+      end
+
+      private
+
+      def erb_compiler_class
+        ::Opal::ERB::Compiler
+      end
+
+      def prepare(source, path)
+        erb_compiler = erb_compiler_class.new(source, path)
+        erb_compiler.prepared_source
+      end
+    end
+
+    class HamlProcessor < RubyProcessor
+      handles :haml
+
+      def initialize(*args)
+        super
+        @source = prepare(@source, @filename)
+      end
+
+      def requires
+        ['opal-haml'] + super
+      end
+
+      def prepare(source, path)
+        haml = ::Haml::Engine.new(source, :ugly => true).precompiled
+        haml = haml.gsub('_hamlout.buffer', '_hamlout')
+
+        ::Opal::Haml.wrap haml, path
+      end
+    end
+
+    class ERB_Processor < Processor
+      handles :erb
+
+      def source
+        "Opal.modules[#{@filename.inspect}] = function() {#{::ERB.new(@source.to_s).result}};"
+      end
+    end
+  end
+end

data/lib/opal/cli.rb

@@ -1,10 +1,24 @@
 require 'opal'
 require 'rack'
+require 'opal/builder'
+require 'opal/cli_runners'
 
 module Opal
   class CLI
-    attr_reader :options, :filename
-    attr_reader :evals, :load_paths, :output, :requires
+    attr_reader :options, :file, :compiler_options, :evals, :load_paths, :argv,
+                :output, :requires, :gems, :stubs, :verbose, :port, :preload
+
+    def compile?
+      @compile
+    end
+
+    def sexp?
+      @sexp
+    end
+
+    def skip_opal_require?
+      @skip_opal_require
+    end
 
     class << self
       attr_accessor :stdout
@@ -12,193 +26,120 @@ module Opal
 
     def initialize options = nil
       options ||= {}
+
+      # Runner
+      @runner_type = options.delete(:runner)    || :nodejs
+      @port       = options.delete(:port)       || 3000
+
       @options    = options
-      @evals      = options[:evals] || []
-      @requires   = options[:requires] || []
-      @filename   = options[:filename]
-      @load_paths = options[:load_paths] || []
-      @output     = options[:output] || self.class.stdout || $stdout
-      raise ArgumentError if @evals.empty? and @filename.nil?
+      @compile    = !!options.delete(:compile)
+      @sexp       = options.delete(:sexp)
+      @file       = options.delete(:file)
+      @argv       = options.delete(:argv)       || []
+      @evals      = options.delete(:evals)      || []
+      @requires   = options.delete(:requires)   || []
+      @load_paths = options.delete(:load_paths) || []
+      @gems       = options.delete(:gems)       || []
+      @stubs      = options.delete(:stubs)      || []
+      @preload    = options.delete(:preload)    || []
+      @output     = options.delete(:output)     || self.class.stdout || $stdout
+      @verbose    = options.fetch(:verbose, false); options.delete(:verbose)
+      @skip_opal_require = options.delete(:skip_opal_require)
+      @compiler_options = Hash[
+        *processor_option_names.map do |option|
+          key = option.to_sym
+          next unless options.has_key? key
+          value = options.delete(key)
+          [key, value]
+        end.compact.flatten
+      ]
+
+      raise ArgumentError, "no runnable code provided (evals or file)" if @evals.empty? and @file.nil?
+      raise ArgumentError, "unknown options: #{options.inspect}" unless @options.empty?
     end
 
     def run
-      set_processor_options
-
       case
-      when options[:sexp];    prepare_eval_code; show_sexp
-      when options[:compile]; prepare_eval_code; show_compiled_source
-      when options[:server];  prepare_eval_code; start_server
-      else                    run_code
+      when sexp?;    show_sexp
+      when compile?; show_compiled_source
+      else           run_code
       end
     end
 
-
-
-
-    # RUN CODE
-
-    class PathFinder < Struct.new(:paths)
-      def find(filename)
-        full_path = nil
-        _path = paths.find do |path|
-          full_path = File.join(path, filename)
-          File.exist? full_path
-        end
-        full_path or raise(ArgumentError, "file: #{filename} not found")
-      end
+    def runner
+      @runner ||= case @runner_type
+                  when :server;    CliRunners::Server.new(output, port)
+                  when :nodejs;    CliRunners::Nodejs.new(output)
+                  when :phantomjs; CliRunners::Phantomjs.new(output)
+                  else raise ArgumentError, @runner_type.inspect
+                  end
     end
 
     def run_code
+      runner.run(compiled_source, argv)
+    end
+
+    def compiled_source
       Opal.paths.concat load_paths
-      path_finder = PathFinder.new(Opal.paths)
-      builder = Opal::Builder.new
-      full_source = builder.build('opal')
-
-      require 'pathname'
-      requires.each do |path|
-        path   = Pathname(path)
-        path   = Pathname(path_finder.find(path)) unless path.absolute?
-        full_source << builder.build_str(path.read, :file => path.to_s)
-      end
+      gems.each { |gem_name| Opal.use_gem gem_name }
 
-      evals.each_with_index do |code, index|
-        full_source << builder.build_str(code, :file => "(eval #{index+1})")
-      end
+      builder = Opal::Builder.new stubs: stubs, compiler_options: compiler_options
 
-      file = Pathname(filename.to_s)
-      full_source << builder.build_str(file.read, :file => file.to_s) if file.exist?
+      builder.build 'opal' unless skip_opal_require?
 
-      run_with_node(full_source)
-    end
+      preload.each { |path| builder.build_require(path) }
 
-    def run_with_node(code)
-      require 'open3'
-      begin
-        stdin, stdout, stderr = Open3.popen3('node')
-      rescue Errno::ENOENT
-        raise MissingNodeJS, 'Please install Node.js to be able to run Opal scripts.'
+      # REQUIRES: -r
+      requires.each do |local_require|
+        builder.build_str("require #{local_require.inspect}", 'require')
       end
 
-      stdin.write code
-      stdin.close
-
-      [stdout, stderr].each do |io|
-        str = io.read
-        puts str unless str.empty?
+      if evals.any?
+        builder.build_str(evals.join("\n"), '-e')
+      else
+        if file and (file.path != '-' or evals.empty?)
+          builder.build_str(file.read, file.path)
+        end
       end
-    end
 
-    class MissingNodeJS < StandardError
-    end
-
-    def start_server
-      require 'rack'
-      require 'webrick'
-      require 'logger'
-
-      Rack::Server.start(
-        :app       => server,
-        :Port      => options[:port] || 3000,
-        :AccessLog => [],
-        :Logger    => Logger.new($stdout)
-      )
+      builder.to_s
     end
 
     def show_compiled_source
-      if sprockets[filename]
-        puts sprockets[filename].to_a.last
-      elsif File.exist?(filename)
-        puts Opal.compile File.read(filename), options
-      else
-        puts Opal.compile(filename, options)
-      end
+      puts compiled_source
     end
 
     def show_sexp
-      puts sexp.inspect
-    end
-
-
-
-    # PROCESSOR
-
-    def set_processor_options
-      processor_options.each do |option|
-        key = option.to_sym
-        next unless options.has_key? key
-        Opal::Processor.send("#{option}=", options[key])
+      if evals.any?
+        sexp = Opal::Parser.new.parse(evals.join("\n"), '-e')
+      else
+        if file and (file.path != '-' or evals.empty?)
+          sexp = Opal::Parser.new.parse(file.read, file.path)
+        end
       end
+      puts sexp.inspect
     end
 
     def map
-      compiler = Opal::Compiler.new
-      compiler.compile(filename, options)
+      compiler = Opal::Compiler.compile(file.read, options.merge(:file => file.path))
+      compiler.compile
       compiler.source_map
     end
 
-    def source
-      File.exist?(filename) ? File.read(filename) : filename
-    end
-
-    def processor_options
+    def processor_option_names
       %w[
         method_missing_enabled
         arity_check_enabled
-        const_missing_enabled
         dynamic_require_severity
         source_map_enabled
         irb_enabled
+        inline_operators
       ]
     end
 
-    ##
-    # SPROCKETS
-
-    def sprockets
-      server.sprockets
-    end
-
-    def server
-      @server ||= Opal::Server.new do |s|
-        load_paths.each do |path|
-          s.append_path path
-        end
-        s.main = File.basename(filename, '.rb')
-      end
-    end
-
-    ##
-    # OUTPUT
-
     def puts(*args)
       output.puts(*args)
     end
 
-    ##
-    # EVALS
-
-    def evals_source
-      evals.inject('', &:<<)
-    end
-
-    def prepare_eval_code
-      if evals.any?
-        require 'tmpdir'
-        path = File.join(Dir.mktmpdir,"opal-#{$$}.js.rb")
-        File.open(path, 'w') do |tempfile|
-          load_paths << File.dirname(path)
-          tempfile.puts 'require "opal"'
-          tempfile.puts evals_source
-        end
-        @filename = File.basename(path)
-      end
-    end
-
-    ##
-    # SOURCE
-
-    def sexp
-      Opal::Parser.new.parse(source)
-    end
   end
 end