cxxproject 0.6.30 → 0.6.31

data/lib/cxxproject/utils/progress.rb

@@ -1,66 +0,0 @@
-module Cxxproject
-  module Utils
-    define_progress = lambda do
-      require 'rake'
-      require 'cxxproject/ext/rake'
-
-      require 'progressbar'
-      require 'cxxproject/ext/progressbar'
-      require 'colored'
-      require 'cxxproject/utils/progress_helper'
-
-      class ProgressListener
-        def initialize
-          @progress_helper = ProgressHelper.new
-          Rake::application.top_level_tasks.each do |name|
-            @progress_helper.count_with_filter(name)
-          end
-          @progress = ProgressBar.new('all tasks', @progress_helper.todo)
-          @progress.title_width = 30
-          @progress.unblock
-        end
-
-        def after_execute(name)
-          needed_tasks = @progress_helper.needed_tasks
-          if needed_tasks[name]
-            task = Rake::Task[name]
-            @progress.title = task.name
-            @progress.inc(task.progress_count)
-            if (@progress.total == @progress.current)
-              puts
-            end
-          end
-        end
-      end
-
-      require 'benchmark'
-      class BenchmarkedProgressListener < ProgressListener
-        def initialize
-          Benchmark.bm do |x|
-            x.report('ProgressListener.initialize') do
-              super
-            end
-          end
-        end
-      end
-
-      desc 'show a progressbar for the build (use with -s for best results)'
-      task :progress do
-        require 'cxxproject/ext/rake_listener'
-        Rake::add_listener(ProgressListener.new)
-      end
-
-      task :benchmark_progress do
-        require 'cxxproject/ext/rake_listener'
-        Rake::add_listener(BenchmarkedProgressListener.new)
-      end
-    end
-
-    could_not_define_progress = lambda {
-      task :progress do
-        puts 'could not define progress'
-      end
-    }
-    optional_package(define_progress, could_not_define_progress)
-  end
-end

data/lib/cxxproject/utils/progress_helper.rb

@@ -1,77 +0,0 @@
-module Cxxproject
-  module Utils
-    class ProgressHelper
-
-      attr_reader :todo
-
-      attr_reader :needed_tasks
-
-      def initialize
-        @todo = 0.0
-        @needed_tasks = {}
-      end
-
-      def count_with_filter(name)
-        tasks = find_tasks_for_toplevel_task(name)
-        tasks.each do |t|
-          count(t)
-        end
-        if @todo < 1
-          @todo = 1
-        end
-      end
-
-      def find_tasks_for_toplevel_task(name)
-        regex = create_regex_for_name(name)
-        return filter_all_tasks(regex)
-      end
-
-      def create_regex_for_name(name)
-        res = Regexp.new(name)
-        res = create_regex_for_filter(name, res)
-        return res
-      end
-
-      def is_filter(name)
-        return name.index('filter')
-      end
-
-      def create_regex_for_filter(name, res)
-        return res unless is_filter(name)
-
-        name = name.gsub('filter', '')
-        if name.index('[') == nil
-          name = name + '.*'
-        else
-          name = name.gsub('[', '')
-          name = name.gsub(']', '')
-        end
-        return Regexp.new(name)
-      end
-
-      def filter_all_tasks(regex)
-        return Rake::Task::tasks.find_all do |t|
-          task_name = t.name
-          res = ((task_name.index('filter') == nil) && regex.match(task_name)!=nil)
-        end
-      end
-
-      def count(task)
-        task.visit() do |t|
-          count_needed_tasks(t)
-          true
-        end
-      end
-
-      def count_needed_tasks(t)
-        c = t.progress_count
-        if c && c > 0
-          if t.needed? && @needed_tasks[t.name] == nil
-            @needed_tasks[t.name] = true
-            @todo += c
-          end
-        end
-      end
-    end
-  end
-end

data/lib/cxxproject/utils/rbcurse.rb

