php-composer 0.1.0

data/lib/composer/package/version/version_selector.rb

@@ -0,0 +1,106 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Package\Version\VersionParser.php
+#
+# (c) Nils Adermann <naderman@naderman.de>
+#     Jordi Boggiano <j.boggiano@seld.be>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module Composer
+  module Package
+    module Version
+      # Selects the best possible version for a package
+      #
+      # PHP Authors:
+      # Ryan Weaver <ryan@knpuniversity.com>
+      #
+      # Ruby Authors:
+      # Ioannis Kappas <ikappas@devworks.gr>
+      class VersionSelector
+
+          def initialize(pool)
+            @pool = pool
+          end
+
+
+          # Given a concrete version, this returns a ~ constraint (when possible)
+          # that should be used, for example, in composer.json.
+          #
+          # For example:
+          #  * 1.2.1         -> ~1.2
+          #  * 1.2           -> ~1.2
+          #  * v3.2.1        -> ~3.2
+          #  * 2.0-beta.1    -> ~2.0@beta
+          #  * dev-master    -> ~2.1@dev      (dev version with alias)
+          #  * dev-master    -> dev-master    (dev versions are untouched)
+          #
+          # @param  Package package
+          # @return string
+          def find_recommended_require_version(package)
+            version = package.version
+            if !package.is_dev
+              return transform_version(version, package.pretty_version, package.stability)
+            end
+
+            loader = Composer::Package::Loader::HashLoader.new(parser)
+            dumper = Composer::Package::Dumper::HashDumper.new
+
+            if (extra = loader.get_branch_alias(dumper.dump(package)))
+              if match = /^(\d+\.\d+\.\d+)(\.9999999)-dev$/.match(extra)
+                extra = "#{match[1]}.0"
+                extra.gsub!('.9999999', '.0')
+                return transform_version(extra, extra, 'dev')
+              end
+            end
+
+            package.pretty_version
+          end
+
+          private
+
+          def transform_version(version, pretty_version, stability)
+            # attempt to transform 2.1.1 to 2.1
+            # this allows you to upgrade through minor versions
+            semantic_version_parts = version.split('.')
+            op = '~'
+
+              # check to see if we have a semver-looking version
+              if semantic_version_parts.length == 4 && /^0\D?/.match(semantic_version_parts[3])
+                # remove the last parts (i.e. the patch version number and any extra)
+                if semantic_version_parts[0] === '0'
+                  if semantic_version_parts[1] === '0'
+                    semantic_version_parts[3] = '*'
+                  else
+                    semantic_version_parts[2] = '*'
+                    semantic_version_parts.delete_at(3)
+                  end
+                  op = ''
+                else
+                  semantic_version_parts.delete_at(3)
+                  semantic_version_parts.delete_at(2)
+                end
+                version = semantic_version_parts.join('.')
+              else
+                return pretty_version
+              end
+
+              # append stability flag if not default
+              if stability != 'stable'
+                version <<  "@#{stability}"
+              end
+
+              # 2.1 -> ~2.1
+              op + version
+          end
+
+          def parser
+            @parser ||= Composer::Package::Version::VersionParser.new
+            @parser
+          end
+      end
+    end
+  end
+end

data/lib/composer/provider.rb

