indexer 0.1.0

data/lib/indexer/components.rb

@@ -0,0 +1,8 @@
+require_relative 'components/author'
+require_relative 'components/organization'
+require_relative 'components/copyright'
+require_relative 'components/conflict'
+require_relative 'components/resource'
+require_relative 'components/repository'
+require_relative 'components/requirement'
+

data/lib/indexer/components/author.rb

@@ -0,0 +1,140 @@
+module Indexer
+
+  # Author is used to model Authors and Maintainers.
+  #
+  # TODO: Should Author have an `organization` field. If so
+  # is it a map with `name` and `website` fields?
+  #
+  # TODO: Should we have `team` field (think Github)?
+  #
+  class Author < Model
+
+    # Parse `entry` and create Author object.
+    def self.parse(entry)
+      case entry
+      when Author
+        entry
+      when String
+        parse_string(entry)
+      when Array
+        parse_array(entry)
+      when Hash
+        new(entry)
+      end
+    end
+
+    #
+    def self.parse_array(array)
+      data = {}
+      array.each do |value|
+        v = value.strip
+        case v
+        when /^(.*?)\s*\<(.*?@.*?)\>/
+          data[:name]  = $1 unless $1.empty?
+          data[:email] = $2
+        when /^(http|https)\:/
+          data[:website] = v
+        when /\@/
+          data[:email] = v
+        else
+          data[:name] = v
+        end
+      end
+      new(data)
+    end
+
+    #
+    def self.parse_string(string)
+      if md = /(.*?)\s*\<(.*?)\>/.match(string)
+        new(:name=>md[1], :email=>md[2])
+      else
+        new(:name=>string)
+      end
+    end
+
+    #
+    def initialize(data)
+      super(data)
+      #raise ArgumentError, "person must have a name" unless name
+    end
+
+    #
+    def initialize_attributes
+      @data = {
+        :roles => []
+      }
+    end
+
+    #
+    attr :name
+
+    #
+    def name=(name)
+      Valid.oneline!(name, :name)
+      @data[:name] = name
+    end
+
+    #
+    attr :email
+
+    #
+    def email=(email)
+      Valid.email!(email, :email)
+      @data[:email] = email
+    end
+
+    #
+    attr :website
+
+    #
+    def website=(website)
+      Valid.url!(website, :website)
+      @data[:website] = website
+    end
+
+    #
+    attr :team
+
+    # TODO: validate team
+    def team=(team)
+      @data[:team] = team
+    end
+
+    # List of roles the person plays in the project.
+    # This can be any string or array of strings.
+    attr :roles
+
+    #
+    def roles=(role)
+      @data[:roles] = (
+        r = [role].flatten
+        r.each{ |x| Valid.oneline?(x) }
+        r
+      )
+    end
+
+    alias :role  :roles
+    alias :role= :roles=
+
+    alias :group  :roles
+    alias :group= :roles=
+
+    #
+    def to_h
+      h = {}
+      h['name']    = name 
+      h['email']   = email   if email
+      h['website'] = website if website
+      h['roles']   = roles   if not roles.empty?
+      h
+    end
+
+    # CONSIDE: Only name has to be equal?
+    def ==(other)
+      return false unless Author === other
+      return false unless name == other.name
+      return true
+    end
+  end
+
+end

data/lib/indexer/components/conflict.rb

@@ -0,0 +1,78 @@
+module Indexer
+
+  # The Conflict class models the name and versions of
+  # packages that have know incompatibilities.
+  #
+  class Conflict < Model
+
+    # Parse `data` into a Dependency 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, "Conflict")
+      end
+    end
+
+  private
+
+    #
+    #
+    def self.parse_string(data)
+      name, version = data.split(/\s+/)
+      new(:name=>name, :version=>version)
+    end
+
+    #
+    #
+    def self.parse_array(data)
+      name, version = *data
+      new(:name=>name, :version=>version)
+    end
+
+    #
+    #
+    def self.parse_hash(data)
+      new(data)
+    end
+
+  public
+
+    #
+    # The name of the package that causes the conflict.
+    #
+    # Yea it's *ALWAYS* THEIR fault ;-)
+    #
+    attr :name
+
+    #
+    # Set the name of the package.
+    #
+    def name=(name)
+      @data[:name] = name.to_s
+    end
+
+    #
+    # The versions constraint of the conflicting package.
+    # This is used when only certain versions of the package
+    # are the problem.
+    #
+    attr_reader :version
+
+    #
+    # Set the version constraint.
+    #
+    def version=(version)
+      @data[:version] = Version::Constraint.parse(version)
+    end
+
+  end
+
+end

data/lib/indexer/components/copyright.rb

