indexer 0.1.0

data/lib/indexer/components/repository.rb

@@ -0,0 +1,140 @@
+module Indexer
+
+  # The Repository class models a packages SCM repository location.
+  # It consists of two parts, the `scm` type of repository, it's `url`.
+  #
+  class Repository < Model
+
+    # Parse `data` returning a new Repository instance.
+    #
+    # @param data [String,Array<String>,Array<Hash>,Hash]
+    #   Repository information.
+    #
+    # @return [Repository] repository instance
+    #--
+    # TODO: Should String be allowed, and thus no `id`?
+    #++
+    def self.parse(data)
+      case data
+      when String
+        new('uri'=>data)
+      when Array
+        h, d = {}, data.dup  # TODO: data.rekey(&:to_s)
+        h.update(d.pop) while Hash === d.last
+        h['name'] = d.shift.to_s unless d.empty?
+        h['uri']  = d.shift.to_s unless d.empty?
+        h['scm']  = d.shift.to_s unless d.empty?
+        new(h)
+      when Hash
+        new(data)
+      else
+        raise(ValidationError, "not a valid repository")
+      end
+    end
+
+    #
+    # Initialize new Repository instance.
+    #
+    def initialize(data={})
+      super(data)
+
+      self.scm = infer_scm(uri) unless scm
+    end
+
+    #
+    # A name that can be used to identify the purpose of a
+    # particular repository.
+    #
+    attr_reader :name
+
+    #
+    # Set the repository name. This can be any one line description but
+    # it generally should be a brief one-word indictor such as "origin"
+    # "upstream", "experimental", "joes-fork", etc.
+    #
+    def name=(name)
+      Valid.oneline!(name)  # should be word!
+      @data[:name] = name.to_str
+    end
+
+    #
+    # The repository's URI.
+    #
+    attr_reader :uri
+
+    #
+    # Set repository URI
+    #
+    def uri=(uri)
+      Valid.oneline!(uri)
+      #Valid.uri!(uri)  # TODO: any other limitations?
+      @data[:scm] = infer_scm(uri)
+      @data[:uri] = uri
+    end
+
+    #
+    #
+    #
+    attr_reader :scm
+
+    #
+    # Set the SCM type of repository. The type is a single downcased word.
+    # Generally recognized types are:
+    #
+    # * git
+    # * hg
+    # * svn
+    # * cvs
+    # * darcs
+    #
+    # But any type can be used.
+    #
+    def scm=(scm)
+      Valid.word!(scm)
+      @data[:scm] = scm.to_str.downcase
+    end
+
+    #
+    # Prefix URI that can be used to link to source code.
+    #
+    # This name is the traditional one from a time when CVS was the
+    # most popular SCM.
+    #
+    attr_reader :webcvs
+
+    #
+    #
+    #
+    def webcvs=(uri)
+      Valid.oneline!(uri)
+      Valid.uri!(uri)  # TODO: any other limitations?
+      @data[:webcvs] = uri
+    end
+
+    # TODO: Should we rename Repository#webcvs to just #web ?
+
+    #
+    alias_method :web, :webcvs
+    alias_method :web=, :webcvs=
+
+  private
+
+    #
+    def infer_scm(uri)
+      case uri
+      when /^git:/, /\.git$/
+        'git'
+      when /^hg:/, /\.hg$/
+        'hg'
+      when /^svn:/
+        'svn'
+      when /darcs/
+        'darcs'
+      else
+        nil
+      end
+    end
+
+  end
+
+end

data/lib/indexer/components/requirement.rb

