puppetfile_editor 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: f3364e07c1a49414ed25fecced5c31afd13a15be
+  data.tar.gz: 3377a602b97e701d1f21a8dae430d9da65e418e4
+SHA512:
+  metadata.gz: 4768b06d6ea7345a02cdd938716fc61a44cbb156dd2fcf056eaff6bb79adc98670adb09c85b5090bfc86911642e941df02a4a447a47815cff93cdc2481b8f14d
+  data.tar.gz: a3f6515c3d4ae5cd647e6fe8b25311d49e06de5b63abff8d44418e578cdc1769a90eb8e76a3d44353c17c3acf88438b6a5d4f7098767707b5dacd4b23a7c726a

data/README.md

@@ -0,0 +1,52 @@
+# PuppetfileEditor
+
+[![Gem Version](https://badge.fury.io/rb/puppetfile_editor.svg)](https://badge.fury.io/rb/puppetfile_editor)
+[![Build Status](https://travis-ci.org/pegasd/puppetfile_editor.svg?branch=master)](https://travis-ci.org/pegasd/puppetfile_editor)
+[![Coverage Status](https://coveralls.io/repos/github/pegasd/puppetfile_editor/badge.svg)](https://coveralls.io/github/pegasd/puppetfile_editor)
+
+This gem provides CLI and Rake interfaces for maintaining Puppetfile.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'puppetfile_editor'
+```
+
+And then execute:
+
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+
+```bash
+$ gem install puppetfile_editor
+```
+
+## Usage
+
+TODO
+
+## Development
+
+After checking out the repo, run `bundle install` to install dependencies. Then, run `rake spec` to run the tests.
+
+To install this gem onto your local machine, run `bundle exec rake install`.
+
+## Contributing
+
+Bug reports and pull requests are welcome on [GitHub](https://github.com/pegasd/puppetfile_editor).
+This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the
+[Contributor Covenant](http://contributor-covenant.org) code of conduct. 
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the PuppetfileEditor project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow the 
+[code of conduct](https://github.com/pegasd/puppetfile_editor/blob/master/CODE_OF_CONDUCT.md).

data/bin/pfile

@@ -0,0 +1,76 @@
+#!/usr/bin/env ruby
+
+require 'puppetfile_editor/cli'
+require 'optparse'
+
+filename = File.basename(__FILE__)
+
+# Display help if no arguments are specified
+ARGV.push('-h') if ARGV.empty?
+
+options = { puppetfile: 'Puppetfile' }
+OptionParser.new do |parser|
+  parser.banner = "Usage: #{filename} [options] [command] [command options]"
+  parser.on('-v', '--[no-]verbose', 'Run verbosely') { |v| options[:verbose] = v }
+  parser.on('-f', '--filename PUPPETFILE', 'Path to your Puppetfile.') do |puppetfile|
+    options[:puppetfile] = puppetfile
+  end
+end.order!
+
+subcommands = {
+  'edit'   => OptionParser.new do |parser|
+    parser.banner = "Usage: #{filename} edit [options]"
+    parser.on('-m', '--module-name NAME', 'Module name') do |setting|
+      options[:name] = setting
+    end
+    parser.on('-u', '--update PARAM=VALUE', 'What to update') do |setting|
+      if (match = setting.match(/^(\w+)=([^=]+)$/))
+        options[:param], options[:value] = match[1], match[2]
+      else
+        warn 'Version must match PARAM=VALUE pattern'
+        exit 1
+      end
+    end
+  end,
+  'format' => OptionParser.new do |parser|
+    parser.banner = "Usage: #{filename} format"
+  end,
+  'add'    => OptionParser.new do |parser|
+    parser.banner = "Usage: #{filename} add [options]"
+    parser.on('-m', '--module-name NAME', 'Module name') do |setting|
+      options[:name] = setting
+    end
+    parser.on('-t', '--type TYPE', [:hg, :forge, :local, :git], 'Type of module to add') do |setting|
+      options[:type] = setting
+    end
+    parser.on('-l', '--url [URL]', 'URL of module (applicable for hg and git modules)') do |setting|
+      options[:url] = setting
+    end
+    parser.on('-u', '--version [PARAM=VALUE]', 'Version of module to add in the form of PARAM=VALUE') do |setting|
+      if (match = setting.match(/^(\w+)=([^=]+)$/))
+        options[:param], options[:value] = match[1], match[2]
+      elsif (match = setting.match(/^\d+(\.\d)*$/))
+        options[:version] = match[0]
+      else
+        warn 'Version must match PARAM=VALUE pattern or be a proper Forge version.'
+        exit 1
+      end
+    end
+  end,
+  'merge'  => OptionParser.new do |parser|
+    parser.banner = "Usage: #{filename} merge [options]"
+    parser.separator '  Merge existing Puppetfile with another one from STDIN.'
+    parser.separator '  Dump the result to STDOUT.'
+    parser.separator ''
+
+    parser.on('-f', '--force', 'Force merge module versions') do |setting|
+      options[:force] = setting
+    end
+  end,
+}
+
+command = ARGV.shift
+subcommands[command].order!
+
+pf = PuppetfileEditor::CLI.new(options[:puppetfile])
+pf.public_send(command, options) if pf.respond_to?(command)

data/lib/puppetfile_editor/cli.rb

@@ -0,0 +1,114 @@
+require 'puppetfile_editor'
+
+module PuppetfileEditor
+  # CLI methods
+  class CLI
+    def initialize(pfile_path)
+      @pfile  = PuppetfileEditor::Puppetfile.new(path: pfile_path)
+      @logger = PuppetfileEditor::Logging.new
+      begin
+        @pfile.load
+      rescue IOError, NoMethodError => e
+        warn_and_exit(e.message)
+      end
+    end
+
+    def edit(opts)
+      opts[:value] = :latest if opts[:value] == 'latest'
+      @pfile.update_module(
+        opts[:name],
+        opts[:param],
+        opts[:value],
+        opts[:verbose],
+      )
+      @pfile.dump
+    end
+
+    def format(_)
+      @pfile.dump
+    end
+
+    def add(opts)
+      warn_and_exit "Module #{opts[:name]} is already present in your Puppetfile." if @pfile.modules.key? opts[:name]
+
+      case opts[:type]
+        when :hg, :git
+          warn_and_exit 'URL must be provided for Git and Hg modules' unless opts.key? :url
+          warn_and_exit 'Version must be provided for Git and Hg modules' unless opts.key? :param
+          opts[:value] = :latest if opts[:value] == 'latest'
+          @pfile.add_module(opts[:name], opts[:type] => opts[:url], opts[:param] => opts[:value])
+        when :local
+          @pfile.add_module(opts[:name], :local)
+        when :forge
+          warn_and_exit 'Version must be provided for Forge modules' unless opts.key? :version
+          @pfile.add_module(opts[:name], opts[:version])
+        else
+          warn_and_exit 'Only hg, git, local, and forge modules are supported at the moment.'
+      end
+      @pfile.dump
+    end
+
+    def merge(opts)
+      @pfdata = PuppetfileEditor::Puppetfile.new(from_stdin: true)
+      @pfdata.load
+      new_mod_types = @pfdata.modules.values.group_by(&:type)
+      new_mod_types.each do |mod_type, mods|
+        puts "\n   #{@pfile.module_sections[mod_type]}\n\n"
+        unless [:hg, :git, :forge].include? mod_type
+          puts " Skipping #{mod_type} section."
+          next
+        end
+        indent = mods.map(&:name).max_by(&:length).length
+        mods.each do |mod|
+          if @pfile.modules.key? mod.name
+            begin
+              @pfile.modules[mod.name].merge_with(mod, opts[:force])
+              @logger.module_log(mod.name, indent, @pfile.modules[mod.name].message, @pfile.modules[mod.name].status)
+            rescue StandardError => e
+              @logger.module_log(mod.name, indent, e.message, @pfile.modules[mod.name].status)
+            end
+          else
+            @logger.module_log(mod.name, indent, 'does not exist in source Puppetfile', :not_found)
+          end
+        end
+      end
+      if opts[:stdout]
+        $stdout.puts(@pfile.generate_puppetfile)
+      else
+        @pfile.dump
+      end
+    end
+
+    def warn_and_exit(message)
+      warn message
+      exit 1
+    end
+  end
+
+  class Logging
+    def initialize
+      @statuses = {
+        updated:         "[ \e[32;1m+\e[0m ]",
+        matched:         "[ \e[33;1m=\e[0m ]",
+        skipped:         "[ \e[33;1m~\e[0m ]",
+        not_found:       "[ \e[31;1mx\e[0m ]",
+        type_mismatched: "[ \e[31;1mx\e[0m ]",
+        wont_upgrade:    "[ \e[33;1m!\e[0m ]",
+        undef:           '',
+      }
+    end
+
+    def log(message, message_type = :undef)
+      status = if @statuses.key? message_type
+                 @statuses[message_type]
+               else
+                 @statuses[:undef]
+               end
+      puts "#{status} #{message}"
+    end
+
+    def module_log(mod_name, indent, message, message_type = :undef)
+      log("#{mod_name.ljust(indent)} => #{message}", message_type)
+    end
+  end
+end

data/lib/puppetfile_editor/module.rb

@@ -0,0 +1,155 @@
+module PuppetfileEditor
+  class Module
+    attr_reader :type
+    attr_reader :params
+    attr_reader :name
+    attr_reader :message
+    attr_reader :status
+
+    def initialize(title, args = nil)
+      @type    = :undef
+      @params  = nil
+      @message = nil
+      @status  = nil
+      if args == :local
+        @type = :local
+      elsif args.nil? || args.is_a?(String) || args.is_a?(Symbol)
+        @type   = :forge
+        @params = { version: args } unless args.nil?
+      elsif args.is_a? Hash
+        if args.key? :hg
+          @type = :hg
+        elsif args.key? :git
+          @type = :git
+        end
+        @params = args
+        calculate_indent
+      end
+      @author, @name = parse_title title
+    end
+
+    def set(param, newvalue, force = false)
+      case @type
+        when :hg, :git
+          if %w[branch tag ref].include? param
+            @params.delete :branch
+            @params.delete :tag
+            @params.delete :ref
+            @params[param.to_sym] = newvalue
+            calculate_indent
+          else
+            raise StandardError, "Only 'branch', 'tag', and 'ref' are supported for '#{@type}' modules."
+          end
+        when :forge
+          if param == 'version'
+            @params[:version] = newvalue
+          else
+            raise StandardError, "Only 'version' is supported for forge modules."
+          end
+        else
+          raise StandardError, "Editing params for '#{@type}' modules is not supported."
+      end
+    end
+
+    def merge_with(mod, force = false)
+      unless mod.type == @type
+        @status = :type_mismatched
+        raise(StandardError, "type mismatch ('#{@type}' vs '#{mod.type}')")
+      end
+      case @type
+        when :hg, :git
+          new = mod.params.reject { |param, _| param.eql? @type }
+          if !force && new.keys == [:tag] && (@params.key?(:branch) || @params.key?(:ref))
+            raise(StandardError, "kept at #{full_version}")
+          end
+          if full_version == mod.full_version
+            @message = "versions match (#{full_version})"
+            @status  = :matched
+          else
+            @message = "updated (#{full_version} to #{mod.full_version})"
+            @status  = :updated
+          end
+          @params.delete_if { |param, _| [:branch, :tag, :ref].include? param }
+          @params.merge!(new)
+          calculate_indent
+        when :forge
+          unless force
+            if mod.params.nil? or mod.params.is_a? Symbol
+              @status = :wont_upgrade
+              raise(StandardError, "won't upgrade to #{mod.full_version}")
+            end
+          end
+          if full_version == mod.full_version
+            @message = "versions match (#{full_version})"
+            @status  = :matched
+          else
+            @message = "updated (#{full_version} to #{mod.full_version})"
+            @status  = :updated
+          end
+          @params = mod.params
+        else
+          @status = :skipped
+          raise(StandardError, 'only git, forge, and hg modules are supported for merging')
+      end
+    end
+
+    def dump(old_hashes = false)
+      output = []
+      case @type
+        when :hg, :git
+          output.push "mod '#{full_title}'"
+          @params.each do |param_name, param_value|
+            value = if param_value == :latest
+                      ':latest'
+                    else
+                      "'#{param_value}'"
+                    end
+            param = old_hashes ? ":#{param_name.to_s.ljust(@indent - 1)} =>" : "#{param_name}:".ljust(@indent)
+            output.push "    #{param} #{value}"
+          end
+        when :local
+          output.push("mod '#{full_title}', :local")
+        else
+          if @params.nil?
+            output.push("mod '#{full_title}'")
+          else
+            output.push("mod '#{full_title}', '#{@params[:version]}'")
+          end
+      end
+      output.join(",\n")
+    end
+
+    def full_title
+      return "#{@author}/#{@name}" if @author
+      @name
+    end
+
+    def full_version
+      case @type
+        when :hg, :git
+          @params.reject { |param, _| param.eql? @type }.map { |param, value| "#{param}: #{value}" }.sort.join(', ')
+        when :forge
+          return @params[:version] if @params.key? :version
+          nil
+        else
+          nil
+      end
+    end
+
+    private
+
+    def parse_title(title)
+      if (match = title.match(/^(\w+)$/))
+        [nil, match[1]]
+      elsif (match = title.match(%r{^(\w+)[/-](\w[\w-]*\w)$}))
+        [match[1], match[2]]
+      else
+        raise ArgumentError, "Module name (#{title}) must match either 'modulename' or 'owner/modulename'"
+      end
+    end
+
+    def calculate_indent
+      @indent = @params.keys.max_by(&:length).length + 1
+    end
+  end
+end

data/lib/puppetfile_editor/puppetfile.rb

@@ -0,0 +1,119 @@
+require 'puppetfile_editor/module'
+
+module PuppetfileEditor
+  # Puppetfile implementation
+  class Puppetfile
+    # @!attribute [r] modules
+    #   @return [Hash<String, PuppetfileEditor::Module>]
+    attr_reader :modules
+
+    # @!attribute [r] puppetfile_path
+    #   @return [String] The path to the Puppetfile
+    attr_reader :puppetfile_path
+
+    attr_reader :module_sections
+
+    # @param [String] path path to Puppetfile
+    def initialize(path: 'Puppetfile', from_stdin: false, old_hashes: false)
+      @puppetfile_path = path
+      @from_stdin      = from_stdin
+      @old_hashes      = old_hashes
+      @modules         = {}
+      @loaded          = false
+      @forge           = nil
+
+      @module_sections = {
+        local: 'Local modules',
+        forge: 'Modules from the Puppet Forge',
+        hg:    'Mercurial modules',
+        git:   'Git modules',
+        undef: 'Other modules',
+      }
+    end
+
+    def load
+      puppetfile_contents = if @from_stdin
+                              $stdin.gets(nil).chomp
+                            else
+                              raise(IOError, "Puppetfile #{@puppetfile_path} missing or unreadable") unless File.readable?(@puppetfile_path)
+
+                              File.read @puppetfile_path
+                            end
+
+      dsl = PuppetfileEditor::DSL.new(self)
+      dsl.instance_eval(puppetfile_contents)
+      @loaded = true
+    end
+
+    def generate_puppetfile
+      raise StandardError, 'File is not loaded' unless @loaded
+
+      contents = []
+
+      contents.push "forge '#{@forge}'\n" if @forge
+
+      @module_sections.each do |module_type, module_comment|
+        module_list = modules.select { |_, mod| mod.type == module_type }
+        next unless module_list.any?
+        contents.push "# #{module_comment}"
+        module_list.values.sort_by(&:name).each do |mod|
+          contents.push mod.dump(@old_hashes)
+        end
+        contents.push ''
+      end
+
+      contents.join("\n")
+    end
+
+    def dump
+      File.write(@puppetfile_path, generate_puppetfile) if @loaded
+    end
+
+    def update_module(name, param, value, verbose = false)
+      if @modules.key? name
+        begin
+          @modules[name].set(param, value)
+          puts "Successfully set #{param} to #{value} for #{name}." if verbose
+        rescue StandardError => e
+          warn e.message
+          exit 1
+        end
+      else
+        warn "Module #{name} does not exist in your Puppetfile"
+      end
+    end
+
+    # @param [String] name Module name
+    # @param [String, Hash] args Module arguments
+    def add_module(name, args)
+      mod                = PuppetfileEditor::Module.new(name, args)
+      @modules[mod.name] = mod
+    end
+
+    def update_forge_url(url)
+      raise StandardError, "Forge URL must be a String, but it is a #{url.class}" unless url.is_a? String
+      @forge = url
+    end
+  end
+
+  # A barebones implementation of the Puppetfile DSL
+  #
+  # @api private
+  class DSL
+    def initialize(librarian)
+      @librarian = librarian
+    end
+
+    def mod(name, args = nil)
+      @librarian.add_module(name, args)
+    end
+
+    def forge(url)
+      @librarian.update_forge_url(url)
+    end
+
+    def method_missing(method, *_)
+      raise NoMethodError, "Unrecognized declaration: '#{method}'"
+    end
+  end
+end

data/lib/puppetfile_editor/version.rb

@@ -0,0 +1,3 @@
+module PuppetfileEditor
+  VERSION = '0.2.0'.freeze
+end

data/lib/puppetfile_editor.rb

@@ -0,0 +1,4 @@
+require 'puppetfile_editor/version'
+require 'puppetfile_editor/puppetfile'
+require 'puppetfile_editor/module'
+require 'puppetfile_editor/cli'

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: puppetfile_editor
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Eugene Piven
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-09-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |2
+      PuppetfileEditor provides an easy-to-use interface to check Puppetfile for validity,
+      update module versions, add, and remove modules.
+email: epiven@gmail.com
+executables:
+- pfile
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- bin/pfile
+- lib/puppetfile_editor.rb
+- lib/puppetfile_editor/cli.rb
+- lib/puppetfile_editor/module.rb
+- lib/puppetfile_editor/puppetfile.rb
+- lib/puppetfile_editor/version.rb
+homepage: https://github.com/pegasd/puppetfile_editor
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: Parse and edit Puppetfile
+test_files: []