RubyGems - snp - Versions diffs - 0.1 - Mend

snp 0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

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