jejune 1.1.0

data/lib/jejune/macro.rb

@@ -0,0 +1,78 @@
+#!/usr/bin/ruby
+# encoding: utf-8
+#
+# author: Kyle Yetter
+#
+
+module Jejune
+class Macro
+  include Constants
+  
+  attr_accessor :manager, :name, :parameters, :blueprint
+  
+  def initialize( manager, tree )
+    @manager = manager
+    #@tree    = tree
+    @name    = tree[ 0 ].text
+    
+    if node = tree[ 1 ] and node.type == PARAMS
+      @parameters = ParameterSet.study( node )
+    else
+      @parameters = ParameterSet.new
+    end
+    
+    body_tokens = tree.last.tokens
+    
+    body_tokens.shift while t = body_tokens.first and t.type != LBRACE
+    body_tokens.shift
+    
+    body_tokens.pop while t = body_tokens.last and t.type != RBRACE
+    body_tokens.pop
+    
+    body_tokens.map! do | token |
+      if token.type == ID and index = @parameters.include?( token.text )
+        index
+      else
+        token.text
+      end
+    end
+    
+    @blueprint = body_tokens
+  end
+  
+  def self._load( serialized )
+    macro = allocate
+    macro.name, macro.parameters, macro.blueprint = Marshal.load( serialized )
+    return macro
+  end
+  
+  def _dump( depth )
+    Marshal.dump( [ @name, @parameters, @blueprint ] )
+  end
+  
+  def apply( *params )
+    params =
+      params.map do | i |
+        if i.respond_to?( :tokens ) then i.tokens
+        elsif TokenData::Token === i then [ i ]
+        else i
+        end
+      end
+    
+    tokens = []
+    for item in @blueprint
+      case item
+      when Fixnum
+        tokens.concat( params[ item ] )
+      else
+        tokens << item
+      end
+    end
+    
+    @manager.translate( tokens.join( '' ) )
+  end
+  
+  alias expand apply
+  
+end
+end

data/lib/jejune/main.rb