@@ -1,284 +0,0 @@
-module Cxxproject
-  module Utils
-    define_rbcurse_ui = lambda do
-      require 'rake'
-      require 'ncurses'
-      require 'rbcurse'
-
-      require 'rbcurse/rtable'
-      require 'rbcurse/table/tablecellrenderer'
-      require 'rbcurse/rsplitpane'
-      require 'rbcurse/rtextview'
-      require 'cxxproject/ext/rake_listener'
-      require 'cxxproject/utils/rbcurse_progress'
-      require 'cxxproject/utils/rbcurse_tasktable'
-
-      include RubyCurses
-
-      Rake::TaskManager.record_task_metadata = true
-
-      class RakeGui
-        def initialize
-          require 'cxxproject/utils/rbcurse_executable_ext'
-          Cxxproject::ColorizingFormatter.enabled = false
-          Rake::Task.output_disabled = true
-
-          $log = Logger.new(File.join("./", "view.log"))
-          $log.level = Logger::ERROR
-          @data_stack = []
-          @path_stack = []
-        end
-
-        def self.keycode(s)
-          return s[0].to_i
-        end
-
-        def create_table
-          @col_names = ['name', 'desc']
-          return TaskTable.new(self) do
-            name 'my table'
-            title 'my table'
-            cell_editing_allowed false
-          end
-        end
-
-        def reenable_including_prerequisites(task)
-          task.visit() do |t|
-            t.reenable
-            true
-          end
-        end
-
-        def invoke(table)
-          t = table.get_value_at(table.focussed_row, 0)
-          @progress_helper = ProgressHelper.new
-          complete_task_name = t.name
-          args = []
-          if @progress_helper.is_filter(t.name)
-            args = [get_string('please input filterpattern', 20, '.*')]
-            complete_task_name = "#{t.name}[#{args[0]}]"
-          end
-          @progress_helper.count_with_filter(complete_task_name)
-
-          @progress.max = @progress_helper.todo
-          Rake::add_listener(self)
-          reenable_including_prerequisites(t)
-          t.invoke(args)
-          Rake::remove_listener(self)
-          show_details_for(table.focussed_row)
-          table.repaint_all(true)
-        end
-
-        def after_execute(name)
-          needed_tasks = @progress_helper.needed_tasks
-          if needed_tasks[name]
-            task = Rake::Task[name]
-            @progress.title = task.name
-            @progress.inc(task.progress_count)
-            @form.repaint
-          end
-        end
-
-        def details(table)
-          t = table.get_value_at(table.focussed_row, 0)
-          pre = t.prerequisite_tasks
-          if pre.size > 0
-            push_table_data(pre, t.name)
-            table.set_focus_on 0
-
-            show_details_for(0)
-          end
-        end
-
-        def repaint_and_next_char
-          @form.repaint
-          @window.wrefresh
-          return @window.getchar
-        end
-
-        def process_input_events
-          ch = repaint_and_next_char
-          while ch != RakeGui.keycode('q')
-            $log.error "entered key: #{ch}"
-            case ch
-            when RakeGui.keycode('a')
-              @h_split.set_divider_location(@h_split.divider_location+1)
-            when RakeGui.keycode('s')
-              @h_split.set_divider_location(@h_split.divider_location-1)
-            else
-              @form.handle_key(ch)
-            end
-            ch = repaint_and_next_char
-          end
-        end
-
-        def push_table_data(task_data, new_path=nil)
-          @path_stack.push(new_path) if new_path
-          set_breadcrumbs
-
-          @data_stack.push(task_data)
-          set_table_data(task_data)
-        end
-        def set_table_data(task_data)
-          size = size()
-          new_data = task_data.map{|t|[t, t.comment]}
-          @table.set_data new_data, @col_names
-          tcm = @table.table_column_model
-          first_col_width = task_data.map{|t|t.name.size}.max
-          tcm.column(0).width(first_col_width)
-          tcm.column(1).width(size[0]-first_col_width-3)
-        end
-        def set_breadcrumbs
-          crumbs = File.join(@path_stack.map{|i|"(#{i})"}.join('/'))
-          @breadcrumbs.text = crumbs
-          @breadcrumbs.repaint_all(true)
-        end
-        def pop_data
-          if @data_stack.size > 1
-            @path_stack.pop
-            set_breadcrumbs
-
-            popped = @data_stack.pop
-            top= @data_stack.last
-            set_table_data(top)
-          end
-        end
-
-        def size
-          return @window.default_for(:width), @window.default_for(:height)
-        end
-
-        def show_details_for(row)
-          buffer = StringIO.new
-          t = @table.get_value_at(row, 0)
-          t.visit do |t|
-            if t.output_string && t.output_string.length > 0
-              buffer.puts(t.output_string)
-            end
-            if t.failure
-              true
-            else
-              false
-            end
-          end
-          @output.set_content(buffer.string)
-          @output.set_focus_on(0)
-          @output.repaint_all(true)
-        end
-
-        def start_editor_for_task(t)
-          file_name = t.name
-          return unless File.exists?(file_name)
-
-          start_editor(file_name, 0, 0)
-        end
-
-        def start_editor(file, line, column)
-          $log.error "starting editor for #{file}:#{line}"
-          editor = ENV['EDITOR']
-          editor = 'vi' unless editor
-          cmd = "#{editor} +#{line} #{file}"
-          shell_out(cmd)
-        end
-
-        def shell_out(cmd)
-          @window.hide
-          Ncurses.endwin
-          system(cmd)
-          Ncurses.refresh
-          @window.show
-        end
-
-        def create_breadcrumbs(size)
-          @breadcrumbs = Label.new @form do
-            name 'breadcrumbs'
-            row 0
-            col 0
-            width size[0]
-            height 1
-          end
-          @breadcrumbs.display_length(size[0])
-          @breadcrumbs.text = ''
-        end
-
-        def create_splitpane(size)
-          @h_split = SplitPane.new @form do
-            name 'mainpane'
-            row 1
-            col 0
-            width size[0]
-            height size[1]-3
-            orientation :HORIZONTAL_SPLIT
-          end
-        end
-
-        def create_output_view(size)
-          @output = TextView.new nil
-          @output.set_content('')
-          @output.configure do
-            bind_key(RakeGui.keycode('e')) do |code|
-              line = selected_item
-              file_pattern = '(.*?):(\d+):(\d*):? '
-              error_pattern = Regexp.new("#{file_pattern}(error: .*)")
-              warning_pattern = Regexp.new("#{file_pattern}(warning: .*)")
-              md = error_pattern.match(line)
-              md = warning_pattern.match(line) unless md
-              if md
-                file_name = md[1]
-                line = md[2]
-                col = md[3]
-                rake_gui.start_editor(file_name, line, col)
-              end
-            end
-          end
-        end
-
-        def create_components(size)
-          create_breadcrumbs(size)
-          @progress = Progress.new(@form, size)
-          create_splitpane(size)
-          @table = create_table
-          push_table_data(Rake::Task.tasks.select {|t|t.comment})
-
-          create_output_view(size)
-        end
-
-        def wire_components
-          @h_split.first_component(@table)
-          @h_split.second_component(@output)
-          @h_split.set_resize_weight(0.50)
-        end
-
-        def run
-          rake_gui = self
-          begin
-            VER::start_ncurses
-
-            @window = VER::Window.root_window
-            @form = Form.new @window
-
-            create_components(size())
-            wire_components
-
-            @table.bind(:TABLE_TRAVERSAL_EVENT) do |e|
-              rake_gui.show_details_for(e.newrow)
-            end
-
-            process_input_events
-          rescue => e
-            puts e
-          end
-          @window.destroy if @window
-          VER::stop_ncurses
-        end
-      end
-
-      task :ui do
-        RakeGui.new.run
-      end
-
-    end
-
-    optional_package(define_rbcurse_ui, nil)
-  end
-end

