jeny 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f302cd633c4386fa74ad685168b0a8676c74dd70a76c93fc2f7403e5dc6d912b
-  data.tar.gz: fff5a77a0735598d92caa0d5c520fbcded3a5cc327717f54a373bb31010603f5
+  metadata.gz: 80c63bb3ba6b2c4dbb710eb1b465427e207663c56d6f03872871ceb999fd01b8
+  data.tar.gz: 99188a6695c03b3520c0a8b03b499125ac8ba8ff9989114b8520b29e372b0652
 SHA512:
-  metadata.gz: b8276ec8e77f88ae26605647e2452976a86b4ede04d18bd626d2ed3574284d994869715d4df7fcc848529c90b0dd0f6c1579211341b7d1618ca4b16f30926eca
-  data.tar.gz: 197fa5b18e11edfb337245e0aa26511150cc0e68415b5004756d13a0b42695885ccf3dd229196cb67d58c8abd5d208b40d40f32cf7bcc4d36ee53064126d4933
+  metadata.gz: dd518b08c9d0e212dbd185552c8acc3e328c727e4a774198c15b9dfdafef2fa8a80103bac09c3c5432b387560450f01ded4b472667b525953cfffce7afc8694f
+  data.tar.gz: 68caadbe294ce2da79a680ee008cbda7d18b0bd2bb2adce536e04c887a96be04dc3be9b6ef685605196077b379c67d252f160079c3172bbc9a360a715426bdab

data/Gemfile

@@ -1,5 +1,2 @@
 source "https://rubygems.org"
 gemspec
-
-# gem "predicate", github: "enspirit/predicate", branch: "placeholders"
-# gem "predicate", path: "../predicate"

data/README.md

@@ -1,7 +1,198 @@
 # Jeny
 
