RubyGems - snp - Versions diffs - 0.1 - Mend

snp 0.1

Files changed (19) hide show

checksums.yaml +7 -0
data/MIT-LICENSE +20 -0
data/README.md +104 -0
data/lib/snp.rb +9 -0
data/lib/snp/cli.rb +226 -0
data/lib/snp/compiler.rb +58 -0
data/lib/snp/data.rb +50 -0
data/lib/snp/path.rb +83 -0
data/lib/snp/template.rb +62 -0
data/lib/snp/template_context.rb +85 -0
data/lib/snp/version.rb +3 -0
data/test/snp/cli_test.rb +99 -0
data/test/snp/compiler_test.rb +42 -0
data/test/snp/data_test.rb +30 -0
data/test/snp/path_test.rb +47 -0
data/test/snp/template_context_test.rb +52 -0
data/test/snp/template_test.rb +37 -0
data/test/test_helper.rb +15 -0
metadata +95 -0

checksums.yaml ADDED Viewed

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 49d5d8be74b2f7914fd8a8eabe8e3b886c70d843
+  data.tar.gz: 7fc0270b98da93a2ff118206b53d69828fa33c02
+SHA512:
+  metadata.gz: 6b13774f35b7f26b96be00454897bdc9954e0896a775fdae12b6f9f53b81d5f2ec38cdb1f2ed318de677fb0f5e92b76ddea5d1fc5ecd11eb20d56ed8f3b08302
+  data.tar.gz: 35dafdd03b76034b47215c682fb5a4e540752c379318026d3fe58b58c0779af0cb82e8937cf6f18f4ff29e8d2263273b61ce8aebfa20aad52dfbaed5c95014d9

data/MIT-LICENSE ADDED Viewed

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Renato Mascarenhas http://renatomascarenhas.name/
+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 ADDED Viewed

@@ -0,0 +1,104 @@
+# snp - easy snippets for everyone
+`snp` is a tool to allow easy snippet creation, in an automated and reusable manner.
+How many times did you create that small HTML document to test out if something worked
+quite the way you thought it did? `snp`'s goal is to free the user from the creation
+of all boilerplate involved in the creation of such snippets, allowing the programmer
+to focus immediately on the feature that she wants to test.
+### Motivation
+It is often in many situations that we wonder how something works in a language or
+library. One of the best ways to find out the answer in such scenarios is to create
+a minimum piece of code that can test the specific case we have in mind. However,
+creating such files may involve some overhead and the creation of boilerplate code
+to allow the testing. This can cause people to give up creating the snippet and instead
+just look up on the Internet, which can take more time and you likely will not learn
+as much. The goal of this project is, therefore, reduce the cost of testing and
+learning on your own.
+### Example
+`snp` is especially useful for quick tests that you want to perform in environments
+in which a significant amount of boilerplate is involved. Suppose you frequently
+test the expected effect of `jQuery` functions. You could create a snippet such as
+~~~erb
+<%# file: ~/.snp/jquery_test.js.erb %>
+<html>
+  <head><title><%= title %></title></head>
+  <body>
+    <script src="http://code.jquery.com/jquery-<%= jquery_version %>.min.js"></script>
+    <script>
+      (function() {
+        // code goes here
+      })();
+    </script>
+  </body>
+</html>
+~~~
+With that file set up once, whenever you want to perform a test of something related to
+`jQuery` all you have to do is type:
+~~~console
+$ snp --title callbacks --jquery-version 2.1.1 jquery_test.js
+~~~
+Variable substitutions happen as you expect them to, and your favorite editor is fired up
+with the snippet content, waiting for you to actually test what you wanted in the first place.
+### Rules of the game
+* Snippet templates are by default placed under the `~/.snp` directory. You can
+override that by defining the `SNP_PATH` environment variable, which accepts a
+list of directories in pretty much the same way that the shell's `PATH` does.
+* All snippet templates are ERB files and must have a name with the according
+`.erb` extension.
+* You do not have fill in every piece of dynamic content in the command line when
+creating a new snippet from a template. They can have defaults and you can define
+them by placing a yaml file with the same name as the template with the default
+contents of each dynamic piece of content in the template. Note that arguments
+passed to the command line override those definitions.
+Example: suppose you have the following snippet named `introduction.txt.erb`:
+~~~erb
+<%= greeting %>, my name is <%= name %>, and I'm from <%= country %>.
+~~~
+You can then create a `introduction.txt.yml` file to define the default values for
+the dynamic variables in the snippet above:
+~~~yaml
+greeting: "Hello"
+name: "Renato"
+country: "Brazil"
+~~~
+Now you can create snippets from that template using the default values using just:
+~~~console
+$ snp introduction.txt
+# => "Hello, my name is Renato, and I'm from Brazil."
+~~~
+You can override specific values when creating a new snippet as well:
+~~~console
+$ snp --name David --country UK
+# => "Hello, my anme is David, and I'm from UK."
+~~~
+### Contributions/Bugs
+Email me, or create an issue/pull request on the GitHub repository.
+### License
+MIT. See `MIT-LICENSE` file for details.

