puppet_forge 1.0.6 → 2.0.0

data/lib/puppet_forge/middleware/symbolify_json.rb

@@ -0,0 +1,72 @@
+module PuppetForge
+  module Middleware
+
+    # SymbolifyJson is a Faraday Middleware that will process any response formatted as a hash
+    # and change all the keys into symbols (as long as they respond to the method #to_sym.
+    #
+    # This middleware makes no changes to the values of the hash.
+    # If the response is not a hash, no changes will be made.
+    class SymbolifyJson < Faraday::Middleware
+
+      # Processes an array
+      #
+      # @return an array with any hash's keys turned into symbols if possible
+      def process_array(array)
+        array.map do |arg|
+          # Search any arrays and hashes for hash keys
+          if arg.is_a? Hash
+            process_hash(arg)
+          elsif arg.is_a? Array
+            process_array(arg)
+          else
+            arg
+          end
+        end
+      end
+
+      # Processes a hash
+      #
+      # @return a hash with all keys turned into symbols if possible
+      def process_hash(hash)
+        
+        # hash.map returns an array in the format
+        # [ [key, value], [key2, value2], ... ]
+        # Hash[] converts that into a hash in the format
+        # { key => value, key2 => value2, ... }
+        Hash[hash.map do |key, val|
+          # Convert to a symbol if possible
+          if key.respond_to? :to_sym
+            new_key = key.to_sym
+          else
+            new_key = key
+          end
+
+          # If value is a hash or array look for more hash keys inside.
+          if val.is_a?(Hash)
+            [new_key, process_hash(val)]
+          elsif val.is_a?(Array)
+            [new_key, process_array(val)]
+          else
+            [new_key, val]
+          end
+        end]
+      end
+
+      def process_response(env)
+        if !env["body"].nil? && env["body"].is_a?(Hash)
+          process_hash(env.body)
+        else
+          env.body
+        end
+      end
+
+      def call(environment)
+        @app.call(environment).on_complete do |env|
+          env.body = process_response(env)
+        end
+      end
+
+    end
+  end
+end
+

data/lib/puppet_forge/tar.rb

@@ -0,0 +1,10 @@
+
+module PuppetForge
+  class Tar
+    require 'puppet_forge/tar/mini'
+
+    def self.instance
+      Mini.new
+    end
+  end
+end

data/lib/puppet_forge/tar/mini.rb

@@ -0,0 +1,81 @@
+require 'zlib'
+require 'archive/tar/minitar'
+
+module PuppetForge
+  class Tar
+    class Mini
+
+      SYMLINK_FLAGS = [2]
+      VALID_TAR_FLAGS = (0..7)
+
+      # @return [Hash{:symbol => Array<String>}] a hash with file-category keys pointing to lists of filenames.
+      def unpack(sourcefile, destdir)
+        # directories need to be changed outside of the Minitar::unpack because directories don't have a :file_done action
+        dirlist = []
+        file_lists = {}
+        Zlib::GzipReader.open(sourcefile) do |reader|
+          file_lists = validate_files(reader)
+          Archive::Tar::Minitar.unpack(reader, destdir, file_lists[:valid]) do |action, name, stats|
+            case action
+            when :file_done
+              FileUtils.chmod('u+rw,g+r,a-st', "#{destdir}/#{name}")
+            when :file_start
+              validate_entry(destdir, name)
+            when :dir
+              validate_entry(destdir, name)
+              dirlist << "#{destdir}/#{name}"
+            end
+          end
+        end
+        dirlist.each {|d| File.chmod(0755, d)}
+        file_lists
+      end
+
+      def pack(sourcedir, destfile)
+        Zlib::GzipWriter.open(destfile) do |writer|
+          Archive::Tar::Minitar.pack(sourcedir, writer)
+        end
+      end
+
+      private
+
+      # Categorize all the files in tarfile as :valid, :invalid, or :symlink.
+      #
+      # :invalid files include 'x' and 'g' flags from the PAX standard but and any other non-standard tar flags.
+      #   tar format info: http://pic.dhe.ibm.com/infocenter/zos/v1r13/index.jsp?topic=%2Fcom.ibm.zos.r13.bpxa500%2Ftaf.htm
+      #   pax format info: http://pic.dhe.ibm.com/infocenter/zos/v1r13/index.jsp?topic=%2Fcom.ibm.zos.r13.bpxa500%2Fpxarchfm.htm
+      # :symlinks are not supported in Puppet modules
+      # :valid files are any of those that can be used in modules
+      # @param tarfile name of the tarfile
+      # @return [Hash{:symbol => Array<String>}] a hash with file-category keys pointing to lists of filenames.
+      def validate_files(tarfile)
+        file_lists = {:valid => [], :invalid => [], :symlinks => []}
+        Archive::Tar::Minitar.open(tarfile).each do |entry|
+          flag = entry.typeflag
+          if flag.nil? || flag =~ /[[:digit:]]/ && SYMLINK_FLAGS.include?(flag.to_i)
+            file_lists[:symlinks] << entry.name
+          elsif flag.nil? || flag =~ /[[:digit:]]/ && VALID_TAR_FLAGS.include?(flag.to_i)
+            file_lists[:valid] << entry.name
+          else
+            file_lists[:invalid] << entry.name 
+          end
+        end
+        file_lists
+      end
+
+      def validate_entry(destdir, path)
+        if Pathname.new(path).absolute?
+          raise PuppetForge::InvalidPathInPackageError, :entry_path => path, :directory => destdir
+        end
+
+        path = File.expand_path File.join(destdir, path)
+
+        if path !~ /\A#{Regexp.escape destdir}/
+          raise PuppetForge::InvalidPathInPackageError, :entry_path => path, :directory => destdir
+        end
+      end
+    end
+  end
+
+end
+