-Jeny aims at being a simple yet powerful code generation and scaffolding
-system.
+![](https://travis-ci.com/enspirit/jeny.svg?branch=master)
+
+Jeny is a simple yet powerful commandline tool for scaffolding new
+projects and generating code snippets in existing ones.
+
+```sh
+jeny --help
+```
+
+The outline of this readme is as follows:
+
+- Two use cases: scaffolding & snippets
+- The templating language
+- How do I generate dynamic file names?
+- Use `--git` for atomic generation of snippets
+- Configuring `jeny`: env vars, .jeny file and commandline options
+- Contributing, Licence, etc.
+
+## Generate a project from a scaffold
+
+The first use case is the generation of a project structure from
+an existing scaffold.
+
+```sh
+jeny --[no-]edit -d ... -d ... generate path/to/scaffold path/to/target
+```
+
+This command will recursively copy and instantiate files and
+directories from the scaffold folder to the destination folder.
+Your favorite editor opens on files having at least one TODO.
+
+File content is generated using a very simple and not that
+powerful templating language, see sections later. Code snippets
+of the following section are NOT supported for now.
+
+## Generate code snippets on an existing project
+
+The second use case is the generation of code snippets inside
+existing annotated source code.
+
+```sh
+jeny --[no-]edit -d ... -d ... snippet snipname path/to/code
+```
+
+Code snippets are commented code blocks prefixed by a jeny delimiter.
+When executing `jeny s`, all files under `path/to/files` are inspected
+and jeny code blocks instantiated as uncommented code. Your favorite
+editor opens on files having at least one TODO.
+
+For instance, when executing
+
+```sh
+jeny -d name:hello snippet method .
+```
+
+the following code block...
+
+```
+#jeny(method) def ${name}
+#jeny(method)   # TODO
+#jeny(method) end
+```
+
+... will generate the code below in the file where it is found,
+while preserving the jeny code block for subsequent calls:
+
+```
+def hello
+  # TODO
+end
+```
+
+The `s[snippet]` command is also able to generate fresh new files,
+provided they end with `.jeny` and have a clearly snippet identifier
+as first line. For instance, a file called `test.rb.jeny` will be
+instantiated when  generating a `method` snippet if it contains the
+following first line:
+
+```
+#jeny(method)
+```
+
+## Templating language
+
+The current template language uses [WLang](https://github.com/blambeau/wlang)
+with a very simple dialect. Jeny only supports simple variable for now. It
+does not support iterations and conditionals, on intent (?).
+
+Let's say you specify a `-d op_name:my_method` commandline option, the
+following casing tags are recognized:
+
+```
+${op_name}     ->    my_method   (snake)
+${opname}      ->    mymethod    (flat)
+${opName}      ->    myMethod    (camel)
+${OpName}      ->    MyMethod    (pascal)
+${OP_NAME}     ->    MY_METHOD   (screaming)
+${OP NAME}     ->    MYMETHOD    (upper)
+${OPNAME}      ->    MYMETHOD    (upper flat)
+${op-name}     ->    my-method   (kebab)
+${Op-Name}     ->    My-Method   (header)
+${OP-NAME}     ->    MY-METHOD   (cobol)
+${OP|NAME}     ->    MY|METHOD   (donner)
+```
+
+## Dynamic file names
+
+If you need generated file name names (and/or ancestor folders), you can use
+the very same tags as those documented in previous section.
+
+* In scaffolding mode, all files can have dynamic names.
+* In snippets mode, only files with a `.jeny` ext can.
+
+## Atomic snippets generation
+
+The `--git` commandline option (or equivalent configuration, see section
+below) can be used to generate snippets in an atomic way.
+
+```sh
+jeny --git -d ... s snipname
+```
+
+Doing so will:
+- stash any current change
+- generate code snippets
+- commit the result
+- unstash stashed changes
+
+If anything fails, all changes are reverted before unstashing.
+
+Please also check the `--no-stash` and `--no-commit` commandline options.
+
+**IMPORTANT** You must execute `jeny` with a git project as current folder.
+
+**IMPORTANT** Please use this option with case, as it is still experimental.
+
+## Configuration and available options
+
+Jeny behavior can be tuned in three different ways (by ascending order of
+priority): environment variables, a .jeny configuration file, and command
+line options.
+
+For full details, please check the documentation of `Jeny::Configuration`.
+
+### Environment variables
+
+* `JENY_EDITOR`, `GIT_EDITOR`, `EDITOR` are inspected in that order to
+  find which source code editor to use
+
+* `JENY_STATE_MANAGER=none|git` is used to know which state manager to
+  use. See `Jeny::StateManager`
+
+### .jeny configuration file
+
+At start `jeny` looks for a `.jeny` configuration file in the current
+folder and all ancestors, and uses it to override default configuration
+infered from environment variables.
+
+```
+Jeny::Configuration.new do |c|
+  # c is a Jeny::Configuration instance
+  #
+  # many accessors are available for options
+end
+```
+
+### Commandline options
+
+Options passed on the commandline always override the configuration
+obtained through environment variables and the .jeny file.
+
+For a full list of options, check the help:
+
+```
+jeny --help
+```
+
+## Public API
+
+This library uses SemVer 2.0. Its public API is:
+
+* The command line tool and its options
+* The Configuration class powering the .jeny file
+* All recognized environment variables and their effect on configuration
+* The syntax and semantics of #jeny blocks and file header
+* The syntax and semantics of the templating language
+
+## Contributing
+
+Use github issues and pull requests for contributions. Please favor pull
+requests if possible for small changes. Make sure to keep in touch with us
+before making big changes though, as they might not be aligned with our
+roadmap, or conflict with open pull requests.
 
 ## Licence
 

data/bin/jeny

@@ -0,0 +1,3 @@
+#/usr/bin/env ruby
+require 'jeny'
+Jeny::Command.call(ARGV.dup)

data/lib/jeny.rb

@@ -1,3 +1,14 @@
+require 'path'
+require 'wlang'
+require 'ostruct'
 module Jeny
+  class Error < StandardError; end
 end
 require_relative 'jeny/version'
+require_relative 'jeny/state_manager'
+require_relative 'jeny/configuration'
+require_relative 'jeny/caser'
+require_relative 'jeny/dialect'
+require_relative 'jeny/file'
+require_relative 'jeny/code_block'
+require_relative 'jeny/command'

data/lib/jeny/caser.rb

@@ -0,0 +1,113 @@
+module Jeny
+  module Caser
+
+    def self.for_hash(hash)
+      hash.each_pair.each_with_object({}) do |(k,v),memo|
+        case v
+        when String
+          Caser.methods(false).each do |m|
+            next if m == :for_hash or m == :gen_parts
+            memo[Caser.send(m, k)] = Caser.send(m, v)
+          end
+        when Hash
+          memo[k] = for_hash(v)
+        when Array
+          memo[k] = v.map{|x| for_hash(x) }
+        else
+          v
+        end
+      end
+    end
+
+    def self.gen_parts(src)
+      src.split(/[ -_]/)
+    end
+
+    def flat(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.join
+    end
+    module_function :flat
+
+    def upper(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:upcase).join(" ")
+    end
+    module_function :upper
+
+    def upperflat(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:upcase).join
+    end
+    module_function :upperflat
+
+    def screaming(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:upcase).join("_")
+    end
+    module_function :screaming
+
+    def macro(src)
+      screaming(src)
+    end
+    module_function :macro
+
+    def constant(src)
+      screaming(src)
+    end
+    module_function :constant
+
+    def underscore(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.join("_")
+    end
+    module_function :underscore
+
+    def snake(src)
+      underscore(src)
+    end
+    module_function :snake
+
+    def camel(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.first + parts[1..-1].map(&:capitalize).join
+    end
+    module_function :camel
+
+    def pascal(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:capitalize).join
+    end
+    module_function :pascal
+
+    def kebab(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.join("-")
+    end
+    module_function :kebab
+
+    def train(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:capitalize).join("-")
+    end
+    module_function :train
+
+    def header(src)
+      train(src)
+    end
+    module_function :header
+
+    def cobol(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.map(&:upcase).join("-")
+    end
+    module_function :cobol
+
+    def donner(src)
+      parts = gen_parts(src) unless src.is_a?(Array)
+      parts.join("|")
+    end
+    module_function :donner
+
+  end # module Caser
+end # module Jeny

data/lib/jeny/code_block.rb

@@ -0,0 +1,29 @@
+module Jeny
+  class CodeBlock
+
+    def initialize(source, path, line, asset)
+      @source = source
+      @path = path
+      @line = line
+      @asset = asset
+    end
+    attr_reader :source, :path, :line, :asset
+
+    def line_index
+      line - 1
+    end
+
+    def instantiate(data)
+      case d = data[asset]
+      when NilClass
+      when Hash
+        Dialect.render(source, d)
+      when Array
+        d.map{|item| instantiate(asset => item) }.join("\n")  
+      else
+        raise Error, "Unexpected block asset: `#{asset} = #{d}`"
+      end
+    end
+
+  end # class CodeBlock
+end # module Jeny

data/lib/jeny/command.rb

@@ -0,0 +1,111 @@
+require 'optparse'
+module Jeny
+  class Command
+
+    def initialize
+      @config = nil
+      @jeny_data = {}
+    end
+    attr_reader :jeny_data
+    attr_reader :config
+
+    def self.call(argv)
+      new.call(argv)
+    rescue Error => ex
+      puts ex.message
+      exit(1)
+    end
+
+    def call(argv)
+      args = parse_argv!(argv, load_config!)
+      case command = args.first
+      when "g", "generate"
+        _, from, to = args
+        from, to = Path(from), Path(to)
+        raise Error, "No such template `#{from}`" unless from.directory?
+        to.mkdir_p
+        Generate.new(@config, jeny_data, from, to).call
+      when "s", "snippets"
+        _, asset, source = args
+        raise Error, "Asset must be specified" if asset.nil? or Path(asset).exist?
+        source ||= Path.pwd
+        Snippets.new(@config, jeny_data, asset, Path(source)).call
+      else
+        raise Error, "Unknown command `#{command}`"
+      end
+    end
+
+    def parse_argv!(argv, config = Configuration.new)
+      @config = config
+      option_parser(config).parse!(argv)
+    end
+
+  private
+
+    def load_config!
+      jeny_file = Path.pwd/".jeny"
+      jeny_file = Path.backfind(".jeny") unless jeny_file.file?
+      unless jeny_file
+        puts "Using default Jeny configuration"
+        return Configuration.new
+      end
+      unless (cf = Path(jeny_file)).file?
+        raise Error, "No such file `#{jeny_file}`"
+      end
+      unless (config = Kernel.eval(cf.read)).is_a?(Configuration)
+        raise Error, "Config file corrupted, no Configuration returned"
+      end
+      puts "Using #{jeny_file}"
+      config.tap{|c|
+        c.jeny_file = cf
+      }
+    end
+
+    def option_parser(config)
+      option_parser ||= OptionParser.new do |opts|
+        opts.banner = <<~B
+          Usage: jeny [options] g[enerate] SOURCE TARGET
+                 jeny [options] s[nippets] ASSET [TARGET]
+        B
+        opts.on("-d key:value", "Add generation data") do |pair|
+          k, v = pair.split(':')
+          @jeny_data[k] = v
+        end
+        opts.on("-f datafile", "Take generation data from a file") do |file|
+          file = Path(file)
+          raise Error, "No such file: #{file}" unless file.exists?
+          require 'yaml' if file.ext == 'yml' || file.ext == 'yaml'
+          require 'json' if file.ext == 'json'
+          @jeny_data = file.load
+        end
+        opts.on("--git", "Use git as state manager") do
+          config.state_manager = :git
+        end
+        opts.on("--edit-if=MATCH", "Edit files matching a given term") do |s|
+          config.edit_changed_files = ->(f,c){ c =~ Regexp.new(s) }
+        end
+        opts.on("--[no-]edit", "Edit files having a TODO") do |s|
+          config.edit_changed_files = s ? Configuration::DEFAULT_EDIT_PROC : false
+        end
+        opts.on("--[no-]stash", "Stash before generating snippets") do |s|
+          config.state_manager_options[:stash] = s
+        end
+        opts.on("--[no-]commit", "Commit generated snippets") do |c|
+          config.state_manager_options[:commit] = c
+        end
+        opts.on("-v", "--version", "Prints version") do
+          puts "Jeny v#{VERSION}"
+          exit
+        end
+        opts.on("-h", "--help", "Prints this help") do
+          puts opts
+          exit
+        end
+      end
+    end
+
+  end # class Command
+end # module Jeny
+require_relative 'command/support'
+require_relative 'command/generate'
+require_relative 'command/snippets'

data/lib/jeny/command/generate.rb

@@ -0,0 +1,35 @@
+module Jeny
+  class Command
+    class Generate
+      include Support
+
+      def initialize(config, data, from, to)
+        @config = config
+        @data = Caser.for_hash(data)
+        @from = from
+        @to = to
+      end
+      attr_reader :config, :data, :from, :to
+
+      def call
+        puts
+        changed = []
+        from.glob("**/*") do |source|
+          target = target_for(source)
+          puts "creating #{simplify_path(target)}"
+          if source.directory?
+            target.mkdir_p
+          else
+            target.parent.mkdir_p
+            file = File::Full.new(source, config)
+            target_content = file.instantiate(data)
+            target.write(target_content)
+            changed << [target, target_content]
+          end
+        end
+        edit_changed_files(changed)
+      end
+
+    end # class Generate
+  end # class Command
+end # module Jeny

data/lib/jeny/command/snippets.rb

@@ -0,0 +1,70 @@
+module Jeny
+  class Command
+    class Snippets
+      include Support
+
+      def initialize(config, data, asset, from)
+        @config = config
+        @data = { asset => Caser.for_hash(data) }
+        @asset = asset
+        @from = from
+      end
+      attr_reader :config, :data, :asset, :from
+
+      alias :to :from
+
+      def call
+        puts
+        sm, state = config.state_manager, OpenStruct.new
+        sm.stash(state) if config.sm_stash?
+
+        changed = []
+        from.glob("**/*").each do |source|
+          next if source.directory?
+          next if config.ignore_file?(source)
+          pair = snippet_it(source)
+          changed << pair if pair
+        end
+
+        sm.commit(changed.map(&:first), state) if config.sm_commit?
+
+        edit_changed_files(changed)
+      rescue
+        sm.reset(changed.map(&:first), state)
+        raise
+      ensure
+        sm.unstash(state) if config.sm_stash?
+      end
+
+      def snippet_it(source)
+        target, target_content = nil
+        if source.ext =~ /\.?jeny/
+          file = File::Full.new(source, config)
+          if file.has_jeny_context?
+            ctx = file.instantiate_context(data)
+            if ctx
+              target_content = file.instantiate(ctx)
+              target = target_for(source, ctx)
+              target.parent.mkdir_p
+              target.write(target_content)
+              puts "snippets #{simplify_path(target)}"
+            end
+          end
+        else
+          file = File::WithBlocks.new(source, config)
+          if file.has_jeny_blocks?
+            target_content = file.instantiate(data)
+            target = target_for(source)
+            target.write(target_content)
+            puts "snippets #{simplify_path(target)}"
+          end
+        end
+        target ? [target, target_content] : nil
+      rescue => ex
+        msg = "Error in `#{simplify_path(source)}`: #{ex.message}"
+        raise Error, msg
+      end
+
+    end # class Snippets
+  end # class Command
+end # module Jeny

data/lib/jeny/command/support.rb

@@ -0,0 +1,30 @@
+module Jeny
+  class Command
+    module Support
+
+      def target_for(source, data = self.data)
+        relative = source.relative_to(from)
+        relative.each_filename.map{|f|
+          Dialect.render(f.gsub(/.jeny$/, ""), data)
+        }.inject(to){|t,part| t/part }
+      end
+
+      def simplify_path(path)
+        if path.to_s.start_with?(Path.pwd.to_s)
+          path.relative_to(Path.pwd)
+        else
+          path
+        end
+      end
+      module_function :simplify_path
+
+      def edit_changed_files(changed)
+        to_open = changed
+          .select{|pair| config.should_be_edited?(*pair) }
+          .map{|pair| simplify_path(pair.first) }
+        config.open_editor(to_open) unless to_open.empty?
+      end
+
+    end # module Support
+  end # class Command
+end # module Jeny

data/lib/jeny/configuration.rb

@@ -0,0 +1,132 @@
+module Jeny
+  class Configuration
+
+    DEFAULT_EDIT_PROC = ->(_,content) {
+      content =~ /TODO/
+    }
+
+    def initialize
+      @jeny_block_delimiter = "#jeny"
+      @ignore_pattern = /^(vendor|\.bundle)/
+      @editor_command = default_editor_command
+      @edit_changed_files = DEFAULT_EDIT_PROC
+      @state_manager = default_state_manager
+      @state_manager_options = {
+        stash: true,
+        commit: true
+      }
+      yield(self) if block_given?
+    end
+    attr_accessor :jeny_file
+
+    # The delimiter used for jeny block in source code files.
+    #
+    # Defaults to `#jeny`
+    attr_accessor :jeny_block_delimiter
+
+    # Regular expression matching files that can always be ignored by Snippets.
+    #
+    # Defaults to /^(vendor|\.bundle)/
+    attr_accessor :ignore_pattern
+
+    # Shell command to open the source code editor.
+    #
+    # Default value checks the JENY_EDITOR, GIT_EDITOR, EDITOR
+    # environment variables, and fallbacks to "code".
+    attr_accessor :editor_command
+
+    def default_editor_command
+      ENV['JENY_EDITOR'] || ENV['GIT_EDITOR'] || ENV['EDITOR']
+    end
+
+    # State manager to use.
+    #
+    # Default value check the JENY_STATE_MANAGER environment variable:
+    # - `none`, no state management is done
+    # - `git`, git is used to stash/unstash/commit/reset
+    #
+    # Defaults to `none`, that is, to an empty state manager.
+    attr_reader :state_manager
+
+    # Options for the state manager.
+    #
+    # This is a Hash, with `:stash` and `:commit` keys mapping to
+    # either true of false.
+    #
+    # Both are true by default.
+    attr_reader :state_manager_options
+
+    # :nodoc:
+    def sm_stash?
+      state_manager_options[:stash]
+    end
+
+    # :nodoc:
+    def sm_commit?
+      state_manager_options[:commit]
+    end
+
+    # Sets the state manager to use. `sm` can be a state manager instance,
+    # of a string of symbol with same value as JENY_STATE_MANAGER env
+    # variable.
+    def state_manager=(sm)
+      @state_manager = case sm
+      when StateManager then sm
+      when :git, "git"  then StateManager::Git.new(self)
+      else StateManager.new(self)
+      end
+    end
+
+    def default_state_manager
+      case ENV['JENY_STATE_MANAGER']
+      when "git"
+        StateManager::Git.new(self)
+      else
+        StateManager.new(self)
+      end
+    end
+
+    # Whether files generated/modified must be edited right after.
+    #
+    # Accepted values are:
+    # - `false`, then source code edition is disabled
+    # - `true`, then all files are open after being snipetted
+    # - `/.../`, then only files whose name match the regexp are open
+    # - `->(f,c){}`, the file `f` whose generated content is `c` is open
+    #   is the proc returns a truthy value.
+    #
+    # Defaults to a Proc that opens files having at least one TODO.
+    attr_accessor :edit_changed_files
+
+    alias :edit_changed_files? :edit_changed_files
+
+    # Should `file` be ignored?
+    def ignore_file?(file)
+      file = Command::Support.simplify_path(file)
+      file.to_s =~ ignore_pattern
+    end
+
+    # Whether file should be edited after being snippetted
+    def should_be_edited?(file, content)
+      return false if editor_command.nil?
+      case edit_changed_files
+      when false, true, nil
+        !!edit_changed_files
+      when Regexp
+        !!(file.to_s =~ edit_changed_files)
+      when Proc
+        !!edit_changed_files.call(file, content)
+      else
+        raise Error, "Wrong edit_changed_files `#{edit_changed_files}`"
+      end
+    end
+
+    def open_editor(files)
+      unless editor_command
+        raise Error, "source code editor is not enabled"
+      end
+      fork{ exec(editor_command + " " + files.join(" ")) }
+    end
+
+  end # class Configuration
+end # module Jeny

data/lib/jeny/dialect.rb

@@ -0,0 +1,12 @@
+module Jeny
+  class Dialect < WLang::Dialect
+
+    def varvalue(buf, fn)
+      var_name  = render(fn)
+      var_value = evaluate(var_name)
+      buf << var_value.to_s
+    end
+    tag '$', :varvalue
+
+  end
+end

data/lib/jeny/file.rb

@@ -0,0 +1,17 @@
+module Jeny
+  class File
+
+    def initialize(path, config)
+      @path = path
+      @config = config
+    end
+    attr_reader :path, :config
+  
+    def rewrite(data, to)
+      to.write(instantiate(data))
+    end
+
+  end # class File
+end # module Jeny
+require_relative 'file/with_blocks'
+require_relative 'file/full'

data/lib/jeny/file/full.rb

@@ -0,0 +1,30 @@
+module Jeny
+  class File
+    class Full < File
+
+      def context_rgx
+        /^#{config.jeny_block_delimiter}\(([a-z]+)\)\s*$/
+      end
+
+      def has_jeny_context?
+        path.readlines.first =~ context_rgx
+      end
+
+      def instantiate_context(data)
+        if path.readlines.first =~ context_rgx
+          data[$1]
+        else
+          data
+        end
+      end
+
+      def instantiate(data)
+        path.readlines.map{|l|
+          next if l =~ context_rgx
+          Dialect.render(l, data)
+        }.compact.join("")
+      end
+
+    end # class Full
+  end # class File
+end # module Jeny

data/lib/jeny/file/with_blocks.rb

@@ -0,0 +1,71 @@
+module Jeny
+  class File
+    class WithBlocks < File
+
+      def has_jeny_blocks?
+        !jeny_blocks.empty?
+      end
+  
+      def jeny_blocks
+        @jeny_blocks ||= _parse_jeny_blocks(path.readlines, 0, [])
+      end
+  
+      def instantiate(data)
+        return path.read unless has_jeny_blocks?
+        _instantiate(data, path.readlines, 0, jeny_blocks, []).join("")
+      end
+  
+    private
+  
+      def _parse_jeny_blocks(lines, index, blocks)
+        if index >= lines.size
+          blocks
+        elsif lines[index] =~ jeny_block_regex
+          source, new_index = _parse_jeny_block(lines, index)
+          blocks << CodeBlock.new(source, path, index+1, $1)
+          _parse_jeny_blocks(lines, new_index+1, blocks)
+        else
+          _parse_jeny_blocks(lines, index+1, blocks)
+        end
+      end
+  
+      def _parse_jeny_block(lines, index, str = "")
+        if lines[index] =~ jeny_block_regex
+          _parse_jeny_block(lines, index+1, str + lines[index])
+        else
+          source = str.split("\n").map{|s|
+            s.gsub(jeny_block_gsub, "")
+          }
+          source = source.size == 1 ? source.first : source.join("\n")+"\n"
+          [source, index]
+        end
+      end
+  
+      def _instantiate(data, lines, index, blocks, acc)
+        block = blocks.first
+        if block.nil?
+          lines[index..-1].each{|l| acc << l }
+          acc
+        elsif block.line_index == index
+          if i = block.instantiate(data)
+            acc << i << "\n"
+          end
+          acc << lines[index]
+          _instantiate(data, lines, index+1, blocks[1..-1], acc)
+        else
+          lines[index...block.line_index].each{|l| acc << l }
+          _instantiate(data, lines, block.line_index, blocks, acc)
+        end
+      end
+  
+      def jeny_block_regex
+        @jeny_block_regex ||= %r{^\s*#{config.jeny_block_delimiter}\(([a-z]+)\)}m
+      end
+  
+      def jeny_block_gsub
+        @jeny_block_gsub ||= %r{#{config.jeny_block_delimiter}(\([a-z]+\))[ ]?}
+      end
+
+    end # class WithBlocks
+  end # class File
+end # module Jeny

data/lib/jeny/state_manager.rb

@@ -0,0 +1,51 @@
+module Jeny
+  # State Manager abstraction used by Snippets to work atomically.
+  #
+  # An implementation is supposed to be stateless (no instance
+  # variables). The methods receive a `state` argument, which is
+  # an OpenStruct that can be used to track state accros calls.
+  #
+  # See StateManager::Git for a typical implementation using git.
+  class StateManager
+
+    def initialize(config)
+      @config = config
+    end
+    attr_reader :config
+
+    # Make sure the working directory is clean, for instance by stashing
+    # any pending change.
+    #
+    # The method MAY raise an Error if the current state is not clean and
+    # nothing can be done about it.
+    #
+    # The method SHOULD NOT raise an Error is nothing needs to be done.
+    def stash(state)
+    end
+
+    # Unstash changes stashed the last time `stash` has been called.
+    #
+    # This method MAY NOT raise errors since a previous `stash`
+    # has been successfuly done earlier.
+    #
+    # The method SHOULD NOT raise an Error is nothing needs to be done.
+    def unstash(state)
+    end
+
+    # Reset all changes to files in `changed`, typically because an error
+    # occured.
+    #
+    # The method SHOULD NOT raise an Error in any case.
+    def reset(changed, state)
+    end
+
+    # Commit all changes to the files in `changed`.
+    #
+    # The method MAY raise an Error, but it will force jeny to reset
+    # everything.
+    def commit(changed, state)
+    end
+
+  end # class StateManage
+end # module Jeny
+require_relative 'state_manager/git'

data/lib/jeny/state_manager/git.rb

@@ -0,0 +1,39 @@
+module Jeny
+  class StateManager
+    # StateManager implementation that uses git to manage state management.
+    #
+    # This state management requires executing jeny in the git root folder.
+    class Git < StateManager
+
+      # Executes a `git stash`
+      def stash(state)
+        system("git diff --exit-code")
+        state.stashed = ($?.exitstatus != 0)
+        system("git stash") if state.stashed
+      end
+
+      # Executes a `git stash pop`
+      def unstash(state)
+        system("git stash pop") if state.stashed
+      end
+
+      # Reset all changes through a `git reset --hard`.
+      #
+      # WARN: changes not related to `changed` are reverted too,
+      # which should be nothing since a stash has been done before.
+      def reset(changed, state)
+        changed.each{|f| f.rm_rf if f.exists? }
+        system("git reset --hard")
+      end
+
+      # Commits all changes, using `git add` the `git commit`
+      def commit(changed, state)
+        return if changed.empty?
+        system("git add #{changed.join(" ")}")
+        msg = "jeny #{$*.join(' ')}"
+        system("git commit -m '#{msg}'")
+      end
+
+    end # class Git
+  end # class StateManager
+end # module Jeny

data/lib/jeny/version.rb

@@ -1,7 +1,7 @@
 module Jeny
   module Version
-    MAJOR = 0
-    MINOR = 1
+    MAJOR = 1
+    MINOR = 0
     TINY  = 0
   end
   VERSION = "#{Version::MAJOR}.#{Version::MINOR}.#{Version::TINY}"

data/tasks/test.rake

@@ -6,10 +6,17 @@ namespace :test do
   desc "Runs unit tests"
   RSpec::Core::RakeTask.new(:unit) do |t|
     t.pattern = "spec/unit/**/test_*.rb"
-    t.rspec_opts = ["-Ilib", "-Ispec/unit", "--color", "--backtrace", "--format=progress"]
+    t.rspec_opts = ["-Ilib", "-Ispec", "--color", "--backtrace", "--format=progress"]
   end
   tests << :unit
 
+  desc "Runs command tests"
+  RSpec::Core::RakeTask.new(:command) do |t|
+    t.pattern = "spec/command/**/test_*.rb"
+    t.rspec_opts = ["-Ilib", "-Ispec", "--color", "--backtrace", "--format=progress"]
+  end
+  tests << :command
+
   task :all => tests
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jeny
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Bernard Lambeau
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-12-29 00:00:00.000000000 Z
+date: 2020-12-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: path
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: wlang
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -54,7 +68,8 @@ dependencies:
         version: '3.7'
 description: Simple scaffolding and code generation
 email: blambeau@gmail.com
-executables: []
+executables:
+- jeny
 extensions: []
 extra_rdoc_files: []
 files:
@@ -62,7 +77,21 @@ files:
 - LICENSE.md
 - README.md
 - Rakefile
+- bin/jeny
 - lib/jeny.rb
+- lib/jeny/caser.rb
+- lib/jeny/code_block.rb
+- lib/jeny/command.rb
+- lib/jeny/command/generate.rb
+- lib/jeny/command/snippets.rb
+- lib/jeny/command/support.rb
+- lib/jeny/configuration.rb
+- lib/jeny/dialect.rb
+- lib/jeny/file.rb
+- lib/jeny/file/full.rb
+- lib/jeny/file/with_blocks.rb
+- lib/jeny/state_manager.rb
+- lib/jeny/state_manager/git.rb
 - lib/jeny/version.rb
 - tasks/gem.rake
 - tasks/test.rake
@@ -70,7 +99,7 @@ homepage: http://github.com/enspirit/jeny
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -85,8 +114,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.1
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Simple scaffolding and code generation
 test_files: []