php-composer 0.1.0

data/Gemfile

@@ -0,0 +1,15 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in composer.gemspec
+gemspec
+
+gem 'json', '>= 1.7', :platforms => [:mri_18, :mri_19]
+gem 'json-schema', '>= 2.5.0'
+# gem 'version_compare', '~> 0.0.2'
+gem 'digest-crc'
+
+group :development, :test do
+  gem 'rubocop', '>= 0.28.0', require: false
+  gem 'rspec'
+  gem 'simplecov', '>= 0.9.2'
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015, Ioannis Kappas <ikappas@devworks.gr>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,35 @@
+# PHP Composer Ruby Gem
+
+A ruby gem library for consistent interactions with php composer dependency manager.
+
+This is a partial port of the [Composer - Dependency Management for PHP](https://github.com/composer/composer) project as a library that enables consistent interactions with php composer.
+
+See [https://getcomposer.org/](https://getcomposer.org/) for more information.
+
+## Installation / Usage
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'php-composer'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install php-composer
+
+## Authors
+Ioannis Kappas - <ikappas@devworks.gr>
+
+## License
+PHP Composer Ruby Gem is licensed under the MIT License - see the LICENSE file for details
+
+## Contributing
+1. Fork it ( https://github.com/ikappas/php-composer/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require 'bundler/gem_tasks'

data/lib/composer.rb

@@ -0,0 +1,52 @@
+# external
+require 'json'
+require 'json-schema'
+
+# /
+require 'composer/version'
+require 'composer/error'
+
+# /json
+require 'composer/json/json_validaton_error'
+require 'composer/json/json_file'
+require 'composer/json/json_formatter'
+
+# /package
+require 'composer/package/base_package'
+require 'composer/package/package'
+require 'composer/package/complete_package'
+require 'composer/package/alias_package'
+require 'composer/package/root_alias_package'
+require 'composer/package/root_package'
+require 'composer/package/link'
+
+# /package/dumper
+require 'composer/package/dumper/hash_dumper'
+
+# /package/link_constraint
+require 'composer/package/link_constraint/base_constraint'
+require 'composer/package/link_constraint/empty_constraint'
+require 'composer/package/link_constraint/specific_constraint'
+require 'composer/package/link_constraint/version_constraint'
+require 'composer/package/link_constraint/multi_constraint'
+
+# /package/loader
+require 'composer/package/loader/hash_loader'
+require 'composer/package/loader/json_loader'
+
+# /package/version
+require 'composer/package/version/version_parser'
+require 'composer/package/version/version_selector'
+
+# Dir[File.join(File.dirname(__FILE__), "composer/package/dumper/*.rb")].each {|file| require file }
+# Dir[File.join(File.dirname(__FILE__), "composer/package/link_constraint/*.rb")].each {|file| require file }
+# Dir[File.join(File.dirname(__FILE__), "composer/package/loader/*.rb")].each {|file| require file }
+# Dir[File.join(File.dirname(__FILE__), "composer/package/version/*.rb")].each {|file| require file }
+
+# /repository
+require 'composer/repository/array_repository'
+require 'composer/repository/writeable_array_repository'
+require 'composer/repository/filesystem_repository'
+
+module Composer
+end

data/lib/composer/error.rb

@@ -0,0 +1,8 @@
+module Composer
+  class Error < ::StandardError; end
+  class ArgumentError < Error; end
+  class TypeError < Error; end
+  class UnexpectedValueError < Error; end
+  class LogicError < Error; end
+  class InvalidRepositoryError < Error; end
+end

data/lib/composer/json/json_file.rb

@@ -0,0 +1,270 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Json\JsonFile.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 Json
+    # Reads/writes json files.
+    #
+    # PHP Authors:
+    # Konstantin Kudryashiv <ever.zet@gmail.com>
+    # Jordi Boggiano <j.boggiano@seld.be>
+    #
+    # Ruby Authors:
+    # Ioannis Kappas <ikappas@devworks.gr>
+    class JsonFile
+      attr_reader :path
+
+      LAX_SCHEMA = 1
+      STRICT_SCHEMA = 2
+
+      JSON_ERROR_NONE = 0
+      JSON_ERROR_DEPTH = 1
+      JSON_ERROR_STATE_MISMATCH = 2
+      JSON_ERROR_CTRL_CHAR = 3
+      JSON_ERROR_SYNTAX = 4
+      JSON_ERROR_UTF8 = 5
+      JSON_ERROR_RECURSION = 6
+      JSON_ERROR_INF_OR_NAN = 7
+      JSON_ERROR_UNSUPPORTED_TYPE = 8
+
+      # Initializes json file reader/parser.
+      # @param [String] path path to a json file
+      # @param [RemoteFileSystem] rfs The remote filesystem to use for http/https json files
+      # @raise [ArgumentError]
+      def initialize(path, rfs = nil)
+        @path = path
+        if rfs === nil && /^https?:\/\//i.match(path)
+          raise ArgumentError,
+                'http urls require a RemoteFilesystem instance to be passed'
+        end
+        @rfs = rfs
+      end
+
+      # Checks whether this json file exists.
+      #
+      # Returns:
+      # true if this json file exists; otherwise false.
+      def exist?
+        File.exist?(path)
+      end
+
+      # Reads the json file.
+      #
+      # Raises:
+      # RuntimeError
+      #
+      # Returns:
+      # mixed
+      def read
+        if @rfs
+          json = @rfs.get_contents(@path, @path, false)
+        else
+          json = File.open(@path, 'r') { |f| f.read }
+        end
+
+        parse_json(json, @path)
+
+      rescue Exception => e
+        raise e
+      end
+
+      def write(hash, options = 448)
+        dir = File.dirname(@path)
+
+        unless File.directory?(storage_path)
+          if File.exist?(dir)
+            raise UnexpectedValueError,
+                  "#{dir} exists and is not a directory."
+          end
+          FileUtils.mkdir_p(dir, 0777)
+        end
+
+        retries = 3
+        while retries >= 0
+          begin
+            file_ending = options & JSON_PRETTY_PRINT ? "\n" : ''
+            File.open(path, 'w') do |f|
+              content = encode(hash, options) + file_ending
+              f.write(content)
+            end
+            break
+
+          rescue Exception => e
+            if retries
+              retries -= 1
+              sleep 0.5
+            else
+              raise e
+            end
+          end
+        end
+
+      end
+
+      # Validates the schema of the current json file according
+      # to composer-schema.json rules
+      #
+      # @param schema int a JsonFile::*_SCHEMA constant
+      # @return bool true if schema is valid; Otherwise false.
+      # @throw Composer::Json::JsonValidationError
+      def validate_schema(schema = STRICT_SCHEMA)
+        content = File.open(@path, 'r') { |f| f.read }
+        data = JSON.parse(content)
+
+        if data == nil && content != 'null'
+          self::validate_syntax(content, @path)
+        end
+
+        schema_file = File.join(
+          File.dirname(__FILE__),
+          '../../../resources/composer-schema.json'
+        )
+
+        schema_data = JSON.parse(
+          File.open(schema_file, 'r') { |f| f.read }
+        )
+
+        if schema === LAX_SCHEMA
+          schema_data['additionalProperties'] = true
+          schema_data['properties']['name']['required'] = false
+          schema_data['properties']['description']['required'] = false
+        end
+
+        errors = JSON::Validator.fully_validate(
+          schema_data,
+          data,
+          {:errors_as_objects => true}
+        )
+
+        unless errors.empty?
+          processed_errors = []
+          errors.each do |error|
+            prefix = error[:fragment] ? "#{error[:fragment]} : " : ''
+            processed_errors.push( prefix + error[:message])
+          end
+          raise Composer::Json::JsonValidationError.new(processed_errors),
+                "\"#{@path}\" does not match the expected JSON schema"
+        end
+
+        true
+      end
+
+      class << self
+
+        # Encodes an hash into (optionally pretty-printed) JSON
+        #
+        # @param  data mixed Data to encode into a formatted JSON string
+        # @param  options int json_encode options (defaults to JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE)
+        # @return string Encoded json
+        def encode(data, options = 448)
+
+          # if (version_compare(PHP_VERSION, '5.4', '>=')) {
+          #     $json = json_encode(data, options);
+
+          #     # compact brackets to follow recent php versions
+          #     if (PHP_VERSION_ID < 50428 || (PHP_VERSION_ID >= 50500 && PHP_VERSION_ID < 50512) || (defined('JSON_C_VERSION') && version_compare(phpversion('json'), '1.3.6', '<'))) {
+          #         $json = preg_replace('/\[\s+\]/', '[]', $json);
+          #         $json = preg_replace('/\{\s+\}/', '{}', $json);
+          #     }
+
+          #     return $json;
+          # }
+
+          # * *indent*: a string used to indent levels (default: ''),
+          # * *space*: a string that is put after, a : or , delimiter (default: ''),
+          # * *space_before*: a string that is put before a : pair delimiter (default: ''),
+          # * *object_nl*: a string that is put at the end of a JSON object (default: ''),
+          # * *array_nl*: a string that is put at the end of a JSON array (default: ''),
+          # * *allow_nan*: true if NaN, Infinity, and -Infinity should be
+          #   generated, otherwise an exception is thrown if these values are
+          #   encountered. This options defaults to false.
+          # * *max_nesting*: The maximum depth of nesting allowed in the data
+          #   structures from which JSON is to be generated. Disable depth checking
+          #   with :max_nesting => false, it defaults to 100.
+
+          if data.nil?
+            return 'null'
+          elsif data.is_a?(TrueClass)
+            return 'true'
+          elsif data.is_a?(FalseClass)
+            return 'false'
+          elsif data.is_a?(Integer)
+            return Integer(data)
+          elsif data.is_a?(Float)
+            return Float(data)
+          else
+            begin
+              json = JSON.generate(data, { quirks_mode: false })
+            rescue JSON::GeneratorError => e
+              if e.message === 'only generation of JSON objects or arrays allowed'
+                #trick into parsing scalar values by wrapping them in an array
+                scalar = data.gsub("\\\\", "\\\\\\")
+                if json = JSON::generate([scalar])
+                  json = json[1..(json.length - 2)]
+                end
+              end
+            end
+          end
+
+          return json unless options
+
+          result = Composer::Json::JsonFormatter::format(
+            json,
+            options
+          )
+
+          result
+        end
+
+        # Parses json string and returns hash.
+        #
+        # Params:
+        # +json+ string The json string to parse
+        # +file+ string The json file
+        #
+        # Returns:
+        # mixed
+        def parse_json(json, file = nil)
+          last_error = JSON_ERROR_NONE
+
+          begin
+            data = JSON.parse(json)
+          rescue Exception => e
+            last_error = e
+          end
+
+          if data.nil? && last_error != JSON_ERROR_NONE
+            validate_syntax(json, file)
+            raise JSON::ParserError,
+                "\"#{file}\" does not contain valid JSON\n
+                #{last_error.message}"
+          end
+
+          data
+        end
+
+        def validate_syntax(json, file)
+          # JSON::
+          # parser = Composer::Json::JsonParser.new
+          # if (result = parser.lint(json))
+          #   raise ParsingError,
+          #       "\"#{file}\" does not contain valid JSON\n
+          #       #{result.message}"
+          # end
+          # if (defined('JSON_ERROR_UTF8') && JSON_ERROR_UTF8 === json_last_error()) {
+          #     throw new \UnexpectedValueException('"'.$file.'" is not UTF-8, could not parse as JSON');
+          # }
+          true
+        end
+      end
+    end
+  end
+end

data/lib/composer/json/json_formatter.rb

@@ -0,0 +1,159 @@
+#
+# This file was ported to ruby from Composer php source code file.
+# Original Source: Composer\Json\JsonFormatter.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.
+#
+
+# JSON_HEX_TAG => 1
+# JSON_HEX_AMP => 2
+# JSON_HEX_APOS => 4
+# JSON_HEX_QUOT => 8
+# JSON_FORCE_OBJECT => 16
+# JSON_NUMERIC_CHECK => 32
+# JSON_UNESCAPED_SLASHES => 64
+# JSON_PRETTY_PRINT => 128
+# JSON_UNESCAPED_UNICODE => 256
+
+module Composer
+  module Json
+    #  * Formats json strings used for php < 5.4 because the json_encode doesn't
+    #  * supports the flags JSON_UNESCAPED_SLASHES | JSON_PRETTY_PRINT | JSON_UNESCAPED_UNICODE
+    #  * in these versions
+    #
+    # PHP Authors:
+    # Konstantin Kudryashiv <ever.zet@gmail.com>
+    # Jordi Boggiano <j.boggiano@seld.be>
+    #
+    # Ruby Authors:
+    # Ioannis Kappas <ikappas@devworks.gr>
+    class JsonFormatter
+
+      JSON_HEX_TAG = 1
+      JSON_HEX_AMP = 2
+      JSON_HEX_APOS = 4
+      JSON_HEX_QUOT = 8
+      JSON_FORCE_OBJECT = 16
+      JSON_NUMERIC_CHECK = 32
+      JSON_UNESCAPED_SLASHES = 64
+      JSON_PRETTY_PRINT = 128
+      JSON_UNESCAPED_UNICODE = 256
+
+      class << self
+        # This code is based on the function found at:
+        # http://recursive-design.com/blog/2008/03/11/format-json-with-php/
+        #
+        # Originally licensed under MIT by Dave Perrett <mail@recursive-design.com>
+        #
+        # @param json string
+        # @param unescape_unicode bool Un escape unicode
+        # @param unescape_slashes bool  Un escape slashes
+        # @return string
+        def format(json, options)
+
+          result = ''
+          pos = 0
+          str_len = json.length
+          indent_str = '    '
+          new_line = "\n"
+          out_of_quotes = true
+          buffer = ''
+          no_escape = true
+
+          for i in 0..(str_len - 1)
+
+            # Grab the next character in the string
+            char = json[i]
+
+            # Are we inside a quoted string?
+            if '"' === char && no_escape
+              out_of_quotes = !out_of_quotes
+            end
+
+            if !out_of_quotes
+              buffer << char
+              no_escape = '\\' === char ? !no_escape : true
+              next
+            elsif buffer != ''
+              if options & JSON_HEX_TAG === JSON_HEX_TAG
+                buffer.gsub!('<', '\\u003C')
+                buffer.gsub!('>', '\\u003E')
+              end
+              if options & JSON_HEX_AMP === JSON_HEX_AMP
+                buffer.gsub!('&', '\\u0026')
+              end
+              if options & JSON_HEX_APOS === JSON_HEX_APOS
+                buffer.gsub!('\'', '\\u0027')
+              end
+              if options & JSON_HEX_QUOT === JSON_HEX_QUOT
+                buffer.gsub!('\"', '\\u0022')
+              end
+              if options & JSON_UNESCAPED_SLASHES === JSON_UNESCAPED_SLASHES
+                buffer.gsub!('\\/', '/')
+              end
+              if options & JSON_UNESCAPED_UNICODE === JSON_UNESCAPED_UNICODE
+                buffer.gsub!(/\\u([\da-fA-F]{4})/) {|m| [$1].pack('H*').unpack('n*').pack('U*')}
+              end
+
+              result << buffer + char
+              buffer = ''
+              next
+            end
+
+            if options & JSON_PRETTY_PRINT === JSON_PRETTY_PRINT
+              if char === ':'
+              # Add a space after the : character
+              char << ' '
+              elsif char === '}' || char === ']'
+                pos -= 1
+                prev_char = json[i - 1] #substr(json, i - 1, 1)
+
+                if prev_char != '{' &&  prev_char != '['
+                  # If this character is the end of an element,
+                  # output a new line and indent the next line
+                  result << new_line
+
+                  for j in 0..(pos - 1)
+                    result << indent_str
+                  end
+                else
+                  # Collapse empty {} and []
+                  result.rstrip!
+                end
+              end
+            end
+
+            result << char
+
+            if options & JSON_PRETTY_PRINT === JSON_PRETTY_PRINT
+              # If the last character was the beginning of an element,
+              # output a new line and indent the next line
+              if char === ',' || char === '{' || char === '['
+                result << new_line
+                pos += 1 if char === '{' || char === '['
+                for j in 0..(pos - 1)
+                  result << indent_str
+                end
+              end
+            end
+          end
+
+          result
+        end
+
+        def unescape_slashes(s)
+          s.gsub('\\/', '/')
+        end
+
+        def unescape_unicode(s)
+          s.gsub(/\\u([\da-fA-F]{4})/) {|m| [$1].pack('H*').unpack('n*').pack('U*')}
+        end
+
+      end
+    end
+  end
+end