opal 0.0.1 → 0.1.0

data/.gitignore

@@ -1,2 +1,11 @@
+announcement.txt
+coverage
+doc
+pkg
 .DS_Store
-build
+cappuccino
+opal_spec
+opal_docs
+.yardoc
+tmp
+.gem

data/Opalfile

@@ -0,0 +1,371 @@
+mode :all do
+  
+  config :all,
+    :build_prefix       => 'tmp/build',
+    :staging_prefix     => 'tmp/staging',
+    :tmp_root           => 'tmp',
+    
+    # where our libs are kept - i.e. what should be a valid build item
+    :lib_directories    => ['lib'],
+    
+    
+    # which sub directory do our javascripts go into
+    :javascripts_prefix => 'javascripts',
+    
+    # which sub dir do our built stylesheets go into
+    :stylesheets_prefix => 'stylesheets',
+    
+    # final name for our js built file (:project_name for name of project, 
+    # other wise to_s is called on it)
+    :javascript_name    => :project_name,
+    
+    # same as above
+    :stylehseet_name    => :project_name,
+    
+    # default bin file to run.. if none given, then it defaults to :project_name
+    # which is replaced by the actual project name. This will then mean either
+    # a bin file of the given name, or lib/project_name will be loaded
+    :bin_file           => :project_name,
+    
+    # by default do NOT build stylesheets.. only cherrykit/spec wants this, so 
+    # for browsers etc, do not do this.
+    :build_stylesheets  => false,
+    
+    # should we copy the html files (if found?)
+    :copy_html          => false
+end
+
+mode :debug do
+  config :all,
+  
+    :build_prefix   => '',
+    :staging_prefix => 'tmp/debug/staging'
+    
+end
+
+mode :spec do
+  config :all,
+  
+    :build_prefix   => 'tmp/built_specs',
+    :staging_prefix => 'tmp/spec/staging'
+    
+end
+
+# This is the root opalfile. It is used as the basis for every target. These can
+# all be overridden by each opalfile, and so provide "defaults".
+
+# Building targets - each opal (app, framework, theme etc) are a single target
+namespace :target do
+  
+  desc "Preparing the target"
+  task :prepare do
+    # set the build root
+    @target.build_root = File.join(@project.build_root, @config.staging_prefix, 'opals', @target.target_name)
+    # set the staging root
+    @target.staging_root = File.join(@project.build_root, @config.staging_prefix, @target.target_name)
+  end
+  
+  desc "Building the target"
+  task :build => [:catalog, :hide_non_build_files, :'prepare_build_tasks:all']
+  
+  desc "catalog"
+  task :catalog do
+    target_root = @target.target_root
+    Dir[File.join(target_root, '**', '*')].each do |source|
+      next if !File.exist?(source) || File.directory?(source)
+      # should check if its another target
+      
+      relative_path = source.sub(/^#{Regexp.escape target_root}\//, "")
+      relative_path = relative_path.split(::File::SEPARATOR).join('/')
+      @target.add_build_item relative_path
+    end
+  end
+  
+  desc "Hide opalfiles etc"
+  task :hide_non_build_files => [:catalog] do
+    # puts "checking for extra files"
+    @target.build_items.each do |item|
+      
+      can_skip = false
+      # skip if item is in our lib directory(s)
+      can_skip = @config.lib_directories.each do |dir|
+        break true if item.filename =~ /^#{dir}.+(rb|js)$/
+      end
+      
+      # puts "trying #{item.filename}"
+      
+      if @config.copy_html && item.filename =~ /\.html$/
+        # allow html files if we have said so
+        next
+      end
+      
+      next if can_skip == true
+      
+      # skip all resources
+      if @config.build_stylesheets
+        # puts "can build styleheets for #{item.filename}"
+        next if item.filename =~ /^resources.+$/
+      end
+      
+      # if we have a bin item, and our config says we should include the bin
+      # file...
+      next if item.filename =~ /^bin.+$/ and @config.include_bin
+      
+      # puts "hiding #{item.filename}"
+        
+      # hide any other file
+      item.hide!
+    end
+    # puts "running hide_opalfiles with #{@target.build_items}"
+    # remove all non build files.. for example, if target is not main target, 
+    # then remove any bin files.. only want lib files, also remove spec folders
+    # really... the only ruby, for example, we want is in the lib folder
+  end
+end
+
+namespace :prepare_build_tasks do
+  
+  desc "This should invoke all needed tasks"
+  task :all => [:css, :ruby, :javascript, :combine]
+  
+  desc "setup"
+  task :setup => [:'target:prepare']
+  
+  desc "Ruby sources"
+  task :ruby => [:setup] do
+    # puts "running ruby tasks for #{@target}"
+    # make sure we only grab the ruby files
+    build_items = @target.build_items.select { |item| item.ext == 'rb' }
+    
+    build_items.each do |item|
+      # p "item.filename is #{item.filename}"
+      item = @target.add_transform item, 
+        :filename     => item.filename,
+        :build_task   => 'build:ruby',
+        :resource     => :ruby,
+        # give our ruby a name.rb.js extension to make it clearer what it is
+        :build_path   => File.join(@target.build_root, item.filename) + '.js',
+        :staging_path => File.join(@target.staging_root, item.filename) + '.js'
+    end
+  end
+  
+  desc "Any javascript sources - not likely to be many"
+  task :javascript => [:setup] do
+    # puts @target.build_items.map { |a| a.filename }
+    build_items = @target.build_items.select { |item| item.ext == 'js' }
+    # puts "found some javascript items: #{build_items}"
+    build_items.each do |item|
+      item = @target.add_transform item,
+        :filename     => item.filename,
+        :build_task   => 'build:javascript',
+        :resource     => :javascript,
+        :build_path   => File.join(@target.build_root, item.filename),
+        :staging_path => File.join(@target.staging_root, item.filename)
+    end
+  end
+  
+  desc "Collect all css resources"
+  task :css => [:setup] do
+    if @config.build_stylesheets
+      build_items = @target.build_items.select { |item| item.ext == "css" }
+    
+      build_items.each do |item|
+        item = @target.add_transform item,
+          :filename     => item.filename,
+          :build_task   => 'build:css',
+          :resource     => :css,
+          :build_path   => File.join(@target.build_root, item.filename),
+          :staging_path => File.join(@target.staging_root, item.filename)
+      end
+    end
+  end
+  
+  desc "combined ruby etc"
+  task :combine => [:css, :ruby, :javascript] do
+    # puts "combining for #{@target.target_name}"
+    code_items = []
+    css_items = []
+    @target.build_items.each do |item|
+      # all resouurce (ruby, css etc) types will have a .resource property
+      next if item.resource.nil?
+      # lookup specific ruby, css etc
+      case item.resource
+      when :ruby, :javascript
+        code_items << item
+      when :css
+        css_items << item
+      else
+        # puts "found NON ruby #{item.inspect}"
+      end
+    end
+    
+    # code target: the opal - javascript and ruby sources
+    code_target_name = @target.target_name + '.js'
+    
+    @target.add_composite code_target_name,
+      :build_task   => 'build:opal',
+      :source_items => code_items
+    
+    if @config.build_stylesheets
+      # css target is all the css resources (less, css, sass)
+      css_target_name = @target.target_name + '.css'
+    
+      @target.add_composite css_target_name,
+        :build_task   => 'build:opal_css',
+        :source_items => css_items
+    end
+  end
+  
+end
+
+namespace :build_item do
+  
+  task :prepare do
+    filename =  @build_item.filename
+    raise "All build items must have a filename." unless filename
+
+    # default build task for a build item
+    @build_item.build_task ||= 'build:copy'
+    # make sure we have an extension set
+    @build_item.ext = File.extname(filename)[1..-1]
+    # make sure our full source path is ready
+    @build_item.source_path ||= File.join(@target.target_root, filename)
+  end
+end
+
+namespace :build do
+  
+  task :clean do
+    # clean.. remove only tmps etc, leave final build as it is
+    staging = File.join @project.build_root, @config.tmp_root
+    FileUtils.rm_rf staging
+  end
+  
+  task :copy do
+    # puts "building simple copy task for #{@build_item.source_path}"
+    from = @build_item.source_path
+    to = File.join(@project.build_root, @config.build_prefix,  @build_item.filename)
+    # puts from
+    # puts to
+    FileUtils.mkdir_p File.dirname(to)
+    FileUtils.copy_file from, to
+  end
+  
+  task :ruby do
+    Vienna::Builders::Ruby.build @build_item, @dst_path
+  end
+  
+  task :javascript do
+    Vienna::Builders::Javascript.build @build_item, @dst_path
+  end
+  
+  task :css do
+    Vienna::Builders::CSS.build @build_item, @dst_path
+  end
+  
+  desc "Build the opal itself (as javascript)"
+  task :opal do
+    Vienna::Builders::Opal.build @build_item, @dst_path
+  end
+  
+  task :opal_css do
+    source_items = @build_item.source_items
+    build_path = @build_item.build_path
+    
+    FileUtils.mkdir_p File.dirname(build_path)
+    
+    File.open(build_path, 'w') do |out|
+      source_items.each do |item|
+        out.write File.read(item.stage!.staging_path)
+      end
+    end
+  end
+  
+  desc "Final package to combine all opals"
+  task :package do
+    # puts "running package task!"
+    # only run package task if we are the main target
+    if @target.main_target?
+      js_build_path = File.join @project.build_root, @config.build_prefix, @config.javascripts_prefix
+      
+      FileUtils.mkdir_p js_build_path
+      
+      js_name = @config.javascript_name
+      
+      if js_name == :project_name
+        js_name = "#{@project.project_name}.js"
+      end
+      
+      # if @config.build_stylesheets
+        css_build_path = File.join @project.build_root, @config.build_prefix, @config.stylesheets_prefix
+      
+        # FileUtils.mkdir_p css_build_path
+      
+        css_name = @config.stylesheet_name
+      
+        if css_name == :project_name
+          css_name = "#{@project.project_name}.css"
+        end
+      # end
+# javascripts_prefix
+      opals = @project.targets.each_value.to_a.dup
+      
+      # puts "opals are:"
+      # p opals
+      
+      # order is more-a-less irrelevant, but we MUST have opal first
+      opals.unshift(opals.find { |o| o.target_name.to_sym == :runtime }).uniq!
+       
+      # puts "opals are now:"
+      # p opals 
+      
+      # build the final javascript.js package
+      File.open(File.join(js_build_path, js_name), 'w') do |out|
+        opals.each do |opal|
+          item = opal.build_item_for("#{opal.target_name}.js")
+          out.puts File.read(item.build_path)
+        end
+        # Also, we must include the bin file we want to use, and set the working
+        # directory (which is in the base folder of the main_target)
+        bin_file = @config.bin_file
+        bin_file = @project.project_name if bin_file == :project_name
+        working_dir = @target.target_name.to_s
+        out.puts "opal.run('#{bin_file}','#{working_dir}');"
+      end
+      
+      # if @config.build_stylesheets
+        # puts "in a"
+        # puts css_build_path
+        # puts css_name
+        
+        all_css_targets = []
+        opals.each do |opal|
+          item = opal.build_item_for("#{opal.target_name}.css")
+          # puts item
+          (all_css_targets << item) if item
+        end
+        
+        if all_css_targets.length > 0
+          FileUtils.mkdir_p css_build_path
+          File.open(File.join(css_build_path, css_name), 'w') do |out|
+            all_css_targets.each do |item|
+              out.puts File.read(item.build_path)
+            end
+          end
+        end
+        # FileUtils.mkdir_p css_build_path
+        
+        # build the final stylesheet.css package
+        # File.open(File.join(css_build_path, css_name), 'w') do |out|
+          # opals.each do |opal|
+            # puts opal.target_name
+            # item = /opal.build_item_for("#{opal.target_name}.css")
+            # puts item
+            # out.puts(File.read(item.build_path)) if item
+          # end
+        # end
+      # end
+      
+    end
+  end
+end

data/README.md

@@ -0,0 +1,45 @@
+Opal: Ruby compiler/runtime for the browser
+=============================================
+
+### NOTE: opal has been renamed from vienna. Any reference to vienna in any part of the documentation should be ignored (fixing references soon).
+
+Opal is the runtime/standard lib for ruby in the browser.
+
+Installing
+-----------
+
+    # Insall gem from gemcutter/rubygems
+    sudo gem install opal
+
+Trying out
+----------
+To make a test project, use the following command where project_name is the name of the project to use.
+
+    # make the project
+    opal new project_name
+    # jump into the project
+    cd project_name
+
+If you look at the generated project, the html file includes a non existant javascript file. This will be where your project is built to. Also, in the lib folder there is a .rb file with the same name as your project with a simple puts command. Build the project:
+
+    opal build
+    
+The javascript file is now there, with all the opal runtime, core libraries and browser libs built in. Opal the file with a web browser and check the console:
+
+    "running project_name"
+
+To avoid the need to rebuild every time, opal comes with a server command that wraps your project and rebuilds every time index.html is reloaded (i.e. every time you reload the page). To run with a server, use the following:
+
+    opal server
+    
+And open your browser to `127.0.0.1:3030`.
+
+Next steps
+----------
+
+Opal has many of the libraries built. Check out the documentation (more coming soon), ask me questions on freenode (adambeynon): usually in #ruby, #ruby-lang, #javascript etc, or email me: adam.beynon@me.com.
+
+Command line tools / v8
+-----------------------
+
+I am playing with experimental support for therubyracer. Essentially, this gem allows you to embed the v8 javascript engine into ruby applications. Vienna has support for this allowing, firstly, a REPL system for trying out commands, but more importantly/interestingly, can run an entire opal application through the engine. The compilation step is not necessary as ruby files are compiled as they are required. For now, all specs are by default run through this system. Node, *nix (unix/linux) only, no windows support for opal command line.

data/Rakefile

@@ -1,52 +1,255 @@
 require 'rubygems'
 require 'rake'
+# require 'spec/rake/spectask'
+# require 'ftools'
+require 'yard'
+# 
+# Dir[File.join(File.dirname(__FILE__), 'tasks', '**', '*.rb')].each do |t|
+#   require t
+# end
 
 begin
   require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "opal"
-    gem.summary = %q{Ruby runtime for the browser}
-    gem.description = %q{Ruby runtime for the browser}
-    gem.email = "adam@adambeynon.com"
-    gem.homepage = "http://github.com/adambeynon/opal"
-    gem.authors = ["Adam Beynon"]
-    gem.add_development_dependency "vienna", ">= 0.0.3"
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "opal"
+    gemspec.summary = "Ruby compiler and runtime for the browser"
+    gemspec.description = "Ruby compiler and runtime for the browser."
+    gemspec.email = "adam@adambeynon.com"
+    gemspec.homepage = "http://opalscript.org"
+    gemspec.authors = ["Adam Beynon"]
   end
   Jeweler::GemcutterTasks.new
 rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
 end
 
-require 'rake/testtask'
-Rake::TestTask.new(:test) do |test|
-  test.libs << 'lib' << 'test'
-  test.pattern = 'test/**/test_*.rb'
-  test.verbose = true
+desc "Simple task to require vienna framework. Uses local, not installed."
+task :opal_gem do
+  require File.join(File.dirname(__FILE__), 'lib', 'opal')
 end
 
-begin
-  require 'rcov/rcovtask'
-  Rcov::RcovTask.new do |test|
-    test.libs << 'test'
-    test.pattern = 'test/**/test_*.rb'
-    test.verbose = true
-  end
-rescue LoadError
-  task :rcov do
-    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
-  end
+# desc "Run all specs"
+# Spec::Rake::SpecTask.new('spec') do |t|
+#   t.spec_files = FileList['spec/**/*.rb']
+# end
+
+
+desc "Rebuild ruby parser (using racc)"
+task :ruby_parser do
+  %x{racc -E lib/vienna/builders/ruby/ruby_parser.rb.y -o lib/vienna/builders/ruby/ruby_parser.rb}
+end
+
+
+# desc "Rebuild vienna.js runtime file"
+# task :vienna do
+#   File.open('build/vienna.js', 'w') do |out|
+#     # pre
+#     out.puts "var vienna = { };"
+#     out.puts "(function(global, exports) {"
+#     
+#     # runtime
+#     out.puts File.read('runtime/vienna.js')
+#     
+#     # post
+#     out.puts "})(window, vienna);"
+#     
+#     # Core library - use all rb files in core dir, but ensure kerenl.rb and     
+#     # module.rb are first in line as most other things rely on them
+#     ['core/kernel.rb', 'core/module.rb'].concat(Dir.glob('core/**/*.rb')).uniq!.each do |rb|
+#       builder = Vienna::CherryKit::RubyBuilder.new(rb, nil, nil)
+#       out.puts "// #{rb}"
+#       out.puts "#{builder.build!}.apply(vienna.top_self);"
+#     end
+#   end
+#   # puts "need to rebuild vienna.js"
+# end
+
+desc "build opal"
+task :opal => :opal_gem do
+  raise "currently disabled. use simple_opal"
+  opal = Vienna::Opal.new File.join(File.dirname(__FILE__),'frameworks', 'opal')
+  opal.build! :build_dir => File.join(File.dirname(__FILE__), 'build')
+end
+
+desc "build simple_opal test opal purely for testing opal etc"
+task :simple_opal => :opal_gem do
+  project = Vienna::Project.new(File.join(File.dirname(__FILE__), 'apps', 'simple_opal'), :build_mode => :debug)
+   p project
+   p project.targets
+   project.build!
+  # root = File.join(File.dirname(__FILE__), 'apps', 'simple_opal')
+  # Vienna::Tools.new(root).build :simple_opal
+end
+
+desc "build simple_opal test opal purely for testing opal etc"
+task :simple_opal_spec => :opal_gem do
+  project = Vienna::Project.new(File.join(File.dirname(__FILE__), 'apps', 'simple_opal'), :build_mode => :spec)
+   p project
+   p project.targets
+   project.build!
+  # root = File.join(File.dirname(__FILE__), 'apps', 'simple_opal')
+  # V
+end
+
+desc "rebuild opal_spec package"
+task :opal_spec => :opal_gem do
+  # opal framework root
+  opal_root = File.join(File.dirname(__FILE__), 'frameworks', 'opal')
+  # custom build root
+  tmp_root = File.join(File.dirname(__FILE__), 'tmp', 'opal_spec')
+  # our project
+  project = Vienna::Project.new opal_root, :build_mode => :spec, 
+                                           :build_root => tmp_root
+  
+  project.build!
+end
+
+desc "Browser Specs"
+task :browser_spec => :opal_gem do
+  browser_root = File.join(File.dirname(__FILE__), 'frameworks', 'browser')
+  
+  tmp_root = File.join(File.dirname(__FILE__), 'tmp', 'browser_spec')
+  
+  project = Vienna::Project.new browser_root, :build_mode => :spec,
+                                              :build_root => tmp_root
+  
+  project.build!
+end
+
+desc "Foundation Specs"
+task :foundation_spec => :opal_gem do
+  browser_root = File.join(File.dirname(__FILE__), 'frameworks', 'foundation')
+  
+  tmp_root = File.join(File.dirname(__FILE__), 'tmp', 'foundation_spec')
+  
+  project = Vienna::Project.new browser_root, :build_mode => :spec,
+                                              :build_root => tmp_root
+  
+  project.build!
 end
 
-task :test => :check_dependencies
+YARD::Rake::YardocTask.new do |t|
+  YARD::Templates::Engine.register_template_path(File.join(Dir.getwd, 'yard_templates'))
+  t.files   = ['core/**/*.rb']               # optional
+  # t.options = ['--any', '--extra', '--opts'] # optional
+  t.options = ['-o./doc/vienna', '-tvienna']
+  t.options += ['--title', 'Vienna Documentation']
+end
 
-task :default => :test
+# YARD::Rake::YardocTask.new(:cherry_kit) do |t|
+#   t.files   = ['lib/**/*.rb', OTHER_PATHS]   # optional
+#   t.options = ['--any', '--extra', '--opts'] # optional
+# end
 
-require 'rake/rdoctask'
-Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+desc "Testing compiler etc"
+task :test => :vienna do
+  test = Vienna::CherryKit::RubyBuilder.new('test/test_vienna.rb', nil, nil)
+  puts test.build!
+end
 
-  rdoc.rdoc_dir = 'rdoc'
-  rdoc.title = "opal #{version}"
-  rdoc.rdoc_files.include('README*')
-  rdoc.rdoc_files.include('lib/**/*.rb')
+namespace :doc do
+  
+  # rebuild demos
+  desc "Rebuild demos"
+  task :demos => :opal_gem do
+    # every demo uses an index.html file inside of the demos folder
+    base = File.join(File.dirname(__FILE__), 'demos')
+    demos = File.join(base, '**', 'index.html')
+    # we build all demos to vienna/doc/demos
+    Dir.glob(demos).each do |demo|
+      puts "building demo: #{demo}"
+      # path will be (demos/)path(/index.html)
+      path = /^#{Regexp.escape base}\/(.*)\/index\.html$/.match(demo)[1]
+      
+      build_root = File.join(File.dirname(__FILE__), 'doc', 'demos', path)
+      
+      puts build_root
+      project = Vienna::Project.new File.dirname(demo),
+        :build_root => build_root
+      
+      # FIXME: maybe only set options if no Opalfile... some of the CherryKit
+      # apps may want to include some css etc etc, so dont overwrite them?
+      project.options :lib_directories    => [""],
+                      :javascripts_prefix => "",
+                      :copy_html          => true
+      project.build!
+      project.clean!
+      # puts project
+    end
+  end
+  
+  # opal/runtime docs
+  YARD::Rake::YardocTask.new(:opal) do |t|
+    t.files   = ['opals/runtime/**/*.rb']
+    t.files += ['opals/opal/spec/core/**/*.rb']
+    t.files += ['-', 'opals/runtime/docs/**/*.md']
+    t.options = ['-o./doc/opal/']
+    t.options += ['-r./opals/runtime/README.md']
+    t.options += ['-mmarkdown']
+    t.options += ['--title', 'Opal Documentation']
+  end
+  
+  # browser docs
+  YARD::Rake::YardocTask.new(:browser) do |t|
+    t.files   = ['opals/browser/**/*.rb']
+    t.options = ['-o./doc/browser/']
+    t.options += ['-r./opals/browser/README.md']
+    t.options += ['-mmarkdown']
+    t.options += ['--title', 'Browser Documentation']
+  end
+  
+  # all specs
+  namespace :spec do
+    
+    %w{opal browser}.each do |opal|
+      desc "rebuild spec for #{opal}"
+      task opal.to_sym => :opal_gem do
+        opal_root = File.join(File.dirname(__FILE__), 'opals', opal)
+        build_root = File.join(File.dirname(__FILE__), 'doc', opal, 'spec')
+        project = Vienna::Project.new opal_root, :build_root => build_root, :build_mode => :spec
+        
+        project.options :javascript_name    => "spec.js",
+                        :stylesheet_name    => "spec.css",
+                        :build_prefix       => ""
+        
+        project.build!
+        project.clean!
+        
+        # spec html file
+        from = File.join(File.dirname(__FILE__), 'opals', 'spec', 'resources', 'index.html')
+        
+        FileUtils.copy from, File.join(build_root, 'index.html')
+      end
+    end
+    
+    # desc "rebuild opal_spec package"
+    # task :opal_spec => :opal_gem do
+    #   # opal framework root
+    #   opal_root = File.join(File.dirname(__FILE__), 'frameworks', 'opal')
+    #   # custom build root
+    #   tmp_root = File.join(File.dirname(__FILE__), 'tmp', 'opal_spec')
+    #   # our project
+    #   project = Vienna::Project.new opal_root, :build_mode => :spec, 
+    #                                            :build_root => tmp_root
+    # 
+    #   project.build!
+    # end
+    
+  end
+end
+
+task :doc => ['doc:browser', 'doc:opal', 'doc:demos'] do
+  # go through each set of generated docs, and replace the style.css file
+  %w{browser opal}.each do |opal|
+    from = File.join(File.dirname(__FILE__), 'yard', 'style.css')
+    to = File.join(File.dirname(__FILE__), 'doc', opal, 'css', 'style.css')
+    FileUtils.copy from, to
+  end
+  
+  # copy our index.html and its necessary css files
+  %w{index.html style.css}.each do |resource|
+    from = File.join File.dirname(__FILE__), 'yard', resource
+    to = File.join(File.dirname(__FILE__), 'doc')
+    FileUtils.copy from, to
+  end
 end