@@ -0,0 +1,94 @@
+module Composer
+  class Provider
+
+    BLANK_PROVIDER = { "packages"=>{} }
+
+    def initialize(project)
+      @project = project
+      @package_dumper = Composer::Package::Dumper::HashDumper.new
+    end
+
+    def add_package(package)
+
+      raise ArgumentError, 'package must be specified' unless package
+      # raise TypeError, 'package must be a subclass of Composer::Package::Package' unless package.kind_of?(Composer::Package::Package)
+
+      name = package.name
+      pretty_version = package.pretty_version
+
+      packages[name] ||= {}
+      packages[name][pretty_version] = @package_dumper.dump(package)
+
+      if packages[name].length >= 2
+        packages[name].keys.sort.each { |k| packages[name][k] = packages[name].delete k }
+      end
+
+    end
+
+    def rm_package(package)
+
+      raise ArgumentError, 'package must be specified' unless package
+      # raise TypeError, 'package must be a subclass of Composer::Package::Package' unless package.kind_of?(Composer::Package::Package)
+
+      name = package.name
+      pretty_version = package.pretty_version
+
+      if has_package?(name, pretty_version)
+        packages[name].delete(pretty_version)
+        if packages[name].empty?
+          packages.delete(name)
+        elsif packages[name].length >= 2
+          packages[name].keys.sort.each { |k| packages[name][k] = packages[name].delete k }
+        end
+      end
+
+    end
+
+    def clear_packages
+      @packages = {}
+    end
+
+    def has_package?(name, pretty_version=nil)
+      if pretty_version
+        packages.key?(name) ? packages[name].key?(pretty_version) : false
+      else
+        packages.key?(name)
+      end
+    end
+
+    def has_packages?
+      !packages.empty?
+    end
+
+    def save_or_delete
+      if has_packages?
+        File.open(filepath, "w") { |f| f.write(content) }
+      else
+        File.delete(filepath) unless not File.exist?(filepath)
+      end
+    end
+
+    def filename
+      "project-#{@project.id}.json"
+    end
+
+    def sha1
+      Digest::SHA1.hexdigest content
+    end
+
+    private
+
+    def packages
+      @packages ||= File.exist?(filepath) ? File.open(filepath, "r") { |f| ActiveSupport::JSON.decode(f.read)["packages"] rescue {} } : {}
+    end
+
+    def content
+      { 'packages' => packages }.to_json
+    end
+
+    def filepath
+      File.join(File.realpath(Rails.root.join('public', 'p')), filename)
+    end
+
+  end
+end

data/lib/composer/repository/array_repository.rb

