indexer 0.1.0

data/lib/indexer/validator.rb

@@ -0,0 +1,313 @@
+module Indexer
+
+  # Validator class models the strict *canonical* specification of the index
+  # file format. It is a one-to-one mapping with no method aliases or other
+  # conveniences.
+  #
+  class Validator < Model
+    include Attributes
+
+    #class << self
+    #  private
+    #  alias :create :new
+    #end
+
+    #
+    # Revision factory returns a versioned instance of the model class.
+    #
+    # @param [Hash] data
+    #   The data to populate the instance.
+    #
+    def self.new(data={})
+      data = revise(data)
+      super(data)
+    end
+
+    #
+    # Load metadata, ensuring canoncial validity.
+    #
+    # @param [String] data
+    #   The data to be validate and then to populate the instance.
+    #
+    def self.valid(data)
+      new(data)
+    end
+
+    #
+    # Update metadata to current revision if using old revision.
+    #
+    def self.revise(data)
+      Revision.upconvert(data)
+    end
+
+    # -- Writers ------------------------------------------------------------
+
+    #
+    def revision=(value)
+      if value.to_i != REVISION
+        # technically this should never happen
+        Valid.raise_invalid_message("revision is not current #{REVISION} -- #{value}")
+      end
+      super(value)
+    end
+
+    # Project's _type_ must be a string without spaces
+    # using only `[a-zA-Z0-9_-:/]`.
+    def type=(value)
+      Valid.type!(value, :type)
+      super(value)
+    end
+
+    # Project's _packaging name_ must be a string without spaces
+    # using only `[a-zA-Z0-9_-]`.
+    def name=(value)
+      Valid.name!(value, :name)
+      super(value)
+    end
+
+    #
+    def version=(value)
+      validate(value, :version, :version_string!)
+      super(value)
+    end
+
+    # Date must be a UTC formated string, time is optional.
+    def date=(value)
+      Valid.utc_date!(value, :date)
+      super(value)
+    end
+
+    # Title of package must be a single-line string.
+    def title=(value)
+      Valid.oneline!(value, :title)
+      super(value)
+    end
+
+    # Summary must be a single-line string.
+    def summary=(value)
+      Valid.oneline!(value, :summary)
+      super(value)
+    end
+
+    # Description must be string.
+    def description=(value)
+      Valid.string!(value, :description)
+      super(value)
+    end
+
+    # Codename must a single-line string.
+    def codename=(value)
+      Valid.oneline!(value, :codename)
+      super(value)
+    end
+
+    # Loadpath must be an Array of valid pathnames or a String of pathnames
+    # separated by colons or semi-colons.
+    def load_path=(value)
+      Valid.array!(value, :load_path)
+      value.each_with_index{ |path, i| Valid.path!(path, "load_path #{i}") }
+      super(value)
+    end
+
+    # List of language engine/version family supported.
+    def engines=(value)
+      Valid.array!(value)
+      super(value)
+    end
+
+    # List of platforms supported.
+    def platforms=(value)
+      Valid.array!(value)
+      super(value)          
+    end
+
+    # Requirements must be a list of package references.
+    def requirements=(value)
+      Valid.array!(value, :requirements)
+      value.each_with_index do |r, i|
+        Valid.hash!(r, "requirements #{i}")
+      end
+      super(value)
+    end
+
+    # Dependencies must be a list of package references.
+    #def dependencies=(value)
+    #  Valid.array!(value, :dependencies)
+    #  value.each_with_index do |r, i|
+    #    Valid.hash!(r, "dependencies #{i}")
+    #  end
+    #  super(value)
+    #end
+
+    # List of packages with which this project cannot function.
+    def conflicts=(value)
+      Valid.array!(value, :conflicts)
+      value.each_with_index do |c, i|
+        Valid.hash!(c, "conflicts #{i}")
+      end
+      super(value)
+    end
+
+    #
+    def alternatives=(value)
+      Valid.array!(value, :alternatives)
+      super(value)
+    end
+
+    # provides?
+
+    #
+    def categories=(value)
+      Valid.array!(value, :categories)
+      value.each_with_index do |c, i|
+        Valid.oneline!(c, "categories #{i}")
+      end
+      super(value)
+    end
+
+    # Suite must be a single line string.
+    def suite=(value)
+      Valid.oneline!(value, :suite)
+      super(value)
+    end
+
+    # The creation date must be a valide UTC formatted date.
+    def created=(value)
+      Valid.utc_date!(value, :created)
+      super(value)
+    end
+
+    # Set sequence of copyrights mappings.
+    def copyrights=(value)
+      Valid.array!(value, :copyrights)
+      value.each{ |h| Valid.hash!(h, :copyrights) }
+      super(value)
+    end
+
+    # Authors must an array of hashes in the form
+    # of `{name: ..., email: ..., website: ..., roles: [...] }`.
+    def authors=(value)
+      Valid.array!(value, :authors)
+      value.each{ |h| Valid.hash!(h, :authors) }
+      super(value)
+    end
+
+    # Organizations must be an array of hashes in the form
+    # of `{name: ..., email: ..., website: ..., roles: [...] }`.
+    def organizations=(value)
+      Valid.array!(value, :organizations)
+      value.each{ |h| Valid.hash!(h, :organizations) }
+      super(value)
+    end     
+
+    # Resources must be an array of hashes in the form
+    # of `{uri: ..., name: ..., type: ...}`.
+    def resources=(value)
+      Valid.array!(value, :resources)
+      value.each{ |h| Valid.hash!(h, :resources) }
+      super(value)
+    end
+
+    # Repositores must be a mapping of <code>name => URL</code>.
+    def repositories=(value)
+      Valid.array! value, :repositories
+      value.each_with_index do |data, index|
+        Valid.hash! data, "repositories #{index}"
+        #Valid.uri!  data['uri'], "repositories ##{index}"
+        Valid.oneline! data['uri'], "repositories ##{index}"
+        Valid.oneline! data['id'],  "repositories ##{index}" if data['id']
+        Valid.word!    data['scm'], "repositories ##{index}" if data['scm']
+      end
+      super value
+    end
+
+    # The post-installation message must be a String.
+    def install_message=(value)
+      Valid.string!(value)
+      super(value)
+    end
+
+# TODO: How to handle project toplevel namespace?
+
+    # Namespace must be a single line string.
+    def namespace=(value)
+      Valid.oneline!(value, :namespace)
+      #raise ValidationError unless /^(class|module)/ =~ value
+      super(value)
+    end
+
+    # TODO: SCM ?
+
+    # SCM must be a word.
+    #def scm=(value)
+    #  Valid.word!(value, :scm)
+    #  super(value)
+    #end
+
+    # The webcvs prefix must be a valid URI.
+    def webcvs=(value)
+      Valid.uri!(value, :webcvs)
+      super(value)
+    end
+
+    #
+    def extra=(value)
+      Valid.hash!(value, :extra)
+      super(value)
+    end
+
+    # A specification is not valid without a name and verison.
+    #
+    # @return [Boolean] valid specification?
+    def valid?
+      return false unless name
+      return false unless version
+      true
+    end
+
+    # By saving via the Validator, we help ensure only the canoncial
+    # form even makes it to disk.
+    #
+    # TODO: Only save when when different?
+    #
+    def save!(file)
+      File.open(file, 'w') do |f|
+        f << to_h.to_yaml
+      end
+    end
+
+  protected
+
+    #
+    # Initializes the {Metadata} attributes.
+    #
+    def initialize_attributes
+      @data = {
+        :type          => 'ruby',
+        :revision      => REVISION,
+        :sources       => [],
+        :authors       => [],
+        :organizations => [],
+        :requirements  => [],
+        :conflicts     => [],
+        :alternatives  => [],
+        :resources     => [],
+        :repositories  => [],
+        :categories    => [],
+        :load_path     => ['lib'],
+        :copyrights    => []
+      }
+    end
+
+  private
+
+    #def validate_package_references(field, references)
+    #  unless Array === references
+    #    raise(ValidationError, "#{field} must be a hash")
+    #  end
+    #  # TODO: valid version and type
+    #end
+
+  end
+
+end

