rubygoo 0.0.3

data/lib/code_statistics.rb

@@ -0,0 +1,107 @@
+class CodeStatistics #:nodoc:
+
+  TEST_TYPES = %w(Units Functionals Unit\ tests Functional\ tests Integration\ tests)
+
+  def initialize(*pairs)
+    @pairs      = pairs
+    @statistics = calculate_statistics
+    @total      = calculate_total if pairs.length > 1
+  end
+
+  def to_s
+    print_header
+    @pairs.each { |pair| print_line(pair.first, @statistics[pair.first]) }
+    print_splitter
+  
+    if @total
+      print_line("Total", @total)
+      print_splitter
+    end
+
+    print_code_test_stats
+  end
+
+  private
+    def calculate_statistics
+      @pairs.inject({}) { |stats, pair| stats[pair.first] = calculate_directory_statistics(pair.last); stats }
+    end
+
+    def calculate_directory_statistics(directory, pattern = /.*\.rb$/)
+      stats = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+
+      Dir.foreach(directory) do |file_name| 
+        if File.stat(directory + "/" + file_name).directory? and (/^\./ !~ file_name)
+          newstats = calculate_directory_statistics(directory + "/" + file_name, pattern)
+          stats.each { |k, v| stats[k] += newstats[k] }
+        end
+
+        next unless file_name =~ pattern
+
+        f = File.open(directory + "/" + file_name)
+
+        while line = f.gets
+          stats["lines"]     += 1
+          stats["classes"]   += 1 if line =~ /class [A-Z]/
+          stats["methods"]   += 1 if line =~ /def [a-z]/
+          stats["codelines"] += 1 unless line =~ /^\s*$/ || line =~ /^\s*#/
+        end
+      end
+
+      stats
+    end
+
+    def calculate_total
+      total = { "lines" => 0, "codelines" => 0, "classes" => 0, "methods" => 0 }
+      @statistics.each_value { |pair| pair.each { |k, v| total[k] += v } }
+      total
+    end
+
+    def calculate_code
+      code_loc = 0
+      @statistics.each { |k, v| code_loc += v['codelines'] unless TEST_TYPES.include? k }
+      code_loc
+    end
+
+    def calculate_tests
+      test_loc = 0
+      @statistics.each { |k, v| test_loc += v['codelines'] if TEST_TYPES.include? k }
+      test_loc
+    end
+
+    def print_header
+      print_splitter
+      puts "| Name                 | Lines |   LOC | Classes | Methods | M/C | LOC/M |"
+      print_splitter
+    end
+
+    def print_splitter
+      puts "+----------------------+-------+-------+---------+---------+-----+-------+"
+    end
+
+    def print_line(name, statistics)
+      m_over_c   = (statistics["methods"] / statistics["classes"])   rescue m_over_c = 0
+      loc_over_m = (statistics["codelines"] / statistics["methods"]) - 2 rescue loc_over_m = 0
+
+      start = if TEST_TYPES.include? name
+        "|   #{name.ljust(18)} "
+      else
+        "| #{name.ljust(20)} " 
+      end
+
+      puts start + 
+           "| #{statistics["lines"].to_s.rjust(5)} " +
+           "| #{statistics["codelines"].to_s.rjust(5)} " +
+           "| #{statistics["classes"].to_s.rjust(7)} " +
+           "| #{statistics["methods"].to_s.rjust(7)} " +
+           "| #{m_over_c.to_s.rjust(3)} " +
+           "| #{loc_over_m.to_s.rjust(5)} |"
+    end
+
+    def print_code_test_stats
+      code  = calculate_code
+      tests = calculate_tests
+
+      puts "  Code LOC: #{code}     Test LOC: #{tests}     Code to Test Ratio: 1:#{sprintf("%.1f", tests.to_f/code)}"
+      puts ""
+    end
+  end

data/lib/platform.rb

@@ -0,0 +1,15 @@
+# Helper functions for determining platform
+
+class Platform
+	def self.mac?
+	  return PLATFORM =~ /darwin/
+	end
+	
+	def self.windows?
+	  return PLATFORM =~ /mswin/
+	end
+	
+	def self.linux?
+		PLATFORM =~ /linux/
+	end
+end

data/lib/rubygoo.rb

@@ -0,0 +1,19 @@
+$: << File.dirname(__FILE__)
+$: << File.join(File.dirname(__FILE__),"rubygoo")
+$: << File.join(File.dirname(__FILE__),"rubygoo","adapters")
+class Rubygoo
+  VERSION = '0.0.3'
+end
+
+require 'goo_event'
+require 'goo_color'
+require 'adapter_factory'
+require 'yaml'
+require 'widget'
+require 'container'
+require 'app'
+require 'label'
+require 'button'
+require 'check_box'
+require 'text_field'
+require 'dialog'

