umwelt 0.1.0

data/lib/umwelt/fragment/mapper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../structs/fragment'
+
+module Umwelt::Fragment
+  class Mapper < Umwelt::Abstract::Mapper
+    def call(data)
+      @struct = fill(Struct::Fragment, data)
+    end
+  end
+end

data/lib/umwelt/history.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Umwelt::History
+end
+
+require_relative './history/file'
+require_relative './history/mapper'
+require_relative './history/aggregate'
+require_relative './history/follow'
+require_relative './history/trace'

data/lib/umwelt/history/aggregate.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Umwelt::History
+  class Aggregate
+    include Hanami::Interactor
+
+    expose :fragments
+
+    def initialize
+      @engaged = {}
+      @forgotten = []
+    end
+
+    def call(episodes)
+      episodes.each do |episode|
+        index_engaged(episode.engaged)
+        collect_forgotten(episode.forgotten)
+      end
+
+      verify_consistency
+
+      @fragments = @engaged.slice(*alive_ids).values
+    end
+
+    private
+
+    def alive_ids
+      @engaged.keys - @forgotten
+    end
+
+    def fantom_ids
+      @forgotten - @engaged.keys
+    end
+
+    def verify_consistency
+      fantom_ids.empty? || error!("Aggregate failed: fantom ids: #{fantom_ids}")
+    end
+
+    def collect_forgotten(ids)
+      @forgotten.push(*ids)
+    end
+
+    def index_engaged(fragments)
+      fragments.each do |fragment|
+        @engaged[fragment[:id]] = fragment
+      end
+    end
+  end
+end

data/lib/umwelt/history/file.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Umwelt::History::File
+end
+
+require_relative './file/store'
+require_relative './file/restore'

data/lib/umwelt/history/file/restore.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../structs/history'
+
+module Umwelt::History::File
+  class Restore < Umwelt::Abstract::File::Restore
+    def initialize(
+      path: '.umwelt',
+      mapper: Umwelt::History::Mapper
+    )
+      super
+    end
+
+    def call
+      @struct = struct parse read full_path
+    end
+
+    def full_path
+      umwelt_root_path / 'history.json'
+    end
+  end
+end

data/lib/umwelt/history/file/store.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Umwelt::History::File
+  class Store < Umwelt::Abstract::File::Store
+    def call(struct)
+      mkpath full_path.dirname
+
+      full_path.write serialize destruct struct
+    end
+
+    def full_path
+      umwelt_root_path / 'history.json'
+    end
+  end
+end

data/lib/umwelt/history/follow.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Umwelt::History
+  class Follow
+    include Hanami::Interactor
+
+    expose :episodes
+
+    def initialize(
+      reader: Umwelt::Episode::File::Restore,
+      path: '.umwelt'
+    )
+      @reader = reader.new(path: path)
+    end
+
+    def call(phases)
+      @episodes = phases.map { |phase| episode(phase) }
+    end
+
+    private
+
+    def episode(phase)
+      restored = restore_episode(phase.id)
+      error! restored.errors if restored.failure?
+      restored.struct
+    end
+
+    def restore_episode(phase_id)
+      @reader.call(phase_id)
+    end
+  end
+end

data/lib/umwelt/history/mapper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../structs/phase'
+require_relative '../structs/project'
+
+module Umwelt::History
+  class Mapper < Umwelt::Abstract::Mapper
+    def call(
+      data = {
+        project: {},
+        phases: []
+      }
+    )
+
+      @struct = Struct::History.new(
+        project: project(data[:project]),
+        phases: phases(data[:phases])
+      )
+    end
+
+    def phases(phases_data)
+      phases_data.map { |phase_data| phase(phase_data) }
+    end
+
+    def project(data)
+      fill(Struct::Project, data)
+    end
+
+    def phase(data)
+      fill(Struct::Phase, data)
+    end
+  end
+end

data/lib/umwelt/history/trace.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Umwelt::History
+  class Trace
+    include Hanami::Interactor
+
+    expose :continuity
+
+    def initialize
+      @queue = Queue.new # for phases
+      @phases_index = {}
+      @continuity = []
+      @timeline = {}
+    end
+
+    def call(history, phase_id)
+      to_index(history.phases)
+
+      @queue.push from_index(phase_id)
+
+      loop do
+        break if @queue.empty?
+
+        process(@queue.pop)
+      end
+
+      @continuity = @timeline.values
+    end
+
+    def process(phase)
+      @timeline[phase[:id]] = phase
+      enqueue(phase)
+    end
+
+    def enqueue(phase)
+      @queue.push from_index(phase.merge_id) unless phase.merge_id.nil?
+      @queue.push from_index(phase.parent_id) unless phase.parent_id.nil?
+    end
+
+    def from_index(phase_id)
+      phase = @phases_index[phase_id]
+      phase || error!("Phase with ID #{phase_id} not exist, but referenced")
+    end
+
+    def to_index(phases)
+      phases.each do |phase|
+        @phases_index[phase[:id]] = phase
+      end
+    end
+  end
+end

