dtk-shell 0.10.0

data/lib/shell/context_aux.rb

@@ -0,0 +1,46 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK
+  module Shell
+    class ContextAux
+
+      class << self
+
+        def is_double_dot?(command)
+          return command.match(/\.\.[\/]?/)
+        end
+
+        # returns number of first '..' elements in array
+        def count_double_dots(entries)
+          double_dots_count = 0
+          # we check for '..' and remove them
+          entries.each do |e| 
+            if is_double_dot?(e)
+              double_dots_count += 1  
+            else
+              break
+            end
+          end
+
+          return double_dots_count
+        end
+
+      end
+    end
+  end
+end

data/lib/shell/domain/active_context.rb

@@ -0,0 +1,186 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Shell
+  class ActiveContext
+
+    # special case when we are not able to provide valid identifier but we are
+    # using it as such
+    NO_IDENTIFIER_PROVIDED = -1
+
+    # TODO: Remove accessor for debug purpose only
+    attr_accessor :context_list
+
+    def clone_me()
+      inst = ActiveContext.new
+      inst.context_list = @context_list.clone
+      return inst
+    end
+
+    def initialize
+      @context_list = []
+    end
+
+    def push_new_context(context_name, entity_name, context_value=nil, shadow_entity=nil)
+      @context_list << ContextEntity.create_context(context_name, entity_name, context_value, :id, shadow_entity)
+    end
+
+    def push_new_name_context(context_name, entity_name, context_value=nil)
+      @context_list << ContextEntity.create_context(context_name, entity_name, context_value, :name)
+    end
+
+    def pop_context(n)
+      return @context_list.pop(n)
+    end
+
+    def find_identifier(entity_name)
+      results = @context_list.select { |e| (e.is_identifier? && (e.entity == entity_name.to_sym))}
+      return results.first
+    end
+
+    def find_command(entity_name)
+      results = @context_list.select { |e| (e.is_command? && (e.entity == entity_name.to_sym))}
+      return results.first
+    end
+
+    def name_list()
+      @context_list.collect { |e|  e.is_alt_identifier? ? e.transform_alt_identifier_name : e.name }
+    end
+
+    def name_list_simple()
+      @context_list.collect { |e|  e.name }
+    end
+
+
+    # returns list of entities that have identifier
+    def commands_that_have_identifiers()
+      filtered_entities = @context_list.select { |e| e.is_identifier? }
+      return filtered_entities.collect { |e| e.entity.to_s }
+    end
+
+    def command_list()
+      filtered_entities = @context_list.select { |e| e.is_command? }
+      return filtered_entities.collect { |e| e.entity.to_s }
+    end
+
+    # returns id to be used to retrive task list form the cache based on
+    # current active context
+    def get_task_cache_id()
+      identifier = command_list().join('_')
+      return 'dtk' if identifier.empty?
+      if current_alt_identifier?
+        return "#{identifier}_#{current_alt_identifier_name()}".to_sym()
+      end
+
+      return current_identifier? ? "#{identifier}_wid".to_sym : identifier.to_sym
+    end
+
+    def full_path()
+      path = name_list().join('/')
+      path = Context.enchance_path_with_alias(path, @context_list)
+
+      return "/#{path}"
+    end
+
+    def clear()
+      @context_list.clear
+    end
+
+    def empty?()
+      return @context_list.empty?
+    end
+
+    def is_n_context?
+      @context_list.size > 2
+    end
+
+    def is_base_context?
+      @context_list.size == 1
+    end
+
+    def is_root_context?
+      @context_list.size == 0
+    end
+
+    def current_command?
+      return @context_list.empty? ? true : @context_list.last.is_command?
+    end
+
+    def current_identifier?
+      return @context_list.empty? ? false : @context_list.last.is_identifier?
+    end
+
+    def current_alt_identifier?
+      return @context_list.empty? ? false : @context_list.last.is_alt_identifier?
+    end
+
+    def current_alt_identifier_name
+      @context_list.last.alt_identifier
+    end
+
+    def first_command_name()
+      @context_list.each do |e|
+        return e.name if e.is_command?
+      end
+
+      return nil
+    end
+
+    def is_there_identifier_for_first_context?
+      @context_list.each { |e| return true if e.is_identifier? }
+      return false
+    end
+
+    def last_command_name()
+      @context_list.reverse.each do |e|
+        return e.name if e.is_command?
+      end
+
+      return nil
+    end
+
+    def last_context_entity_name()
+      return @context_list.empty? ? nil : @context_list.last.entity
+    end
+
+    def last_context_name()
+      return @context_list.empty? ? nil : @context_list.last.name
+    end
+
+    def first_context_name()
+      return @context_list.empty? ? nil : @context_list.first.name
+    end
+
+    def first_context()
+      return @context_list.empty? ? nil : @context_list.first
+    end
+
+    def last_context()
+      return @context_list.empty? ? nil : @context_list.last
+    end
+
+    def last_context_is_shadow_entity?
+      return false if @context_list.empty?
+      !!last_context().shadow_entity
+    end
+
+    def shadow_entity()
+      return if @context_list.empty?
+      last_context().shadow_entity
+    end
+  end
+end