data/lib/snp.rb ADDED Viewed

@@ -0,0 +1,9 @@
+require 'snp/version'
+require 'snp/path'
+require 'snp/template'
+require 'snp/template_context'
+require 'snp/data'
+require 'snp/compiler'
+module Snp
+end

data/lib/snp/cli.rb ADDED Viewed

@@ -0,0 +1,226 @@
+require 'tempfile'
+require 'slop'
+module Snp
+  # Snp::Printer
+  #
+  # This class is responsible for outputing string in normal output and error streams.
+  # It defaults to `STDOUT` and `STDERR`, respectively but can be used to generate output
+  # for other streams.
+  #
+  # Example
+  #
+  #   stream = Snp::Printer.new
+  #   stream.out('Hello')  # => 'Hello' is written to the standard output
+  #   stream.err('ERROR!') # => 'ERROR!' is written to the standard error
+  class Printer
+    def initialize(out = STDOUT, err = STDERR)
+      @out = out
+      @err = err
+    end
+    def out(message)
+      @out.puts message
+    end
+    def err(message)
+      @err.puts message
+    end
+  end
+  # Snp::InvalidOptions
+  #
+  # This exception is raised when there is an error parsing command line options
+  # passed to `snp`.
+  class InvalidOptions < StandardError
+    def initialize(invalid_option)
+      super("Invalid option: #{invalid_option}")
+    end
+  end
+  # Snp::CLI
+  #
+  # This class is responsible for parsing command line options passed to `snp` and
+  # retrieve the template name to be compiled and possibly options to override data
+  # for the template.
+  #
+  # Example
+  #
+  #   CLI.parse_options # => ['/Users/john/.snp/jquery.html.erb', { version: '1.9' }]
+  class CLI
+    # Public: extract template name and other data that should be used to compile the
+    # template.
+    #
+    # arguments - an array of arguments that should be parsed. Defaults to `ARGV`.
+    #
+    # This method generates the snippet and fires your text editor in case it is set up,
+    # or prints the snippet to the standard output.
+    def self.run(arguments = ARGV.dup)
+      new(arguments).start
+    end
+    attr_reader :printer, :template_name
+    # Internal: creates a new `Snp::CLI` instance.
+    #
+    # params  - array of arguments.
+    # printer - the printer object through which feedback messages are sent to.
+    #           The passed object must respond to `out` and `err` for normal
+    #           and error situations, respectively.
+    def initialize(params, printer = Printer.new)
+      @params  = params
+      @options = {}
+      @printer = printer
+    end
+    # Internal: actually does the parsing job and compiles the snippet.
+    def start
+      @template_name, template_data = parse
+      snippet = Compiler.build(template_name, template_data)
+      edit(snippet) || printer.out(snippet)
+    rescue => exception
+      printer.err exception.message
+      help_and_exit
+    end
+    # Internal: parses command line options.
+    #
+    # Returns the template name and extra options to be used when compiling
+    # the snippet, extracted from command line arguments.
+    def parse
+      help_and_exit if no_options_passed?
+      template_name = parse_static_options
+      template_data = parse_dynamic_options
+      [template_name, template_data]
+    end
+    private
+    # Internal: parses the command line options to check for static options
+    # (version number and help).
+    def parse_static_options
+      option_parser.parse!(@params)
+      @params.pop
+    end
+    # Internal: parses dynamic options, creating options according to the arguments
+    # passed on the command line.
+    #
+    # Example
+    #
+    #   # command is '--project snp --language ruby template_name'
+    #   parse_dynamic_options # => { 'project' => 'snp', 'language' => 'ruby' }
+    def parse_dynamic_options
+      if no_options_passed?
+        {}
+      else
+        dynamic_parser.parse!(@params)
+        data = dynamic_parser.to_hash
+        invalid_key = data.find { |key, value| value.nil? }
+        if invalid_key
+          raise InvalidOptions.new(invalid_key.first)
+        end
+        data
+      end
+    end
+    # Internal: builds the static option parser. Recognizes `-V` for version and `-h`
+    # for help.
+    def option_parser
+      @_option_parser ||= Slop.new do |command|
+        command.banner "Usage: #{program_name} [options] [template_name]"
+        command.on('-V', 'Shows version and exits') do
+          print_and_exit Snp::VERSION
+        end
+        command.on('-h', 'Shows this message') do
+          print_and_exit command.to_s
+        end
+      end
+    end
+    # Internal: builds the dynamic option parser, that creates options on the fly according
+    # to the passed command line options.
+    def dynamic_parser
+      @_dynamic_parser ||= Slop.new(autocreate: true)
+    end
+    # Internal: prints a message and exits.
+    #
+    # message - the message to be printed before exiting.
+    #
+    # This method finishes the current process with a success exit status.
+    def print_and_exit(message)
+      printer.out message
+      exit
+    end
+    # Internal: returns the editor that should be used when editing a generated
+    # snippet. Looks for editor names in the `SNP_EDITOR` and `EDITOR` environment
+    # variables, respectively.
+    def editor
+      @_editor ||= ENV['SNP_EDITOR'] || ENV['EDITOR']
+    end
+    # Internal: Opens the preferred text editor with the content of a snippet.
+    #
+    # snippet - a string with the snippet content that should be edited.
+    def edit(snippet)
+      if editor && !editor.empty?
+        snippet_file = file_for(snippet)
+        Process.exec "#{editor} '#{snippet_file}'"
+      end
+    end
+    # Internal: creates a file in the working directory to wihch the snippet
+    # contents will be written to, allowing it to be edited.
+    #
+    # content - the content of the final snippet.
+    def file_for(content)
+      "snp_#{template_name}".tap do |file_name|
+        File.open(file_name, "w+") { |f| f.write(content) }
+      end
+    end
+    # Internal: the program name to be used when generating output to the user.
+    def program_name
+      File.basename($0, '.*')
+    end
+    # Internal: prints help message and exits with a failure exit status.
+    def help_and_exit
+      printer.err help_message
+      exit 1
+    end
+    # Internal: returns the help message for the `snp` command.
+    def help_message
+      option_parser.to_s
+    end
+    # Internal: checks whether or not any arguments were passed on the command line.
+    def no_options_passed?
+      @params.empty?
+    end
+    # Internal: returns the extension of the template name, to be used in the
+    # generated snippet.
+    def template_extension
+      @_extension ||= begin
+        match_data = template_name.match(/.+(\..+)/)
+        # set it to the empty string in case there is no extension to allow for
+        # proper memoization of its value
+        match_data ? match_data[1] : ""
+      end
+    end
+  end
+end

