opal 0.3.41 → 0.3.42

data/config.ru

@@ -1,8 +0,0 @@
-require 'bundler'
-Bundler.require
-
-run Opal::Server.new { |s|
-  s.main = 'opal/spec/sprockets_runner'
-  s.append_path 'spec'
-  s.debug = false
-}

data/lib/opal/processor.rb

@@ -1,47 +0,0 @@
-require 'opal'
-require 'sprockets'
-
-module Opal
-  class Processor < Tilt::Template
-    self.default_mime_type = 'application/javascript'
-
-    def self.engine_initialized?
-      true
-    end
-
-    class << self
-      attr_accessor :method_missing_enabled
-      attr_accessor :optimized_operators_enabled
-      attr_accessor :arity_check_enabled
-    end
-
-    self.method_missing_enabled = true
-    self.optimized_operators_enabled = true
-    self.arity_check_enabled = false
-
-    def initialize_engine
-      require_template_library 'opal'
-    end
-
-    def prepare
-    end
-
-    def evaluate(context, locals, &block)
-      options = { :method_missing       => self.class.method_missing_enabled,
-                  :optimized_operators  => self.class.optimized_operators_enabled,
-                  :arity_check          => self.class.arity_check_enabled }
-
-      parser  = Opal::Parser.new 
-      result  = parser.parse data, options
-
-      parser.requires.each { |r| context.require_asset r }
-      result
-    end
-  end
-end
-
-Tilt.register 'rb',               Opal::Processor
-Sprockets.register_engine '.rb',  Opal::Processor
-
-Tilt.register 'opal',               Opal::Processor
-Sprockets.register_engine '.opal',  Opal::Processor

data/lib/opal/scope.rb

@@ -1,236 +0,0 @@
-module Opal
-  class Parser
-    # Instances of Scope are used by the parser when a new scope is
-    # being processed. It is used to keep track of used variables,
-    # temp variables and ivars so they can be processed and output
-    # along with the scope implementation.
-    class Scope
-      attr_accessor :parent
-
-      attr_accessor :name
-
-      attr_accessor :block_name
-
-      attr_reader :scope_name
-      attr_reader :ivars
-
-      attr_reader :type
-
-      attr_accessor :defines_defn
-      attr_accessor :defines_defs
-
-      attr_accessor :mid
-
-      # true if singleton def, false otherwise
-      attr_accessor :defs
-
-      # used by modules to know what methods to donate to includees
-      attr_reader :methods
-
-      # uses parents super method
-      attr_accessor :uses_super
-
-      def initialize(type, parser)
-        @parser  = parser
-        @type    = type
-        @locals  = []
-        @temps   = []
-        @args    = []
-        @ivars   = []
-        @parent  = nil
-        @queue   = []
-        @unique  = "a"
-        @while_stack = []
-
-        @defines_defs = false
-        @defines_defn = false
-
-        @methods  = []
-
-        @uses_block = false
-
-        # used by classes to store all ivars used in direct def methods
-        @proto_ivars = []
-      end
-
-      # Returns true if this scope is a class/module body scope
-      def class_scope?
-        @type == :class or @type == :module
-      end
-
-      def class?
-        @type == :class
-      end
-
-      def module?
-        @type == :module
-      end
-
-      def top?
-        @type == :top
-      end
-
-      def iter?
-        @type == :iter
-      end
-
-      # Is this a normal def method directly inside a class? This is
-      # used for optimizing ivars as we can set them to nil in the
-      # class body
-      def def_in_class?
-        !@defs && @type == :def && @parent && @parent.class?
-      end
-
-      def proto
-        "def"
-      end
-      
-      def should_donate?
-        @type == :module or @name.to_s == 'Object'
-      end
-
-      ##
-      # Vars to use inside each scope
-      def to_vars
-        vars = @locals.map { |l| "#{l} = nil" }
-        vars.push *@temps
-        current_self = @parser.current_self
-
-        iv = ivars.map do |ivar|
-         "if (#{current_self}#{ivar} == null) #{current_self}#{ivar} = nil;\n"
-        end
-
-        indent = @parser.parser_indent
-        res = vars.empty? ? '' : "var #{vars.join ', '};"
-        str = ivars.empty? ? res : "#{res}\n#{indent}#{iv.join indent}"
-
-        if class? and !@proto_ivars.empty?
-          pvars = @proto_ivars.map { |i| "#{proto}#{i}"}.join(' = ')
-          "%s\n%s%s = nil;" % [str, indent, pvars]
-        else
-          str
-        end
-      end
-
-      # Generates code for this module to donate methods
-      def to_donate_methods
-        if should_donate? and !@methods.empty?
-          "%s;#{@name}._donate([%s]);" % [@parser.parser_indent, @methods.map(&:inspect).join(', ')]
-        else
-          ""
-        end
-      end
-
-      def add_ivar(ivar)
-        if def_in_class?
-          @parent.add_proto_ivar ivar
-        else
-          @ivars << ivar unless @ivars.include? ivar
-        end
-      end
-
-      def add_proto_ivar(ivar)
-        @proto_ivars << ivar unless @proto_ivars.include? ivar
-      end
-
-      def add_arg(arg)
-        @args << arg unless @args.include? arg
-      end
-
-      def add_local(local)
-        return if has_local? local
-
-        @locals << local
-      end
-
-      def has_local?(local)
-        return true if @locals.include? local or @args.include? local
-        return @parent.has_local?(local) if @parent and @type == :iter
-
-        false
-      end
-
-      def add_temp(*tmps)
-        @temps.push *tmps
-      end
-
-      def has_temp?(tmp)
-        @temps.include? tmp
-      end
-
-      def new_temp
-        return @queue.pop unless @queue.empty?
-
-        tmp = "_#{@unique}"
-        @unique = @unique.succ
-        @temps << tmp
-        tmp
-      end
-
-      def queue_temp(name)
-        @queue << name
-      end
-
-      def push_while
-        info = {}
-        @while_stack.push info
-        info
-      end
-
-      def pop_while
-        @while_stack.pop
-      end
-
-      def in_while?
-        !@while_stack.empty?
-      end
-
-      def uses_block!
-        if @type == :iter && @parent
-          @parent.uses_block!
-        else
-          @uses_block = true
-          # identify!
-        end
-      end
-
-      def identify!
-        return @identity if @identity
-
-        @identity = @parser.unique_temp
-        @parent.add_temp @identity if @parent
-
-        @identity
-      end
-
-      def identity
-        @identity
-      end
-
-      def get_super_chain
-        chain, scope, defn, mid = [], self, 'null', 'null'
-
-        while scope
-          if scope.type == :iter
-            chain << scope.identify!
-            scope = scope.parent if scope.parent
-
-          elsif scope.type == :def
-            defn = scope.identify!
-            mid  = "'$#{scope.mid}'"
-            break
-
-          else
-            break
-          end
-        end
-
-        [chain, defn, mid]
-      end
-
-      def uses_block?
-        @uses_block
-      end
-    end
-  end
-end

