me 0.0.1 → 1.0.0

data/lib/me/identity.rb

@@ -0,0 +1,64 @@
+require "me/thread_scope"
+require "me/git_config"
+require "me/store2"
+
+module Me
+  # Represents certain person, or person in certain role or situation
+  class Identity
+    def initialize(name)
+      @name = name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(Identity)
+      self.name == other.name
+    end
+
+    def build_view(view_factory)
+      view_factory.new(name: name)
+    end
+
+    def activate
+      mapper.update(active_identity: name)
+    end
+
+    def git_config
+      GitConfig.for_identity(name)
+    end
+
+    def ssh_config
+      SshConfig.for_identity(name)
+    end
+
+    def with_mapper(mapper)
+      @mapper = mapper
+      self
+    end
+
+    protected
+
+    attr_reader :name, :mapper
+  end
+
+  class << Identity
+    def active
+      Registry.identity_mapper_factory.new.find
+    end
+
+    def build(mapper:, name:, active_identity:)
+      Identity.new(name).with_mapper(mapper)
+    end
+  end
+
+  # @abstract
+  class Identity::Mapper
+    def initialize(name = nil)
+    end
+
+    def find
+    end
+
+    def update(name: nil, active_identity: nil)
+    end
+  end
+end

data/lib/me/identity_view_model.rb

@@ -0,0 +1,5 @@
+require "me/view"
+
+module Me
+  IdentityViewModel = View.new(:name)
+end

data/lib/me/mappers/git_config_store2.rb

@@ -0,0 +1,65 @@
+require "me/store2"
+require "me/git_config"
+require "me/errors"
+
+module Me
+  module Mappers
+    class GitConfigStore2 < GitConfig::Mapper
+      def self.find_by_identity(identity_name)
+        new(nil, nil, identity_name).find
+      end
+
+      def initialize(name, email, identity_name)
+        @identity_name = identity_name
+        @name = name || fetch_name
+        @email = email || fetch_email
+      end
+
+      def find
+        ensure_present
+        GitConfig
+          .new(name, email, identity_name)
+          .with_mapper(self)
+      end
+
+      def update(name: nil, email: nil)
+        return unless name || email
+        scoped.set("name", name) if name
+        scoped.set("email", email) if email
+        scoped.save
+      end
+
+      private
+
+      attr_reader :name, :email, :identity_name, :fetched
+
+      def ensure_present
+        return if name && email
+        fail Errors::GitNotConfigured, identity_name
+      end
+
+      def fetch_name
+        scoped.get("name")
+      end
+
+      def fetch_email
+        scoped.get("email")
+      end
+
+      def store
+        @_store ||= Store2.build
+      end
+
+      def scoped
+        @_scoped ||= _scoped
+      end
+
+      def _scoped
+        store.get_or_set("identities", {})
+        store.get_or_set("identities", identity_name, {})
+        store.get_or_set("identities", identity_name, "git", {})
+        store.scoped("identities", identity_name, "git")
+      end
+    end
+  end
+end

data/lib/me/mappers/identity_store2.rb

@@ -0,0 +1,40 @@
+require "me/identity"
+require "me/store2"
+
+module Me
+  module Mappers
+    class IdentityStore2 < Identity::Mapper
+      def initialize(name = nil)
+        @name = name || active_identity
+      end
+
+      def find
+        Identity.build(
+          mapper: self,
+          name: name,
+          active_identity: active_identity,
+        )
+      end
+
+      def update(name: nil, active_identity: nil)
+        return unless active_identity
+        store.set("active_identity", active_identity)
+        store.save
+      end
+
+      protected
+
+      attr_reader :name
+
+      private
+
+      def active_identity
+        store.get_or_set("active_identity", "<none>")
+      end
+
+      def store
+        @_store ||= Store2.build
+      end
+    end
+  end
+end

data/lib/me/mappers/ssh_config_store2.rb

@@ -0,0 +1,68 @@
+require "me/store2"
+require "me/ssh_config"
+require "me/errors"
+
+module Me
+  module Mappers
+    class SshConfigStore2 < SshConfig::Mapper
+      def self.find_by_identity(identity_name)
+        new(nil, identity_name).find
+      end
+
+      def initialize(keys, identity_name)
+        @identity_name = identity_name
+        @keys = fetch_keys(keys)
+      end
+
+      def find
+        ensure_present
+        SshConfig
+          .new(keys, identity_name)
+          .with_mapper(self)
+      end
+
+      def update(keys: nil, identity_name: nil)
+        return unless keys
+        scoped.set("keys", keys)
+        scoped.save
+      end
+
+      private
+
+      attr_reader :identity_name, :keys
+
+      def ensure_present
+        return if keys && !keys.empty?
+        fail Errors::SshNotConfigured, identity_name
+      end
+
+      def fetch_keys(keys)
+        return keys if keys && !keys.empty?
+        scoped.get("keys")
+      end
+
+      def store
+        @_store ||= Store2.build
+      end
+
+      def identity
+        @_identity ||= _identity
+      end
+
+      def _identity
+        store.get_or_set("identities", {})
+        store.get_or_set("identities", identity_name, {})
+        store.scoped("identities", identity_name)
+      end
+
+      def scoped
+        @_scoped ||= _scoped
+      end
+
+      def _scoped
+        identity.get_or_set("ssh", {})
+        identity.scoped("ssh")
+      end
+    end
+  end
+end