data/lib/snp/compiler.rb ADDED Viewed

@@ -0,0 +1,58 @@
+require 'yaml'
+module Snp
+  # Snp::Compiler
+  #
+  # This class takes a template file name and builds it, using the template
+  # definition, default data to be used and extra options that override the
+  # default ones.
+  #
+  # Example
+  #
+  #   Compiler.build('js.html', inline: true)
+  class Compiler
+    def self.build(template_name, extra_options)
+      new(template_name, extra_options).compile
+    end
+    # Public: creates a new Snp::Compiler instance.
+    #
+    # template      - the template name.
+    # extra_options - options to override default data to build the template.
+    def initialize(template, extra_options)
+      @template = template
+      @options  = extra_options
+    end
+    # Public: actually compiles the template.
+    #
+    # Returns a string with the compiled version of the snippet.
+    def compile
+      template.compile(compilation_context)
+    end
+    private
+    # Internal: builds the ERB context to be used to generate the snippet.
+    # Consists of the default for the template plus the extra options
+    # passed on initialization.
+    def compilation_context
+      TemplateContext.for(default_data.merge(@options))
+    end
+    # Internal: searches the default data file for the template and parses it.
+    #
+    # Returns a hash with the default data if available, or an empty hash otherwise.
+    def default_data
+      Data.for(@template)
+    end
+    def template
+      Template.new(@template, path)
+    end
+    def path
+      @_path ||= Path.new
+    end
+  end
+end

