neo_rad 0.4.0

data/lib/rad/sketch_compiler.rb

@@ -0,0 +1,47 @@
+# TODO:
+#   compilation
+#   gather pieces of code we need as strings
+#   translate non-loop methods
+#   do plugin stuff
+#   deal with examples/ exception
+#   manage upload process
+#   compose_setup should move in here entirely
+
+# require 'arduino_sketch'
+
+class SketchCompiler
+  attr_accessor :path, :body, :klass, :target_dir, :name
+  
+  def initialize path_to_sketch 
+    @path = File.expand_path(path_to_sketch)
+    @body = open(@path).read
+    @name = @path.split("/").last.split(".").first
+    @klass = @name.split(".").first.split("_").collect{|c| c.capitalize}.join("")     
+    @target_dir = parent_dir
+  end
+  
+  def parent_dir
+    self.path.split("/")[0..@path.split("/").length-2].join("/")
+  end
+  
+  def build_dir
+    "#{self.target_dir}/#{self.name}"
+  end
+
+  def create_build_dir! optional_path_prefix=nil
+    self.target_dir = optional_path_prefix if optional_path_prefix
+    mkdir_p build_dir
+  end
+  
+  def process_constants
+    self.body.gsub!("HIGH", "1")
+    self.body.gsub!("LOW", "0")
+    self.body.gsub!("ON", "1")
+    self.body.gsub!("OFF", "0")
+  end
+  
+  def sketch_methods
+    self.body.scan(/^\s*def\s.\w*/).collect{ |m| m.gsub(/\s*def\s*/, "") }
+  end
+  
+end

data/lib/rad/tasks/build_and_make.rake