data/lib/puppet_forge/unpacker.rb

@@ -0,0 +1,68 @@
+require 'pathname'
+require 'puppet_forge/error'
+require 'puppet_forge/tar'
+
+module PuppetForge
+  class Unpacker
+    # Unpack a tar file into a specified directory
+    #
+    # @param filename [String] the file to unpack
+    # @param target [String] the target directory to unpack into
+    # @return [Hash{:symbol => Array<String>}] a hash with file-category keys pointing to lists of filenames.
+    #   The categories are :valid, :invalid and :symlink
+    def self.unpack(filename, target, tmpdir)
+      inst = self.new(filename, target, tmpdir)
+      file_lists = inst.unpack
+      inst.move_into(Pathname.new(target))
+      file_lists
+    end
+
+    # Set the owner/group of the target directory to those of the source
+    # Note: don't call this function on Microsoft Windows
+    #
+    # @param source [Pathname] source of the permissions
+    # @param target [Pathname] target of the permissions change
+    def self.harmonize_ownership(source, target)
+        FileUtils.chown_R(source.stat.uid, source.stat.gid, target)
+    end
+
+    # @param filename [String] the file to unpack
+    # @param target [String] the target directory to unpack into
+    def initialize(filename, target, tmpdir)
+      @filename = filename
+      @target = target
+      @tmpdir = tmpdir
+    end
+
+    # @api private
+    def unpack
+      begin
+        PuppetForge::Tar.instance.unpack(@filename, @tmpdir)
+      rescue PuppetForge::ExecutionFailure => e
+        raise RuntimeError, "Could not extract contents of module archive: #{e.message}"
+      end
+    end
+
+    # @api private
+    def move_into(dir)
+      dir.rmtree if dir.exist?
+      FileUtils.mv(root_dir, dir)
+    ensure
+      FileUtils.rmtree(@tmpdir)
+    end
+
+    # @api private
+    def root_dir
+      return @root_dir if @root_dir
+
+      # Grab the first directory containing a metadata.json file
+      metadata_file = Dir["#{@tmpdir}/**/metadata.json"].sort_by(&:length)[0]
+
+      if metadata_file
+        @root_dir = Pathname.new(metadata_file).dirname
+      else
+        raise "No valid metadata.json found!"
+      end
+    end
+  end
+end

data/lib/puppet_forge/v3.rb

@@ -2,9 +2,20 @@ module PuppetForge
 
   # Models specific to the Puppet Forge's v3 API.
   module V3
+    # Normalize a module name to use a hyphen as the separator between the
+    # author and module.
+
+    # @example
+    #   PuppetForge::V3.normalize_name('my/module') #=> 'my-module'
+    #   PuppetForge::V3.normalize_name('my-module') #=> 'my-module'
+    def self.normalize_name(name)
+      name.tr('/', '-')
+    end
   end
 end
 
+require 'puppet_forge/v3/metadata'
+
 require 'puppet_forge/v3/user'
 require 'puppet_forge/v3/module'
 require 'puppet_forge/v3/release'

data/lib/puppet_forge/v3/base.rb

@@ -1,97 +1,130 @@
-require 'her'
-require 'her/lazy_accessors'
-require 'her/lazy_relations'
-
-require 'puppet_forge/middleware/json_for_her'
+require 'puppet_forge/connection'
 require 'puppet_forge/v3/base/paginated_collection'
+require 'puppet_forge/error'
+
+require 'puppet_forge/lazy_accessors'
+require 'puppet_forge/lazy_relations'
 
 module PuppetForge
   module V3
 
-    # Acts as the base class for all PuppetForge::V3::* models. This class provides
-    # some overrides of behaviors from Her, in addition to convenience methods
-    # and abstractions of common behavior.
+    # Acts as the base class for all PuppetForge::V3::* models.
     #
     # @api private
     class Base
-      include Her::Model
-      include Her::LazyAccessors
-      include Her::LazyRelations
-
-      use_api begin
-        begin
-          # Use Typhoeus if available.
-          Gem::Specification.find_by_name('typhoeus', '~> 0.6')
-          require 'typhoeus/adapters/faraday'
-          adapter = Faraday::Adapter::Typhoeus
-        rescue Gem::LoadError
-          adapter = Faraday::Adapter::NetHttp
-        end
+      include PuppetForge::LazyAccessors
+      include PuppetForge::LazyRelations
 