data/lib/umwelt/node.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require_relative './structs/node'
+
+module Umwelt::Node
+  class Base < Struct::Node
+    def semantics
+      [:Plain]
+    end
+
+    def semantic(semantic_name)
+      semantic_klass(semantic_name).new(node: self)
+    end
+
+    def ancestry
+      if context_id
+        context.ancestry << self
+      else
+        [self]
+      end
+    end
+
+    def context
+      tree.node(context_id)
+    end
+
+    def label
+      self.class.name.split('::').last.to_sym
+    end
+
+    private
+
+    # Umwelt::Node::Space.new.semantic_klass(semantic)
+    # => Umwelt::Semantic::Plain::Space
+    def semantic_klass(semantic_name)
+      [semantic_name, label]
+        .reduce(Umwelt::Semantic) do |klass, name|
+        klass.const_get name
+      end
+    end
+  end
+end
+
+require_relative './node/build'
+require_relative './node/root'
+require_relative './node/space'

data/lib/umwelt/node/build.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Umwelt::Node
+  class Build
+    extend Forwardable
+    def_delegators Hanami::Utils::String, :classify
+
+    def initialize(tree)
+      @tree = tree
+    end
+
+    def call(frag)
+      node_klass(frag.kind).new(attributes(frag))
+    end
+
+    private
+
+    attr_reader :tree
+
+    def attributes(frag)
+      frag
+        .to_h
+        .slice(:id, :abstract_id, :context_id, :body, :note)
+        .merge(tree: tree)
+    end
+
+    def node_klass(kind)
+      Umwelt::Node.const_get classify(kind)
+    end
+  end
+end

data/lib/umwelt/node/root.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Umwelt::Node
+  class Root < Base
+  end
+end

data/lib/umwelt/node/space.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Umwelt::Node
+  class Space < Base
+  end
+end

data/lib/umwelt/phase.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Umwelt::Phase
+end
+
+require_relative './phase/mapper'

data/lib/umwelt/phase/mapper.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../structs/phase'
+
+module Umwelt::Phase
+  class Mapper < Umwelt::Abstract::Mapper
+    def call(data)
+      @struct = fill(
+        Struct::Phase,
+        data.merge(finished_at: time(data[:finished_at]))
+      )
+    end
+
+    def time(str)
+      Time.parse str if str
+    end
+  end
+end

data/lib/umwelt/project.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Umwelt::Project
+end
+
+require_relative './project/file'
+require_relative './project/mapper'

data/lib/umwelt/project/file.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Umwelt::Project::File
+end
+
+require_relative './file/store'
+require_relative './file/restore'

data/lib/umwelt/project/file/restore.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative '../../structs/history'
+
+module Umwelt::Project::File
+  class Restore < Umwelt::Abstract::File::Restore
+    def initialize(
+      path: '.umwelt',
+      mapper: Umwelt::Project::Mapper
+    )
+      super
+    end
+
+    def call
+      @struct = struct parse read full_path
+    end
+
+    def full_path
+      umwelt_root_path / 'project.json'
+    end
+  end
+end

data/lib/umwelt/project/file/store.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Umwelt::Project::File
+  class Store < Umwelt::Abstract::File::Store
+    def call(struct)
+      mkpath full_path.dirname
+
+      full_path.write serialize destruct struct
+    end
+
+    def full_path
+      umwelt_root_path / 'project.json'
+    end
+  end
+end

data/lib/umwelt/project/mapper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../structs/project'
+
+module Umwelt::Project
+  class Mapper < Umwelt::Abstract::Mapper
+    def call(data)
+      @struct = fill(Struct::Project, data)
+    end
+  end
+end

data/lib/umwelt/semantic.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Umwelt::Semantic
+  class Base
+    extend Forwardable
+    def_delegators Hanami::Utils::String, :classify, :underscore
+    def_delegators :node, :ancestry, :body, :note
+
+    attr_reader :node
+
+    def initialize(node:)
+      @node = node
+    end
+
+    def s(type, *children)
+      Parser::AST::Node.new(type, children)
+    end
+
+    def ancestry_path
+      ancestry
+        .collect(&:body)
+        .map { |body| underscore(body) }
+        .join '/'
+    end
+
+    def code
+      Unparser.unparse(ast)
+    end
+
+    # default_location defined, for example,
+    # in Semantic::Plain::Base
+    # or base file from another semantic
+    def path(location: nil)
+      Pathname.pwd / (location || default_location) / tail_path
+    end
+
+    # nil check for case of root node, which has not context
+    def context
+      node.context&.semantic(:Plain)
+    end
+
+    # classified symbol
+    def csymbol
+      classify(body).to_sym
+    end
+
+    def label
+      self.class.name.split('::').last.to_sym
+    end
+
+    def tail_path
+      Pathname.new(ancestry_path).sub_ext('.rb')
+    end
+  end
+end
+
+require_relative './semantic/plain'