clerq 0.1.0

data/lib/clerq/interactors/query_nodes.rb

@@ -0,0 +1,62 @@
+# encoding: UTF-8
+
+require_relative "interactor"
+require_relative "join_nodes"
+
+module Clerq
+  module Interactors
+
+    class QueryNodes < Interactor
+
+      def call
+        proc = prepare_query
+        join = JoinNodes.()
+        list = join.select{|node| proc.call(node)}
+        return Node.new(title: "#{Clerq.settings.title}. Query: #{@query}") if list.empty?
+        make_response(list)
+      end
+
+      protected
+
+      def initialize(query:)
+        raise ArgumentError, "Invalid argument :query" if !(query.is_a?(String) && !query.empty?)
+        @query = query
+      end
+
+      def prepare_query
+        proc = Proc.new {|node| eval(@query)}
+        test = Node.new
+        test.select{|node| proc.call(node)}
+        proc
+      rescue Exception => e
+        msg = <<~EOF
+        Invalid query #{@query} (#{e.message})
+        It must eval as 'Proc.new{|node| eval(<query>)}'
+        Valid query examples are following:
+        node.id == 'uc'
+        node.belong?('uc')
+        node.belong?('ud') && node[:source] == 'sales'
+        EOF
+        raise self.class::Failure, msg
+      end
+
+      # @param nodes [Array<Node>] result of node.select
+      # @return [Node] node that includes all selected nodes
+      def make_response(nodes)
+        if nodes.size == 1
+          node = nodes.first
+          node.orphan!
+          return node
+        end
+        Node.new(id: @query).tap{|node|
+          nodes.each{|n|
+            n.orphan!
+            node << n
+          }
+        }
+      end
+
+    end
+
+  end
+end

data/lib/clerq/properties.rb

@@ -0,0 +1,21 @@
+module Clerq
+
+  module Properties
+    def property(name, options = {}, &validation)
+      default_value = options[:default]
+      define_method name do
+        v = instance_variable_get("@#{name}")
+        v = default_value unless v
+        v
+      end
+
+      define_method "#{name}=" do |val|
+        if validation && !validation.call(val)
+          raise ArgumentError, "Invalid property value #{name}: #{val}"
+        end
+        instance_variable_set("@#{name}", val)
+      end
+    end
+  end
+
+end

data/lib/clerq/repositories.rb

@@ -0,0 +1,5 @@
+require_relative 'repositories/repository'
+require_relative 'repositories/in_memory'
+require_relative 'repositories/node_reader'
+require_relative 'repositories/node_repository'
+require_relative 'repositories/template_repository'

data/lib/clerq/repositories/in_memory.rb

@@ -0,0 +1,45 @@
+require_relative 'repository'
+
+module Clerq
+  module Repositories
+
+    class InMemory < Repository
+
+      def initialize
+        @counter = 0
+        @items = {}
+      end
+
+      def items(id = nil)
+        return @items[id] if id
+        @items.values
+      end
+
+      def find(id)
+        @items[id]
+      end
+
+      def save(e)
+        raise ArgumentError, "Invalid argument" unless entity?(e)
+        id = has_id?(e) ? e.id : counter
+        @items[id] = e
+      end
+
+      protected
+
+        def counter
+          @counter += 1
+        end
+
+        def has_id?(e)
+          e.id && !e.id.empty?
+        end
+
+        def entity?(e)
+          e.is_a?(Object) && e.respond_to?(:id)
+        end
+
+    end
+
+  end
+end

data/lib/clerq/repositories/node_reader.rb