data/lib/indexer/version/constraint.rb

@@ -0,0 +1,124 @@
+module Indexer
+
+  module Version
+
+    # The Constraint class models a single version equality or inequality.
+    # It consists of the operator and the version number.
+    #--
+    # TODO: Please improve me!
+    #
+    # TODO: This should ultimately replace the class methods of Version::Number.
+    #
+    # TODO: Do we need to support version "from-to" spans ?
+    #++
+    class Constraint
+
+      #
+      def self.parse(constraint)
+        new(constraint)
+      end
+
+      #
+      def self.[](operator, number)
+        new([operator, number])
+      end
+
+      #
+      def initialize(constraint)
+        @operator, @number = parse(constraint || '0+')
+
+        case constraint
+        when Array
+          @stamp = "%s %s" % [@operator, @number]
+        when String
+          constraint = "0+" if constraint.strip == ""
+          @stamp = constraint
+        end
+      end
+
+      # Constraint operator.
+      attr :operator
+
+      # Verison number.
+      attr :number
+
+      #
+      def to_s
+        @stamp
+      end
+
+      # Converts the version into a constraint string recognizable
+      # by RubyGems.
+      #--
+      # TODO: Better name Constraint#to_s2.
+      #++
+      def to_gem_version
+        op = (operator == '=~' ? '~>' : operator)
+        "%s %s" % [op, number]
+      end
+
+      # Convert constraint to Proc object which can be
+      # used to test a version number.
+      def to_proc
+        lambda do |v|
+          n = Version::Number.parse(v)
+          n.send(operator, number)
+        end
+      end
+
+    private
+
+      #
+      def parse(constraint)
+        case constraint
+        when Array
+          op, num = constraint
+        when ""
+          op, val = ">=", "0"
+        when /^(.*?)\~$/
+          op, val = "=~", $1
+        when /^(.*?)\+$/
+          op, val = ">=", $1
+        when /^(.*?)\-$/
+          op, val = "<", $1
+        when /^(=~|~>|<=|>=|==|=|<|>)?\s*(\d+(:?[-.]\w+)*)$/
+          if op = $1
+            op = '=~' if op == '~>'
+            op = '==' if op == '='
+            val = $2.split(/\W+/)
+          else
+            op = '=='
+            val = constraint.split(/\W+/)
+          end
+        else
+          raise ArgumentError #constraint.split(/\s+/)
+        end
+        return op, Version::Number.new(*val)
+      end
+
+      # Parse package entry into name and version constraint.
+      #def parse(package)
+      #  parts = package.strip.split(/\s+/)
+      #  name = parts.shift
+      #  vers = parts.empty? ? nil : parts.join(' ')
+      # [name, vers]
+      #end
+
+    public
+
+      # Parses a string constraint returning the operation as a lambda.
+      def self.constraint_lambda(constraint)
+        new(constraint).to_proc
+      end
+
+      # Parses a string constraint returning the operator and value.
+      def self.parse_constraint(constraint)
+        c = new(constraint)
+        return c.operator, c.number
+      end
+
+    end
+
+  end
+
+end

