jekyll_new_page 0.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: df0e076b6b2d46c74606c84e450c4ef65ea18d466a6a4601c528ba5558645612
+  data.tar.gz: 2f038313dd4ea563f64aeec075c18f81a541ceca5bc088234deb8531e84f62d5
+SHA512:
+  metadata.gz: f9c25ac0716449256113720eb27f37771880b5f3357faae150382b5c2858cdcefdb70c53e762259126451df75f5833a1915e35c26e8d299247b419be5b649904
+  data.tar.gz: ee03f9a7e86730e83d4d5fdc010eb796c620ef58a0f57cbee4ede085ca097c1e4b47d041be3055c2ac260ea20efd08713962f825c32d279eeb9bd05cce5936ce

data/bin/new_from_template

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+
+require_relative "../lib/new_page/process_template.rb"
+require_relative "../lib/new_page/input_hash.rb"
+
+require 'optparse'
+
+options = {}
+OptionParser.new do |opts|
+  opts.banner = "Usage: new_from_template [options]"
+
+  opts.separator ""
+  opts.separator "\tCreates a new file based on a liquid template."
+  opts.separator ""
+  opts.separator "Options:"
+
+  opts.on("-o", "--output [NAME]", "Path where the file is to be created.") do |out|
+    options[:output] = out
+  end
+
+  opts.on( "-n", "--name=NAME", "Name of the created file. If there's no extension the same extension of the template will be used.") do |name|
+    options[:name] = name
+  end
+
+  opts.on( "--template FILE|DIRECTORY", "Template file or directory. This should point to either a directory with the templates or the actual template.") do |template|
+    options[:path] = template
+  end
+
+  opts.on("--template_name=[NAME]", "Template name, name or \"glob\" of the template. This options uses '--template' as a directory, it is an error if '--template' specifies a file and there's also a '--template-name' specified.") do |template_name|
+    options[:template_name] = template_name
+  end
+
+  opts.separator ""
+  opts.separator "Common options:"
+
+  opts.on_tail("-h", "--help", "-?", "Shows this message") do
+    puts opts
+    exit
+  end
+end.parse!
+
+options[:dir] = false
+
+processor = NewPage::ProcessTemplate.new(context: NewPage::InputableContext.new, **options)
+processor.render({})
+

data/lib/jekyll_new_page.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/ruby
+
+require 'yaml'
+require 'pathname'
+
+require 'jekyll'
+
+require 'new_page/input_hash.rb'
+require 'new_page/process_template.rb'
+
+module NewPage
+
+  class CreateNewPage < Jekyll::Command
+    class << self
+
+      def init_with_program(c)
+        c.command("create-page".to_sym) do |prog|
+          prog.syntax "create-page [options] <Template name>"
+          prog.description "create a new page, based on a liquid template." 
+
+          prog.option 'output', '-o', '--output PATH', 'Path where to create the new document.' do |out| 
+            return Pathname.new(out)
+          end
+
+          prog.option 'path', '--path [PATH]', 'Path where to locate the template.'
+          prog.option 'name', '-n', '--name NAME', 'Name of the document'
+          prog.option 'dir', '-d', '--create-subdir', 'Create a subdir to store the new page'
+
+          prog.action do |args, options|
+            options.transform_keys! { |old_key| old_key.to_sym }
+
+            raise ArgumentError("Need to specify a template name") if args.size > 1
+            raise ArgumentError("No output path specified.") if options[:output].nil?
+            raise ArgumentError("No page name specified.") if options[:name].nil?
+
+            options[:dir] = false unless options.include? :dir
+
+            [:output, :path].each do |key|
+              options[key] = Pathname.new(options[key]) unless options[key].nil?
+            end
+
+            options[:template_name] = args[0] || '*'
+
+            options[:history_file] = options[:output] / Pathname.new('.history.txt')
+            context = InputableContext.new(outer_scope: {name: options[:name]}, reader: NewPage::ReadlineInputHandler, completion_handler: NewPage::HistoryHandler, **options)
+
+            begin
+              process = ProcessTemplate.new(context: context,  **options)
+
+              process.render(context)
+
+              exec('nvim', "#{process.output_file}")
+            rescue ArgumentError => error
+              print error.message
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/new_page/input_hash.rb