data/lib/snp/data.rb ADDED Viewed

@@ -0,0 +1,50 @@
+require 'yaml'
+module Snp
+  # Snp::Data
+  #
+  # This class is responsible for fetching the default data to be used when
+  # compiling a template. This defaults to the data available on a YAML file
+  # located in `SNP_PATH`, if available.
+  #
+  # Example
+  #
+  #   # Given there is a jquery.yml file in `SNP_PATH`, then
+  #   data = Snp::Data.for('jquery')
+  #   # => { 'version' => '1.9', 'cdn' => true }
+  class Data
+    # Public: fetches the default data for the given template and parses it.
+    #
+    # template - the template name whose data is to be fetched.
+    #
+    # Returns a hash with the data.
+    def self.for(template)
+      new(template).to_hash
+    end
+    # Public: creates a new `Snp::Data` instance for the template given.
+    def initialize(template, path = Path.new)
+      @template = template
+      @path     = path
+    end
+    # Public: fetches the data file and parses it, if available.
+    #
+    # Returns a hash of the parsed data.
+    def to_hash
+      if absolute_path
+        YAML.load_file(absolute_path)
+      else
+        {}
+      end
+    end
+    private
+    # Internal: returns the absolute path to the template file, searching for the
+    # directories in `SNP_PATH`.
+    def absolute_path
+      @path.which(@template, 'yml')
+    end
+  end
+end

data/lib/snp/path.rb ADDED Viewed

@@ -0,0 +1,83 @@
+module Snp
+  # Snp::Path
+  #
+  # This class is intended to wrap the logic of finding the paths in which template
+  # and data files should be placed.
+  #
+  # Example
+  #
+  #   Snp::Path.new.which('jquery') # => '/etc/snp/jquery.erb'
+  class Path
+    # Public: returns the list of absolute paths to the directories in which
+    # the templates should be looked.
+    def absolute_paths
+      dir_list.map { |d| File.expand_path(d) }
+    end
+    # Public: resolves a template file by looking in the template path.
+    #
+    # template  - the template name.
+    # extension - the extension of the desired template.
+    #
+    # Returns a string with the full path of the template file, or nil if it is not
+    # found.
+    def which(template, extension)
+      template_with_extension = with_extension(template, extension)
+      path = absolute_paths.find do |path|
+        File.exists?(File.join(path, template_with_extension))
+      end
+      if path
+        File.join(path, template_with_extension)
+      end
+    end
+    private
+    # Internal: retrieves a list of paths that should be searched by looking the `SNP_PATH`
+    # environment variable or falling back to the default path.
+    def dir_list
+      path_from_env || default_path
+    end
+    # Internal: parses the SNP_PATH environment variable, if it is set. The format
+    # of this variable follows the same convention of the shell's PATH variable: a series
+    # of directories separated by a collon.
+    def path_from_env
+      ENV['SNP_PATH'] && ENV['SNP_PATH'].split(':')
+    end
+    # Internal: The default path to be used when the SNP_PATH environment variable
+    # is not set.
+    def default_path
+      ['~/.snp']
+    end
+    # Internal: checks if the given name ends with the passed `extension`.
+    #
+    # template - the template file name.
+    def has_extension?(template, extension)
+      comparison_length = extension.size + 1 # account for the separator `.`
+      template[-comparison_length, comparison_length] == ".#{extension}"
+    end
+    # Internal: appends a given extension to the template file name, unless it is
+    # already present.
+    #
+    # template  - the template name.
+    # extension - the extension to be appended.
+    #
+    # Examples
+    #
+    #   with_extension('template', 'erb')     # => 'template.erb'
+    #   with_extension('template.erb', 'erb') # => 'template.erb'
+    def with_extension(template, extension)
+      if has_extension?(template, extension)
+        template
+      else
+        [template, extension].join(".")
+      end
+    end
+  end
+end

