puppet-editor-services 2.0.4

data/Rakefile

@@ -0,0 +1,185 @@
+require 'rspec/core/rake_task'
+
+rubocop_available = Gem::Specification::find_all_by_name('rubocop').any?
+require 'rubocop/rake_task' if rubocop_available
+
+namespace :test do
+  desc 'Run tests with code coverage'
+  task :coverage do
+    ENV['COVERAGE'] = 'yes'
+    Rake::Task['test_languageserver'].execute
+    Rake::Task['test_languageserver_sidecar'].execute
+    Rake::Task['test_debugserver'].execute
+  end
+end
+
+desc 'Run rspec tests for the Language Server with coloring.'
+RSpec::Core::RakeTask.new(:test_languageserver) do |t|
+  t.rspec_opts = %w[--color --format documentation --default-path spec/languageserver]
+  t.pattern    = ['spec/languageserver/unit/**/*_spec.rb', 'spec/languageserver/integration/**/*_spec.rb']
+end
+
+desc 'Run acceptance tests for the Language Server with coloring.'
+RSpec::Core::RakeTask.new(:acceptance_languageserver) do |t|
+  t.rspec_opts = %w[--color --format documentation --default-path spec/languageserver]
+  t.pattern    = ['spec/languageserver/acceptance/**/*_spec.rb']
+end
+
+desc 'Run rspec tests for the Language Server Sidecar with coloring.'
+RSpec::Core::RakeTask.new(:test_languageserver_sidecar) do |t|
+  t.rspec_opts = %w[--color --format documentation --default-path spec/languageserver-sidecar]
+  t.pattern    = 'spec/languageserver-sidecar'
+end
+
+desc 'Run rspec tests for the Debug Server with coloring.'
+RSpec::Core::RakeTask.new(:test_debugserver) do |t|
+  t.rspec_opts = %w[--color --format documentation --default-path spec/debugserver]
+  t.pattern    = 'spec/debugserver'
+end
+
+if rubocop_available
+  desc 'Run RuboCop'
+  RuboCop::RakeTask.new(:rubocop) do |task|
+    task.options << '--display-cop-names'
+    task.options << '--config'
+    task.options << '.rubocop.yml'
+  end
+end
+
+namespace :rubocop do
+  desc "Generate the Rubocop Todo file"
+  task :generate do
+    begin
+      sh "rubocop --auto-gen-config"
+    rescue => exception
+      # Ignore any errors
+    end
+  end
+end
+
+desc "Download and vendor required gems"
+task :gem_revendor do
+  require 'fileutils'
+
+  gem_list = [
+    {
+      :directory => 'puppet-lint',
+      :github_repo => 'https://github.com/puppetlabs/puppet-lint.git',
+      :github_ref => 'v4.2.4',
+    },
+    {
+      :directory => 'hiera-eyaml',
+      :github_repo => 'https://github.com/voxpupuli/hiera-eyaml',
+      :github_ref => 'v2.1.0',
+    },
+    {
+      :directory => 'puppetfile-resolver',
+      :github_repo => 'https://github.com/puppetlabs/puppetfile-resolver.git',
+      :github_ref => 'v0.6.3',
+    },
+    {
+      :directory => 'molinillo',
+      :github_repo => 'https://github.com/CocoaPods/Molinillo.git',
+      :github_ref => '0.6.6',
+    },
+    {
+      :directory => 'puppet-strings',
+      :github_repo => 'https://github.com/puppetlabs/puppet-strings.git',
+      :github_ref => 'v4.1.2',
+    },
+    {
+      :directory => 'yard',
+      :github_repo => 'https://github.com/lsegal/yard.git',
+      :github_ref => 'v0.9.24',
+    },
+  ]
+
+  # Clean out the vendor directory first
+  puts "Clearing the vendor directory..."
+  vendor_dir = File.join(File.dirname(__FILE__),'vendor')
+  gem_list.each do |vendor|
+    gem_dir = File.join(vendor_dir,vendor[:directory])
+    FileUtils.rm_rf(gem_dir) if Dir.exist?(gem_dir) 
+  end
+  Dir.mkdir(vendor_dir) unless Dir.exist?(vendor_dir)
+
+  gem_list.each do |vendor|
+    puts "Vendoring #{vendor[:directory]}..."
+    gem_dir = File.join(vendor_dir,vendor[:directory])
+
+    sh "git clone #{vendor[:github_repo]} #{gem_dir}"
+    Dir.chdir(gem_dir) do
+      sh 'git fetch origin'
+      sh "git reset --hard #{vendor[:github_ref]}"
+    end
+
+    # Cleanup the gem directory...
+    FileUtils.rm_rf(File.join(gem_dir,'.git'))
+    FileUtils.rm_rf(File.join(gem_dir,'spec'))
+    FileUtils.rm_rf(File.join(gem_dir,'features'))
+    FileUtils.rm_rf(File.join(gem_dir,'docs'))
+  end
+
+  # Generate the README
+  readme = <<-HEREDOC
+# Vendored Gems
+
+The puppet language server is designed to run within the Puppet Agent ruby environment which means no access to Native Extensions or Gem bundling.
+
+This means any Gems required outside of Puppet Agent for the language server must be vendored in this directory and the load path modified in the `puppet-languageserver` file.
+
+Note - To comply with Licensing, the Gem source should be MIT licensed or even more unrestricted.
+
+Note - To improve the packaging size, test files etc. were stripped from the Gems prior to committing.
+
+Gem List
+--------
+
+HEREDOC
+  gem_list.each { |vendor| readme += "* #{vendor[:directory]} (#{vendor[:github_repo]} ref #{vendor[:github_ref]})\n"}
+  File.open(File.join(vendor_dir,'README.md'), 'wb') { |file| file.write(readme + "\n") }
+end
+
+desc "Create compressed files of the language and debug servers for release"
+task build: [:gem_revendor] do
+  require 'fileutils'
+  require 'archive/zip'
+  require 'zlib'
+  require 'minitar'
+  require 'digest'
+
+  project_dir = File.dirname(__FILE__)
+  output_dir = File.join(project_dir, 'output')
+
+  file_list = ['lib', 'vendor', 'puppet-languageserver', 'puppet-debugserver', 'puppet-languageserver-sidecar', 'LICENSE']
+  # Remove files in the list that do not exist.
+  file_list.reject! { |filepath| !File.exist?(filepath) }
+
+  puts "Cleaning output directory..."
+  FileUtils.rm_rf Dir.glob("#{output_dir}/*") if Dir.exist?(output_dir)
+  Dir.mkdir(output_dir) unless Dir.exist?(output_dir)
+
+  puts "Fetch editor services version..."
+  require_relative 'lib/puppet_editor_services/version'
+  version = PuppetEditorServices.version
+  puts "Editor services is v#{version}"
+
+  puts "Creating zip file..."
+  zip_archive_file = File.join(output_dir,"puppet_editor_services_v#{version}.zip")
+  Archive::Zip.archive(zip_archive_file, file_list)
+  puts "Created #{zip_archive_file}"
+
+  puts "Creating tar file..."
+  tar_archive_file = File.join(output_dir,"puppet_editor_services_v#{version}.tar.gz")
+  Minitar.pack(file_list, Zlib::GzipWriter.new(File.open(tar_archive_file, 'wb')))
+  puts "Created #{tar_archive_file}"
+
+  puts "Creating checksums..."
+  [zip_archive_file, tar_archive_file].each do |filepath|
+    sha = Digest::SHA256.hexdigest(File.open(filepath, 'rb') { |file| file.read })
+    File.open(filepath + '.sha256', 'wb') { |file| file.write(sha) }
+  end
+  puts "Created checksums"
+end
+
+task :default => [:test]