@@ -0,0 +1,289 @@
+#!/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 'optparse'
+require 'jejune'
+
+module Jejune
+
+module Options
+  # the input encoding type; defaults to +nil+ (currently, not used)
+  attr_accessor :encoding
+  # the input stream used by the Main script; defaults to <tt>$stdin</tt>
+  attr_accessor :input
+  # a boolean flag indicating whether or not to run the Main
+  # script in interactive mode; defaults to +false+
+  attr_accessor :interactive
+  attr_accessor :no_output
+  attr_accessor :profile
+  attr_accessor :debug_socket
+  attr_accessor :ruby_prof
+  
+  def initialize( options = {} )
+    @no_output    = options.fetch( :no_output, false )
+    @profile      = options.fetch( :profile, false )
+    @debug_socket = options.fetch( :debug_socket, false )
+    @ruby_prof    = options.fetch( :ruby_prof, false )
+    @encoding     = options.fetch( :encoding, nil )
+    @interactive  = options.fetch( :interactive, false )
+    @input        = options.fetch( :input, $stdin )
+  end
+  
+  # constructs an OptionParser and parses the argument list provided by +argv+
+  def parse_options( argv = ARGV )
+    oparser = OptionParser.new do | o |
+      o.separator 'Input Options:'
+      
+      o.on( '-i', '--input "text to process"', doc( <<-END ) ) { |val| @input = val }
+      | a string to use as direct input to the recognizer
+      END
+      
+      o.on( '-I', '--interactive', doc( <<-END ) ) { @interactive = true }
+      | run an interactive session with the recognizer
+      END
+    end
+    
+    setup_options( oparser )
+    return oparser.parse( argv )
+  end
+  
+private
+  
+  def setup_options( oparser )
+    # overridable hook to modify / append options
+  end
+  
+  def doc( description_string )
+    description_string.chomp!
+    description_string.gsub!( /^ *\| ?/, '' )
+    description_string.gsub!( /\s+/, ' ' )
+    return description_string
+  end
+  
+end
+
+=begin rdoc ANTLR3::Main::Main
+
+The base-class for the three primary Main script-runner classes.
+It defines the skeletal structure shared by all main
+scripts, but isn't particularly useful on its own.
+
+=end
+
+class Main
+  include Options
+  include Util
+  attr_accessor :output, :error
+  
+  def initialize( options = {} )
+    @input  = options.fetch( :input, $stdin )
+    @output = options.fetch( :output, $stdout )
+    @error  = options.fetch( :error, $stderr )
+    @name   = options.fetch( :name, File.basename( $0, '.rb' ) )
+    super
+    block_given? and yield( self )
+  end
+  
+  
+  # runs the script
+  def execute( argv = ARGV )
+    args = parse_options( argv )
+    setup
+    
+    @interactive and return execute_interactive
+    
+    in_stream = 
+      case
+      when @input.is_a?( ::String ) then StringStream.new( @input )
+      when args.length == 1 && args.first != '-'
+        ANTLR3::FileStream.new( args[ 0 ] )
+      else ANTLR3::FileStream.new( @input )
+      end
+    case
+    when @ruby_prof
+      load_ruby_prof
+      profile = RubyProf.profile do
+        recognize( in_stream )
+      end
+      printer = RubyProf::FlatPrinter.new( profile )
+      printer.print( @output )
+    when @profile
+      require 'profiler'
+      Profiler__.start_profile
+      recognize( in_stream )
+      Profiler__.print_profile
+    else
+      recognize( in_stream )
+    end
+  end
+  
+private
+  
+  def recognize( *args )
+    # overriden by subclasses
+  end
+  
+  def execute_interactive
+    @output.puts( tidy( <<-END ) )
+    | ===================================================================
+    | Ruby ANTLR Console for #{ $0 }
+    | ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~ ~
+    | * Enter source code lines 
+    | * Enter EOF to finish up and exit
+    |   (control+D on Mac/Linux/Unix or control+Z on Windows)
+    | ===================================================================
+    | 
+    END
+    
+    read_method = 
+      begin
+        require 'readline'
+        line_number = 0
+        lambda do
+          begin
+            if line = Readline.readline( "#@name:#{ line_number += 1 }> ", true )
+              line << $/
+            else
+              @output.print( "\n" ) # ensures result output is on a new line after EOF is entered
+              nil
+            end
+          rescue Interrupt, EOFError
+            retry
+          end
+          line << "\n" if line
+        end
+        
+      rescue LoadError
+        lambda do
+          begin
+            printf( "%s:%i> ", @name, @input.lineno )
+            flush
+            line = @input.gets or
+              @output.print( "\n" ) # ensures result output is on a new line after EOF is entered
+            line
+          rescue Interrupt, EOFError
+            retry
+          end
+          line
+        end
+      end
+    
+    stream = InteractiveStringStream.new( :name => @name, &read_method )
+    recognize( stream )
+  end
+  
+  def screen_width
+    ( ENV[ 'COLUMNS' ] || 80 ).to_i
+  end
+  
+  def attempt( lib, message = nil, exit_status = nil )
+    yield
+  rescue LoadError => error
+    message or raise
+    @error.puts( message )
+    report_error( error )
+    report_load_path
+    exit( exit_status ) if exit_status
+  rescue => error
+    @error.puts( "received an error while attempting to load %p" % lib )
+    report_error( error )
+    exit( exit_status ) if exit_status
+  end
+  
+  def report_error( error )
+    puts!( "~ error details:" )
+    puts!( '  [ %s ]' % error.class.name )
+    message = error.to_s.gsub( /\n/, "\n     " )
+    puts!( '  -> ' << message )
+    for call in error.backtrace
+      puts!( '     ' << call )
+    end
+  end
+  
+  def report_load_path
+    puts!( "~ content of $LOAD_PATH: " )
+    for dir in $LOAD_PATH
+      puts!( "  - #{ dir }" )
+    end
+  end
+  
+  def setup
+    # hook
+  end
+  
+  def fetch_class( name )
+    name.nil? || name.empty? and return( nil )
+    unless constant_exists?( name )
+      try_to_load( name )
+      constant_exists?( name ) or return( nil )
+    end
+    
+    name.split( /::/ ).inject( Object ) do |mod, name|
+      # ::SomeModule splits to ['', 'SomeModule'] - so ignore empty strings
+      name.empty? and next( mod ) 
+      mod.const_get( name )
+    end
+  end
+  
+  def constant_exists?( name )
+    eval( "defined?(#{ name })" ) == 'constant'
+  end
+  
+  def try_to_load( name )
+    if name =~ /(\w+)::(Lexer|Parser|TreeParser)$/
+      retry_ok = true
+      module_name, recognizer_type = $1, $2
+      script = name.gsub( /::/, '' )
+      begin
+        return( require( script ) )
+      rescue LoadError
+        if retry_ok
+          script, retry_ok = module_name, false
+          retry
+        else
+          return( nil )
+        end
+      end
+    end
+  end
+  
+  %w(puts print printf flush).each do |method|
+    class_eval( <<-END, __FILE__, __LINE__ )
+      private
+      
+      def #{ method }(*args)
+        @output.#{ method }(*args) unless @no_output
+      end
+      
+      def #{ method }!( *args )
+        @error.#{ method }(*args) unless @no_output
+      end
+    END
+  end
+end
+
+
+
+end

