code_snippet 0.2.6

data/lib/code_snippet/cli.rb

@@ -0,0 +1,52 @@
+require 'code_snippet/cli/commands'
+require 'code_snippet/cli/presenters'
+
+require 'logger'
+
+module CodeSnippet
+  # Command line interface helpers and actions
+  module CLI
+    # CLI Helpers
+    class <<self
+      ##
+      # Retrieves snippet dir from environment
+      #
+      def snip_dir
+        @snippet_dir = ENV['SNIPPET_DIR']
+        raise 'SNIPPET_DIR environment variable not set' unless @snippet_dir
+        unless File.exist?(@snippet_dir)
+          raise "SNIPPET_DIR #{@snippet_dir} does not exist"
+        end
+
+        @snippet_dir
+      end
+
+      ##
+      # Creates logger for printing messages
+      #
+      def logger
+        @logger ||= Logger.new(STDOUT)
+        @logger.formatter = proc do |_sev, _time, _prog, msg|
+          "#{msg}\n"
+        end
+
+        @logger
+      end
+
+      ##
+      # Prints command line message to CLI
+      #
+      def print_message(message)
+        logger.info(message)
+      end
+
+      ##
+      # Prints a message and then exits with given status code
+      #
+      def print_message_and_exit(message, exit_code = 1)
+        print_message(message)
+        exit(exit_code)
+      end
+    end
+  end
+end

data/lib/code_snippet/manager.rb

@@ -0,0 +1,50 @@
+module CodeSnippet
+  # Manager looks after a set of snippets
+  class Manager
+    DEFAULT_QUERY = ->(_snip) { return true }
+
+    attr_reader :snippets
+
+    def initialize(snippet_dir)
+      @snippet_dir = snippet_dir
+      @snippets = []
+    end
+
+    def load_snippets
+      Dir.glob(File.join(@snippet_dir, '**', '*')).each do |file|
+        next if File.directory?(file)
+
+        @snippets << CodeSnippet::Snip.new_from_file(file)
+      end
+    end
+
+    def filter(query = DEFAULT_QUERY)
+      @snippets.select do |snip|
+        query.call(snip)
+      end
+    end
+
+    def find(search_term, lang = nil)
+      name_query = lambda do |snip|
+        snip.name.include?(search_term)
+      end
+
+      results = filter(name_query)
+
+      unless lang.nil?
+        results = results.select do |snip|
+          snip.ext == lang
+        end
+      end
+
+      results
+    end
+
+    def filter_by_extension(ext)
+      ext = ".#{ext}" unless ext.start_with?('.')
+
+      ext_query = ->(snip) { snip.ext == ext }
+      filter(ext_query)
+    end
+  end
+end

data/lib/code_snippet/snip.rb

@@ -0,0 +1,35 @@
+module CodeSnippet
+  # Snip is a file with a code snippet
+  class Snip
+    attr_reader :path, :ext
+
+    def self.new_from_file(path)
+      new(
+        path,
+        File.basename(path),
+        File.extname(path)
+      )
+    end
+
+    def initialize(path, name, ext)
+      @path = path
+      @name = name
+      @ext = ext
+    end
+
+    def name
+      @name
+        .gsub(@ext, '')
+    end
+
+    def exist?
+      File.exist?(@path)
+    end
+
+    def content
+      raise 'cannot read snippet code' unless exist?
+
+      File.read(@path)
+    end
+  end
+end

data/lib/code_snippet/version.rb

@@ -0,0 +1,3 @@
+module CodeSnippet
+  VERSION = '0.2.6'.freeze
+end

data/lib/code_snippet.rb

@@ -0,0 +1,7 @@
+require 'code_snippet/version'
+require 'code_snippet/manager'
+require 'code_snippet/snip'
+
+# Snippet is the namespace for snippet
+module CodeSnippet
+end

