jejune 1.1.0

data/lib/jejune/node-test.rb

@@ -0,0 +1,71 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#--
+# Copyright (c) 2010-2011 Kyle C. Yetter
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+
+module Jejune
+module NodeTest
+  include Constants
+  
+private
+  
+  def property_definition?( node )
+    if PROPERTY_DEFINITION_TYPES.include?( node.type )
+      if node.type == ARROW and not PROPERTY_TYPES.include?( node.first.type )
+        return false
+      end
+      return true
+    end
+    return false
+  end
+  
+  def need_parentheses?( type_in_question, base_type )
+    OPERATOR_PRECEDENCE[ type_in_question ] < OPERATOR_PRECEDENCE[ base_type ]
+  end
+  
+  def property_name?( node )
+    PROPERTY_TYPES.include?( node.type )
+  end
+  
+  def expression?( node )
+    EXPRESSION_TYPES.include?( node.type )
+  end
+  
+  def enclosed?( node )
+    if node.start.type == LPAREN and node.stop.type == RPAREN
+      depth = 1
+      for token in node.tokens[ 1...-1 ]
+        case token.type
+        when LPAREN then depth += 1
+        when RPAREN
+          depth == 1 and return( false )
+          depth -= 1
+        end
+      end
+      return true
+    end
+  end
+
+end
+end

data/lib/jejune/parameters.rb

@@ -0,0 +1,83 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#
+# author: Kyle Yetter
+#
+
+
+module Jejune
+
+ParameterSet = Struct.new( :parameters, :defaults, :indices, :splat )
+
+class ParameterSet
+  include Constants
+  
+  def self.study( params )
+    set = self.new
+    
+    # Check that the parameters node actually meets the current
+    # semantic requirements of req > def > splat
+    # Also, organize the actual parameters by type
+    last_type = ID
+    for node in params
+      if last_type == SPLAT
+        raise( "additional parameters may not follow a splat parameter" )
+      end
+      
+      case type = node.type
+      when ID
+        last_type == ASGN and
+          raise( "required parameters may not follow default parameters" )
+        set.add( node.source )
+      when ASGN
+        set.add( node.first.source, node.last.source )
+      when SPLAT
+        set.splat = node.first.source
+      else
+        raise( "Why is `#{ node.name }' in a parameters list? That shouldn't happen" )
+      end
+      
+      last_type = type
+    end
+    
+    return set
+  end
+  
+  def initialize( parameters = [], defaults = {}, indices = {}, splat = nil )
+    super
+  end
+  
+  def declaration
+    parameters.empty? ? '()' : '( ' << parameters.join( ', ' ) << ' )'
+  end
+  
+  def add( name, value = nil )
+    indices[ name ] = parameters.length
+    parameters << name
+    value and defaults[ name ] = value
+    self
+  end
+  
+  def include?( name )
+    indices[ name ]
+  end
+  
+  def parsing_source
+    arity = parameters.length
+    source = StringIO.new( '' )
+    if splat
+      source.puts( "var #{ splat } = Array.prototype.slice.call( arguments, #{ arity } );" )
+    end
+    unless defaults.empty?
+      source.puts( "switch ( arguments.length ) {" )
+      parameters.each_with_index do | name, i |
+        source.puts( "  case #{ i }:" )
+        value = defaults[ name ] and source.puts( "    #{ name } = #{ value };" )
+      end
+      source.puts( "}" )
+    end
+    return source.string
+  end
+end
+
+end