data/lib/shell/domain/context_entity.rb

@@ -0,0 +1,89 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Shell
+  class ContextEntity
+    attr_accessor   :entity
+    attr_accessor   :name
+    attr_accessor   :identifier
+    attr_accessor   :alt_identifier
+    attr_accessor   :shadow_entity
+
+    SHELL_SEPARATOR = '/'
+
+    def self.create_context(context_name, entity_name, context_value=nil, type_id=:id, shadow_entity=nil)
+      if context_value
+        if :id.eql?(type_id)
+          return ContextEntity.create_identifier(context_name, entity_name, context_value, shadow_entity)
+        else
+          return ContextEntity.create_name_identifier(context_name, entity_name, context_value, shadow_entity)
+        end
+      else
+        return ContextEntity.create_command(context_name, entity_name, shadow_entity)
+      end
+    end
+
+    def is_identifier?
+      return !@identifier.nil?
+    end
+
+    def is_alt_identifier?
+      return !@alt_identifier.nil?
+    end
+
+    def is_command?
+      return @identifier.nil?
+    end
+
+    def get_identifier(type)
+      return (type == 'id' ? self.identifier : self.name)
+    end
+
+    def transform_alt_identifier_name()
+      @name.gsub(::DTK::Client::CommandBaseThor::ALT_IDENTIFIER_SEPARATOR, SHELL_SEPARATOR)
+    end
+
+    private
+
+    def self.create_command(name, entity_name, shadow_entity=nil)
+      instance = ContextEntity.new
+      instance.name   = name
+      instance.entity = entity_name.to_sym
+      instance.shadow_entity = shadow_entity
+      return instance
+    end
+
+    def self.create_name_identifier(name, entity_name, value, shadow_entity=nil)
+      instance            = self.create_command(name,entity_name)
+      instance.name           = value
+      instance.identifier     = value
+      instance.alt_identifier = value
+      instance.shadow_entity = shadow_entity
+
+      return instance
+    end
+
+    def self.create_identifier(name, entity_name, value, shadow_entity=nil)
+      instance                = self.create_command(name,entity_name)
+      instance.identifier     = value
+      alt_identifier_name = name.to_s.split(::DTK::Client::CommandBaseThor::ALT_IDENTIFIER_SEPARATOR)
+      instance.alt_identifier = alt_identifier_name.size > 1 ? alt_identifier_name.first : nil
+      instance.shadow_entity  = shadow_entity
+      return instance
+    end
+  end
+end

data/lib/shell/domain/context_params.rb