data/spec/snippet/cli/commands_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+RSpec.describe CodeSnippet::CLI::Commands do
+  let(:snippet_dir) { 'path/to/snippets' }
+  let(:lang) { '.rb' }
+  let(:copy) { false }
+  let(:vars) { [] }
+
+  before do
+    allow(ENV)
+      .to receive(:[]).with('SNIPPET_DIR')
+                      .and_return(snippet_dir)
+
+    allow(File)
+      .to receive(:exist?)
+      .with(snippet_dir)
+      .and_return(true)
+  end
+
+  describe '.show' do
+  end
+
+  describe '.list' do
+    let(:manager) { double(CodeSnippet::Manager) }
+    let(:lang) { nil }
+
+    let(:snip) { double(CodeSnippet::Snip) }
+    let(:filtered_snips) { [snip, snip] }
+    let(:all_snips) { [snip, snip, snip, snip] }
+
+    before do
+      allow(CodeSnippet::CLI).to receive(:snip_dir)
+        .and_return('path/to/snips')
+
+      allow(CodeSnippet::Manager)
+        .to receive(:new)
+        .and_return(manager)
+
+      allow(manager).to receive(:load_snippets)
+      allow(manager)
+        .to receive(:filter_by_extension)
+        .and_return(filtered_snips)
+
+      allow(manager)
+        .to receive(:snippets)
+        .and_return(all_snips)
+
+      allow(CodeSnippet::CLI::Presenters)
+        .to receive(:list_snippets)
+
+      described_class.list(lang, copy, vars)
+    end
+
+    it 'loads snippets' do
+      expect(manager).to have_received(:load_snippets)
+    end
+
+    it 'presents a list of snippets' do
+      expect(CodeSnippet::CLI::Presenters)
+        .to have_received(:list_snippets)
+        .with(all_snips)
+    end
+
+    context 'when language filter is applied' do
+      let(:lang) { '.rb' }
+
+      it 'presents a list of filtered snippets' do
+        expect(CodeSnippet::CLI::Presenters)
+          .to have_received(:list_snippets)
+          .with(filtered_snips)
+      end
+    end
+  end
+
+  describe '.path' do
+    before do
+      allow(CodeSnippet::CLI)
+        .to receive(:print_message)
+        .and_return(nil)
+
+      described_class.path(lang, copy, vars)
+    end
+
+    it 'prints snippet dir' do
+      expect(CodeSnippet::CLI).to have_received(:print_message)
+        .with(snippet_dir)
+    end
+  end
+
+  describe '.version' do
+    before do
+      allow(CodeSnippet::CLI)
+        .to receive(:print_message)
+        .and_return(nil)
+
+      described_class.version(lang, copy, vars)
+    end
+
+    it 'prints snippet version' do
+      expect(CodeSnippet::CLI).to have_received(:print_message)
+        .with(CodeSnippet::VERSION)
+    end
+  end
+end

data/spec/snippet/cli/presenters_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+RSpec.describe CodeSnippet::CLI::Presenters do
+  let(:snippets) { [snip, snip] }
+
+  let(:snip) { double(CodeSnippet::Snip) }
+  let(:name) { 'snippet' }
+  let(:ext) { '.snip' }
+  let(:path) { 'path/to/snippet' }
+  let(:content) { 'snip-content' }
+
+  before do
+    allow(CodeSnippet::CLI).to receive(:print_message).and_return(double)
+    allow(snip).to receive(:name).and_return(name)
+    allow(snip).to receive(:ext).and_return(ext)
+    allow(snip).to receive(:path).and_return(path)
+    allow(snip).to receive(:content).and_return(content)
+  end
+  describe '.pick_from' do
+    let(:question) { 'are you sure?' }
+    let(:snips) { [snip, snip] }
+    let(:prompt) { double(TTY::Prompt) }
+
+    before do
+      allow(TTY::Prompt).to receive(:new).and_return(prompt)
+      allow(prompt).to receive(:select).and_return(path)
+      @choice = subject.pick_from(question, snips)
+    end
+
+    it 'asks which path' do
+      expect(prompt).to have_received(:select)
+        .with(question, [path, path])
+    end
+
+    it 'returns chosen path' do
+      expect(@choice).to eq snip
+    end
+  end
+
+  describe '.show' do
+    before do
+      described_class.show(snip)
+    end
+
+    it 'puts content to STDOUT' do
+      expect(CodeSnippet::CLI).to have_received(:print_message).with(content)
+    end
+  end
+
+  describe '.list_snippets' do
+    let(:table) { double(TTY::Table) }
+    before do
+      allow(TTY::Table).to receive(:new).and_return(table)
+      allow(table).to receive(:render)
+      described_class.list_snippets(snippets)
+    end
+
+    it 'sets up render' do
+      expect(TTY::Table).to have_received(:new).with(
+        %w[NAME LANG PATH],
+        [
+          [name, ext, path],
+          [name, ext, path]
+        ]
+      )
+    end
+
+    it 'renders table' do
+      expect(table).to have_received(:render).with(:ascii)
+    end
+  end
+end