data/lib/me/registry.rb

@@ -0,0 +1,54 @@
+require "forwardable"
+require "me/thread_scope"
+
+module Me
+  module Registry
+    extend self
+    extend Forwardable
+
+    delegate [
+      :identity_mapper_factory, :register_identity_mapper_factory,
+      :git_config_mapper_factory, :register_git_config_mapper_factory,
+      :ssh_config_mapper_factory, :register_ssh_config_mapper_factory,
+      :executor_factory, :register_executor_factory,
+    ] => :thread_scoped
+
+    delegate [
+      :error_view_factories, :register_error_view_factories,
+      :kernel, :register_kernel,
+    ] => :process_scoped
+
+    private
+
+    def process_scoped
+      @_process_scoped ||= ProcessScoped.new
+    end
+
+    def thread_scoped
+      ThreadScope[:thread_scoped_registry] ||= ThreadScoped.new
+    end
+
+    class Base
+      def self.def_registry_readers(*names)
+        names.each do |name|
+          attr_reader(name)
+          define_method(:"register_#{name}") do |value|
+            instance_variable_set(:"@#{name}", value)
+          end
+        end
+      end
+    end
+
+    class ProcessScoped < Base
+      def_registry_readers :error_view_factories,
+        :kernel
+    end
+
+    class ThreadScoped < Base
+      def_registry_readers :identity_mapper_factory,
+        :git_config_mapper_factory,
+        :ssh_config_mapper_factory,
+        :executor_factory
+    end
+  end
+end

data/lib/me/ssh_activation.rb

@@ -0,0 +1,28 @@
+require "me/activation"
+require "me/registry"
+
+module Me
+  class SshActivation < Activation
+    def initialize(keys)
+      @keys = keys
+    end
+
+    def call
+      clear_ssh_keys
+      keys.each(&method(:add_ssh_key))
+      execute
+    end
+
+    protected
+
+    attr_reader :keys
+
+    def clear_ssh_keys
+      commands << ["ssh-add", "-D"]
+    end
+
+    def add_ssh_key(key)
+      commands << ["ssh-add", key]
+    end
+  end
+end

data/lib/me/ssh_config.rb

@@ -0,0 +1,65 @@
+require "me/registry"
+require "me/ssh_activation"
+
+module Me
+  class SshConfig
+    def initialize(keys, identity_name)
+      @keys = keys
+      @identity_name = identity_name
+    end
+
+    def ==(other)
+      return false unless other.is_a?(SshConfig)
+      self.keys == other.keys
+    end
+
+    def with_mapper(mapper)
+      @mapper = mapper
+      self
+    end
+
+    def configure
+      return if keys.empty?
+      mapper.update(keys: keys)
+    end
+
+    def activate
+      activation.call
+      activation
+    end
+
+    def build_view(view_factory)
+      view_factory.new(keys: keys)
+    end
+
+    protected
+
+    attr_reader :keys, :identity_name, :mapper
+
+    private
+
+    def activation
+      @_activation ||= SshActivation.new(keys)
+    end
+  end
+
+  class << SshConfig
+    def for_identity(identity_name)
+      Registry.ssh_config_mapper_factory.find_by_identity(identity_name)
+    end
+  end
+
+  class SshConfig::Mapper
+    def self.find_by_identity(identity_name)
+    end
+
+    def initialize(keys, identity_name)
+    end
+
+    def find
+    end
+
+    def update(keys: nil, identity_name: nil)
+    end
+  end
+end

data/lib/me/ssh_config_view_model.rb

@@ -0,0 +1,5 @@
+require "me/view"
+
+module Me
+  SshConfigViewModel = View.new(:keys)
+end

data/lib/me/store2.rb

