umwelt 0.1.0

data/lib/umwelt/abstract.rb

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

data/lib/umwelt/abstract/file.rb

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

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'hanami/interactor'
+require 'json'
+
+module Umwelt::Abstract::File
+  class Restore
+    include Hanami::Interactor
+
+    expose :struct
+
+    def initialize(path: '.umwelt',
+                   mapper: Struct)
+      @path = path
+      @mapper = mapper
+    end
+
+    private
+
+    def read(path)
+      path.read
+    rescue Errno::ENOENT
+      error! "Failed reading #{path}"
+    end
+
+    def parse(str)
+      JSON.parse(str, symbolize_names: true)
+    rescue JSON::ParserError
+      error! "Failed JSON parsing #{self.class.name}"
+    end
+
+    def struct(struct_hash)
+      clean @mapper.new.call(struct_hash)
+    end
+
+    def clean(result)
+      if result.success?
+        result.struct
+      else
+        error! result.errors
+      end
+    end
+
+    def umwelt_root_path
+      Pathname.pwd / @path
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'hanami/interactor'
+require 'json'
+require 'fileutils'
+require 'pathname'
+
+module Umwelt::Abstract::File
+  class Store
+    extend Forwardable
+    include Hanami::Interactor
+    def_delegators FileUtils, :mkpath
+
+    def initialize(path: '.umwelt')
+      @path = path
+    end
+
+    private
+
+    def serialize(struct)
+      JSON.pretty_generate struct
+    end
+
+    def destruct(obj)
+      obj.is_a?(Struct) ? destruct_members(obj.to_h) : obj
+    end
+
+    def destruct_members(hash)
+      hash.transform_values do |value|
+        if value.is_a?(Array)
+          value.map { |member| destruct(member) }
+        elsif value.is_a? Time
+          value.to_s
+        else
+          destruct(value)
+        end
+      end
+    end
+
+    def umwelt_root_path
+      Pathname.pwd / @path
+    end
+  end
+end

data/lib/umwelt/abstract/mapper.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'hanami/interactor'
+# require_relative './structs/phase'
+# require_relative './structs/fragment'
+
+class Umwelt::Abstract::Mapper
+  include Hanami::Interactor
+
+  expose :struct
+
+  def fill(struct, data)
+    struct.new(data)
+  rescue ArgumentError => e
+    error! [self.class.name, e.message, data]
+  end
+end

data/lib/umwelt/cli.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI
+end
+
+require_relative './cli/commands'

data/lib/umwelt/cli/commands.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI::Commands
+  require_relative './commands/convey'
+  require_relative './commands/clone'
+  require_relative './commands/pull'
+  require_relative './commands/version'
+
+  extend Hanami::CLI::Registry
+
+  register 'convey', Convey
+  register 'clone', Clone
+  register 'pull', Pull
+  register 'version', Version
+end

data/lib/umwelt/cli/commands/clone.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI
+  class Commands::Clone < Hanami::CLI::Command
+    desc 'Clone project from remote Umwelt'
+
+    argument :project,
+             type: :string, required: true,
+             desc: 'provide project as USERNAME/PROJECTNAME'
+
+    def call(project:)
+      puts "Cloning project: <#{project}>"
+      # Generator::Element.new(element).create
+    end
+  end
+end

data/lib/umwelt/cli/commands/convey.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI::Commands
+  class Convey < Hanami::CLI::Command
+    extend Forwardable
+    def_delegators Hanami::Utils::String, :classify
+
+    desc 'Convey Phase in Semantic from local Umwelt'
+
+    argument :phase,
+             type: :integer,
+             required: true,
+             desc: 'provide PHASE_ID to imprint'
+
+    argument :semantic,
+             type: :string,
+             default: 'plain',
+             values: %w[plain],
+             required: true,
+             desc: 'provide SEMANTIC to imprint'
+
+    option :source,
+           type: :string,
+           default: '.umwelt',
+           desc: 'provide folder where source stored'
+
+    option :target,
+           type: :string,
+           default: 'umwelt',
+           desc: 'provide folder for imprint'
+
+    def call(phase:, semantic:, **options)
+      puts "Buildung phase: #{phase} with semantic #{semantic}..."
+
+      if phase.to_i.zero?
+        puts 'Error: Phase must be an integer'
+        return
+      end
+
+      @convey = Umwelt::Command::Convey.new.call(
+        phase_id: phase.to_i,
+        semantic: classify(semantic).to_sym,
+        source: Pathname.new(options.fetch(:source)),
+        target: Pathname.new(options.fetch(:target))
+      )
+
+      if @convey.success?
+        @convey.result.each_pair do |key, value|
+          puts "#{key} => (#{value})"
+        end
+        puts "#{@convey.result.keys.count} files written succesfully"
+      else
+        @convey.errors.each { |e| puts "Error: #{e}" }
+      end
+    end
+  end
+end