@@ -0,0 +1,188 @@
+require 'liquid'
+require 'readline'
+require 'set'
+
+module NewPage
+
+  class HistoryHandler
+    attr_reader :completion
+
+    def initialize(history_file: Pathname.new(".history.yaml"), **)
+      if (history_file.is_a? Pathname)
+        @history_file = history_file
+      else
+        @history_file = Pathname.new(history_file)
+      end
+
+      @completion = read_history(history_file)
+    end
+
+    def [](key)
+      @completion[key]
+    end
+
+    def []=(key, value)
+      @completion[key] = value
+    end
+
+    def include?
+      @completions.include?(key)
+    end
+
+    def read_history
+      YAML.load_file(@history_file)
+    end
+
+    def write_history
+      File.open { |file| file.write { |out| out << @completion.to_yaml } }
+    end
+  end
+
+  class NoCompletion < Hash
+    def completion
+      return {}
+    end
+
+    def write_history
+    end
+  end
+
+  class ReadlineInputHandler
+    attr_reader :history
+
+    def initialize(**args)
+      print "#{self} -> #{args}\n"
+      if (args.include?('completion_handler'))
+        @history = args['completion_handler'].new(**args)
+      else
+        @history = NoCompletion.new
+      end
+    end
+
+    def completion
+      @history.completion
+    end
+
+    def update_completion(key, value)
+      values = value.split /[ \t]/
+      if (completion.include?(key)) then
+        completion[key] += values
+      else
+        completion[key] = values
+      end
+    end
+
+    def input(key)
+      print "Reading #{key} at #{self}"
+      old = Readline.completion_proc
+      Readline.completion_proc = proc do |partial|
+        if completion.include? key.to_s then
+          completion[key.to_s].query(/^#{Regexp.escape(partial)}/)
+        else
+          []
+        end
+      end
+      line = ""
+      begin
+        line = Readline.readline("#{key} : ", true).strip
+      ensure
+        Readline.completion_proc = old unless old.nil?
+      end
+      update_completion(key, line)
+      @history.write_history
+      line
+    end
+  end
+
+  class NoInput
+    def input(key)
+      return nil
+    end
+  end
+
+  class InputHash < Hash
+    attr_reader :reader, :filled_keys
+
+    def normalize_key(key)
+      return key.to_s.strip.tr("._ ", "-").to_sym
+    end
+
+    def initialize(data = {}, reader: NoInput, **args)
+      if (reader != NoInput)
+        @reader = reader.new(**args)
+      else
+        @reader = reader.new()
+      end
+
+      super()
+
+      data = Hash.new unless data.is_a? Hash
+
+      merge! data.transform_keys { |k| normalize_key(k) }
+      @filled_keys = data.keys
+    end
+
+    def filled?(key)
+      return filled_keys.include?(key)
+    end
+
+    def include?(key)
+      return super.include?(key) || filled?(key)
+    end
+
+    def [](key)
+      key = normalize_key(key)
+      if (@filled_keys.include?(key))
+        value = super(key)
+      else
+        print "Reading #{key} with #{@reader}\n"
+        value = @reader.input(key) unless @filled_keys.include?(key)
+        self[key]=value
+      end
+      value
+    end
+
+    def []=(key, value)
+      key=normalize_key(key)
+      @filled_keys += [ key ] unless @filled_keys.include?(key)
+      super(key, value)
+    end
+  end
+
+  class InputableContext < ::Liquid::Context
+
+    def initialize(enviroments: {}, outer_scope: {}, registers: {}, rethrow_errors: true, resource_limits: nil, **args)
+      print "InputableContext #{args}\n"
+      @context_args= args
+
+      environments = [environments].flatten.map { |env| new_hash(env) }
+      outer_scope = new_hash(outer_scope) unless outer_scope.is_a? InputHash
+
+      super(environments, outer_scope, registers, rethrow_errors, resource_limits)
+      @filled_keys = []
+
+      Readline.completion_append_character = " "
+      Readline.completer_word_break_characters = " \t"
+    end
+
+    def hash_create_args
+      @context_args
+    end
+
+    def new_hash(source)
+      source = {} if source.nil?
+      return InputHash.new(source, **@context_args)
+    end
+
+    def do_not_input(*keys)
+      keys.map { |key| key.to_sym }.each do |key|
+        @filled_keys << key unless @data.has_key? key
+      end
+    end
+
+    def push(new_scope)
+      new_scope = new_hash(new_scope) unless new_scope.is_a? InputHash
+      super(new_hash(new_scope))
+    end
+  end
+end

data/lib/new_page/process_template.rb

@@ -0,0 +1,68 @@
+require 'liquid'
+require 'pathname'
+
+module NewPage
+
+class ProcessTemplate
+  TEMPLATE_PATH = Pathname.new("_template")
+  attr :file, :output_file, :context
+
+  def initialize(output:, template_name: nil, name: nil, dir: false, path: nil, data: {}, context: nil, **)
+    @path = if (path.nil?) then 
+              Pathname.new(output) / TEMPLATE_PATH
+            else
+              Pathname.new(path)
+            end
+
+    output = Pathname.new(output)
+
+    if (name.nil?) then
+      name = output.basename
+      output = output.dirname
+    end
+
+    if (dir) then
+      @output = Pathname.new(output) / Pathname.new(name)
+      FileUtils.mkdir_p(@output) unless @output.directory?
+      name = 'index'
+    else 
+      @output = Pathname.new(output)
+    end
+
+    @context = context 
+
+    if not template_name.nil? then
+      templates = if (@path / template_name).file? then
+        [ @path / template_name ]
+      else
+        glob = File.expand_path(@path) + "/#{template_name}"
+        Dir::glob(glob)
+      end
+      templates.map! { |name| Pathname.new(name) }
+
+      raise ArgumentError.new("Ambiguos template name #{template_name} : #{templates}") if templates.size > 1
+
+      raise ArgumentError.new("No such template #{template_name} at #{glob}") if templates.empty? || !templates[0].file?
+      @input_file = templates[0]
+    else 
+      if @path.file? then
+        @input_file = @path
+        @path = @path.dirname
+      else
+        @input_file = @path / template_name
+      end
+    end
+
+    @output_file = @output / Pathname.new(name).sub_ext(@input_file.extname)
+
+    raise "#{@input_file} cannot be the same as #{@output_file}" if @input_file == @output_file
+
+    @template = Liquid::Template.parse(File.read(@input_file)) 
+  end
+
+  def render(defaults)
+    @output_file.write(@template.render(@context), mode: 'w')
+  end
+end
+
+end

metadata

@@ -0,0 +1,91 @@
+--- !ruby/object:Gem::Specification
+name: jekyll_new_page
+version: !ruby/object:Gem::Version
+  version: '0.6'
+platform: ruby
+authors:
+- Victor Bogado da Silva Lins
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Makes it easy to create a new page, without adding a bunch of boiler
+  plate manually.
+email: victor@bogado.net
+executables:
+- new_from_template
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/new_from_template
+- lib/jekyll_new_page.rb
+- lib/new_page/input_hash.rb
+- lib/new_page/process_template.rb
+homepage: https://www.github.com/bogado/jekyll-new-page-creator
+licenses:
+- MIT
+metadata: {}
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- reline
+- readline
+- liquid
+- jekyll
+rubygems_version: 4.0.6
+specification_version: 4
+summary: Create a new page, based on a template stored on a '_template' directory.
+test_files: []