@@ -0,0 +1,210 @@
+require File.expand_path(File.dirname(__FILE__) + "/../init.rb")
+require 'ruby_to_ansi_c'
+
+C_VAR_TYPES = "unsigned|int|long|double|str|char|byte|bool"
+
+# incredibly primitive tests 
+# rake test:compile or rake test:upload
+# runs through all sketches in the example directory
+
+def run_tests(sketch, type)
+  sh %{rake make:#{type} sketch=examples/#{sketch}}
+end
+
+namespace :test do
+  
+  desc "iterate through all the sketches in the example directory"
+  task :upload => :gather do 
+    @examples.each {|e| run_tests(e, "upload")}
+  end
+  
+  task :compile => :gather do 
+
+    @examples.each {|e| run_tests(e, "compile")}
+  end
+  
+  desc "gather all tests"
+  task :gather do # => "make:upload" do
+    @examples = []
+    if ENV['sketch']
+      @examples << ENV['sketch']
+    else
+      Dir.entries( File.expand_path("#{RAD_ROOT}/examples/") ).each do |f|
+        @examples << f.split('.').first if (f =~ /\.rb$/)
+      end
+    end
+  end
+
+end
+
+
+namespace :make do
+  
+  desc "compile the sketch and then upload it to your Arduino board"
+  task :upload => :compile do
+    if Makefile.hardware_params['physical_reset']
+      puts "Reset the Arduino and hit enter.\n==If your board doesn't need it, you can turn off this prompt in config/software.yml=="
+      STDIN.gets.chomp
+    end
+    sh %{cd #{@sketch.build_dir}; make upload}
+  end
+    
+  desc "generate a makefile and use it to compile the .cpp"
+  task :compile => [:clean_sketch_dir, "build:sketch"] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp using the current .cpp file"
+  task :compile_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make}
+  end
+  
+  desc "generate a makefile and use it to compile the .cpp and upload it using current .cpp file"
+  task :upload_cpp => ["build:sketch_dir", "build:gather_required_plugins", "build:plugin_setup", "build:setup", :clean_sketch_dir] do # should also depend on "build:sketch"
+    Makefile.compose_for_sketch( @sketch.build_dir )
+    # not allowed? sh %{export PATH=#{Makefile.software_params[:arduino_root]}/tools/avr/bin:$PATH}
+    sh %{cd #{@sketch.build_dir}; make depend; make upload}
+  end
+  
+  task :clean_sketch_dir => ["build:file_list", "build:sketch_dir"] do
+    FileList.new(Dir.entries("#{@sketch.build_dir}")).exclude("#{@sketch.name}.cpp").exclude(/^\./).each do |f|
+      sh %{rm #{@sketch.build_dir}/#{f}}
+    end
+  end
+  
+end
+
+namespace :build do
+
+  desc "actually build the sketch"
+  task :sketch => [:file_list, :sketch_dir, :gather_required_plugins, :plugin_setup, :setup] do
+    c_methods = []
+    sketch_signatures = []
+    # until we better understand RubyToC let's see what's happening on errors
+    @sketch.sketch_methods.each do |meth|   
+      raw_rtc_meth = RADProcessor.translate(constantize(@sketch.klass), meth)
+      puts "Translator Error: #{raw_rtc_meth.inspect}" if raw_rtc_meth =~ /\/\/ ERROR:/ 
+      c_methods << raw_rtc_meth unless meth == "setup"
+      # treat the setup method differently
+      @additional_setup = [] if meth == "setup"
+      raw_rtc_meth.each {|m| @additional_setup << ArduinoSketch.add_to_setup(m) } if meth == "setup"
+    end
+    c_methods.each {|meth| sketch_signatures << "#{meth.scan(/^\w*\s?\*?\n.*\)/)[0].gsub("\n", " ")};" }
+    clean_c_methods = []
+    # remove external variables that were previously injected
+    c_methods.join("\n").each { |meth| clean_c_methods << ArduinoSketch.post_process_ruby_to_c_methods(meth) }
+    c_methods_with_timer = clean_c_methods.join.gsub(/loop\(\)\s\{/,"loop() {")
+    # last chance to add/change setup
+    @setup[2] << sketch_signatures.join("\n") unless sketch_signatures.empty?
+    # add special setup method to existing setup if present
+    if @additional_setup
+      @setup[2] << "void additional_setup();" # declaration
+      @setup[4] << "\tadditional_setup();" # call from setup 
+      @setup[5] << @additional_setup.join("") # 
+    end
+    result = "#{@setup.join( "\n" )}\n#{c_methods_with_timer}\n"
+    File.open("#{@sketch.build_dir}/#{@sketch.name}.cpp", "w"){|f| f << result}
+  end
+
+  # needs to write the library include and the method signatures
+  desc "build setup function"
+  task :setup do
+    eval "class #{@sketch.klass} < ArduinoSketch; end;"
+    
+    @@as = HardwareLibrary.new
+    
+    delegate_methods = @@as.methods - Object.new.methods
+    delegate_methods.reject!{|m| m == "compose_setup"}
+        
+    delegate_methods.each do |meth|
+       constantize(@sketch.klass).module_eval <<-CODE
+       def self.#{meth}(*args)
+       @@as.#{meth}(*args)
+       end
+       CODE
+    end
+    # allow variable declaration without quotes: @foo = int 
+    ["long","unsigned","int","byte","short"].each do |type|
+      constantize(@sketch.klass).module_eval <<-CODE
+       def self.#{type}
+        return "#{type}"
+       end
+       CODE
+    end   
+    
+    @sketch.process_constants
+    
+    eval ArduinoSketch.pre_process(@sketch.body)
+    @@as.process_external_vars(constantize(@sketch.klass))
+    @setup = @@as.compose_setup
+  end
+  
+  desc "add plugin methods"
+  task :plugin_setup do
+    $plugins_to_load.each do |name|
+       klass = name.split(".").first.split("_").collect{|c| c.capitalize}.join("")
+       eval "class #{klass} < ArduinoPlugin; end;"
+    
+       @@ps = ArduinoPlugin.new
+       plugin_delegate_methods = @@ps.methods - Object.new.methods
+       plugin_delegate_methods.reject!{|m| m == "compose_setup"}
+    
+       plugin_delegate_methods.each do |meth|
+         constantize(klass).module_eval <<-CODE
+         def self.#{meth}(*args)
+           @@ps.#{meth}(*args)
+         end
+         CODE
+       end
+
+      eval ArduinoPlugin.process(File.read("vendor/plugins/#{name}"))
+      
+    end
+    @@no_plugins = ArduinoPlugin.new if @plugin_names.empty?
+  end
+  
+  desc "determine which plugins to load based on use of methods in sketch"
+  task :gather_required_plugins do
+    @plugin_names.each do |name|
+       ArduinoPlugin.check_for_plugin_use(@sketch.body, File.read("vendor/plugins/#{name}"), name )
+    end
+    puts "#{$plugins_to_load.length} of #{$plugin_methods_hash.length} plugins are being loaded:  #{$plugins_to_load.join(", ")}"
+  end
+  
+  desc "setup target directory named after your sketch class"
+  task :sketch_dir => [:file_list] do
+    @sketch.create_build_dir!
+  end
+
+  task :file_list do
+    # take another look at this, since if the root directory name is changed, everything breaks
+    # perhaps we generate a constant when the project is generated an pop it here or in the init file
+    if ENV['sketch']
+      @sketch = SketchCompiler.new File.expand_path("#{ENV['sketch']}.rb")
+    else
+      # assume the only .rb file in the sketch dir is the sketch:
+      @sketch = SketchCompiler.new Dir.glob("#{File.expand_path(File.dirname(__FILE__))}/../../../*.rb").first
+    end
+
+    @plugin_names = []
+    Dir.entries( File.expand_path("#{RAD_ROOT}/vendor/plugins/") ).each do |f|
+      if (f =~ /\.rb$/)
+        @plugin_names << f
+      end
+    end
+  end
+end
+
+#yoinked from Rails
+def constantize(camel_cased_word)
+  unless /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/ =~ camel_cased_word
+    raise NameError, "#{camel_cased_word.inspect} is not a valid constant name!"
+  end
+
+  Object.module_eval("::#{$1}", __FILE__, __LINE__)
+end

data/lib/rad/tasks/rad.rb

@@ -0,0 +1,2 @@
+require 'rake'
+Dir["#{File.dirname(__FILE__)}/*.rake"].each { |ext| load ext }

data/lib/rad/todo.txt

@@ -0,0 +1,13 @@
+TODO:
+=====
+	
+Future:
+	- complete library system: script/install library some_library
+	- bin/rad:
+		- setup and use a ~/.rad for new project defaults
+	- put repository on git
+	- project gallery (examples with movies)
+	- testing framework
+	- implement wire lib
+	- subclasses of ArduinoSketch (should just work, but what are they for?)
+	- simulator

data/lib/rad/variable_processing.rb

@@ -0,0 +1,153 @@
+module ExternalVariableProcessing
+  # issues 
+  # testing 
+  # add checking for colon
+
+    
+    ## need to clean this up
+    ## need to test 
+    def process_external_vars(klass)
+      vars = eval "#{klass}.instance_variables"
+      local_vars = []
+      vars.each { |v| local_vars << ":#{v.gsub("@", "")}" }
+      loc_vars = local_vars.join(", ")
+      # add accessors 
+      klass.module_eval "class << self; attr_accessor #{loc_vars} end"
+      local_vars.each do |symbol|
+        name = symbol.gsub(":","")
+        t_var = eval "#{klass}.#{name}"
+        pre_process_vars(name, t_var)
+      end
+    end
+    
+    
+    def pre_process_vars(name, var)
+        # puts 
+        # puts
+        case var
+        when Integer
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} 29"
+          value = var
+          type = "int"
+          post_process_vars(name, type, value)
+        when Float
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} 34"
+          value = var
+          type = "float"
+          post_process_vars(name, type, value)
+        when String
+          # puts "pre_process: #{name}, #{var.inspect} got #{var.class} on 39"
+          if var.match(",").nil? && var =~ /long|byte|unsigned|int|short/
+            # puts "pre_process #{name}, #{var.inspect} got #{var.class} level three sublevel"
+            type = var
+            value = nil
+            post_process_vars(name, type, value)
+          else
+            value = var.split(",").first.lstrip
+            type = var.split(",")[1].nil? ?  nil : var.split(",")[1].lstrip
+            translate_variables( name , type, value )
+          end
+        when TrueClass
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} on 50"
+          value = 1
+          type = "bool"
+          post_process_vars(name, type, value)
+        when FalseClass
+          # puts "pre_process: #{name}, #{var}, #{var.inspect} got #{var.class} on 55"
+          value = 0
+          type = "bool"
+          post_process_vars(name, type, value)
+        when Array
+          post_process_arrays(name, var)
+        else
+          raise ArgumentError, "not sure what to do here...  got #{name} with value #{var} which is a #{var.class}" 
+        end      
+    end     
+    
+    
+    def translate_variables(name, type = nil, value = nil)
+      
+      unless type.nil?
+        check_variable_type(type)
+      end
+
+      # classify the values
+      if value.class == Fixnum 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a fixnum, got #{value.class} on 74"
+      elsif value.class == Float 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a float, got #{value.class} on 76"
+      elsif value =~ /^-(\d|x)*$/ 
+        value = value.to_i
+        type = "int" if type.nil?
+      elsif value =~ /^-(\d|\.|x)*$/ 
+        value = value.to_f
+        unless type.nil?
+          raise ArgumentError, "#{value} should be a float got  #{type}" unless type == "float"
+        end
+        type = "float" if type.nil?   
+
+      elsif value[0,1] !~ /\d/
+        # puts value[0,1]
+        # puts "translate_variables: #{name}, #{value}, #{type} is a number of some type, got #{value.class} on 79"
+        type = "char*"
+        value = "\"#{value}\""
+      elsif value !~ /(\.|x)/
+        # puts "translate_variables: #{name}, #{value}, #{type} is an integer, got #{value.class} on 83"
+        value = value.to_i
+        type = "int" if type.nil?
+      elsif value =~ /(\d*\.\d*)/ # and no 
+        # puts "translate_variables: #{name}, #{value}, #{type} is a float, got #{value.class} on 87"
+        value = value.to_f
+        type = "float"
+      elsif value =~ /0x\d\d/
+        # puts "translate_variables: #{name}, #{value}, #{type} is a byte, got #{value.class} on 91"
+        type = "byte"
+      else
+        raise ArgumentError, "not sure what to do with a value of #{value} with a type like #{type}" 
+      end
+     
+      post_process_vars(name, type, value)
+    end
+    
+
+    
+    def post_process_vars(name, type, value = nil)
+      value = " = #{value}" if value 
+      $external_var_identifiers << "__#{name}" unless $external_var_identifiers.include?("__#{name}")
+      $external_vars << "#{type} __#{name}#{value};"
+    end
+    
+    def post_process_arrays(name, var)
+      type = c_type(var[0])
+      $array_types[name] = type
+      assignment = var.inspect.gsub("[","{").gsub("]","}")      
+      c_style_array = "#{type} __#{name}[] = #{assignment};"
+      $external_var_identifiers << "__#{name}" unless $external_var_identifiers.include?("__#{name}")
+      $external_array_vars << c_style_array unless $external_array_vars.include?(c_style_array)
+    end
+    
+    def check_variable_type(type)
+      unless type =~ /#{C_VAR_TYPES}/
+        raise ArgumentError, "the following variable types are supported \n #{C_VAR_TYPES.gsub("|",", ")} got #{type}" 
+      end
+    end
+    
+    def c_type(typ)
+      type = 
+        case typ 
+        when Integer
+          "int"
+        when String
+          "char*"
+        when TrueClass
+          "bool"
+        when FalseClass
+          "bool"
+        else
+          raise "Bug! Unknown type #{typ.inspect} in c_type"
+        end
+
+        type
+    end
+   
+end

data/lib/rad/version.rb

@@ -0,0 +1,9 @@
+module Rad #:nodoc:
+  module VERSION #:nodoc:
+    MAJOR = 0
+    MINOR = 3
+    TINY  = 1
+
+    STRING = [MAJOR, MINOR, TINY].join('.')
+  end
+end

data/lib/rad.rb

@@ -0,0 +1,5 @@
+module Rad
+end
+
+require 'rad/version'
+require 'rad/init'

data/scripts/txt2html

@@ -0,0 +1,67 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'redcloth'
+require 'syntax/convertors/html'
+require 'erb'
+require File.dirname(__FILE__) + '/../lib/rad/version.rb'
+
+version  = Rad::VERSION::STRING
+download = 'http://rubyforge.org/projects/rad'
+
+class Fixnum
+  def ordinal
+    # teens
+    return 'th' if (10..19).include?(self % 100)
+    # others
+    case self % 10
+    when 1: return 'st'
+    when 2: return 'nd'
+    when 3: return 'rd'
+    else    return 'th'
+    end
+  end
+end
+
+class Time
+  def pretty
+    return "#{mday}#{mday.ordinal} #{strftime('%B')} #{year}"
+  end
+end
+
+def convert_syntax(syntax, source)
+  return Syntax::Convertors::HTML.for_syntax(syntax).convert(source).gsub(%r!^<pre>|</pre>$!,'')
+end
+
+if ARGV.length >= 1
+  src, template = ARGV
+  template ||= File.dirname(__FILE__) + '/../website/template.rhtml'
+  
+else
+  puts("Usage: #{File.split($0).last} source.txt [template.rhtml] > output.html")
+  exit!
+end
+
+template = ERB.new(File.open(template).read)
+
+title = nil
+body = nil
+File.open(src) do |fsrc|
+  title_text = fsrc.readline
+  body_text = fsrc.read
+  syntax_items = []
+  body_text.gsub!(%r!<(pre|code)[^>]*?syntax=['"]([^'"]+)[^>]*>(.*?)</
>!m){
+    ident = syntax_items.length
+    element, syntax, source = $1, $2, $3
+    syntax_items << "<#{element} class='syntax'>#{convert_syntax(syntax, source)}</#{element}>"
+    "syntax-temp-#{ident}"
+  }
+  title = RedCloth.new(title_text).to_html.gsub(%r!<.*?>!,'').strip
+  body = RedCloth.new(body_text).to_html
+  body.gsub!(%r!(?:<pre><code>)?syntax-temp-(d+)(?:</code></pre>)?!){ syntax_items[$1.to_i] }
+end
+stat = File.stat(src)
+created = stat.ctime
+modified = stat.mtime
+
+$stdout << template.result(binding)