packo 0.0.1.alpha.1

data/lib/packo/rbuild/package/manifest.rb

@@ -0,0 +1,169 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of packo.
+#
+# packo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# packo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with packo. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'nokogiri'
+require 'base64'
+
+require 'packo'
+
+module Packo; module RBuild; class Package < Packo::Package
+
+class Manifest
+  def self.parse (text)
+    dom = Nokogiri::XML.parse(text)
+
+    Manifest.new(OpenStruct.new(
+      maintainer: dom.root['maintainer'],
+
+      tags:    Packo::Package::Tags.parse(dom.xpath('//package/tags').first.text),
+      name:    dom.xpath('//package/name').first.text,
+      version: Versionomy.parse(dom.xpath('//package/version').first.text),
+      slot:    dom.xpath('//package/slot').first.text,
+
+      exports: Marshal.load(Base64.decode64(dom.xpath('//package/exports').first.text)),
+
+      description: dom.xpath('//package/description').first.text,
+      homepage:    dom.xpath('//package/homepage').first.text.split(/\s+/),
+      license:     dom.xpath('//package/license').first.text.split(/\s+/),
+
+      flavor:   Packo::Package::Flavor.parse(dom.xpath('//package/flavor').first.text || ''),
+      features: Packo::Package::Features.parse(dom.xpath('//package/features').first.text || ''),
+
+      environment: Hash[dom.xpath('//package/environment/variable').map {|env|
+        [env['name'], env.text]
+      }],
+
+      dependencies: dom.xpath('//dependencies/dependency').map {|dependency|
+        Package::Dependency.parse("#{dependency.text}#{['', '!', '!!'][['both', 'build', 'runtime'].index(dependency['type'])]}")
+      },
+
+      blockers: dom.xpath('//blockers/blocker').map {|blocker|
+        Package::Blocker.parse("#{blocker.text}#{['', '!', '!!'][['both', 'build', 'runtime'].index(dependency['type'])]}")
+      },
+
+      selector: dom.xpath('//selectors/selector').map {|selector|
+        Hash[
+          name:        selector['name'],
+          description: selector['description'],
+          path:        selector.text
+        ]
+      }
+    ))
+  end
+
+  def self.open (path)
+    Manifest.parse(File.read(path))
+  end
+
+  attr_reader :package, :dependencies, :blockers, :selectors
+
+  def initialize (what)
+    @package = OpenStruct.new(
+      maintainer: what.maintainer,
+
+      tags:    what.tags,
+      name:    what.name,
+      version: what.version,
+      slot:    what.slot,
+
+      exports: what.exports,
+
+      description: what.description,
+      homepage:    [what.homepage].flatten.compact.join(' '),
+      license:     [what.license].flatten.compact.join(' '),
+
+      flavor:   what.flavor,
+      features: what.features,
+
+      environment: what.environment.reject {|name, value|
+        [:DATABASE, :FLAVORS, :PROFILE, :CONFIG_FILE, :CONFIG_PATH,
+         :CONFIG_MODULES, :REPOSITORIES, :SELECTORS, :FETCHER,
+         :NO_COLORS, :DEBUG, :VERBOSE, :TMP, :SECURE
+        ].member?(name.to_sym)
+      }
+    )
+
+    @dependencies = what.dependencies
+    @blockers     = what.blockers
+    @selectors    = [what.selector].flatten.compact.map {|selector| OpenStruct.new(selector)}
+
+    if (what.filesystem.selectors rescue false)
+      what.filesystem.selectors.each {|name, file|
+        matches = file.content.match(/^#\s*(.*?):\s*(.*)([\n\s]*)?\z/) or next
+
+        @selectors << OpenStruct.new(name: matches[1], description: matches[2], path: name)
+      }
+    end
+
+    @builder = Nokogiri::XML::Builder.new {|xml|
+      xml.manifest(version: '1.0') {
+        xml.package(maintainer: self.package.maintainer) {
+          xml.tags     self.package.tags
+          xml.name     self.package.name
+          xml.version  self.package.version
+          xml.slot     self.package.slot
+          xml.revision self.package.revision
+
+          xml.description self.package.description
+          xml.homepage    self.package.homepage
+          xml.license     self.package.license
+
+          xml.flavor   self.package.flavor
+          xml.features self.package.features
+
+          xml.environment {
+            self.package.environment.each {|name, value|
+              xml.variable({ name: name }, value)
+            }
+          }
+
+          xml.exports Base64.encode64(Marshal.dump(self.package.exports))
+        }
+
+        xml.dependencies {
+          self.dependencies.each {|dependency|
+            xml.dependency({ type: dependency.type }, dependency.to_s)
+          }
+        }
+
+        xml.blockers {
+          self.blockers.each {|blocker|
+            xml.blocker({ type: blocker.type }, blocker.to_s)
+          }
+        }
+
+        xml.selectors {
+          self.selectors.each {|selector|
+            xml.selector({ name: selector.name, description: selector.description }, selector.path)
+          }
+        }
+      }
+    }
+  end
+
+  def save (to, options={})
+    File.write(to, self.to_s(options))
+  end
+
+  def to_s (options={})
+    @builder.to_xml({ indent: 4 }.merge(options))
+  end
+end
+
+end; end; end

data/lib/packo/rbuild/stages.rb

@@ -0,0 +1,171 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of packo.
+#
+# packo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# packo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with packo. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+require 'packo/rbuild/stages/stage'
+require 'packo/rbuild/stages/callbacks'
+
+module Packo; module RBuild
+
+class Stages
+  module Callable
+    def before (name, data=nil, &block)
+      self.package.stages.register(:before, name, block, { binding: self }.merge(data || {}))
+    end
+
+    def after (name, data=nil, &block)
+      self.package.stages.register(:after, name, block, { binding: self }.merge(data || {}))
+    end
+
+    def avoid (chain, name, known=nil)
+      self.package.stages.unregister(chain, name, known)
+    end
+  end
+
+  attr_reader :package, :stages, :callbacks
+
+  def initialize (package)
+    @package = package
+
+    @stages    = []
+    @callbacks = {}
+  end
+
+  def add (name, method, options={})
+    @stages.delete_if {|stage|
+      stage.name == name
+    }
+
+    @stages << Stage.new(name, method, options)
+
+    @sorted = false
+  end
+
+  def delete (name, method=nil)
+    @stages.delete_if {|stage|
+      stage.name == name && (!method || stage.method == method)
+    }
+
+    @sorted = false
+  end
+
+  # Ugly incomprensibile shit ahead. It's dangerous to go alone! Take this! <BS>
+  #
+  # In short it tries to sort stuff as it wanted to be placed depending on stage's options  
+  def sort! (strict=false)
+    return if @sorted
+
+    funcs = {
+      atom: lambda {
+        { stricts: [], normals: [] }
+      },
+
+      leaf: lambda {
+        Hash[
+          after:  funcs[:atom].call,
+          before: funcs[:atom].call,
+          at:     funcs[:atom].call,
+          stage:  nil
+        ]
+      },
+
+      type: lambda {|stage|
+        stage.options[:strict] ? :stricts : :normals
+      },
+
+      plain: lambda {|pi|
+        pi.sort {|a, b|
+          pr = (a[:stage].options[:priority] || 0) <=> (b[:stage].options[:priority] || 0)
+          pr.zero? ? a[:stage].name.to_s.downcase <=> b[:stage].name.to_s.downcase : pr
+        }.map {|l|
+          funcs[:flat].call(l)
+        }.flatten
+      },
+
+      flat: lambda {|leaf|
+        funcs[:plain].call(leaf[:after][:normals]) + funcs[:plain].call(leaf[:after][:stricts]) +
+          (leaf[:stage] ? [leaf[:stage]] : (funcs[:plain].call(leaf[:at][:stricts]) + funcs[:plain].call(leaf[:at][:normals]))) +
+          funcs[:plain].call(leaf[:before][:stricts]) + funcs[:plain].call(leaf[:before][:normals])
+      }
+    }
+
+    tree = { beginning: funcs[:leaf].call, end: funcs[:leaf].call }
+
+    remained = @stages.dup
+    prev_rem = @stages.size
+
+    begin
+      prev_rem = remained.size
+
+      remained.dup.each {|stage|
+        place = (if tree[stage.options[:after]]
+          [stage.options[:after], :before, funcs[:type].call(stage)]
+        elsif tree[stage.options[:before]]
+          [stage.options[:before], :after, funcs[:type].call(stage)]
+        elsif [:beginning, :end].include?(stage.options[:at])
+          [stage.options[:at], :at, funcs[:type].call(stage)]
+        else
+          nil
+        end)
+
+        next unless place
+
+        remained.delete(stage)
+
+        leaf         = funcs[:leaf].call
+        leaf[:stage] = stage
+
+        tree[place[0]][place[1]][place[2]] << leaf
+
+        tree[stage.name.to_sym] = leaf
+      }
+    end while prev_rem != remained.size
+
+    tree[:beginning][:after] = tree[:end][:before] = funcs[:atom].call
+
+    @stages = funcs[:flat].call(tree[:beginning]) + funcs[:flat].call(tree[:end])
+    @sorted = true
+  end
+
+  def stop!;    @stopped = true;  end
+  def restart!; @stopped = false; end
+
+  def each (&block)
+    self.sort!
+
+    @stages.each {|stage|
+      block.call stage
+
+      break if @stopped
+    }
+  end
+
+  def register (chain, name, callback, data={})
+    (@callbacks[name.to_sym] ||= Callbacks.new(name.to_sym)).register(chain, callback, data)
+  end
+
+  def unregister (chain, name, known=nil)
+    (@callbacks[name.to_sym] ||= Callbacks.new(name.to_sym)).unregister(chain, known)
+  end
+
+  def callbacks (name)
+    @callbacks[name.to_sym] ||= Callbacks.new(name.to_sym)
+  end
+end
+
+end; end

data/lib/packo/rbuild/stages/callbacks.rb

@@ -0,0 +1,96 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of packo.
+#
+# packo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# packo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with packo. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Packo; module RBuild; class Stages
+
+class Callbacks
+  Chains = [:before, :after]
+
+  class Callback
+    attr_accessor :binding
+
+    attr_reader :name, :priority, :position
+
+    def initialize (callback, data)
+      @callback = callback
+      @priority = data[:priority] || 0
+      @binding  = data[:binding]  || binding
+      @position = data[:position] || 0
+      @name     = data[:name]
+    end
+
+    def call (*args)
+      if binding
+        binding.instance_exec(*args, &@callback)
+      else
+        @callback.call(*args)
+      end
+    end
+  end
+
+  attr_reader :name
+
+  def initialize (name)
+    @name      = name
+    @callbacks = Hash[before: [], after: []]
+    @position  = 0
+  end
+
+  def register (chain, callback, data)
+    @callbacks[Chains.member?(chain) ? chain : :before] << Callback.new(callback, { position: @position += 1 }.merge(data))
+  end
+
+  def unregister (chain, name=nil)
+    @callbacks[Chains.member?(chain) ? chain : :before].delete_if {|callback|
+      callback.name == name || name.nil?
+    }
+  end
+
+  def sort!
+    Chains.each {|chain|
+      @callbacks[chain].sort! {|a, b|
+        if a.priority == b.priority
+          a.position <=> b.position
+        else
+          a.priority <=> b.priority
+        end
+      }
+    }
+  end
+
+  def do (*args)
+    self.sort!
+
+    catch(:halt) do
+      @callbacks[:before].each {|c|
+        c.call(*args)
+      }
+
+      result = yield *args if block_given?
+
+      @callbacks[:after].each {|c|
+        c.call(result, *args)
+      }
+
+      result
+    end
+  end
+end
+
+end; end; end

data/lib/packo/rbuild/stages/stage.rb

@@ -0,0 +1,50 @@
+#--
+# Copyleft meh. [http://meh.doesntexist.org | meh@paranoici.org]
+#
+# This file is part of packo.
+#
+# packo is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# packo is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with packo. If not, see <http://www.gnu.org/licenses/>.
+#++
+
+module Packo; module RBuild; class Stages;
+
+class Stage
+  attr_reader :name, :options, :method
+
+  def initialize (name, method, options)
+    @name    = name.to_sym
+    @method  = method
+    @options = options
+
+    if (@options[:at] || @options[:after] == :beginning || @options[:before] == :ending) && @options[:strict].nil?
+      @options[:strict] = true
+    end
+
+    @options[:priority] ||= 0
+  end
+
+  def call (*args)
+    @method.call(*args)
+  end
+
+  def == (value)
+    @name == value || @method == value
+  end
+
+  def inspect
+    "#<Stage: #{name} (#{@options.inspect})>"
+  end
+end
+
+end; end; end