data/lib/jejune/manager.rb

@@ -0,0 +1,333 @@
+#!/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 Manager
+  include Constants
+  include Utils
+  include JString
+  
+  attr_reader   :load_path, :input, :translator, :data_directory, :macros, :dependency_map
+  attr_accessor :browser, :location_markers, :verbose, :root_input
+  
+  alias location_markers? location_markers
+  private :location_markers
+  
+  def initialize( *args )
+    options = {}
+    args.last.is_a?( Hash ) and options.update( args.pop )
+    @root_input = args.shift
+    
+    @data_directory = File.expand_path( '~/.jejune' )
+    test( ?d, @data_directory ) or Dir.mkdir( @data_directory )
+    @cache_directory = File.join( @data_directory, 'cache' )
+    test( ?d, @cache_directory ) or Dir.mkdir( @cache_directory )
+    
+    @input       = nil
+    @input_stack = []
+    
+    @load_path  = options.fetch( :load_path, [] )
+    @load_path  = [ @load_path ].flatten
+    @load_path.compact!
+    
+    @loaded_files     = {}
+    @translator       = Translator.new( self )
+    @browser          = options[ :browser ]
+    @location_markers = options.fetch( :location_markers, true )
+    @macros           = options.fetch( :macros, {} )
+    @verbose          = options.fetch( :verbose, false )
+    @dependency_map   = {}
+  end
+  
+  
+  def define_macro( node )
+    macro = Macro.new( self, node )
+    @macros[ macro.name ] = macro
+    @input and @input.macros[ macro.name ] = macro
+    return macro
+  end
+  
+  def add_to_path( *directories )
+    directories = [ directories ].flatten!.map! { | i | i.to_s }
+    @load_path.unshift( *directories )
+  end
+  
+  def set_root_file( file, options = {} )
+    options[ :manager ] = self
+    @root_input         = JJSFile.new( file, options )
+  end
+  
+  def set_root_source( source, options = {} )
+    options[ :manager ] = self
+    @root_input         = JJSSource.new( source, options )
+  end
+  
+  def find_path( name, exts = DEFAULT_EXT )
+    find_in_path_list( @load_path, name, exts )
+  end
+  
+  def find_resource( name, ext, system = false )
+    unless path = system ? find_path( name, ext ) : find_relative( name, ext )
+      raise( "cannot locate file `#{ name }' (exts = #{ ext })" )
+    end
+    return path
+  end
+  
+  def find_relative( name, exts = DEFAULT_EXT )
+    find_in_directory( @input ? @input.directory : File.expand_path( '.' ), name, exts )
+  end
+  
+  def find_library( name, system = false )
+    unless path = system ? find_path( name ) : find_relative( name )
+      raise( "cannot locate file `#{ name }'" )
+    end
+    return path
+  end
+  
+  
+  def cache_file( path )
+    id = MD5.hexdigest( File.expand_path( path ) << "\0" << @browser.to_s )
+    File.join( @cache_directory, id )
+  end
+  
+  def loaded?( path )
+    @loaded_files.has_key?( File.expand_path( path ) )
+  end
+  
+  def load_file( path )
+    #$stderr.puts( "- loading #{ path } #{ File.basename( cache_file( File.expand_path( path ) ) ) }" )
+    log( "cache check - #{ path }", 34 )
+    full_path = File.expand_path( path )
+    add_dependency( full_path )
+    
+    @loaded_files.fetch( full_path ) do
+      cache  = cache_file( full_path )
+      output = nil
+      
+      begin
+        if test( ?f, cache ) and test( ?>, cache, path )
+          data = Marshal.load( File.read( cache ) )
+          for depend in data[ :dependencies ]
+            unless test( ?f, depend ) and test( ?>, cache, depend )
+              #$stderr.puts( "  old   < #{ depend }" )
+              raise "no cache"
+            end
+          end
+          
+          data[ :macros ].each_value { | macro | macro.manager = self }
+          @macros.update( data[ :macros ] )
+          
+          return( @loaded_files[ full_path ] = data[ :output ] )
+        end
+      rescue => e
+        #$stderr.puts( e.inspect )
+        # ignore
+      end
+      
+      @loaded_files[ full_path ] = JJSFile.new( path, :manager => self, :cache_file => cache )
+    end
+  end
+  
+  def require!( lib, system = lib !~ /^[\.\/\~]/ )
+    path = find_library( lib, system )
+    @input and @input.dependencies.add( File.expand_path( path ) )
+    log( "require! #{ path.inspect }" )
+    jejune_file?( path ) ? loaded?( path ) ? nil : load_file( path ) : File.read( path )
+  end
+  
+  def include!( lib )
+    require!( lib, false )
+  end
+  
+  def load!( lib, system = false )
+    path = find_library( lib, system )
+    @input and @input.dependencies.add( File.expand_path( path ) )
+    log( "load! #{ path.inspect }" )
+    jejune_file?( path ) ? load_file( path ) : File.read( path )
+  end
+  
+  def expand_macro( name, *parameters )
+    macro = @macros[ name.to_s ] or raise MacroNotFound.new( name.to_s )
+    macro.expand( *parameters )
+  end
+  
+  def translate( input = @root_input, options = nil )
+    case input
+    when RewriteTree
+      @translator.translate( input )
+    when JJSInput
+      log( "translating #{ input.path }" )
+      with_input( input ) do
+        @translator.translate( input.tree )
+      end
+    when IO, ARGF
+      options ||= {}
+      options[ :manager ] = self
+      input = JJSFile.new( input, options )
+      translate( input )
+    when String
+      options ||= {}
+      options[ :manager ] = self
+      input = JJSSource.new( input, options )
+      translate( input )
+    end
+  end
+  
+  def compress( source, type = 'js' )
+    command = %W( yui-compressor --type #{ type } ).join( ' ' )
+    Open3.popen3( command ) do | inp, out, err |
+      inp.write source
+      inp.close
+      return out.read
+    end
+  end
+  
+  def parse( tokens, *args )
+    options = args.last.is_a?( Hash ) ? args.pop : {}
+    rule = args.pop || options[ :rule ] || :program
+    
+    stream = RewriteStream.new( tokens, options )
+    adaptor = RewriteAdaptor.new( stream )
+    parser = Parser.new( stream, :adaptor => adaptor )
+    parser.send( rule ).tree
+  end
+  
+  def commit_dependencies( file, deps )
+    @dependency_map[ file ] = deps.to_a
+  end
+  
+  def with_input( input )
+    @input_stack.push( @input ) if @input
+    @input = input
+    yield self
+  ensure
+    @input = @input_stack.pop
+  end
+  
+  def add_dependency( path )
+    full_path = File.expand_path( path )
+    @input and @input.dependencies.add( full_path )
+    @input_stack.each { | f | f.dependencies.add( full_path ) }
+  end
+  
+  def interpolate( blob, outdent = false )
+    segments = []
+    
+    s = SourceScanner.new(
+      blob.data, :file => blob.file, :line => blob.line, :column => blob.data_column
+    )
+    indent = nil
+    margin = true
+    nlines = 0
+    
+    until s.eos?
+      case
+      when s.scan( /#(?:(\{)|([@%\$][\$\w]*))/ )
+        if s[ 1 ]
+          tks = s.lexer { | lx | lx.tokenize_until_balanced( LBRACE, RBRACE ) }
+          tree = parse( tks, :source_name => blob.file )
+          segments << [ ?c, translate( tree ) ]
+        elsif variable = s[ 2 ]
+          case variable[ 0 ]
+          when ?$
+            segments << [ ?c, variable ]
+          when ?@
+            variable.length > 1 or raise( "syntax error -- expected variable name: `#{ s.matched }'" )
+            segments << [ ?c, 'this.' << variable[ 1, variable.length ] ]
+          when ?%
+            variable.length > 1 or raise( "syntax error -- expected variable name: `#{ s.matched }'" )
+            segments << [ ?c, variable[ 1, variable.length ] ]
+          else
+            raise( "BUG: this shouldn't happen" )
+          end
+        else
+          raise( "BUG: this shouldn't happen" )
+        end
+      when s.scan( /\r?\n(?:\s*\r?\n)* / )
+        nl = s.matched
+        nlines += nl.count( "\n" )
+        
+        if last = segments.last and last[ 0 ] == ?s
+          last[ 1 ] << nl
+        else
+          segments << [ ?s, nl ]
+        end
+        
+        if leading_space = s.check( /^\s*(?=(\S))/ )
+          margin &&= ( s[ 1 ] == '|' )
+          n = expand_tabs( leading_space ).length
+          indent = indent ? n < indent ? n : indent : n
+        end
+      when s.scan( %r<(?: [^\\\r\n\#]+ | (?: \\ \\ )+ | \\ \r? \n | \\ . | \# (?! [\{\$@%] ))+>mx )
+        if last = segments.last and last[ 0 ] == ?s
+          last[ 1 ] << s.matched
+        else
+          segments << [ ?s, s.matched ]
+        end
+      else
+        msg = "BUG: this shouldn't happen!\n"
+        msg << ( '= ' * 30 ) << "\n"
+        msg << blob.inspect << "\n"
+        msg << ( '= ' * 30 ) << "\n"
+        msg << s.inspect
+        raise( msg )
+      end
+    end
+    
+    if outdent and nlines > 0
+      if first = segments.first and first[ 0 ] == ?s
+        first[ 1 ].sub!( /\A[ \t]*\r?\n/, '' )
+        first.empty? and segments.shift
+      end
+      if last = segments.last and last[ 0 ] == ?s
+        last[ 1 ].sub!( /\r?\n[ \t]*\z/, '' )
+        last.empty? and segments.pop
+      end
+      
+      for type, text in segments
+        if type == ?s
+          margin ? text.gsub!( /(\r?\n)[ \t]*\|[ \t]?/, '\1' ) :
+            text.gsub!( /(\r?\n)([ \t]*)/ ) { $1 << $2[ indent, $2.length ].to_s }
+        end
+      end
+    end
+    
+    case segments.length
+    when 0 then %q("")
+    when 1
+      type, text = segments.first
+      type == ?s ? jstring( text ) : "(#{ text }).toString()"
+    else
+      segments.map! { | type, text | type == ?s ? jstring( text ) : text.strip }
+      %([#{ segments.join( ',' ) }].join(''))
+    end
+  end
+  
+  def log( message, color = 33 )
+    @verbose and $stderr.puts( "\e[#{ color }m#{ message }\e[0m" )
+  end
+  
+end
+end