data/lib/umwelt/cli/commands/pull.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI
+  class Commands::Pull < Hanami::CLI::Command
+    desc 'Pull project from remote Umwelt'
+
+    def call(*)
+      puts 'Pulling project'
+    end
+  end
+end

data/lib/umwelt/cli/commands/version.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Umwelt::CLI::Commands
+  class Version < Hanami::CLI::Command
+    def call(*)
+      puts Umwelt::VERSION
+    end
+  end
+end

data/lib/umwelt/command.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Umwelt::Command
+end
+
+require_relative './command/convey'

data/lib/umwelt/command/convey.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Umwelt::Command
+  class Convey
+    include Hanami::Interactor
+    # TODO: change to dry-rb transaction here
+
+    expose :result
+
+    def call(phase_id:, semantic:, source:, target:)
+      @result = imprint(
+        tree(source, phase_id), target, semantic
+      )
+    end
+
+    private
+
+    def tree(source, phase_id)
+      tree_fill(
+        aggregate_history(
+          follow_history(
+            trace_history(
+              restore_history(source),
+              phase_id
+            ), source
+          )
+        )
+      )
+    end
+
+    def imprint(tree, target, semantic)
+      result = Umwelt::Tree::Imprint.new(tree, location: target).call(semantic)
+      if result.success?
+        result.written_paths
+      else
+        error! result.errors
+      end
+    end
+
+    def tree_fill(fragments)
+      Umwelt::Tree::Fill.new.call(fragments)
+    end
+
+    def aggregate_history(episodes)
+      result = Umwelt::History::Aggregate.new.call(episodes)
+      if result.success?
+        result.fragments
+      else
+        error! result.errors
+      end
+    end
+
+    def follow_history(continuity, source)
+      result = Umwelt::History::Follow
+               .new(path: source)
+               .call(continuity)
+      if result.success?
+        result.episodes
+      else
+        error! result.errors
+      end
+    end
+
+    def trace_history(history, phase_id)
+      result = Umwelt::History::Trace.new.call(history, phase_id)
+      if result.success?
+        result.continuity
+      else
+        error! result.errors
+      end
+    end
+
+    def restore_history(source)
+      restored = Umwelt::History::File::Restore
+                 .new(path: source)
+                 .call
+      if restored.success?
+        restored.struct
+      else
+        error! "Cannot restore history of #{phase_id}: #{restored.errors}"
+      end
+    end
+  end
+end

data/lib/umwelt/episode.rb

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

data/lib/umwelt/episode/file.rb

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

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

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

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

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Umwelt::Episode::File
+  class Store < Umwelt::Abstract::File::Store
+    def call(id, struct)
+      mkpath full_path(id).dirname
+
+      full_path(id).write serialize(destruct(struct))
+    end
+
+    def full_path(id)
+      umwelt_root_path / "episodes/#{id}.json"
+    end
+  end
+end

data/lib/umwelt/episode/mapper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative '../structs/phase'
+require_relative '../structs/fragment'
+
+module Umwelt::Episode
+  class Mapper < Umwelt::Abstract::Mapper
+    def call(
+      data = {
+        phase: {},
+        engaged: [],
+        forgotten: []
+      }
+    )
+
+      @struct = Struct::Episode.new(
+        phase: phase(data[:phase]),
+        engaged: fragments(data[:engaged]),
+        forgotten: data[:forgotten]
+      )
+    end
+
+    private
+
+    def fragments(array)
+      array.map { |data| fill(Struct::Fragment, data) }
+    end
+
+    def phase(data)
+      fill(Struct::Phase, data)
+    end
+  end
+end

data/lib/umwelt/fragment.rb

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