data/bin/puppet-debugserver

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'puppet_debugserver'
+
+PuppetDebugServer.init_puppet(PuppetDebugServer::CommandLineParser.parse(ARGV))
+rpc_thread = PuppetDebugServer.rpc_server_async(PuppetDebugServer::CommandLineParser.parse(ARGV))
+PuppetDebugServer.execute(rpc_thread)

data/bin/puppet-languageserver

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'puppet_languageserver'
+
+PuppetLanguageServer.init_puppet(PuppetLanguageServer::CommandLineParser.parse(ARGV))
+PuppetLanguageServer.rpc_server(PuppetLanguageServer::CommandLineParser.parse(ARGV))

data/bin/puppet-languageserver-sidecar

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'puppet_languageserver_sidecar'
+
+PuppetLanguageServerSidecar.init_puppet_sidecar(PuppetLanguageServerSidecar::CommandLineParser.parse(ARGV))
+PuppetLanguageServerSidecar.execute_and_output(PuppetLanguageServerSidecar::CommandLineParser.parse(ARGV))

data/lib/dsp/dsp.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+%w[dsp_base dsp_protocol].each do |lib|
+  require "dsp/#{lib}"
+rescue LoadError
+  require File.expand_path(File.join(__dir__, lib))
+end

data/lib/dsp/dsp_base.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module DSP
+  class DSPBase
+    def initialize(initial_hash = nil)
+      from_h!(initial_hash) unless initial_hash.nil?
+    end
+
+    def to_h
+      value = {}
+      optional_names = @optional_method_names.nil? ? [] : @optional_method_names
+
+      instance_method_names.each do |name|
+        item_value = send(name)
+        if item_value.is_a?(Array)
+          # Convert the items in the array .to_h
+          item_value = item_value.map { |item| item.to_h }
+        elsif !item_value.nil? && item_value.respond_to?(:to_h)
+          item_value = item_value.to_h
+        end
+        value[name.to_s] = item_value unless optional_names.include?(name) && item_value.nil?
+      end
+
+      value
+    end
+
+    def from_h!(value); end
+
+    def to_json(*options)
+      to_h.to_json(options)
+    end
+
+    private
+
+    def instance_method_names
+      method_names = methods - DSP::DSPBase.instance_methods
+
+      method_names.reject { |name| name.to_s.end_with?('=') }
+    end
+
+    def to_typed_aray(val, expected_type)
+      return nil if val.nil?
+
+      val.map { |item| expected_type.new(item) }
+    end
+  end
+
+  def self.create_range(from_line, from_char, to_line, to_char)
+    {
+      'start' => {
+        'line' => from_line,
+        'character' => from_char
+      },
+      'end' => {
+        'line' => to_line,
+        'character' => to_char
+      }
+    }
+  end
+end