@@ -0,0 +1,147 @@
+require "yaml"
+
+module Me
+  class Store2
+    class Scoped
+      def initialize(store, scope)
+        @store, @scope = store, scope
+      end
+
+      def ==(other)
+        return false unless other.is_a?(Scoped)
+        [self.store, self.scope] ==
+          [other.store, other.scope]
+      end
+
+      def scoped(*add_scope)
+        Scoped.new(store, scope + add_scope)
+      end
+
+      def get(*keys)
+        store.get(scope + keys)
+      end
+
+      def set(*keys, value)
+        store.set(scope + keys, value)
+      end
+
+      def has?(*keys)
+        store.has?(scope + keys)
+      end
+
+      def get_or_set(*keys, value)
+        store.get_or_set(scope + keys, value)
+      end
+
+      def fetch(*keys, &block)
+        store.fetch(scope + keys, &block)
+      end
+
+      def save
+        store.save
+      end
+
+      def _reset
+        store._reset
+      end
+
+      protected
+
+      attr_reader :store, :scope
+    end
+
+    def initialize
+      @data = load
+    end
+
+    def self.build
+      Store2.new.scoped
+    end
+
+    def ==(other)
+      other.is_a?(Store2)
+    end
+
+    def scoped(*scope)
+      Scoped.new(self, scope)
+    end
+
+    def get(keys)
+      keys.inject(data) { |data, key| data[key] }
+    end
+
+    def set(keys, value)
+      get(keys[0...-1])[keys[-1]] = value
+    end
+
+    def has?(keys)
+      get(keys[0...-1]).has_key?(keys[-1])
+    end
+
+    def get_or_set(keys, value)
+      set(keys, value) unless has?(keys)
+      get(keys)
+    end
+
+    def fetch(keys, &block)
+      return block.call unless has?(keys)
+      get(keys)
+    end
+
+    def save
+      File.write(filename, to_yaml)
+    end
+
+    def to_yaml
+      data.to_yaml
+    end
+
+    def _reset
+      create
+    end
+
+    protected
+
+    attr_reader :data
+
+    private
+
+    def load
+      return create unless File.exist?(filename)
+      YAML.load_file(filename)
+    end
+
+    def create
+      (@data = {}).tap { save }
+    end
+
+    def filename
+      "#{user_home}/.me#{filename_suffix}.yml"
+    end
+
+    def user_home
+      ENV.fetch("HOME")
+    end
+
+    def filename_suffix
+      Environment.wrap(ENV.fetch("ME_ENV", NullEnvironment.new))
+    end
+
+    class Environment < Struct.new(:value)
+      def self.wrap(env)
+        return env if env.is_a?(self)
+        new(env)
+      end
+
+      def to_s
+        "_#{value}"
+      end
+    end
+
+    class NullEnvironment < Environment
+      def to_s
+        ""
+      end
+    end
+  end
+end

data/lib/me/thread_scope.rb

@@ -0,0 +1,29 @@
+module Me
+  module ThreadScope
+    extend self
+
+    NAMESPACE = :__me
+
+    def [](name)
+      scope[name]
+    end
+
+    def []=(name, value)
+      scope[name] = value
+    end
+
+    def _reset
+      current[NAMESPACE] = {}
+    end
+
+    private
+
+    def scope
+      current[NAMESPACE] ||= {}
+    end
+
+    def current
+      Thread.current
+    end
+  end
+end

data/lib/me/version.rb

@@ -1,3 +1,3 @@
 module Me
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/lib/me/view.rb

@@ -0,0 +1,15 @@
+module Me
+  module View
+    def self.new(*args)
+      return super if args[0].is_a?(Hash)
+      Class.new(Struct.new(*args)) do
+        include View
+      end
+    end
+
+    def initialize(hash)
+      super()
+      hash.each { |k, v| self[k] = v }
+    end
+  end
+end

data/me.gemspec

@@ -18,6 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "thor"
+
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rake", "~> 10.0"
 end

data/spec/me/activation_spec.rb

@@ -0,0 +1,22 @@
+require "me/activation"
+
+module Me
+  RSpec.describe Activation do
+    subject(:activation) { Activation.new._with_commands(commands) }
+
+    let(:commands) { double("commands") }
+
+    let(:view_factory) { double("ViewFactory") }
+    let(:view) { double("View") }
+
+    describe "#build_view" do
+      it "gives commands to a view" do
+        allow(view_factory)
+          .to receive(:new)
+          .with(commands: commands)
+          .and_return(view)
+        expect(activation.build_view(view_factory)).to eq(view)
+      end
+    end
+  end
+end

data/spec/me/cli/activate_command_spec.rb

@@ -0,0 +1,56 @@
+require "me/cli/activate_command"
+require "me/registry"
+require "me/git_config"
+require "me/ssh_config"
+require "me/activation"
+
+module Me
+  module Cli
+    RSpec.describe ActivateCommand do
+      subject(:command) { described_class.new }
+
+      let(:identity) { instance_double(Identity) }
+      let(:git_config) { instance_double(GitConfig, activate: git_activation) }
+      let(:ssh_config) { instance_double(SshConfig, activate: ssh_activation) }
+
+      let(:git_activation) { instance_double(Activation) }
+      let(:ssh_activation) { instance_double(Activation) }
+
+      let(:git_view) { instance_double(ActivationView) }
+      let(:ssh_view) { instance_double(ActivationView) }
+
+      before do
+        allow(Identity).to receive(:active).and_return(identity)
+
+        allow(identity).to receive(:git_config).and_return(git_config)
+        allow(identity).to receive(:ssh_config).and_return(ssh_config)
+
+        allow(git_activation)
+          .to receive(:build_view)
+          .with(ActivationView)
+          .and_return(git_view)
+
+        allow(ssh_activation)
+          .to receive(:build_view)
+          .with(ActivationView)
+          .and_return(ssh_view)
+      end
+
+      describe "#call" do
+        it "activates active identity's git configuration" do
+          expect(git_config).to receive(:activate)
+          command.call
+        end
+
+        it "activates active identity's ssh configuration" do
+          expect(ssh_config).to receive(:activate)
+          command.call
+        end
+
+        it "renders proper response" do
+          expect(command.call).to eq([git_view, ssh_view])
+        end
+      end
+    end
+  end
+end