data/lib/snp/template.rb ADDED Viewed

@@ -0,0 +1,62 @@
+require 'erb'
+module Snp
+  # Snp::TemplateNotFound
+  #
+  # This exception is raised in case the template file passed is not found in any
+  # directory in snp path.
+  class TemplateNotFound < StandardError
+    def initialize(template_name, path)
+      super("Template #{template_name} was not found in #{path.inspect}")
+    end
+  end
+  # Snp::Template
+  #
+  # The Template class represents a snippet definition through an ERB template.
+  # Template files are looked in a series of directories that can be defined via
+  # the SNP_PATH environment variable. By default, these snippet definitions are
+  # searched in the `.snp` directory in your home directory.
+  #
+  # Examples
+  #
+  #   t = Snp::Template.new('jquery.erb')
+  #   t.compile(binding) # => '<html><head>...'
+  class Template
+    # Public: creates a new template instance.
+    #
+    # template_file - the basename of the template file.
+    def initialize(template_file, path = Path.new)
+      @file = template_file
+      @path = path
+    end
+    # Public: compiles the template content to an effective snippet, ready to use.
+    #
+    # context - a `Binding` object to be used as context in the template compilation.
+    #
+    # Returns a string with the compiled template.
+    def compile(context)
+      if template_content
+        ERB.new(template_content, 0, '-').result(context)
+      else
+        raise TemplateNotFound.new(@file, @path.absolute_paths)
+      end
+    end
+    private
+    # Internal: returns a string with the content of the template file.
+    def template_content
+      if absolute_path
+        File.read(absolute_path)
+      end
+    end
+    # Internal: returns the absolute path to the template, or `nil`, in case it is
+    # not found.
+    def absolute_path
+      @path.which(@file, 'erb')
+    end
+  end
+end

data/lib/snp/template_context.rb ADDED Viewed