@@ -0,0 +1,195 @@
+#
+# This file was ported to ruby from Composer php source code.
+# Original Source: Composer\Repository\ArrayRepository.php
+#
+# (c) Nils Adermann <naderman@naderman.de>
+#     Jordi Boggiano <j.boggiano@seld.be>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module Composer
+  module Repository
+    class ArrayRepository
+      def initialize(packages = [])
+        packages.each do |package|
+          add_package(package)
+        end
+      end
+
+      def find_package(name, version = nil)
+        # normalize name
+        name = name.downcase
+
+        # normalize version
+        if version != nil
+          version_parser = Composer::Package::Verision::VersionParser.new
+          version = version_parser.normalize(version)
+        end
+
+        packages.each do |package|
+          if package.name === name && (nil === $version || version === package.version)
+            return package
+          end
+        end
+
+      end
+
+      def find_packages(name, version = nil)
+          # normalize name
+          name = name.downcase
+
+          # normalize version
+          if version != nil
+            version_parser = Composer::Package::Verision::VersionParser.new
+            version = version_parser.normalize(version)
+          end
+
+          matches = []
+          packages.each do |package|
+            if package.name === name && (nil === $version || version === package.version)
+              matches << package
+            end
+          end
+          matches
+      end
+
+      def search(query, full_search = false)
+        regex = /(?:#{query.split(/\s+/).join('|')})/i
+        matches = {}
+        packages.each do |package|
+          name = package.name
+
+          # allready matched
+          next if matches['name']
+
+          # search
+          if full_search
+            next unless (
+              package.instance_of(Composer::Package::CompletePackage) &&
+              regex.match("#{package.keywords.join(' ')} #{package.description}")
+            )
+          else
+            next unless (
+              full_search == false &&
+              regex.match(name)
+            )
+          end
+
+          matches[name] = {
+            'name' => package.pretty_name,
+            'description' => $package.description,
+          }
+        end
+        matches
+      end
+
+      def package?(package)
+        unless package
+          raise ArgumentError,
+                'package must be specified'
+        end
+        unless package.is_a(Composer::Package::BasePackage)
+          raise TypeError,
+                'package must be a class or superclass of \
+                Composer::Package::Package'
+        end
+
+        package_id = package.unique_name
+        packages.each do |repo_package|
+          return true if repo_package.unique_name === package_id
+        end
+
+        false
+      end
+
+      # Adds a new package to the repository
+      #
+      # Params:
+      # +package+ Package The package to add
+      def add_package(package)
+        unless package
+          raise ArgumentError,
+                'package must be specified'
+        end
+        unless package.is_a(Composer::Package::BasePackage)
+          raise TypeError,
+                'package must be a class or superclass of \
+                Composer::Package::Package'
+        end
+
+        initialize_repository unless @packages
+
+        package.repository = self
+
+        @packages << package
+
+        if package.instance_of(Composer::Package::AliasPackage)
+          aliased_package = package.alias_of
+          if aliased_package.repository === nil
+            add_package(aliased_package)
+          end
+        end
+      end
+
+      # Removes package from repository.
+      #
+      # Params:
+      # +package+ package instance to remove
+      def remove_package(package)
+        unless package
+          raise ArgumentError,
+                'package must be specified'
+        end
+        unless package.is_a(Composer::Package::BasePackage)
+          raise TypeError,
+                'package must be a class or superclass of \
+                Composer::Package::Package'
+        end
+
+        package_id = package.unique_name
+
+        index = 0
+        packages.each do |repo_package|
+          if repo_package.unique_name === package_id
+            @packages.delete_at(index)
+            return
+          end
+          index = index + 1
+        end
+      end
+
+      def packages
+        initialize_repository unless @packages
+        @packages
+      end
+
+      def count
+        @packages.lenght
+      end
+
+      protected
+
+      # Initializes the packages array.
+      # Mostly meant as an extension point.
+      def initialize_repository
+        @packages = []
+      end
+
+      def create_alias_package(package, version, pretty_version)
+        if package.instance_of(Composer::Package::AliasPackage)
+          alias_of = package.alias_of
+        else
+          alias_of = package
+        end
+        Composer::Package::AliasPackage.new(
+          alias_of,
+          version,
+          pretty_version
+        )
+      end
+
+    end
+  end
+end

data/lib/composer/repository/filesystem_repository.rb

@@ -0,0 +1,86 @@
+#
+# This file was ported to ruby from Composer php source code.
+# Original Source: Composer\Repository\FilesystemRepository.php
+#
+# (c) Nils Adermann <naderman@naderman.de>
+#     Jordi Boggiano <j.boggiano@seld.be>
+#
+# For the full copyright and license information, please view the LICENSE
+# file that was distributed with this source code.
+#
+
+module Composer
+  module Repository
+    # Filesystem repository.
+    #
+    # PHP Authors:
+    # Konstantin Kudryashov <ever.zet@gmail.com>
+    # Jordi Boggiano <j.boggiano@seld.be>
+    #
+    # Ruby Authors:
+    # Ioannis Kappas <ikappas@devworks.gr>
+    class FilesystemRepository < Composer::Repository::WritableArrayRepository
+
+      # Initializes filesystem repository.
+      # @param [Composer::Json::JsonFile] repository_file repository json file
+      def initialize(repository_file)
+        unless repository_file
+          raise ArgumentError,
+                'repository_file must be specified'
+        end
+        unless repository_file.is_a(Composer::Json::JsonFile)
+          raise TypeError,
+                'repository_file type must be a \
+                Composer::Json::JsonFile or superclass'
+        end
+        super([])
+        @file = repository_file
+      end
+
+
+      def reload
+        @packages = nil
+        configure
+      end
+
+      # Writes writable repository.
+      def write
+        data = []
+        dumper = Composer::Package::Dumper::HashDumper.new
+
+        canonical_packages.each { |package| data << dumper.dump(package) }
+
+        @file.write(data)
+      end
+
+      protected
+
+      # Initializes repository (reads file, or remote address).
+      def initialize_repository
+        super
+        return unless @file.exists
+
+        begin
+          packages_data = @file.read
+          unless packages_data.is_a(Hash)
+            raise UnexpectedValueError,
+                  'Could not parse package list from the repository'
+          end
+        rescue Exception => e
+          raise InvalidRepositoryError,
+                "Invalid repository data in #{@file.path}, \
+                packages could not be loaded: \
+                [#{e.class}] #{e.message}"
+        end
+
+        loader = Composer::Package::Loader::ArrayLoader.new(nil, true)
+        packages_data.each do |package_data|
+          package = loader.load(package_data)
+          add_package(package)
+        end
+
+      end
+
+    end
+  end
+end