data/lib/rubygoo/adapters/adapter_factory.rb

@@ -0,0 +1,14 @@
+class AdapterFactory
+
+  def app_for(platform,*args)
+    require "#{platform}_app_adapter"
+    ObjectSpace.const_get("#{platform.to_s.capitalize}AppAdapter").new *args
+  end
+
+  def renderer_for(platform,*args)
+    require "#{platform}_render_adapter"
+    ObjectSpace.const_get("#{platform.to_s.capitalize}RenderAdapter").new *args
+  end
+
+
+end

data/lib/rubygoo/adapters/gosu_app_adapter.rb

@@ -0,0 +1,50 @@
+class GosuAppAdapter
+
+  def initialize(app,main_window)
+    @app = app
+    @main_window = main_window
+  end
+
+  def update(time)
+    @app.update time
+  end
+
+  def draw(target)
+    @app.draw target
+  end
+
+  # TODO convert keys?!?
+  def button_down(id)
+    case id
+    when MsLeft
+      @app.on_event GooEvent.new(:mouse_down, { 
+        :x => @main_window.mouse_x, :y => @main_window.mouse_y, 
+        :button => MOUSE_LEFT})
+
+    # gosu doens't track mouse motion?
+    when MouseMotionEvent
+      @app.on_event GooEvent.new(:mouse_motion, { 
+        :x => event.pos[0], :y => event.pos[1]})
+    else
+      # assume it's a key
+      # where do I get the mods? ie shift,alt,ctrl
+      # where do I get the string rep of the char?
+      mods = []
+      mods << K_LALT if @main_window.button_down? KbLeftAlt
+      mods << K_RALT if @main_window.button_down? KbRightAlt
+      mods << K_LCTRL if @main_window.button_down? KbLeftControl
+      mods << K_RCTRL if @main_window.button_down? KbRightControl
+      mods << K_LSHIFT if @main_window.button_down? KbLeftShift
+      mods << K_RSHIFT if @main_window.button_down? KbRightShift
+      button_string = @main_window.button_id_to_char(id)
+      @app.on_event GooEvent.new(:key_pressed, { 
+        :key => id, :mods => mods, :string => button_string})
+    end
+  end
+
+  def button_up(id)
+    # TODO copy and tweak from above
+  end
+
+
+end

data/lib/rubygoo/adapters/gosu_render_adapter.rb

@@ -0,0 +1,53 @@
+class GosuRenderAdapter
+
+  def initialize(window)
+    @window = window
+  end
+
+  def draw_box(x1,y1,x2,y2,color)
+    c = convert_color(color)
+    @window.draw_quad x1, y1, c, x2, y1, c, x1, y2, c, x2, y2, c
+  end
+
+  # fill in a rect with color or full screen if no color
+  def fill(color,rect=nil)
+    if rect.nil? 
+      draw_box 0, 0, @window.width, @window.height, color
+    else
+      draw_box rect[0], rect[1], rect[2], rect[3], color
+    end
+  end
+
+  # make static for now for migration ease of rendering fonts
+  def convert_color(goo_color)
+    Gosu::Color.new goo_color.a,goo_color.r,goo_color.g,goo_color.b
+  end
+
+  def start_drawing(); end
+
+  def finish_drawing(); end
+
+  def draw_image(img, x, y)
+    # z is unused here
+    img.draw x, y, 1
+  end
+
+  def size_text(text, font_file, font_size)
+    @font_cache ||= {}
+    @font_cache[font_file] ||= {}
+    font = @font_cache[font_file][font_size] ||= Font.new(@window, font_file, font_size)
+
+    return [font.text_width(text),font.height]
+  end
+
+  def render_text(text, font_file, font_size, color)
+    @font_cache ||= {}
+    @font_cache[font_file] ||= {}
+    font = @font_cache[font_file][font_size] ||= Font.new(@window, font_file, font_size)
+
+    # TODO how do you set the color here?
+    text_image = Image.from_text(@window, text, font_file, font_size, 2, 9999, :left)
+  end
+
+
+end

data/lib/rubygoo/adapters/rubygame_app_adapter.rb

@@ -0,0 +1,37 @@
+class RubygameAppAdapter
+
+  def initialize(app)
+    @app = app
+  end
+
+  def update(time)
+    @app.update time
+  end
+
+  def draw(target)
+    @app.draw target
+  end
+
+  # TODO convert keys?!?
+  def on_event(event)
+    case event
+    when KeyUpEvent
+      @app.on_event GooEvent.new(:key_released, { 
+        :key => event.key, :mods => event.mods, :string => event.string})
+    when KeyDownEvent
+      @app.on_event GooEvent.new(:key_pressed, { 
+        :key => event.key, :mods => event.mods, :string => event.string})
+    when MouseUpEvent
+      @app.on_event GooEvent.new(:mouse_up, { 
+        :x => event.pos[0], :y => event.pos[1], :button => event.button})
+    when MouseDownEvent
+      @app.on_event GooEvent.new(:mouse_down, { 
+        :x => event.pos[0], :y => event.pos[1], :button => event.button})
+    when MouseMotionEvent
+      @app.on_event GooEvent.new(:mouse_motion, { 
+        :x => event.pos[0], :y => event.pos[1]})
+    end
+  end
+
+
+end