data/lib/jejune/rewrite-debug.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#--
+# Copyright (c) 2010-2011 Kyle C. Yetter
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module Jejune
+module DebugRewrite
+  def debug_rewrite( tokens )
+    rewrite = tokens.rewrite
+    
+    operations = rewrite.instance_variable_get( :@operations )
+    for op in operations
+      print_rewrite( op )
+    end
+  end
+  
+  def print_rewrite( operation )
+    tokens = operation.stream
+    
+    case operation.name
+    when 'insert-before'
+      print(
+        "\e[33minsert-before\e[0m : ",
+        operation.stream[ operation.location ].inspect,
+        ' -> ', operation.text.inspect
+      )
+    when 'replace'
+      range = operation.location
+      start, stop = range.begin, range.end
+      content = '%p %s %p' % [ tokens[ start ], range.exclude_end? ? '...' : '..', tokens[ stop ] ]
+      print( "\e[32mreplace\e[0m : ", content, ' -> ', operation.text.inspect )
+    when 'delete'
+      range = operation.location
+      start, stop = range.begin, range.end
+      content = '%p %s %p' % [ tokens[ start ], range.exclude_end? ? '...' : '..', tokens[ stop ] ]
+      print( "\e[34mdelete\e[0m : ", content )
+    end
+    puts
+  end
+end
+end

data/lib/jejune/rewrite.rb

@@ -0,0 +1,125 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#--
+# Copyright (c) 2010-2011 Kyle C. Yetter
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+module Jejune
+class RewriteTree < CommonTree
+  attr_accessor :token_stream
+  
+  def initialize( payload = nil, stream = nil )
+    super( payload )
+    @token_stream = stream
+  end
+  
+  def tokens( range = token_range )
+    @token_stream[ range ]
+  end
+  
+  def rewrite( *args, &block )
+    @token_stream.rewrite( *args, &block )
+  end
+  
+  def start
+    start_index > 0 and @token_stream.at( start_index )
+  end
+  
+  def stop
+    stop_index > 0 and @token_stream.at( stop_index )
+  end
+  
+  def source( range = token_range )
+    @token_stream.rewrite.execute( range )
+  end
+  
+  def inner_range
+    first.start_index .. last.stop_index
+  end
+  
+  def inner_source
+    @token_stream.rewrite.execute( inner_range )
+  end
+  
+  def insert_after!( text, *more )
+    if more.empty?
+      @token_stream.insert_after( stop_index, text )
+    else
+      @token_stream.insert_after( text, *more )
+    end
+  end
+  
+  def insert_before!( text, *more )
+    if more.empty?
+      @token_stream.insert_before( start_index, text )
+    else
+      @token_stream.insert_before( text, *more )
+    end
+  end
+  
+  def delete!( *more )
+    if more.empty?
+      @token_stream.delete( token_range )
+    else
+      @token_stream.delete( *more )
+    end
+  end
+  
+  def replace!( text, *more )
+    if more.empty?
+      @token_stream.replace( token_range, text )
+    else
+      @token_stream.replace( text, *more )
+    end
+  end
+  
+  def strip!
+    @token_stream.delete( start_index )
+    @token_stream.delete( stop_index )
+  end
+  
+  def surround!( before, after = before )
+    @token_stream.insert_before( start_index, before )
+    @token_stream.insert_after( stop_index, after )
+  end
+  
+  alias prepend! insert_before!
+  alias append!  insert_after!
+  
+  def source_name
+    token.source_name rescue nil
+  end
+end
+
+class RewriteAdaptor < CommonTreeAdaptor
+  def initialize( stream )
+    @token_stream = stream
+    super( TokenData::Token )
+  end
+  
+  def create_with_payload( payload )
+    return RewriteTree.new( payload, @token_stream )
+  end
+end
+end
+
+

data/lib/jejune/scanner.rb