@@ -0,0 +1,107 @@
+# encoding: UTF-8
+
+require_relative '../entities'
+include Clerq::Entities
+
+module Clerq
+  module Repositories
+  end
+end
+
+class Clerq::Repositories::NodeReader
+
+  # @param [String] file_name with node
+  # @return [Array<Node>] from file
+  def self.call(file_name)
+    new(file_name).call
+  end
+
+  # @param [Enumerator] lines; for testing purpose
+  # @return [Array<Node>] from file
+  def call(text = File.foreach(@file_name))
+    STDOUT.print "Reading #{@file_name} ..."
+
+    read_nodes(text).each do |node_text|
+      level, node = parse_node(node_text)
+      next unless node
+      node[:file_name] = @file_name
+      insert_node(node, level)
+    end
+
+    STDOUT.puts @errors.empty? ? "OK" : "Errors found"
+    unless @errors.empty?
+      STDERR.puts "Errors reading #{@file_name}"
+      STDERR.puts @errors.map{|e| "\t#{e}"}.join("\n")
+    end
+
+    nodes = Array.new(@node.items)
+    nodes.each(&:orphan!)
+    nodes
+  end
+
+  protected
+
+    def initialize(file_name)
+      @file_name = file_name
+      @node = Node.new(id: file_name)
+      @errors = []
+    end
+
+    # @param [Enumerator<String>] text
+    # @return [Array<String>] where each item represents one node
+    def read_nodes(text)
+      [].tap do |nodes|
+        quote, body = false, ''
+        text.each do |line|
+          if line.start_with?('#') && !quote && !body.empty?
+            nodes << body
+            body = ''
+          end
+          body << line
+          quote = !quote if line.start_with?('```')
+        end
+        nodes << body unless body.empty?
+      end
+    end
+
+    def insert_node(node, level)
+      parent = @node
+      while parent.last_item && (parent.nesting_level + 1) < level
+        parent = parent.last_item
+      end
+      unless (parent.nesting_level + 1) == level
+        @errors << "invalid header level: #{'#' * level} [#{node.id}]"
+        parent = @node
+      end
+      parent << node
+    end
+
+    def parse_node(text)
+      text += "\n" unless text.end_with?("\n")
+      parts = NODE_REGX.match(text)
+      lv = parts[1] || ''
+      id = parts[3] || ''
+      title = parts[4] || ''
+      body = parts[7] || ''
+      meta = {}
+      meta.merge!(parse_meta(parts[6])) if parts[6]
+      [lv.size, Node.new(id: id, title: title, body: body.strip, meta: meta)]
+    rescue StandardError
+      @errors << "invalid node format:\n#{text}"
+      [nil, nil]
+    end
+
+    def parse_meta(text)
+      text.strip.split(/[;\n]/).inject({}) do |h, i|
+        pair = /\s?(\w*):\s*(.*)/.match(i)
+        h.merge(pair[1].to_sym => pair[2])
+      end || {}
+    rescue StandardError
+      @errors << "invalid meta format:\n{{#{text}}}"
+      {}
+    end
+
+    NODE_REGX =
+      /^(\#+)[ ]*(\[([^\[\]\s]*)\][ ]*)?([\s\S]*?)\n({{([\s\S]*?)}})?(.*)$/m
+
+end

data/lib/clerq/repositories/node_repository.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+require_relative '../entities'
+require_relative 'repository'
+include Clerq::Entities
+
+module Clerq
+  module Repositories
+
+    class NodeRepository < Repository
+      def initialize(path = Dir.pwd)
+        @path = path
+        @items = []
+      end
+
+      def items(id = nil)
+        load_nodes if @items.empty?
+        return @items.find {|i| i.id == id} if id
+        @items
+      end
+
+      def save(node)
+        raise ArgumentError, "Invalid argument" unless node.is_a? Node
+        Dir.chdir(@path){ File.write(node.id + '.md', markdown(node))}
+      end
+
+      protected
+
+        def load_nodes
+          @items = []
+          Dir.chdir(@path) do
+            Dir.glob('**/*.md').each do |f|
+              # TODO: what to do with errors?
+              nodes = NodeReader.(f)
+              nodes.each{|n| @items << n}
+            end
+          end
+        end
+
+        def markdown(n)
+          [].tap do |out|
+            out << "#{'#' * (n.nesting_level + 1)} [#{n.id}] #{n.title}"
+            unless n.meta.empty?
+              out << '{{'
+              n.meta.each{|k,v| out << "#{k}: #{v}"}
+              out << '}}'
+              out << "\n"
+            end
+            out << n.body
+          end.join("\n")
+        end
+
+    end
+
+  end
+end

data/lib/clerq/repositories/repository.rb

@@ -0,0 +1,11 @@
+module Clerq
+  module Repositories
+
+    class Repository
+      def items(id = nil); end
+      def find(id); end
+      def save(e); end
+    end
+
+  end
+end

data/lib/clerq/repositories/template_repository.rb

@@ -0,0 +1,53 @@
+# encoding: UTF-8
+
+require_relative '../entities'
+require_relative 'repository'
+include Clerq::Entities
+
+module Clerq
+  module Repositories
+
+    class TemplateRepository < Repository
+      attr_reader :path
+      def initialize(path = Dir.pwd)
+        @items = {}
+        @path = path
+      end
+
+      # TODO move id parameter to #find
+      def items(id = nil)
+        load if @items.empty?
+        return find(id) if id
+        @items.values
+      end
+
+      def find(id)
+        return @items[id] if @items[id]
+        PATTERNS.each do |p|
+          i0 = "#{id}#{p[1..-1]}"
+          return @items[i0] if @items[i0]
+        end
+        return nil
+      end
+
+      def save(tt)
+        raise ArgumentError, "Invalid argument" unless tt.is_a? Template
+        Dir.chdir(@path){ File.write(tt.id, tt.body) }
+      end
+
+      protected
+
+      def load
+        Dir.chdir(@path) do
+          Dir.glob(PATTERNS)
+            .map {|f| Template.new(id: f, body: File.read(f))}
+            .each{|t| @items[t.id] = t}
+        end
+      end
+
+      PATTERNS = ['*.tt', '*.erb']
+
+    end
+
+  end
+end

data/lib/clerq/settings.rb

@@ -0,0 +1,56 @@
+# encoding: UTF-8
+
+require 'pp'
+require 'yaml'
+require_relative 'properties'
+
+module Clerq
+
+  class Settings
+    extend Properties
+
+    STORAGE = 'clerq.yml'.freeze
+
+    # binary document settings that can be changed through 'clerq.yml'
+    property :document, default: 'Clеrk SRS'
+    property :template, default: 'default.md.erb'
+    property :title, default: 'Clеrk SRS'
+
+    # folders structure
+    property :bin, default: 'bin'
+    property :src, default: 'src'
+    property :knb, default: 'knb'
+    property :lib, default: 'lib'
+    property :tt,  default: 'tt'
+    property :assets, default: 'bin/assets'
+
+    def folders
+      [bin, src, knb, lib, tt, assets]
+    end
+
+    def initialize
+      load
+    end
+
+    # TODO: load settings than can be changed by user
+    def load
+      return unless File.exist?(STORAGE)
+
+      props = YAML.load(File.read(STORAGE))
+      props.each{|k, v| instance_variable_set("@#{k}", v) }
+    end
+
+    # TODO: it saves only changed properties
+    #       properties with default values won't be saved
+    def save
+      props = {}
+      instance_variables.each{|v|
+        # props[v.to_s[1..-1]] = instance_variable_get("#{v}")
+        p = v.to_s[1..-1]
+        props[p] = self.send(p)
+      }
+      File.write(STORAGE, YAML.dump(props))
+    end
+  end
+
+end

data/lib/clerq/templater.rb

@@ -0,0 +1,32 @@
+# encoding: UTF-8
+
+require 'erb'
+
+module Clerq
+
+  # Compile @object to text in accordance with @template
+  # Usage
+  #   tt = "id: <%= @object.id %>\ntitle: <%= @object.title %>\n"
+  #   n = Node.new(id: 'uc', title: 'Use Cases', meta: {skip_meta: true})
+  #   text = Templater.call(tt, n) # or Templater.(tt, n)
+  class Templater
+
+    # @param tt [Template]
+    # @param object [Object]
+    # @result [String?]
+    def self.call(template, object)
+      new(template, object).call
+    end
+
+    def call
+      tt = ERB.new(@template, nil, "-")
+      tt.result(binding)
+    end
+
+    def initialize(template, object)
+      @template = template
+      @object = object
+    end
+  end
+
+end