data/spec/snippet/cli_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+RSpec.describe CodeSnippet::CLI do
+  let(:logger) { double(Logger) }
+  let(:message) { 'lorem ipsum' }
+
+  before do
+    allow(described_class).to receive(:exit).and_return(double)
+  end
+
+  describe '.snip_dir' do
+    let(:snippet_dir) { 'path/to/snippets' }
+    let(:exists) { true }
+
+    before do
+      allow(ENV)
+        .to receive(:[])
+        .with('SNIPPET_DIR')
+        .and_return(snippet_dir)
+
+      allow(File).to receive(:exist?).and_return(exists)
+    end
+
+    it 'returns path to snippets' do
+      expect(described_class.snip_dir).to eq snippet_dir
+    end
+
+    context 'when the environment variable is not set' do
+      let(:snippet_dir) { nil }
+
+      it 'raises error' do
+        expect do
+          described_class.snip_dir
+        end.to raise_error 'SNIPPET_DIR environment variable not set'
+      end
+    end
+
+    context 'when the snippet directory does not exist' do
+      let(:exists) { false }
+
+      it 'raises error' do
+        expect do
+          described_class.snip_dir
+        end.to raise_error "SNIPPET_DIR #{snippet_dir} does not exist"
+      end
+    end
+  end
+
+  describe '.logger' do
+    before do
+      allow(Logger).to receive(:new).and_return(logger)
+      allow(logger).to receive(:formatter=)
+      @logger = subject.logger
+    end
+
+    it 'creates a new logger to STDOUT' do
+      expect(Logger).to have_received(:new).with(STDOUT)
+    end
+  end
+
+  describe '.print_message' do
+    let(:logger) { double(Logger) }
+
+    before do
+      allow(described_class).to receive(:logger).and_return(logger)
+      allow(logger).to receive(:info)
+      described_class.print_message(message)
+    end
+
+    it 'prints message to stdout' do
+      expect(logger).to have_received(:info).with(message)
+    end
+  end
+
+  describe '.print_message_and_exit' do
+    let(:exit_code) { 2 }
+
+    before do
+      allow(described_class).to receive(:print_message)
+      described_class.print_message_and_exit(message, exit_code)
+    end
+
+    it 'prints message' do
+      expect(described_class).to have_received(:print_message).with(message)
+    end
+
+    it 'exits with set status' do
+      expect(described_class).to have_received(:exit).with(exit_code)
+    end
+  end
+end

data/spec/snippet/manager_spec.rb

@@ -0,0 +1,166 @@
+require 'spec_helper'
+
+RSpec.describe CodeSnippet::Manager do
+  let(:snippet_dir) { 'path/to/snippets' }
+
+  subject do
+    described_class.new(snippet_dir)
+  end
+
+  describe '#load_snippets' do
+    let(:directory) { File.join(snippet_dir, 'path/to/dir') }
+    let(:file)      { File.join(snippet_dir, 'path/to/dir/file') }
+
+    let(:file_snip) { double(CodeSnippet::Snip) }
+    let(:files) do
+      [
+        directory,
+        directory,
+        file,
+        file
+      ]
+    end
+
+    before do
+      allow(File).to receive(:directory?).with(directory)
+                                         .and_return(true)
+
+      allow(File).to receive(:directory?).with(file)
+                                         .and_return(false)
+
+      allow(Dir).to receive(:glob).and_return(files)
+      allow(CodeSnippet::Snip).to receive(:new_from_file)
+        .and_return(file_snip)
+
+      subject.load_snippets
+    end
+
+    it 'creates snips from files' do
+      expect(subject.snippets.count).to be 2
+
+      subject.snippets.each do |snip|
+        expect(snip).to eq file_snip
+      end
+    end
+  end
+
+  describe '#filter' do
+    let(:query) do
+      ->(snip) { snip == target_snip }
+    end
+
+    let(:snip) { double(CodeSnippet::Snip) }
+    let(:target_snip) { double(CodeSnippet::Snip) }
+
+    let(:snips) do
+      [
+        snip,
+        snip,
+        target_snip
+      ]
+    end
+
+    before do
+      subject.instance_variable_set(:@snippets, snips)
+      @result = subject.filter(query)
+    end
+
+    it 'finds target snip in set' do
+      expect(@result.count).to be 1
+      expect(@result.first).to eq target_snip
+    end
+
+    context 'when no query is defined' do
+      before do
+        @results = subject.filter
+      end
+
+      it 'returns everything' do
+        expect(@results.count).to eq 3
+      end
+    end
+  end
+
+  describe '#find' do
+    let(:search_term) { 'foo' }
+    let(:lang) { '.rb' }
+
+    let(:snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'snip.rb', '.rb')
+    end
+
+    let(:target_snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'foo.rb', '.rb')
+    end
+
+    let(:almost_target_snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'foo.go', '.go')
+    end
+
+    let(:snips) do
+      [
+        snip,
+        snip,
+        target_snip,
+        almost_target_snip
+      ]
+    end
+
+    before do
+      subject.instance_variable_set(:@snippets, snips)
+      @result = subject.find(search_term, lang)
+    end
+
+    it 'returns expected snip' do
+      expect(@result.count).to be 1
+      expect(@result.first).to eq target_snip
+    end
+
+    context 'when language filter is not provided' do
+      let(:lang) { nil }
+
+      it 'returns expected snips' do
+        expect(@result.count).to be 2
+        expect(@result[0]).to be target_snip
+        expect(@result[1]).to be almost_target_snip
+      end
+    end
+  end
+
+  describe '#filter_by_extension' do
+    let(:search_term) { 'foo' }
+    let(:lang) { '.rb' }
+
+    let(:snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'snip.go', '.go')
+    end
+
+    let(:target_snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'foo.rb', '.rb')
+    end
+
+    let(:another_target_snip) do
+      CodeSnippet::Snip.new('path/to/snip.rb', 'bar.rb', '.rb')
+    end
+
+    let(:snips) do
+      [
+        snip,
+        snip,
+        target_snip,
+        another_target_snip
+      ]
+    end
+
+    before do
+      subject.instance_variable_set(:@snippets, snips)
+      @result = subject.filter_by_extension(lang)
+    end
+
+    it 'returns files matching extension' do
+      expect(@result.count).to be 2
+      expect(@result[0]).to be target_snip
+      expect(@result[1]).to be another_target_snip
+    end
+  end
+end