@@ -0,0 +1,85 @@
+module Snp
+  # Snp::TemplateContext
+  #
+  # This class aims to represent the context in which a snippet template is
+  # compiled. It receives a hash of keys and values that act as properties to be
+  # used in the template. For example, if you have a template with the content:
+  #
+  #   <html>
+  #     <head><title><%= title %></title></head>
+  #   </html>
+  #
+  # Then a proper context for this snippet compilation would be:
+  #
+  #   TemplateContext.for(title: 'My beautiful page')
+  class TemplateContext
+    class InsufficientContext < StandardError
+      attr_reader :missing_property
+      def initialize(property)
+        @missing_property = property.to_s
+        super %(Insufficient context: no defined value for property "#{missing_property}")
+      end
+    end
+    # Public: returns the binding for the passed `attributes`.
+    def self.for(attributes)
+      new(attributes).erb_binding
+    end
+    # Public: creates a new Snp::TemplateContext object.
+    #
+    # context - a hash of properties and values to be used in as context of the template.
+    #
+    # The hash is used so that the resulting object responds to each key in `context`,
+    # returning the accoring value.
+    def initialize(context)
+      @context = context
+      context.each do |property, value|
+        method_name = normalize(property)
+        define_property(method_name, value)
+      end
+    end
+    def erb_binding
+      binding
+    end
+    def respond_to_missing?(method, *)
+      @context.has_key?(normalize(method))
+    end
+    # In case an unknown method is called on the template context, we raise a proper
+    # exception that must be rescued and properly handled.
+    #
+    # Reaching this point means we need variables in the snippet that were not provided.
+    def method_missing(method, *)
+      raise InsufficientContext.new(method)
+    end
+    private
+    # Internal: returns a propperty name with underscores where dashes were present.
+    #
+    # name - the property name.
+    #
+    # Examples
+    #
+    #   prepare('name')       # => 'name'
+    #   prepare('update-ref') # => 'update_ref'
+    def normalize(name)
+      name.to_s.gsub('-', '_')
+    end
+    # Internal: defines a method with `property` name, and returning `value`.
+    # If `value` is a boolean, this method will also define a predicate method.
+    def define_property(property, value)
+      define_singleton_method(property) { value }
+      if value == true || value == false
+        define_singleton_method("#{property}?") { value }
+      end
+    end
+  end
+end

data/lib/snp/version.rb ADDED Viewed

@@ -0,0 +1,3 @@
+module Snp
+  VERSION = '0.1'
+end

data/test/snp/cli_test.rb ADDED Viewed

@@ -0,0 +1,99 @@
+require 'test_helper'
+require 'snp/cli'
+describe Snp::CLI do
+  class TestPrinter
+    attr_reader :output, :error
+    def initialize
+      @output = ''
+      @error  = ''
+    end
+    def out(message)
+      @output << message
+    end
+    def err(message)
+      @error << message
+    end
+  end
+  describe '.parse_options' do
+    it 'delegates to #run' do
+      double = stub(start: 'double')
+      Snp::CLI.stubs(:new).returns(double)
+      Snp::CLI.run.must_equal 'double'
+    end
+  end
+  describe '#parse' do
+    def no_exit(&block)
+      block.call
+    rescue SystemExit
+    end
+    it 'prints help message when no arguments are passed' do
+      printer = TestPrinter.new
+      cli     = Snp::CLI.new([], printer)
+      no_exit { cli.parse }
+      printer.output.wont_be_nil
+    end
+    it 'can print version' do
+      printer = TestPrinter.new
+      cli     = Snp::CLI.new(['-V'], printer)
+      no_exit { cli.parse }
+      printer.output.must_equal Snp::VERSION
+    end
+    it 'can print help message' do
+      printer = TestPrinter.new
+      cli    = Snp::CLI.new(['-h'], printer)
+      no_exit { cli.parse }
+      printer.output.wont_be_nil
+    end
+    it 'retrieves the template name' do
+      cli = Snp::CLI.new(['snp'])
+      options = cli.parse
+      options.must_equal ['snp', {}]
+    end
+    it 'fetches dynamic options' do
+      cli = Snp::CLI.new(['--type', 'gem', '--count', '3', 'snp'])
+      options = cli.parse
+      options.must_equal ['snp', { type: 'gem', count: '3' }]
+    end
+    it 'throws an error if more than one template name is given' do
+      printer = TestPrinter.new
+      cli = Snp::CLI.new(['--count', '3', 'some_name', 'snp'], printer)
+      lambda {
+        no_exit { cli.parse }
+      }.must_raise(Snp::InvalidOptions)
+    end
+  end
+  describe '#start' do
+    it 'writes the compiled version to its output stream' do
+      printer = TestPrinter.new
+      cli = Snp::CLI.new(['snp'], printer)
+      Snp::Compiler.stubs(:build).returns('compiled snippet')
+      cli.start
+      printer.output.must_equal 'compiled snippet'
+    end
+  end
+end

data/test/snp/compiler_test.rb ADDED Viewed