@@ -0,0 +1,201 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#--
+# Copyright (c) 2010-2011 Kyle C. Yetter
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject to
+# the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+# LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+# OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+#++
+
+require 'strscan'
+require 'delegate'
+
+module Jejune
+class SourceScanner < DelegateClass( StringScanner )
+  ESCAPE = /\\./m
+  SKIPPABLE = %r(
+    (?: // [^\n]* \n?
+    | /\* .*? \*/
+    | [ \  \t \f ]+
+    | \\ \r? \n
+    )+
+  )mx
+  SKIPPABLE_NL = %r(
+    (?: // [^\n]* \n?
+    | /\* .*? \*/
+    | \s+
+    )+
+  )mx
+  ID_RX = %r( [\$_a-z] [\$_a-z0-9]* )ix
+  STRING_RX = %r(
+    (?: " (?: [^ " \\ ] | \\ . )* "
+    |   ' (?: [^ ' \\ ] | \\ . )* '
+    |   ` (?: [^ ` \\ ] | \\ . )* `
+    )
+  )mx
+  CHUNK_RX = %r(
+    (?: [^ \s \\ ] | \\ . )+
+  )mx
+  
+  attr_accessor :line, :column, :file
+  alias position pos
+  alias position= pos=
+  
+  def self.from_token( token, options = {} )
+    options.is_a?( Integer ) and options = { :position => options }
+    source = token.text
+    options[ :file ] ||= token.source_name
+    options[ :line ] ||= token.line
+    options[ :column ] ||= token.column
+    new( source, options )
+  end
+  
+  def initialize( source, options = {} )
+    @scanner = StringScanner.new( source )
+    super( @scanner )
+    
+    @file   = options.fetch( :file, nil )
+    @line   = options.fetch( :line, 1 )
+    @column = options.fetch( :column, 0 )
+    @lexer  = @stream = nil
+    if pos = options[ :position ] and pos > 0
+      @scanner.pos = pos
+      advance_over( source[ 0, pos ] )
+    end
+  end
+  
+  for m in %w( scan scan_until skip skip_until )
+    class_eval( <<-END )
+      def #{ m }( pattern )
+        if match = super( pattern )
+          advance_over( match )
+          return match
+        end
+      end
+    END
+  end
+  
+  def advance_over( str )
+    l = str.count( $/ )
+    if l.zero?
+      @column += str.length
+    else
+      @line += l
+      @column = str.length - str.rindex( $/ ) - 1
+    end
+    self
+  end
+  
+  def stream
+    @stream ||= ANTLR3::StringStream.new(
+      @scanner.string,
+      :position => @scanner.pos,
+      :file => @file,
+      :line => @line,
+      :column => @column
+    )
+  end
+  
+  def lexer
+    input = self.stream
+    input.position == @scanner.pos or input.seek( @scanner.pos )
+    lexer = Lexer.new( input )
+    block_given? or return( lexer )
+    
+    value = yield( lexer )
+    @scanner.pos = @stream.position
+    @line = @stream.line
+    @column = @stream.column
+    return value
+  end
+  
+  def jump_to( pattern )
+    if found = @scanner.check_until( pattern )
+      size = found.length - @scanner.matched.length
+      size > 0 or return ''
+      matched = found[ 0, size ]
+      @scanner.pos += size
+      advance_over( matched )
+      return matched
+    end
+  end
+  
+  def see?( str )
+    peek( str.length ) == str
+  end
+  
+  def space!( include_newlines = false )
+    scan( include_newlines ? SKIPPABLE_NL : SKIPPABLE )
+  end
+  
+  def id!
+    scan( ID_RX )
+  end
+  
+  @@delimited_rx = {}
+  
+  def string!
+    scan( STRING_RX )
+  end
+  
+  def chunk!
+    scan( CHUNK_RX )
+  end
+  
+  def delimited!( open, close = open )
+    c = Regexp.escape( close[ 0, 1 ] )
+    pattern = /#{ cast_rx( open ) }(?m-ix:[^\\#{ c }]|\\.)*#{ cast_rx( close ) }/
+    scan( pattern )
+  end
+  
+  def nested!( open, close )
+    start = @scanner.pos
+    @scanner.scan( cast_rx( open ) ) or return nil
+    depth = 1
+    pause = Regexp.union( open, close, /\\.|\z/m )
+    while @scanner.skip_until( pause )
+      case @scanner.matched
+      when open
+        depth += 1
+      when close
+        depth -= 1
+        depth.zero? and break
+      when /\\./m
+        # do nothing
+      else
+        @scanner.pos = start
+        return nil
+      end
+    end
+    text = @scanner.string[ start ... @scanner.pos ]
+    advance_over( text )
+    return text
+  end
+  
+private
+  
+  def cast_rx( arg )
+    case arg
+    when Regexp then arg
+    else Regexp.new( Regexp.escape( arg ) )
+    end
+  end
+  
+end
+end