kgem 0.1.0

data/lib/installedwin.rb

@@ -0,0 +1,286 @@
+#
+#
+#
+
+class StaleGemItem
+    attr_reader :name, :version, :atime
+    def initialize(name, ver, atime)
+        @name = name
+        @version = ver
+        @atime = atime
+    end
+end
+
+
+#-----------------------------------------------
+#
+#
+class GemListTable < Qt::TableWidget
+    #
+    #
+    class Item < Qt::TableWidgetItem
+        def initialize(text)
+            super(text)
+            self.flags = Qt::ItemIsSelectable | Qt::ItemIsEnabled
+        end
+
+        def gem
+            tableWidget.gem(self)
+        end
+    end
+
+
+    # column no
+    PACKAGE_NAME = 0
+    PACKAGE_VERSION = 1
+    PACKAGE_SUMMARY = 2
+    PACKAGE_ATIME = 3
+
+    def initialize(title)
+        super(0,4)
+
+        self.windowTitle = title
+        setHorizontalHeaderLabels(['package', 'version', 'summary', 'last access'])
+        self.horizontalHeader.stretchLastSection = true
+        self.selectionBehavior = Qt::AbstractItemView::SelectRows
+        self.selectionMode = Qt::AbstractItemView::SingleSelection
+        self.alternatingRowColors = true
+        self.sortingEnabled = true
+        sortByColumn(PACKAGE_NAME, Qt::AscendingOrder )
+        @gems = {}
+    end
+
+    # caution ! : befor call, sortingEnabled must be set false.
+    #   if sortingEnabled is on while updating table, it is very sluggish.
+    def addPackage(row, gem)
+#         self.sortingEnabled = false
+        nameItem = Item.new(gem.package)
+        @gems[nameItem] = gem           # 0 column item is hash key.
+        setItem( row, PACKAGE_NAME, nameItem  )
+        setItem( row, PACKAGE_VERSION, Item.new(gem.version) )
+        setItem( row, PACKAGE_SUMMARY, Item.new(gem.summary) )
+        setItem( row, PACKAGE_ATIME, Item.new('') )
+    end
+
+
+    def updateGemList(gemList)
+        sortFlag = self.sortingEnabled
+        self.sortingEnabled = false
+
+        clearContents
+        self.rowCount = gemList.length
+        gemList.each_with_index do |g, r|
+            addPackage(r, g)
+        end
+
+        self.sortingEnabled = sortFlag
+    end
+
+
+    def gem(item)
+        gemAtRow(item.row)
+    end
+
+    def gemAtRow(row)
+        @gems[item(row,0)]       # use 0 column item as hash key.
+    end
+
+    def currentGem
+        gemAtRow(currentRow)
+    end
+
+    def showall
+        rowCount.times do |r|
+            showRow(r)
+        end
+    end
+
+
+    slots   'filterChanged(const QString &)'
+    def filterChanged(text)
+        unless text && !text.empty?
+            showall
+            return
+        end
+
+        regxs = /#{Regexp.escape(text.strip)}/i
+        rowCount.times do |r|
+            gem = gemAtRow(r)
+            txt = [ gem.package, gem.summary, gem.author, gem.platform ].inject("") do |s, t|
+                        t.nil? ? s : s + t.to_s
+            end
+            if regxs =~ txt then
+                showRow(r)
+            else
+                hideRow(r)
+            end
+        end
+    end
+
+    # @return : number : row of found item.
+    def find
+        rowCount.times do |r|
+            i = gemAtRow(r)
+            return r if yield i
+        end
+        false
+    end
+end
+
+
+
+#--------------------------------------------------------------------
+#
+#
+class InstalledGemWin < Qt::Widget
+    def initialize(parent=nil)
+        super(parent)
+
+        createWidget
+        readSettings
+
+        Qt::Timer.singleShot(0, self, SLOT(:updateInstalledGemList))
+    end
+
+    def createWidget
+        @installedGemsTable = GemListTable.new('installed')
+
+        @viewDirBtn = KDE::PushButton.new(KDE::Icon.new('folder'), 'View Directory')
+        @viewRdocBtn = KDE::PushButton.new(KDE::Icon.new('help-contents'), 'View RDoc')
+        @generateRdocBtn = KDE::PushButton.new(KDE::Icon.new('document-new'), 'Generate RDoc/ri')
+        @updateGemBtn = KDE::PushButton.new(KDE::Icon.new('view-refresh'), 'Update')
+
+        @uninstallBtn = KDE::PushButton.new(KDE::Icon.new('list-remove'), 'Uninstall')
+
+        @filterInstalledLineEdit = KDE::LineEdit.new do |w|
+            connect(w,SIGNAL('textChanged(const QString &)'),
+                    @installedGemsTable, SLOT('filterChanged(const QString &)'))
+            w.setClearButtonShown(true)
+        end
+        @checkTestBtn = KDE::PushButton.new(KDE::Icon.new('checkbox'), 'Test')
+
+
+        # connect
+        connect(@viewDirBtn, SIGNAL(:clicked), self, SLOT(:viewDir))
+        connect(@viewRdocBtn, SIGNAL(:clicked), self, SLOT(:viewRdoc))
+        connect(@uninstallBtn, SIGNAL(:clicked), self, SLOT(:uninstallGem))
+        connect(@installedGemsTable, SIGNAL('itemClicked(QTableWidgetItem *)'),
+                    self, SLOT('itemClicked(QTableWidgetItem *)'))
+        connect(@generateRdocBtn, SIGNAL(:clicked), self, SLOT(:generateRdoc))
+        connect(@updateGemBtn, SIGNAL(:clicked), self, SLOT(:updateGem))
+        connect(@checkTestBtn, SIGNAL(:clicked), self, SLOT(:testGem))
+
+        # layout
+        lo = Qt::VBoxLayout.new do |w|
+                w.addWidgets('Filter:', @filterInstalledLineEdit)
+                w.addWidget(@installedGemsTable)
+                w.addWidgets(nil, @viewDirBtn, @viewRdocBtn, @generateRdocBtn, @checkTestBtn, @updateGemBtn, @uninstallBtn)
+            end
+        setLayout(lo)
+    end
+
+
+    GroupName = "InstalledGemWindow"
+    def writeSettings
+        config = $config.group(GroupName)
+        config.writeEntry('Header', @installedGemsTable.horizontalHeader.saveState)
+    end
+
+    def readSettings
+        config = $config.group(GroupName)
+        @installedGemsTable.horizontalHeader.restoreState(config.readEntry('Header', @installedGemsTable.horizontalHeader.saveState))
+    end
+
+
+    #------------------------------------
+    #
+    #
+    def notifyInstall
+        updateInstalledGemList
+    end
+
+    slots :testGem
+    def testGem
+        gem = @installedGemsTable.currentGem
+        return unless gem
+
+        @gemViewer.testGem(gem)
+    end
+
+    slots :updateGem
+    def updateGem
+        gem = @installedGemsTable.currentGem
+        return unless gem
+
+        @gemViewer.updateGem(gem)
+    end
+
+    slots :generateRdoc
+    def generateRdoc
+        gem = @installedGemsTable.currentGem
+        return unless gem
+
+        @gemViewer.generateRdoc(gem)
+    end
+
+    slots :updateInstalledGemList
+    def updateInstalledGemList
+        gemList = InstalledGemList.get
+        @installedGemsTable.updateGemList(gemList)
+    end
+
+    def setStaleTime(stales)
+        stales.each do |i|
+            r = @installedGemsTable.find do |g|
+                    g.name == i.name && g.version == i.version
+            end
+            if r then
+                @installedGemsTable.item(r, GemListTable::PACKAGE_ATIME).text = i.atime.to_s
+            end
+        end
+        @installedGemsTable.sortItems(GemListTable::PACKAGE_ATIME)
+        @installedGemsTable.clearSelection
+        parent.parent.currentIndex = parent.indexOf(self)
+    end
+
+    attr_accessor :gemViewer
+    slots 'itemClicked(QTableWidgetItem *)'
+    def itemClicked(item)
+        unless item.gem.spec then
+            specStr = %x{gem specification #{item.gem.package} -l --marshal}
+            begin
+                spec = Marshal.load(specStr)
+            rescue NoMethodError, ArgumentError => e
+                # rescue from some error gems.
+                @gemViewer.setError(item.gem, e)
+                return
+            end
+            item.gem.spec = spec
+        end
+        @gemViewer.setDetail( item.gem )
+        files = %x{gem contents --prefix #{item.gem.package} -v #{item.gem.version}}.split(/[\r\n]+/)
+        @gemViewer.setFiles( files )
+
+        proc = lambda do |item|
+            file = item.text
+            @gemViewer.previewWin.setFile( file )
+        end
+        @gemViewer.setPreviewProc(proc)
+    end
+
+    slots :viewRdoc
+    def viewRdoc
+        @gemViewer.viewGemRdoc(@installedGemsTable.currentGem)
+    end
+
+
+    slots :viewDir
+    def viewDir
+        @gemViewer.viewGemDir(@installedGemsTable.currentGem)
+    end
+
+    slots :uninstallGem
+    def uninstallGem
+        @gemViewer.uninstall(@installedGemsTable.currentGem)
+    end
+end

data/lib/mylibs.rb

@@ -0,0 +1,407 @@
+#
+#  My library
+#
+#   Qt & other miscs
+
+require 'singleton'
+require 'korundum4'
+
+#
+class Qt::HBoxLayout
+    def addWidgets(*w)
+        w.each do |i|
+            if i then
+                e = i.kind_of?(String) ? Qt::Label.new(i) : i
+                addWidget(e)
+            else
+                addStretch
+            end
+        end
+    end
+end
+
+class Qt::VBoxLayout
+    def addWidgetWithNilStretch(*w)
+        addLayout(
+            Qt::HBoxLayout.new do |l|
+                l.addWidgets(*w)
+            end
+        )
+    end
+    alias :addWidgets :addWidgetWithNilStretch
+
+    def addWidgetAtCenter(*w)
+        w.unshift(nil)
+        addWidgetWithNilStretch(*w)
+    end
+
+    def addWidgetAtRight(*w)
+        w.unshift(nil)
+        addWidgetWithNilStretch(*w)
+    end
+
+    def addWidgetAtLeft(*w)
+        w.push(nil)
+        addWidgetWithNilStretch(*w)
+    end
+end
+
+
+#
+class VBoxLayoutWidget < Qt::Widget
+    def initialize(parent=nil)
+        @layout = Qt::VBoxLayout.new
+        super(parent)
+        setLayout(@layout)
+    end
+
+    def addLayout(l)
+        @layout.addLayout(l)
+    end
+
+    def addWidget(w)
+        @layout.addWidget(w)
+    end
+
+    def addWidgetWithNilStretch(*w)
+        @layout.addWidgetWithNilStretch(*w)
+    end
+    alias :addWidgets :addWidgetWithNilStretch
+
+    def addWidgetAtRight(*w)
+        @layout.addWidgetAtRight(*w)
+    end
+
+    def addWidgetAtCenter(*w)
+        @layout.addWidgetAtCenter(*w)
+    end
+
+    def layout
+        @layout
+    end
+end
+
+class HBoxLayoutWidget < Qt::Widget
+    def initialize(parent=nil)
+        @layout = Qt::HBoxLayout.new
+        super(parent)
+        setLayout(@layout)
+    end
+
+    def addLayout(l)
+        @layout.addLayout(l)
+    end
+
+    def addWidget(w)
+        @layout.addWidget(w)
+    end
+
+    def addWidgets(*w)
+        @layout.addWidgets(*w)
+    end
+
+    def layout
+        @layout
+    end
+end
+
+
+#--------------------------------------------------------------------------
+#
+#
+def passiveMessage(text)
+    %x{ kdialog --passivepopup #{text.shellescape} }
+end
+
+
+
+#--------------------------------------------------------------------------
+#
+#
+
+class Qt::Action
+    def setVData(data)
+        setData(Qt::Variant.new(data))
+    end
+
+    def vData
+        self.data.toString
+    end
+end
+
+module Mime
+    def self.services(url)
+        mimeType = KDE::MimeType.findByUrl(KDE::Url.new(url))
+        mime = mimeType.name
+        services = KDE::MimeTypeTrader.self.query(mime)
+    end
+end
+
+class KDE::ActionCollection
+    # @return : KDE::Action
+    # @parameter name :
+    # @parameter parent : parent Qt::Object
+    # @parameter options { :text=>name, :icon=>iconName, :shortCut=>key, :triggered=>SLOT or [object, SLOT] }
+    def addNew(name, parent=self.parent, options = {})
+        text = options[:text] || name
+        icon = options[:icon]
+        if icon then
+            action = KDE::Action.new(KDE::Icon.new(icon), text, parent)
+        else
+            action = KDE::Action.new(text, parent)
+        end
+        shortCut = options[:shortCut]
+        if shortCut then
+            action.setShortcut(KDE::Shortcut.new(shortCut))
+        end
+        self.addAction(action.text, action)
+        slot = options[:triggered]
+        if slot then
+            if slot.kind_of? Array then
+                self.connect(action, SIGNAL(:triggered), slot[0], \
+                               SLOT(slot[1]))
+            else
+                self.connect(action, SIGNAL(:triggered), parent, \
+                               SLOT(slot))
+            end
+        end
+        action
+    end
+end
+
+
+
+
+
+
+
+#--------------------------------------------------------------------------
+#
+#
+class SettingsBase < KDE::ConfigSkeleton
+    include Singleton
+
+    public
+    # @sym : instance symbol to be added.
+    def addBoolItem(sym, default=true)
+        name = sym.to_s
+        defineItem(sym, 'value', ItemBool, default)
+    end
+
+    def addStringItem(sym, default="")
+        defineItem(sym, 'toString', ItemString, default)
+    end
+
+    def addIntItem(sym, default="")
+        defineItem(sym, 'value', ItemInt, default)
+    end
+
+    def addUrlItem(sym, default=KDE::Url.new)
+        if default.kind_of? String then
+            default = KDE::Url.new(default)
+        end
+        defineItem(sym, 'value', ItemUrl, default)
+    end
+
+    def addStringListItem(sym, default="")
+        defineItem(sym, 'value', ItemStringList, default)
+    end
+
+    def addChoiceItem(name, list, default=0)
+        choices = makeChoices(list)
+        defineItemProperty(name, 'value')
+        item = ItemEnum.new(currentGroup, name.to_s, default, choices, default)
+        addItem(item)
+    end
+
+    def [](name)
+        findItem(name)
+    end
+
+    protected
+    def makeChoices(list)
+        choices = []
+        list.each do |i|
+            c = ItemEnum::Choice.new
+            c.name = i
+            choices << c
+        end
+        choices
+    end
+
+    def defineItem(name, valueMethod, itemClass, default)
+        defineItemProperty(name, valueMethod)
+        item = itemClass.new(currentGroup, name.to_s, default, default)
+        addItem(item)
+    end
+
+    def defineItemProperty(name, valueMethod)
+        self.class.class_eval %Q{
+            def #{name}
+                findItem('#{name}').property.#{valueMethod}
+            end
+
+            def self.#{name}
+                s = self.instance
+                s.#{name}
+            end
+
+            def set#{name}(v)
+                item = findItem('#{name}')
+#                 unless item.immutable?
+                    item.property = Qt::Variant.fromValue(v)
+#                 end
+            end
+
+            def self.set#{name}(v)
+                s = self.instance
+                s.set#{name}(v)
+            end
+
+            def #{name}=(v)
+                set#{name}(v)
+            end
+
+            def self.#{name}=(v)
+                self.set#{name}(v)
+            end
+        }
+    end
+
+    def self.allChildren(obj)
+        all = children = obj.children
+        children.each do |o|
+            all += allChildren(o)
+        end
+        all
+    end
+
+    def self.printAllProperties(obj)
+        puts "============= settings properties =============="
+        options = self.instance
+        allChildren(obj).each do |o|
+            if o.objectName =~ /^kcfg_/ then
+                name = o.objectName.sub(/^kcfg_/, '')
+                if o.kind_of? Qt::CheckBox
+                    prop = o.checked.to_s
+                elsif o.kind_of? Qt::ComboBox
+                    prop = o.currentIndex.to_s
+                elsif o.kind_of? KDE::UrlRequester
+                    prop = o.text
+                else
+                    prop = '?'
+                end
+                if options.respond_to? name then
+                    val = options.send(name).inspect
+                else
+                    val = ''
+                end
+                err = prop == val ? '' : '  !!  Error !!'
+                puts " name:#{name}, property:#{prop}, settings value:#{val} #{err}"
+            end
+        end
+    end
+
+    def self.updateWidgets(obj)
+        options = self.instance
+        allChildren(obj).each do |o|
+            if o.objectName =~ /^kcfg_/ then
+                name = o.objectName.sub(/^kcfg_/, '')
+                if options.respond_to? name then
+                    val = options.send(name)
+                    if o.kind_of? Qt::CheckBox
+                        o.checked = val
+                    elsif o.kind_of? Qt::ComboBox
+                        o.currentIndex = val
+                    elsif o.kind_of? KDE::UrlRequester
+                        o.setUrl(val)
+                    end
+                end
+            end
+        end
+    end
+
+    def self.updateSettings(obj)
+        options = self.instance
+        allChildren(obj).each do |o|
+            if o.objectName =~ /^kcfg_/ then
+                name = o.objectName.sub(/^kcfg_/, '') + '='
+                if options.respond_to? name then
+                    if o.kind_of? Qt::CheckBox
+                        options.send(name, o.checked)
+                        if options.send(name[0..-2]) != o.checked then
+                            puts "Error !!  : #{name[0..-2]}(#{options.send(name[0..-2])} != #{o.checked}"
+                        end
+                    elsif o.kind_of? Qt::ComboBox
+                        options.send(name, o.currentIndex)
+                    elsif o.kind_of? KDE::UrlRequester
+                        options.send(name, o.url)
+                    else
+                        puts "not know type class:#{o.class.name}"
+                    end
+                end
+            end
+        end
+    end
+end
+
+
+#--------------------------------------------------------------------------
+#
+#
+def openDirectory(dir)
+    cmd = KDE::MimeTypeTrader.self.query('inode/directory').first.exec[/\w+/]
+    cmd += " " + dir
+    fork do exec(cmd) end
+end
+
+#--------------------------------------------------------------------------
+#
+#   stdlib
+#
+module Enumerable
+    class Proxy
+        instance_methods.each { |m| undef_method(m) unless m.match(/^__/) }
+        def initialize(enum, method=:map)
+            @enum, @method = enum, method
+        end
+        def method_missing(method, *args, &block)
+            @enum.__send__(@method) {|o| o.__send__(method, *args, &block) }
+        end
+    end
+
+    def every
+        Proxy.new(self)
+    end
+end
+
+#
+#
+#
+class String
+    def double_quote
+        '"' + self + '"'
+    end
+    alias   :dquote :double_quote
+
+    def single_quote
+        "'" + self + "'"
+    end
+    alias   :squote :single_quote
+
+    def _chomp_null
+        gsub(/\0.*/, '')
+    end
+
+    def sql_quote
+        str = _chomp_null
+        return 'NULL' if str.empty?
+        "'#{str.sql_escape}'"
+    end
+
+    def sql_escape
+        str = _chomp_null
+        str.gsub(/\\/, '\&\&').gsub(/'/, "''")    #'
+    end
+end
+