@@ -0,0 +1,42 @@
+require 'test_helper'
+describe Snp::Compiler do
+  describe '.build' do
+    it 'delegates to #compile' do
+      compiler = stub(compile: 'compiled snippet')
+      Snp::Compiler.stubs(:new).returns(compiler)
+      Snp::Compiler.build('snp', {}).must_equal 'compiled snippet'
+    end
+  end
+  describe '#compile' do
+    def template_content
+      '<% if say_hello? %>' +
+        'Hello, <%= name %>' +
+      '<% else %>' +
+        'Farewell, <%= name %>' +
+      '<% end %>'
+    end
+    def default_options
+      { say_hello: true, name: 'John' }
+    end
+    def stub_file_operations
+      File.stubs(:exists?).returns(true)
+      File.stubs(:read).returns(template_content)
+      YAML.stubs(:load_file).returns(default_options)
+    end
+    it 'generates compiled snippet when all options are available' do
+      stub_file_operations
+      Snp::Compiler.new('template_name', {}).compile.must_equal 'Hello, John'
+    end
+    it 'overrides default data with the ones passed' do
+      stub_file_operations
+      Snp::Compiler.new('template_name', name: 'Arthur').compile.must_equal 'Hello, Arthur'
+    end
+  end
+end

data/test/snp/data_test.rb ADDED Viewed

@@ -0,0 +1,30 @@
+require 'test_helper'
+describe Snp::Data do
+  describe '.for' do
+    it 'delegates to #to_hash' do
+      data = stub(to_hash: 'snp')
+      Snp::Data.stubs(:new).returns(data)
+      Snp::Data.for('anything').must_equal 'snp'
+    end
+  end
+  describe '#to_hash' do
+    it 'is empty when no data file is found' do
+      File.stubs(:exists?).returns(false)
+      Snp::Data.new('snp').to_hash.must_equal({})
+    end
+    it 'parses the content of the data file' do
+      data = { name: 'snp', language: 'ruby' }
+      path = File.expand_path('~/.snp/snp.yml')
+      File.stubs(:exists?).returns(true)
+      YAML.stubs(:load_file).with(path).returns(data)
+      Snp::Data.new('snp').to_hash.must_equal data
+    end
+  end
+end

data/test/snp/path_test.rb ADDED Viewed

@@ -0,0 +1,47 @@
+require 'test_helper'
+describe Snp::Path do
+  describe '#absolute_paths' do
+    it 'defaults to the user home directory' do
+      Snp::Path.new.absolute_paths.must_equal Array(File.expand_path('~/.snp'))
+    end
+    it 'uses the value in the `SNP_PATH` variable when available' do
+      ENV['SNP_PATH'] = '~/.snp:/etc/snp'
+      Snp::Path.new.absolute_paths.must_equal [File.expand_path('~/.snp'), '/etc/snp']
+      ENV['SNP_PATH'] = nil
+    end
+  end
+  describe '#which' do
+    def subject
+      Snp::Path.new
+    end
+    it 'is nil in case there is no file in the path' do
+      File.stubs(:exists?).returns(false)
+      subject.which('template', 'erb').must_be_nil
+    end
+    it 'returns the absolute path to the template appending the extension' do
+      File.stubs(:exists?).returns(true)
+      subject.which('snp', 'erb').must_equal File.expand_path('~/.snp/snp.erb')
+    end
+    it 'finds the snippet in case it has more than one extension' do
+      File.stubs(:exists?).returns(true)
+      subject.which('snp.erb.js', 'js').must_equal File.expand_path('~/.snp/snp.erb.js')
+    end
+    it 'does not append extension if it template already has it' do
+      File.stubs(:exists?).returns(true)
+      subject.which('snp.erb', 'erb').must_equal File.expand_path('~/.snp/snp.erb')
+    end
+  end
+end

data/test/snp/template_context_test.rb ADDED Viewed