data/spec/snippet/snip_spec.rb

@@ -0,0 +1,78 @@
+require 'spec_helper'
+
+RSpec.describe CodeSnippet::Snip do
+  let(:file_name) { 'snippet-file' }
+  let(:file_ext) { '.ext' }
+  let(:snip_dir) { 'path/to/snippets' }
+  let(:path) { "#{snip_dir}/path/to/#{file_name}#{file_ext}" }
+
+  describe '.new_from_file' do
+    before do
+      allow(CodeSnippet::CLI).to receive(:snip_dir)
+        .and_return(snip_dir)
+
+      @snip = described_class.new_from_file(path)
+    end
+
+    it 'creates snip from path' do
+      expect(@snip.path).to eq path
+      expect(@snip.name).to eq file_name
+      expect(@snip.ext).to eq file_ext
+    end
+  end
+
+  subject { described_class.new_from_file(path) }
+
+  describe '#name' do
+    it 'returns file name without snip_dir or file extension' do
+      expect(subject.name).to eq file_name
+    end
+  end
+
+  describe '#exist?' do
+    let(:exists) { true }
+    before do
+      allow(File).to receive(:exist?)
+        .with(path)
+        .and_return(exists)
+    end
+
+    it 'returns true when file exists' do
+      expect(subject.exist?).to be true
+    end
+
+    context 'when file does not exist' do
+      let(:exists) { false }
+
+      it 'returns false' do
+        expect(subject.exist?).to be false
+      end
+    end
+  end
+
+  describe '#content' do
+    let(:exist) { true }
+    let(:content) { 'some-snippet' }
+
+    before do
+      allow(subject).to receive(:exist?).and_return(exist)
+      allow(File).to receive(:read)
+        .with(path)
+        .and_return(content)
+    end
+
+    it 'returns snippet file content' do
+      expect(subject.content).to eq content
+    end
+
+    context 'when file does not exist' do
+      let(:exist) { false }
+
+      it 'raises error' do
+        expect do
+          subject.content
+        end.to raise_error('cannot read snippet code')
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'simplecov'
+require 'pry'
+require 'bundler/setup'
+
+SimpleCov.start
+
+SimpleCov.configure do
+  add_filter 'config'
+  add_filter 'spec'
+  add_filter 'vendor'
+  coverage_dir 'target/reports/coverage'
+  minimum_coverage 10
+end
+
+require 'code_snippet'
+require 'code_snippet/cli'
+
+RSpec.configure do |config|
+  config.example_status_persistence_file_path = '.rspec_status'
+  config.disable_monkey_patching!
+
+  config.expect_with :rspec do |c|
+    c.syntax = :expect
+  end
+end