data/lib/indexer/version/exceptions.rb

@@ -0,0 +1,11 @@
+module Indexer
+
+  module Version
+
+    # Base calss for all version errors.
+    class Exception < RuntimeError
+    end
+
+  end
+
+end

data/lib/indexer/version/number.rb

@@ -0,0 +1,497 @@
+module Indexer
+
+  module Version
+
+    # Represents a versiou number. Developer SHOULD use three point 
+    # SemVer standard, but this class is mildly flexible in it's support
+    # for variations.
+    #
+    # @see http://semver.org/
+    #
+    class Number
+      include Enumerable
+      include Comparable
+
+      # Recognized build states in order of completion.
+      # This is only used when by #bump_state.
+      STATES = ['alpha', 'beta', 'pre', 'rc']
+
+      #
+      # Creates a new version.
+      #
+      # @param points [Array] version points
+      #
+      def initialize(*points)
+        @crush = false
+        points.map! do |point|
+          sane_point(point)
+        end
+        @tuple = points.flatten.compact
+      end
+
+      # Shortcut for creating a new verison number
+      # given segmented elements.
+      #
+      #   VersionNumber[1,0,0].to_s
+      #   #=> "1.0.0"
+      #
+      #   VersionNumber[1,0,0,:pre,2].to_s
+      #   #=> "1.0.0.pre.2"
+      #
+      def self.[](*args)
+        new(*args)
+      end
+
+      #
+      # Parses a version string.
+      #
+      # @param [String] string
+      #   The version string.
+      #
+      # @return [Version]
+      #   The parsed version.
+      #
+      def self.parse(version)
+        case version
+        when String
+          new(*version.split('.'))
+        when Number #self.class
+          new(*version.to_a)
+        else
+          new(*version.to_ary)  #to_a) ?
+        end
+      end
+
+      #
+      def self.cmp(version1, version2)
+        # TODO: class level compare might be handy
+      end
+
+      # Major version number
+      def major
+        (state_index && state_index == 0) ? nil : self[0]
+      end
+
+      # Minor version number
+      def minor
+        (state_index && state_index <= 1) ? nil : self[1]
+      end
+
+      # Patch version number
+      def patch
+        (state_index && state_index <= 2) ? nil : self[2]
+      end
+
+      # The build.
+      def build
+        if b = state_index
+          str = @tuple[b..-1].join('.')
+          str = crush_point(str) if crush?
+          str
+        elsif @tuple[3].nil?
+          nil
+        else
+          str = @tuple[3..-1].join('.')
+          str = crush_point(str) if crush?
+          str
+        end
+      end
+
+      #
+      def state
+        state_index ? @tuple[state_index] : nil
+      end
+
+      #
+      alias status state
+
+      # Return the state revision count. This is the
+      # number that occurs after the state.
+      #
+      #   Version::Number[1,2,0,:rc,4].build_number
+      #   #=> 4
+      #
+      def build_number #revision
+        if i = state_index
+          self[i+1] || 0
+        else
+          nil
+        end
+      end
+
+      # @param [Integer] major
+      #   The major version number.
+      def major=(number)
+        @tuple[0] = number.to_i
+      end
+
+      # @param [Integer, nil] minor
+      #   The minor version number.
+      def minor=(number)
+        @tuple[1] = number.to_i
+      end
+
+      # @param [Integer, nil] patch
+      #   The patch version number.
+      def patch=(number)
+        @tuple[2] = number.to_i
+      end
+
+      # @param [Integer, nil] build (nil)
+      #   The build version number.
+      def build=(point)
+        @tuple = @tuple[0...state_index] + sane_point(point)
+      end
+
+      #
+      def stable?
+        build.nil?
+      end
+
+      alias_method :stable_release?, :stable?
+
+      #
+      def alpha?
+        s = status.dowcase
+        s == 'alpha' or s == 'a'
+      end
+
+      #
+      def beta?
+        s = status.dowcase
+        s == 'beta' or s == 'b'
+      end
+
+      #
+      def prerelease?
+        status == 'pre'
+      end
+
+      #
+      def release_candidate?
+        status == 'rc'
+      end
+
+      # Fetch a sepecific segement by index number.
+      # In no value is found at that position than
+      # zero (0) is returned instead.
+      #
+      #   v = Version::Number[1,2,0]
+      #   v[0]  #=> 1
+      #   v[1]  #=> 2
+      #   v[3]  #=> 0
+      #   v[4]  #=> 0
+      #
+      # Zero is returned instead of +nil+ to make different
+      # version numbers easier to compare.
+      def [](index)
+        @tuple.fetch(index,0)
+      end
+
+      # Returns a duplicate of the underlying version tuple.
+      #
+      def to_a
+        @tuple.dup
+      end
+
+      # Converts version to a dot-separated string.
+      #
+      #   Version::Number[1,2,0].to_s
+      #   #=> "1.2.0"
+      #
+      # TODO: crush
+      def to_s         
+        str = @tuple.compact.join('.')
+        str = crush_point(str) if crush?
+        return str
+      end
+
+      # This method is the same as #to_s. It is here becuase
+      # `File.join` calls it instead of #to_s.
+      #
+      #   VersionNumber[1,2,0].to_str
+      #   #=> "1.2.0"
+      #
+      def to_str
+        to_s
+      end
+
+      # Returns a String detaling the version number.
+      # Essentially it is the same as #to_s.
+      #
+      #   VersionNumber[1,2,0].inspect
+      #   #=> "1.2.0"
+      #
+      def inspect
+        to_s
+      end
+
+      #
+      # Converts the version to YAML.
+      #
+      # @param [Hash] opts
+      #   Options supporte by YAML.
+      #
+      # @return [String]
+      #   The resulting YAML.
+      #
+      #--
+      # TODO: Should this be here?
+      #++
+      def to_yaml(opts={})
+        to_s.to_yaml(opts)
+      end
+
+      #
+      #def ==(other)
+      #  (self <=> other) == 0
+      #end
+
+      # Compare versions.
+      def <=>(other)
+        [@tuple.size, other.size].max.times do |i|
+          p1, p2 = (@tuple[i] || 0), (other[i] || 0)
+          # this is bit tricky, basically a string < integer.
+          if p1.class != p2.class
+            cmp = p2.to_s <=> p1.to_s
+          else
+            cmp = p1 <=> p2
+          end
+          return cmp unless cmp == 0
+        end
+        #(@tuple.size <=> other.size) * -1
+        return 0
+      end
+
+      # For pessimistic constraint (like '~>' in gems).
+      #
+      # FIXME: Ensure it can handle trailing state.
+      def =~(other)
+        upver = other.bump(:last)
+        #@segments >= other and @segments < upver
+        self >= other and self < upver
+      end
+
+      # Iterate of each segment of the version. This allows
+      # all enumerable methods to be used.
+      #
+      #   Version::Number[1,2,3].map{|i| i + 1}
+      #   #=> [2,3,4]
+      #
+      # Though keep in mind that the state segment is not
+      # a number (and techincally any segment can be a string
+      # instead of an integer).
+      def each(&block)
+        @tuple.each(&block)
+      end
+
+      # Return the number of version segements.
+      #
+      #   Version::Number[1,2,3].size
+      #   #=> 3
+      #
+      def size
+        @tuple.size
+      end
+
+      # Bump the version returning a new version number object.
+      # Select +which+ segement to bump by name: +major+, +minor+,
+      # +patch+, +state+, +build+ and also +last+.
+      #
+      #   Version::Number[1,2,0].bump(:patch).to_s
+      #   #=> "1.2.1"
+      #
+      #   Version::Number[1,2,1].bump(:minor).to_s
+      #   #=> "1.3.0"
+      #
+      #   Version::Number[1,3,0].bump(:major).to_s
+      #   #=> "2.0.0"
+      #
+      #   Version::Number[1,3,0,:pre,1].bump(:build).to_s
+      #   #=> "1.3.0.pre.2"
+      #
+      #   Version::Number[1,3,0,:pre,2].bump(:state).to_s
+      #   #=> "1.3.0.rc.1"
+      #
+      def bump(which=:patch)
+        case which.to_sym
+        when :major, :first
+          bump_major
+        when :minor
+          bump_minor
+        when :patch
+          bump_patch
+        when :state, :status
+          bump_state
+        when :build
+          bump_build
+        when :revision
+          bump_revision
+        when :last
+          bump_last
+        else
+          self.class.new(@tuple.dup.compact)
+        end
+      end
+
+      #
+      def bump_major
+        self.class[inc(major), 0, 0]
+      end
+
+      #
+      def bump_minor
+        self.class[major, inc(minor), 0]
+      end
+
+      #
+      def bump_patch
+        self.class[major, minor, inc(patch)]
+      end
+
+      #
+      def bump_state
+        if i = state_index
+          if n = inc(@tuple[i])
+            v = @tuple[0...i] + [n] + (@tuple[i+1] ? [1] : [])
+          else
+            v = @tuple[0...i]
+          end
+        else
+          v = @tuple.dup
+        end
+        self.class.new(v.compact)
+      end
+
+      #
+      alias :bump_status :bump_state
+
+      #
+      def bump_build
+        if i = state_index
+          if i == @tuple.size - 1
+            v = @tuple + [1]
+          else
+            v = @tuple[0...-1] + [inc(@tuple.last)]
+          end
+        else
+          if @tuple.size <= 3
+            v = @tuple + [1]
+          else
+            v = @tuple[0...-1] + [inc(@tuple.last)]
+          end
+        end
+        self.class.new(v.compact)
+      end
+
+      #
+      def bump_build_number #revision
+        if i = state_index
+          v = @tuple[0...-1] + [inc(@tuple.last)]
+        else
+          v = @tuple[0..2] + ['alpha', 1]
+        end
+        self.class.new(v.compact)
+      end
+
+      #
+      def bump_last
+        v = @tuple[0...-1] + [inc(@tuple.last)]
+        self.class.new(v.compact)
+      end
+
+      # Return a new version have the same major, minor and
+      # patch levels, but with a new state and revision count.
+      #
+      #   Version::Number[1,2,3].restate(:pre,2).to_s
+      #   #=> "1.2.3.pre.2"
+      #
+      #   Version::Number[1,2,3,:pre,2].restate(:rc,4).to_s
+      #   #=> "1.2.3.rc.4"
+      #
+      def restate(state, revision=1)
+        if i = state_index
+          v = @tuple[0...i] + [state.to_s] + [revision]
+        else
+          v = @tuple[0...3] + [state.to_s] + [revision]
+        end
+        self.class.new(v)
+      end
+
+      # Does the version string representation compact
+      # string segments with the subsequent number segement?
+      def crush?
+        @crush
+      end
+
+      # Does this version match a given constraint? The constraint is a String
+      # in the form of "{operator} {version number}".
+      #--
+      # TODO: match? will change as Constraint class is improved.
+      #++
+      def match?(*constraints)
+        constraints.all? do |c|
+          Constraint.constraint_lambda(c).call(self)
+        end
+      end
+
+      protected
+
+      # Return the undelying segments array.
+      attr :tuple
+
+      private
+
+      # Convert a segment into an integer or string.
+      def sane_point(point)      
+        point = point.to_s if Symbol === point
+        case point
+        when Integer
+          point
+        when /^\d+$/
+          point.to_i
+        when /^(\d+)(\w+)(\d+)$/
+          @crush = true
+          [$1.to_i, $2, $3.to_i]
+        when /^(\w+)(\d+)$/
+          @crush = true
+          [$1, $2.to_i]
+        else
+          point
+        end
+      end
+
+      # Take a point string rendering of a version and crush it!
+      def crush_point(string)
+        string.gsub(/(^|\.)(\D+)\.(\d+)(\.|$)/, '\2\3')
+      end
+
+      # Return the index of the first recognized state.
+      #
+      #   VersionNumber[1,2,3,'pre',3].state_index
+      #   #=> 3
+      #
+      # You might ask why this is needed, since the state
+      # position should always be 3. However, there isn't 
+      # always a state entry, which means this method will
+      # return +nil+, and we also leave open the potential
+      # for extra-long version numbers --though we do not
+      # recommend the idea, it is possible.
+      def state_index
+        @tuple.index{ |s| String === s }
+      end
+
+      # Segement incrementor.
+      def inc(val)
+        if i = STATES.index(val.to_s)
+          STATES[i+1]
+        else
+          val.succ
+        end
+      end
+
+    end
+
+  end
+
+end