@@ -0,0 +1,52 @@
+require 'test_helper'
+describe Snp::TemplateContext do
+  describe '.for' do
+    it 'delegates to #erb_binding' do
+      context = stub(erb_binding: 'binding')
+      Snp::TemplateContext.stubs(:new).returns(context)
+      Snp::TemplateContext.for('template_name').must_equal 'binding'
+    end
+  end
+  describe '#erb_binding' do
+    it 'returns an instance of `Binding`' do
+      Snp::TemplateContext.new(key: 'value').erb_binding.must_be_instance_of Binding
+    end
+  end
+  it 'responds to methods passed as hash' do
+    context = Snp::TemplateContext.new(greeting: 'Hello', name: 'snp')
+    context.greeting.must_equal 'Hello'
+    context.name.must_equal 'snp'
+  end
+  it 'generates predicate methods for boolean attributes' do
+    context = Snp::TemplateContext.new(awesome: true, sad: false)
+    context.awesome?.must_equal true
+    context.sad?.must_equal false
+  end
+  it 'changes dash for underscore in generated methods' do
+    context = Snp::TemplateContext.new('is-awesome' => true)
+    context.is_awesome?.must_equal true
+  end
+  it 'politely responds to methods named after context keys' do
+    context = Snp::TemplateContext.new(snp: 'snp')
+    context.must_respond_to(:snp)
+  end
+  it 'responds to method names in its normalized forms' do
+    context = Snp::TemplateContext.new(:"gem-name" => 'snp')
+    context.must_respond_to(:gem_name)
+  end
+  it 'raises proper error when called with non-existing property' do
+    context = Snp::TemplateContext.new(snp: 'snp')
+    lambda {
+      context.invalid_property
+    }.must_raise(Snp::TemplateContext::InsufficientContext)
+  end
+end

data/test/snp/template_test.rb ADDED Viewed

@@ -0,0 +1,37 @@
+require 'test_helper'
+describe Snp::Template do
+  describe '#compile' do
+    class ERBContext
+      def greeting
+        'Hello'
+      end
+      def name
+        'snp'
+      end
+      def context
+        binding
+      end
+    end
+    it 'generates a string with the processed template' do
+      template_content = '<%= greeting %> from <%= name %>'
+      File.stubs(:exists?).returns(true)
+      File.stubs(:read).returns(template_content)
+      template = Snp::Template.new('template.erb')
+      template.compile(ERBContext.new.context).must_equal 'Hello from snp'
+    end
+    it 'raises an error in case the template is not found' do
+      File.stubs(:exists?).returns(false)
+      template = Snp::Template.new('template.erb')
+      lambda {
+        template.compile({})
+      }.must_raise Snp::TemplateNotFound
+    end
+  end
+end

data/test/test_helper.rb ADDED Viewed

@@ -0,0 +1,15 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'minitest/pride'
+require 'mocha/setup'
+require 'snp'
+# unset any possibly set `SNP_PATH` variable
+ENV.delete('SNP_PATH')
+# unset editors by default
+ENV.delete('SNP_EDITOR')
+ENV.delete('EDITOR')

metadata ADDED Viewed

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification
+name: snp
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Renato Mascarenhas
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.6'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+description: snp allows you to create snippets in an automated and reusable manner.
+email: mascarenhas.renato@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- lib/snp.rb
+- lib/snp/cli.rb
+- lib/snp/compiler.rb
+- lib/snp/data.rb
+- lib/snp/path.rb
+- lib/snp/template.rb
+- lib/snp/template_context.rb
+- lib/snp/version.rb
+- test/snp/cli_test.rb
+- test/snp/compiler_test.rb
+- test/snp/data_test.rb
+- test/snp/path_test.rb
+- test/snp/template_context_test.rb
+- test/snp/template_test.rb
+- test/test_helper.rb
+homepage: https://github.com/rmascarenhas/snp
+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: snp
+rubygems_version: 2.2.2
+signing_key:
+specification_version: 4
+summary: Quickly and easily create code snippets.
+test_files:
+- test/snp/compiler_test.rb
+- test/snp/data_test.rb
+- test/snp/template_test.rb
+- test/snp/cli_test.rb
+- test/snp/template_context_test.rb
+- test/snp/path_test.rb
+- test/test_helper.rb