data/lib/cxxproject/utils/ubigraph.rb

@@ -1,228 +0,0 @@
-module Cxxproject
-  define_ubigraph = lambda do
-    require 'rubigraph'
-
-    module Rubigraph
-      class Vertex
-        alias_method :initialize_original, :initialize
-        def initialize(id = nil)
-          if id != nil
-            @id = id
-          else
-            initialize_original
-          end
-        end
-      end
-    end
-
-    class IdsAndEdges
-      attr_reader :ids, :edges
-      def initialize
-        @ids = Hash.new
-        @edges = Hash.new
-      end
-    end
-
-    class V
-
-      def self.shutdown
-        File.open('id_cache', 'w') do |f|
-          f.write(@@ids_and_edges.to_yaml)
-        end
-      end
-
-      def self.reset
-        begin
-          File.delete('id_cache')
-        rescue StandardError => e
-          puts e
-          puts 'problem deleting id_cache'
-        end
-        @@ids_and_edges = IdsAndEdges.new
-      end
-
-      def self.startup
-        begin
-          @@ids_and_edges = YAML.load_file('id_cache')
-        rescue
-          @@ids_and_edges = IdsAndEdges.new
-        end
-      end
-
-      attr_reader :v
-
-      def initialize(name)
-        h = @@ids_and_edges.ids
-        id = h[name]
-        if !id
-          @v = Rubigraph::Vertex.new
-          @@ids_and_edges.ids()[name] = @v.id
-        else
-          @v = Rubigraph::Vertex.new(id)
-        end
-      end
-      def self.create_edge(edge_and_task1, edge_and_task2)
-        complete_name = "#{edge_and_task1[:task].name}->#{edge_and_task2[:task].name}"
-        if @@ids_and_edges.edges.has_key?(complete_name)
-          return nil
-        else
-          e = Rubigraph::Edge.new(edge_and_task1[:vertex].v, edge_and_task2[:vertex].v)
-          @@ids_and_edges.edges[complete_name] = true
-          return e
-        end
-      end
-    end
-
-    class UbiGraphSupport
-
-      def object?(name)
-        name.match(/.*\.o\Z/) != nil
-      end
-
-      def exe?(name)
-        name.match(/.*\.exe\Z/) != nil
-      end
-      def library?(name)
-        name.match(/.*\.a\Z/) != nil
-      end
-      def multitask?(name)
-        name.index("Sources") == 0
-      end
-      def interesting?(name)
-        exe?(name) || object?(name) || library?(name) || multitask?(name)
-      end
-      def create_vertices
-        @vertices = {}
-        @interesting_tasks.each do |task|
-          v = V.new(task.name)
-          @vertices[task.name] = {:vertex=>v, :task=>task}
-        end
-      end
-      def create_edges
-        @interesting_tasks.each do |task|
-          name = task.name
-          v1 = @vertices[name]
-          task.prerequisites.each do |p|
-            v2 = @vertices[p]
-            if (v2 != nil)
-              e = V.create_edge(v1, v2)
-              e.width=2 if e
-            end
-          end
-        end
-      end
-      def color_vertices
-        @vertices.each do |k, value|
-          v = value[:vertex]
-          v.v.label = k
-          set_attributes(v, k)
-        end
-      end
-      def initialize
-        @interesting_tasks = Rake::Task.tasks.select { |i| interesting?(i.name) }
-        create_vertices
-        create_edges
-        color_vertices
-      end
-
-      def update_colors
-        @vertices.each_key do |k|
-          set_attributes(v, k)
-        end
-      end
-
-      def set_attributes(v, name)
-        v.v.color = state2color(name)
-        v.v.shape = name2shape(name)
-        v.v.size = name2size(name)
-      end
-
-      def name2shape(name)
-        if object?(name)
-          return 'cube'
-        elsif exe?(name)
-          return 'sphere'
-        elsif multitask?(name)
-          return 'torus'
-        else
-          return 'octahedron'
-        end
-      end
-      def name2size(name)
-        if object?(name)
-          return 0.7
-        elsif exe?(name)
-          return 1.2
-        else
-          return 1.0
-        end
-      end
-      def state2color(name)
-        t = @vertices[name][:task]
-        begin
-          if t.dirty?
-            return '#ff0000'
-          else
-            return '#00ff00'
-          end
-        rescue StandardError => bang
-          puts bang
-          return '#ff00ff'
-        end
-      end
-
-      def update(name, color)
-        @vertices[name][:vertex].v.color = color if @vertices[name]
-      end
-
-      YELLOW = '#ffff00'
-      def before_prerequisites(name)
-        update(name, YELLOW)
-      end
-
-      ORANGE = '#ff7f00'
-      def after_prerequisites(name)
-        update(name, ORANGE)
-      end
-
-      BLUE = '#0000ff'
-      def before_execute(name)
-        update(name, BLUE)
-      end
-
-      GREEN = '#00ff00'
-      def after_execute(name)
-        update(name, GREEN)
-      end
-    end
-
-    namespace :rubygraph do
-      task :init do
-        Rubigraph.init
-        V.startup
-        at_exit do
-          V.shutdown
-        end
-      end
-
-      desc 'clear rubygraph'
-      task :clear => :init do
-        Rubigraph.clear
-        V.reset
-      end
-
-      desc 'update rubygraph'
-      task :update => :init do
-        begin
-          require 'cxxproject/ext/rake_listener'
-          require 'cxxproject/ext/rake_dirty'
-          Rake::add_listener(UbiGraphSupport.new)
-        rescue StandardError => e
-          puts e
-        end
-      end
-    end
-  end
-
-  Utils.optional_package(define_ubigraph, nil)
-end