@@ -0,0 +1,223 @@
+#
+# Copyright (C) 2010-2016 dtk contributors
+#
+# This file is part of the dtk project.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module DTK::Shell
+  class ContextParams
+
+    attr_accessor :current_context
+    attr_accessor :method_arguments
+    attr_accessor :pure_cli_mode
+
+    def initialize(override_method_arguments = [])
+      @current_context  = ActiveContext.new
+      @method_arguments = override_method_arguments
+      @thor_options     = Hash.new
+      @pure_cli_mode    = false
+
+      @method_arguments
+    end
+
+    def add_context_to_params(context_name, entity_name, context_value = nil)
+      @current_context.push_new_context(context_name, stand_name(entity_name), context_value)
+    end
+
+    def add_context_name_to_params(context_name, entity_name, context_value = nil)
+      @current_context.push_new_name_context(context_name, stand_name(entity_name), context_value)
+    end
+
+    def forward_options(options)
+      @thor_options = options
+    end
+
+    def get_forwarded_options()
+      @thor_options
+    end
+
+    def get_forwarded_thor_option(option_key)
+      return @thor_options ? @thor_options[option_key] : nil
+    end
+
+    def override_method_argument!(key, value)
+      id = match_argument_id(key)
+      raise DTK::Client::DtkImplementationError, "Wrong identifier used '#{key}', ID not matched!" unless id
+      @method_arguments[id] = value
+    end
+
+    # can be class methods but no need, since we have this instance available in each method
+    def retrieve_thor_options(mapping, options)
+      results = []
+      errors  = []
+
+      mapping.each do |key|
+        required = key.to_s.match(/.+!$/)
+        thor_key = key.to_s.gsub('!','')
+
+        results << element = options[thor_key]
+
+        if required && element.nil?
+          errors << thor_key
+        end
+      end
+
+      unless errors.empty?
+        raise DTK::Client::DtkValidationError.new("Missing required option#{errors.size > 1 ? 's' : ''}: #{errors.join(', ')}", true)
+      end
+
+      return ((results.size == 1) ? results.first : results)
+    end
+
+    def retrieve_arguments(mapping, method_info = [])
+      results = []
+      errors  = []
+
+      # using context_name when have array as key_mapping [:assembly_id, :workspace_id]
+      # to determine which context is used
+      context_name = method_info.first.split('-').first unless method_info.empty?
+
+      mapping.each do |key_mapping|
+
+        is_array = key_mapping.is_a?(Array)
+
+        selected_key = is_array ? key_mapping.first : key_mapping
+
+        required = selected_key.to_s.match(/.+!$/)
+
+        element = nil
+        matched = selected_key.to_s.match(/option_([0-9]+)/)
+        if matched
+          id = matched[1].to_i - 1
+          element = @method_arguments[id].dup if @method_arguments[id]
+
+          # used if last parameter has more than one word
+          # e.g. set-attribute attr_name "some value" (thor separates 'some value' as two parameters but we need it as one)
+          if(mapping.last.to_s.eql?(key_mapping.to_s))
+            new_id = id+1
+            while @method_arguments[new_id] do
+              element << " #{@method_arguments[new_id]}"
+              new_id += 1;
+            end
+          end
+
+          unless method_info.empty?
+            unless element
+              errors << method_info[id] if required
+            end
+          end
+
+        else
+          # More complex split regex for extracting entitiy name from mapping due to complex context names
+          # i.e. assembly-template will have assembly_template_id mapping
+          element = check_context_for_element(selected_key)
+
+          # if we are dealing with array we need to check rest of the keys since it is OR
+          # approach if first element not found take second
+          if element.nil? && is_array
+            key_mapping[1..-1].each do |alternative_key|
+              element = check_context_for_element(alternative_key)
+              break if element
+              if context_name
+                if alternative_key.to_s.include?(context_name.downcase)
+                  required = alternative_key.to_s.match(/.+!$/)
+                  selected_key = alternative_key
+                end
+              end
+            end
+          end
+
+          unless element
+            errors << "#{entity_name(selected_key).upcase} ID/NAME" if required
+          end
+        end
+
+        results << element
+      end
+
+      unless errors.empty?
+        raise DTK::Client::DtkValidationError.new("Missing required argument#{errors.size > 1 ? 's' : ''}: #{errors.join(', ')}", true)
+      end
+
+      return ((results.size == 1) ? results.first : results)
+    end
+
+    def is_last_command_eql_to?(command_name)
+      return @current_context.last_command_name() == command_name.to_s
+    end
+
+    def is_there_identifier?(entity_name)
+      return @current_context.find_identifier(entity_name) != nil
+    end
+
+    def is_there_command?(entity_name)
+      return @current_context.find_command(entity_name) != nil
+    end
+    def current_command?
+      return @current_context.current_command?
+    end
+    def root_command_name
+      @current_context.first_command_name
+    end
+    def last_entity_name
+      @current_context.last_context_entity_name
+    end
+    def shadow_entity_name()
+      @current_context.shadow_entity()
+    end
+
+    private
+
+    # matches argument id (integer) from used identifier (symbol)
+    #
+    # Returns: Integer as ID , or nil if not found
+    def match_argument_id(identifier)
+      matched = identifier.to_s.match(/option_([0-9]+)/)
+      (matched ? matched[1].to_i - 1 : nil)
+    end
+
+    # based on map key binding e.g. assembly_id, assembly_name we will extrace value
+    # from our ActiveContext
+    def check_context_for_element(key_mapping)
+      split_info  =  split_info(key_mapping)
+      entity_name =  entity_name(key_mapping,split_info)
+      id_type     = split_info[1].gsub(/!/,'')   # for required elements we remove '!' required marker
+      context_identifier = @current_context.find_identifier(entity_name)
+      if context_identifier
+        return context_identifier.get_identifier(id_type)
+      else
+        return nil
+      end
+    end
+
+    def entity_name(key_mapping,split_info=nil)
+      split_info ||= split_info(key_mapping)
+      split_info[0].gsub(/_/,'-')  # makes sure we are using entity names with '_'
+    end
+
+    #
+    # Standardize context name since we are in domain treating :component_module as :'component-module'
+    # and need to be careful about these changes
+    #
+
+    def stand_name(name)
+      name.to_s.gsub('_','-').to_sym
+    end
+
+    def split_info(key_mapping)
+      key_mapping.to_s.split(/_([a-z]+!?$)/)
+    end
+
+  end
+end