@@ -0,0 +1,95 @@
+module Indexer
+
+  # Copyright class models a copyright holer, the year of copyright
+  # and the accosiated license.
+  #
+  class Copyright < Model
+
+    # Parse copyright entry.
+    #
+    def self.parse(copyright, default_license=nil)
+      case copyright
+      when Array
+        year, holder, license = *copyright
+      when Hash
+        year    = copyright['year']    || copyright[:year]
+        holder  = copyright['holder']  || copyright[:holder]
+        license = copyright['license'] || copyright[:license]
+      when String
+        case copyright
+        when /(\d\d\d\d)\s+(.*?)\s*\((.*?)\)$/
+          year, holder, license = $1, $2, $3
+        when /(\d\d\d\d)\s+(.*?)\s*$/
+          year, holder, license = $1, $2, nil
+        when /(opyright|\(c\))(.*?)\s*\((.*?)\)$/
+          year, holder, license = nil, $1, $2
+        when /(opyright|\(c\))(.*?)\s*$/
+          year, holder, license = nil, $1, nil
+        end
+      else
+        raise ValidationError, "copyright"
+      end
+      license = license || default_license
+      new(:holder=>holder, :year=>year, :license=>license)
+    end
+
+    #
+    def initialize(data)
+      super(data)
+      raise(ValidationError, "copyright must have a holder") unless holder
+    end
+
+    #
+    attr :year
+
+    #
+    attr :holder
+
+    #
+    attr :license
+
+    #
+    def year=(year)
+      Valid.copyright_year!(year, "copyright.year")
+      @data[:year] = year
+    end
+
+    #
+    def holder=(holder)
+      Valid.oneline!(holder, "copyright.holder")
+      @data[:holder] = holder
+    end
+
+    #
+    def license=(license)
+      if license.nil?
+        @data.delete(:license)
+      else
+        Valid.oneline!(license, "copyright.license")
+        @data[:license] = license
+      end
+    end
+
+    #
+    # Standard copyright stamp.
+    #
+    def to_s
+      s = ["Copyright (c)"]
+      s << year if year
+      s << holder
+      s << "(#{license})" if license
+      s.join(' ') + ". All Rights Reserved."
+    end
+
+    #
+    def to_h
+      h = {}
+      h['holder']  = holder
+      h['year']    = year    if year
+      h['license'] = license if license
+      h
+    end
+
+  end
+
+end

data/lib/indexer/components/dependency.rb

@@ -0,0 +1,18 @@
+module Indexer
+
+  # Dependency class is essentially the same as {Requirement}, but
+  # a dependency represents a binary package requirement that would
+  # need to be installed using an operating systems own package
+  # management system, or installed manually.
+  #
+  # Dependency is a sublcass of {Requirement}. It only exists as a separate
+  # class becuase an OS package managers MIGHT require some additional
+  # information --but as of yet that's not the case.
+  #
+  # TODO: Why not merge the two and add a field to distinguish them?
+  #
+  class Dependency < Requirement
+  end
+
+end
+

data/lib/indexer/components/organization.rb

@@ -0,0 +1,133 @@
+module Indexer
+
+  # Organization is used to model companies involved in project.
+  #
+  class Organization < Model
+
+    # Parse `entry` and create Organization object.
+    def self.parse(entry)
+      case entry
+      when Organization
+        entry
+      when String
+        parse_string(entry)
+      when Array
+        parse_array(entry)
+      when Hash
+        new(entry)
+      end
+    end
+
+    #
+    def self.parse_array(array)
+      data = {}
+      array.each do |value|
+        v = value.strip
+        case v
+        when /^(.*?)\s*\<(.*?@.*?)\>/
+          data[:name]  = $1 unless $1.empty?
+          data[:email] = $2
+        when /^(http|https)\:/
+          data[:website] = v
+        when /\@/
+          data[:email] = v
+        else
+          data[:name] = v
+        end
+      end
+      new(data)
+    end
+
+    #
+    def self.parse_string(string)
+      if md = /(.*?)\s*\<(.*?)\>/.match(string)
+        new(:name=>md[1], :email=>md[2])
+      else
+        new(:name=>string)
+      end
+    end
+
+    #
+    def initialize(data)
+      super(data)
+      #raise ArgumentError, "person must have a name" unless name
+    end
+
+    #
+    def initialize_attributes
+      @data = {
+        :roles => []
+      }
+    end
+
+    #
+    attr :name
+
+    #
+    def name=(name)
+      Valid.oneline!(name, :name)
+      @data[:name] = name
+    end
+
+    #
+    attr :email
+
+    #
+    def email=(email)
+      Valid.email!(email, :email)
+      @data[:email] = email
+    end
+
+    #
+    attr :website
+
+    #
+    def website=(website)
+      Valid.url!(website, :website)
+      @data[:website] = website
+    end
+
+    # List of roles the person plays in the project.
+    # This can be any string or array of strings.
+    attr :roles
+
+    #
+    def roles=(roles)
+      @data[:roles] = (
+        r = [roles].flatten
+        r.each{ |x| Valid.oneline?(x) }
+        r
+      )
+    end
+
+    # Signular term for #roles can be used as well.
+    alias :role  :roles
+    alias :role= :roles=
+
+    # Group is a synonym for role.
+    alias :group  :roles
+    alias :group= :roles=
+
+    # Team is a common synonym for role too.
+    alias :team   :roles
+    alias :teams= :roles=
+
+    # Convert to simple Hash represepentation.
+    def to_h
+      h = {}
+      h['name']    = name 
+      h['email']   = email   if email
+      h['website'] = website if website
+      h['roles']   = roles   if not roles.empty?
+      h
+    end
+
+    # CONSIDER: Only name has to be equal?
+    def ==(other)
+      return false unless Organization === other
+      return false unless name == other.name
+      return true
+    end
+  end
+
+end