data/lib/rubygoo/adapters/rubygame_render_adapter.rb

@@ -0,0 +1,51 @@
+class RubygameRenderAdapter
+
+  def initialize(screen)
+    @screen = screen
+    TTF.setup
+  end
+
+  def draw_box(x1,y1,x2,y2,color)
+    @screen.draw_box [x1,y1], [x2,y2], convert_color(color)
+  end
+
+  # fill in a rect with color or full screen if no color
+  def fill(color,rect=nil)
+    if rect.nil? 
+      @screen.fill convert_color(color)
+    else
+      @screen.fill convert_color(color), rect
+    end
+  end
+
+  def convert_color(goo_color)
+    [goo_color.r,goo_color.g,goo_color.b,goo_color.a]
+  end
+
+  def start_drawing(); end
+
+  def finish_drawing()
+    @screen.flip
+  end
+
+  def draw_image(img, x, y)
+    img.blit @screen, [x,y]
+  end
+
+  def size_text(text, font_file, font_size)
+    @font_cache ||= {}
+    @font_cache[font_file] ||= {}
+    font = @font_cache[font_file][font_size] ||= TTF.new(font_file, font_size)
+
+    font.size_text text
+  end
+
+  def render_text(text, font_file, font_size, color)
+    @font_cache ||= {}
+    @font_cache[font_file] ||= {}
+    font = @font_cache[font_file][font_size] ||= TTF.new(font_file, font_size)
+
+    text_image = font.render text, true, convert_color(color)
+  end
+
+end

data/lib/rubygoo/app.rb

@@ -0,0 +1,80 @@
+class App < Container
+
+  DEFAULT_PARAMS = {:theme=>'default',:x=>10,:y=>10,:width=>600,:height=>480,:data_dir=>File.join(File.dirname(__FILE__),"..","..","themes")}
+  attr_accessor :theme_name, :theme, :data_dir, :theme_dir, :renderer
+
+  def initialize(opts={})
+    merged_opts = DEFAULT_PARAMS.merge opts
+    @widgets = []
+    @tabbed_widgets = []
+    @focussed_widget = 0
+    theme_name = merged_opts[:theme]
+    @data_dir = merged_opts[:data_dir]
+    @theme_name = theme_name
+    @theme = load_theme theme_name
+    @renderer = merged_opts[:renderer]
+    super merged_opts
+  end
+
+  def app()
+    self
+  end
+
+  def load_theme(theme_name)
+    @theme_dir = File.join(@data_dir,theme_name)
+    @theme = YAML::load_file(File.join(@theme_dir,"config.yml"))
+  end
+
+  def draw(screen)
+    screen.start_drawing
+    super screen
+    screen.finish_drawing
+  end
+
+  def add_tabbed_widget(w)
+    w.focus_priority = @tabbed_widgets.size unless w.focus_priority
+    @focussed_widget = 1
+    w.focus if @tabbed_widgets.empty?
+    @tabbed_widgets << w 
+    @tabbed_widgets.sort_by {|w| w.focus_priority}
+  end
+
+  def focus_back()
+    @tabbed_widgets[@focussed_widget].unfocus
+    @focussed_widget += 1
+    @focussed_widget %= @tabbed_widgets.size
+    @tabbed_widgets[@focussed_widget].focus
+  end
+
+  def focus_forward()
+    @tabbed_widgets[@focussed_widget].unfocus
+    @focussed_widget -= 1
+    @focussed_widget %= @tabbed_widgets.size
+    @tabbed_widgets[@focussed_widget].focus
+  end
+
+  # this is where all the rubygame to rubygoo event mapping will
+  # happen
+  def on_event(event)
+    case event.event_type
+    when :key_released
+      modal_keyboard_call :key_released, event
+    when :key_pressed
+      case event.data[:key]
+      when K_TAB
+        if event.data[:mods].include? K_LSHIFT or event.data[:mods].include? K_RSHIFT
+          focus_back
+        else
+          focus_forward
+        end
+      else
+        modal_keyboard_call :key_pressed, event
+      end
+    else
+      # ALL mouse events go here
+      modal_mouse_call event.event_type, event
+    end
+  end
+
+end
+