-        Her::API.new :url => "#{PuppetForge.host}/v3/" do |c|
-          c.use PuppetForge::Middleware::JSONForHer
-          c.use adapter
+      def initialize(json_response)
+        @attributes = json_response
+        orm_resp_item json_response
+      end
+
+      def orm_resp_item(json_response)
+        json_response.each do |key, value|
+          unless respond_to? key
+            define_singleton_method("#{key}") { @attributes[key] }
+            define_singleton_method("#{key}=") { |val| @attributes[key] = val }
+          end
         end
       end
 
+      # @return true if attribute exists, false otherwise
+      #
+      def has_attribute?(attr)
+        @attributes.has_key?(:"#{attr}")
+      end
+
+      def attribute(name)
+        @attributes[:"#{name}"]
+      end
+
+      def attributes
+        @attributes
+      end
+
       class << self
-        # Overrides Her::Model#request to allow end users to dynamically update
-        # both the Forge host being communicated with and the user agent string.
-        #
-        # @api private
-        # @api her
-        # @see Her::Model#request
-        # @see PuppetForge.host
-        # @see PuppetForge.user_agent
-        def request(*args)
-          unless her_api.base_uri =~ /^#{PuppetForge.host}/
-            her_api.connection.url_prefix = "#{PuppetForge.host}/v3/"
+
+        include PuppetForge::Connection
+
+        API_VERSION = "v3"
+
+        def api_version
+          API_VERSION
+        end
+
+        # @private
+        def request(resource, item = nil, params = {})
+          unless conn.url_prefix =~ /^#{PuppetForge.host}/
+            conn.url_prefix = "#{PuppetForge.host}"
+          end
+
+
+          if item.nil?
+            uri_path = "/v3/#{resource}"
+          else
+            uri_path = "/v3/#{resource}/#{item}"
           end
 
-          her_api.connection.headers[:user_agent] = %W[
-            #{PuppetForge.user_agent}
-            PuppetForge.gem/#{PuppetForge::VERSION}
-            Her/#{Her::VERSION}
-            Faraday/#{Faraday::VERSION}
-            Ruby/#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL} (#{RUBY_PLATFORM})
-          ].join(' ').strip
+          PuppetForge::V3::Base.conn.get uri_path, params
+        end
+
+        def find(slug)
+          return nil if slug.nil?
+
+          resp = request("#{self.name.split("::").last.downcase}s", slug)
 
-          super
+          self.new(resp.body)
         end
 
-        # Overrides Her::Model#new_collection with custom logic for handling the
-        # paginated collections produced by the Forge API. These collections are
-        # then wrapped in a {PaginatedCollection}, which enables navigation of
-        # the paginated dataset.
-        #
-        # @api private
-        # @api her
-        # @param parsed_data [Hash<(:data, :errors)>] the parsed response data
-        # @return [PaginatedCollection] the collection
-        def new_collection(parsed_data)
-          col = super :data =>     parsed_data[:data][:results] || [],
-                      :metadata => parsed_data[:data][:pagination] || { limit: 10, total: 0, offset: 0 },
-                      :errors =>   parsed_data[:errors]
-
-          PaginatedCollection.new(self, col.to_a, col.metadata, col.errors)
+        def where(params)
+          resp = request("#{self.name.split("::").last.downcase}s", nil, params)
+
+          new_collection(resp)
         end
-      end
 
-      # FIXME: We should provide an actual unique identifier.
-      primary_key :slug
-      store_metadata :_metadata
-      after_initialize do
-        attributes[:slug] ||= uri[/[^\/]+$/]
-      end
+        # Return a paginated collection of all modules
+        def all(params = {})
+          where(params)
+        end
 
-      # Since our data is primarily URI based rather than ID based, we should
-      # use our URIs as the request_path whenever possible.
-      #
-      # @api private
-      # @api her
-      # @see Her::Model::Paths#request_path
-      def request_path(*args)
-        if has_attribute? :uri then uri else super end
+        def get_collection(uri_path)
+          resource, params = split_uri_path uri_path
+          resp = request(resource, nil, params)
+
+          new_collection(resp)
+        end
+
+        # Faraday's Util#escape method will replace a '+' with '%2B' to prevent it being
+        # interpreted as a space. For compatibility with the Forge API, we would like a '+'
+        # to be interpreted as a space so they are changed to spaces here.
+        def convert_plus_to_space(str)
+          str.gsub(/[+]/, ' ')
+        end
+
+        # @private
+        def split_uri_path(uri_path)
+          all, resource, params = /(?:\/v3\/)([^\/]+)(?:\?)(.*)/.match(uri_path).to_a
+
+          params = convert_plus_to_space(params).split('&')
+
+          param_hash = Hash.new
+          params.each do |param|
+            key, val = param.split('=')
+            param_hash[key] = val
+          end
+
+          [resource, param_hash]
+        end
+
+        # @private
+        def new_collection(faraday_resp)
+          if faraday_resp[:errors].nil?
+            PaginatedCollection.new(self, faraday_resp.body[:results], faraday_resp.body[:pagination], nil)
+          else
+            PaginatedCollection.new(self)
+          end
+        end
       end
     end
   end