data/lib/opal/server.rb

@@ -1,94 +0,0 @@
-require 'opal'
-require 'erb'
-
-module Opal
-  class Server
-
-    attr_accessor :debug, :index_path, :main, :public_dir, :sprockets
-
-    def initialize(debug = true)
-      @sprockets = Sprockets::Environment.new
-      Opal.paths.each { |p| @sprockets.append_path p }
-
-      @public_dir = '.'
-      @debug = debug
-
-      yield self if block_given?
-      create_app
-    end
-
-    def append_path(path)
-      @sprockets.append_path path
-    end
-
-    def create_app
-      server, sprockets = self, @sprockets
-
-      @app = Rack::Builder.app do
-        map('/assets') { run sprockets }
-        use Index, server
-        run Rack::Directory.new(server.public_dir)
-      end
-    end
-
-    def call(env)
-      @app.call env
-    end
-
-    class Index
-
-      def initialize(app, server)
-        @app = app
-        @server = server
-        @index_path = server.index_path
-      end
-
-      def call(env)
-        if %w[/ /index.html].include? env['PATH_INFO']
-          [200, { 'Content-Type' => 'text/html' }, [html]]
-        else
-          @app.call env
-        end
-      end
-
-      def html
-        source = if @index_path
-          raise "index does not exist: #{@index_path}" unless File.exist?(@index_path)
-          File.read @index_path
-        else
-          SOURCE
-        end
-
-        ERB.new(source).result binding
-      end
-
-      def javascript_include_tag(source)
-        if @server.debug
-          assets = @server.sprockets[source].to_a
-
-          raise "Cannot find asset: #{source}" if assets.empty?
-
-          scripts = assets.map do |a|
-            %Q{<script src="/assets/#{ a.logical_path }?body=1"></script>}
-          end
-
-          scripts.join "\n"
-        else
-          "<script src=\"/assets/#{source}.js\"></script>"
-        end
-      end
-
-      SOURCE = <<-HTML
-  <!DOCTYPE html>
-  <html>
-  <head>
-    <title>Opal Server</title>
-  </head>
-  <body>
-    <%= javascript_include_tag @server.main %>
-  </body>
-  </html>
-      HTML
-    end
-  end
-end

data/spec/core/boolean/and_spec.rb

@@ -1,17 +0,0 @@
-describe "Boolean#&" do
-  it "when false returns false" do
-    (false & true).should == false
-    (false & false).should == false
-    (false & nil).should == false
-    (false & "").should == false
-    (false & mock('x')).should == false
-  end
-
-  it "when true returns false if other is nil or false, otherwise true" do
-    (true & true).should == true
-    (true & false).should == false
-    (true & nil).should == false
-    (true & "").should == true
-    (true & mock('x')).should == true
-  end
-end

data/spec/core/boolean/inspect_spec.rb

@@ -1,9 +0,0 @@
-describe "Boolean#inspect" do
-  it "when false returns the string 'false'" do
-    false.inspect.should == "false"
-  end
-
-  it "when true returns the string 'true'" do
-    true.inspect.should == "true"
-  end
-end

data/spec/core/boolean/or_spec.rb

@@ -1,17 +0,0 @@
-describe "Boolean#|" do
-  it "when false returns false if other is nil or false, otherwise true" do
-    (false | false).should == false
-    (false | true).should == true
-    (false | nil).should == false
-    (false | "").should == true
-    (false | mock('x')).should == true
-  end
-
-  it "when true returns true" do
-    (true | true).should == true
-    (true | false).should == true
-    (true | nil).should == true
-    (true | "").should == true
-    (true | mock('x')).should == true
-  end
-end

data/spec/core/boolean/to_s_spec.rb

@@ -1,9 +0,0 @@
-describe "Boolean#to_s" do
-  it "when true returns the string 'false'" do
-    false.to_s.should == "false"
-  end
-
-  it "when false returns the string 'true'" do
-    true.to_s.should == "true"
-  end
-end