@@ -0,0 +1,360 @@
+module Indexer
+
+  # Requirement class.
+  #
+  # QUESTION: Does Requirement really need to handle multiple version constraints?
+  # Currently this only supports one version constraint.
+  #
+  class Requirement < Model
+
+    #
+    # Parse `data` into a Requirement instance.
+    #
+    # TODO: What about respond_to?(:to_str) for String, etc.
+    #
+    def self.parse(data)
+      case data
+      when String
+        parse_string(data)
+      when Array
+        parse_array(data)
+      when Hash
+        parse_hash(data)
+      else
+        raise(ValidationError, "requirement")
+      end
+    end
+
+  private
+
+    #
+    #
+    def self.parse_hash(data)
+      name = (data.delete('name') || data.delete(:name)).to_s
+      # make sure groups are strings
+      groups = []
+      groups << (data.delete('groups') || data.delete(:groups))
+      groups << (data.delete('group')  || data.delete(:group))
+      groups = groups.flatten.compact.map{ |g| g.to_s }
+      data[:groups] = groups
+      #
+      new(name, data)
+    end
+
+    #
+    #
+    def self.parse_string(string)
+      case string.strip
+      when /^(\w.*?)\s+(.*?)\s*\((.*?)\)$/
+        name    = $1
+        version = $2
+        groups  = $3
+      when /^(\w.*?)\s+(.*?)$/
+        name    = $1
+        version = $2
+        groups  = nil
+      when /^(\w.*?)$/
+        name    = $1
+        version = nil
+        groups  = nil
+      else
+        raise(ValidationError, "requirement")
+      end
+
+      version = nil                          if version.to_s.strip.empty?
+      groups = groups.split(/\s*[,;]?\s+/) if groups
+
+      specifics = {}
+      specifics['version']     = version  if version
+      specifics['groups']      = groups   if groups
+
+      if groups && !groups.empty? && !groups.include?('runtime')
+        specifics['development'] = true     
+      end
+
+      new(name, specifics)
+    end
+
+    #
+    #
+    #
+    def self.parse_array(array)
+      name, data = *array
+      case data
+      when Hash
+        groups = []
+        groups << (data.delete('groups') || data.delete(:groups))
+        groups << (data.delete('group')  || data.delete(:group))
+        groups = groups.flatten.compact.map{ |g| g.to_s }
+        data[:groups] = groups
+
+        new(name.to_s, data)
+      when String
+        parse_string(name + " " + data)
+      else
+        raise(ValidationError, "requirement")
+      end
+    end
+
+    #
+    # Create new instance of Requirement.
+    #
+    def initialize(name, specifics={})
+      specifics[:name] = name
+      super(specifics)
+    end
+
+    #
+    def initialize_attributes
+      @data = {
+        :groups    => [],
+        :engines   => [],
+        :platforms => [],
+        :sources   => []
+      }
+    end
+
+  public
+
+    #
+    #
+    attr_reader :name
+
+    #
+    #
+    def name=(name)
+      @data[:name] = name.to_s
+    end
+
+    #
+    # The requirement's version constraint.
+    #
+    # @return [Version::Constraint] version constraint.
+    #
+    attr_reader :version
+
+    #
+    # Set the version constraint.
+    #
+    # @param version [String,Array,Version::Constraint]
+    #   Version constraint(s)
+    #
+    def version=(version)
+      @data[:version] = Version::Constraint.parse(version)
+    end
+
+    #
+    alias :versions= :version=
+
+    #
+    # Returns true if the requirement is a development requirement.
+    #
+    # @return [Boolean] development requirement?
+    def development?
+      @data[:development]
+    end
+
+    #
+    # Set the requirement's development flag.
+    #
+    # @param [Boolean] true/false development requirement
+    #
+    def development=(boolean)
+      @data[:development] = !!boolean
+    end
+
+    #
+    # Return `true` if requirement is a runtime requirement.
+    #
+    # @return [Boolean] runtime requirement?
+    def runtime?
+     ! @data[:development]
+    end
+
+    #
+    # The groups to which the requirement belongs.
+    #
+    # @return [Array] list of groups
+    #
+    attr_reader :groups
+
+    #
+    # Set the groups to which the requirement belongs.
+    #
+
+    # @return [Array, String] list of groups
+    #
+    def groups=(groups)
+      @data[:groups] = [groups].flatten
+    end
+
+    # Singular alias for #groups.
+    alias :group :groups
+    alias :group= :groups=
+
+    #
+    # Is the requirment optional? An optional requirement is recommended
+    # but not strictly necessary.
+    #
+    # @return [Boolean] optional requirement?
+    #
+    def optional?
+      @data[:optional]
+    end
+
+    #
+    # Set optional.
+    #
+    # @param [Boolean] optional requirement?
+    #
+    def optional=(boolean)
+      @data[:optional] = !!boolean
+    end
+
+    #
+    # Is the requirment external? An external requirement is one that is only
+    # available outside the expected packaging system. For a Ruby application, for example,
+    # this would be library not available via rubygems.org, such as a C library that is only
+    # avaialble via an operating system's package manager or via a direct download using the
+    # "make; make install" compile and installation procedure.
+    #
+    # @return [Boolean] external requirement?
+    #
+    def external?
+      @data[:external]
+    end
+
+    #
+    # Set external.
+    #
+    # @param [Boolean] external requirement?
+    #
+    def external=(boolean)
+      @data[:external] = !!boolean
+    end
+
+    #
+    # Applies only for specified Ruby engines. Each entry can be
+    # the `RUBY_ENGINE` value and optionally a version constraint
+    # on `RUBY_VERSION`.
+    #
+    # @return [Array] name and version constraint
+    #
+    attr :engines
+
+    #
+    # Applies only for specified Ruby engines. Each entry can be
+    # the `RUBY_ENGINE` value and optionally a version constraint
+    # on `RUBY_VERSION`.
+    #
+    # @example
+    #
+    #   requirement.engines = [
+    #     'ruby 1.8~'
+    #   ]
+    #
+    def engines=(engines)
+      @data['engines'] = Array(engines).map do |engine|
+        case engine
+        when String
+          name, vers = engine.strip.split(/\s+/)
+          vers = nil if vers.empty?
+        when Array
+          name, vers = *engine
+        when Hash
+          name = engine['name']
+          vers = engine['version']
+        end
+        e = {}
+        e['name']    = name
+        e['version'] = Version::Constraint.parse(vers) if vers
+        e
+      end
+    end
+
+    alias_method :engine,  :engines
+    alias_method :engine=, :engines=
+
+    attr :platforms
+
+    #
+    # Applies only for specified platforms. The platform must be verbatim
+    # `RUBY_PLATFORM` value.
+    #
+    # @example
+    #   requirement.platforms = ['x86_64-linux']
+    #
+    def platforms=(platforms)
+      @data[:platforms] = Array(platforms)
+    end
+
+    alias_method :platform,  :platforms
+    alias_method :platform=, :platforms=
+
+    #
+    # The public repository resource in which the requirement source code
+    # can be found.
+    #
+    attr :repository
+
+    #
+    # Set the public repository resource in which the requirement
+    # source code can be found.
+    #
+    def repository=(repository)
+      @data[:repository] = Repository.parse(repository)
+    end
+
+    alias :repo :repository
+    alias :repo= :repository=
+
+    #
+    # Places from which the requirement can be obtained. Generally a source
+    # should be a URI, but there is no strict requirement. It can be as 
+    # simple as a name, e.g. `rubygems` or as specific as a URL to a downloadable
+    # `.zip` package.
+    #
+    # @example
+    #   requirement.sources = ['http://rubygems.org']
+    #
+    attr :sources
+
+    #
+    # Set sources.
+    #
+    def sources=(sources)
+      @data[:sources] = Array(sources)
+    end
+
+    #
+    # Convert to canonical hash.
+    #
+    def to_h
+      h = super
+
+      h['version']     = version.to_s if version
+      h['repository']  = repository.to_h if repository
+
+      h.delete('groups')    if h['groups']    && h['groups'].empty?
+      h.delete('engines')   if h['engines']   && h['engines'].empty?
+      h.delete('platforms') if h['platforms'] && h['platforms'].empty?
+      h.delete('sources')   if h['sources']   && h['sources'].empty?
+
+      h
+    end
+
+  private
+
+    # ensure engine entries are strings
+    #def engines_to_h
+    #  engines.map do |engine|
+    #    hash = {}
+    #    hash['name'] = engine['name']
+    #    hash['version'] = engine['version'].to_s
+    #    hash
+    #  end
+    #end
+
+  end
+
+end