dtk-client 0.9.1 → 0.10.0

data/lib/view_processor/augmented_simple_list.rb

@@ -1,44 +0,0 @@
-#
-# 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.
-#
-#TODO: test for assembly list/display; want to make assembly specfic stuff datadriven
-dtk_require 'simple_list'
-module DTK
-  module Client
-    class ViewProcAugmentedSimpleList < ViewProcSimpleList
-     private
-      def initialize(type,command_class,data_type_index=nil)
-        super
-        @meta = get_meta(type,command_class)
-      end
-      def failback_meta(ordered_cols)
-        nil
-      end
-      def simple_value_render(ordered_hash,ident_info)
-        augmented_def?(ordered_hash,ident_info) || super
-      end
-      def augmented_def?(ordered_hash,ident_info)
-        return nil unless @meta
-        if aug_def =  @meta["#{ordered_hash.object_type}_def".to_sym]
-          ident_str = ident_str(ident_info[:ident]||0)
-          vals = aug_def[:keys].map{|k|ordered_hash[k.to_s]}
-          "#{ident_str}#{aug_def[:fn].call(*vals)}\n"
-        end
-      end
-    end
-  end
-end

data/lib/view_processor/hash_pretty_print.rb

@@ -1,123 +0,0 @@
-#
-# 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 Client
-    class ViewProcHashPrettyPrint < ViewProcessor
-      include ::DTK::Client::Auxiliary
-      def render(hash)
-        object_def = get_top_def()
-        raise_error() unless object_def
-        render_object_def(hash,object_def)
-      end
-     private
-      attr_reader :meta
-      def initialize(type,command_class,data_type_index=nil)
-        super
-        @meta = get_meta(type,command_class,data_type_index)
-      end
-
-      def failback_meta(ordered_cols)
-        {
-          :top_type => :top,
-          :defs => {:top_def => ordered_cols}
-        }
-      end
-
-      def get_top_def()
-        raise_error("No Top def") unless top_object_type = meta[:top_type]
-        get_object_def(top_object_type)
-      end
-
-      def get_object_def(object_type)
-        if defs = meta[:defs] and object_type
-          {object_type => defs["#{object_type}_def".to_sym]}
-        end
-      end
-      def raise_error(msg=nil)
-        msg ||= "No hash pretty print view defined"
-        raise Error.new(msg)
-      end
-      def render_object_def(object,object_def,opts={})
-        #TODO: stub making it only first level
-        return object unless object.kind_of?(Hash)
-        hash = object
-        ret = ViewPrettyPrintHash.new(object_def.keys.first)
-
-        object_def.values.first.each do |item|
-          if item.kind_of?(Hash)
-            render_object_def__hash_def!(ret,hash,item)    
-          else
-            key = item.to_s
-            target_key = replace_with_key_alias?(key) 
-            #TODO: may want to conditionally include nil values
-            ret[target_key] = hash[key] if hash[key]
-          end
-        end
-        #catch all for keys not defined
-        unless opts[:only_explicit_cols]
-          (hash.keys.map{|k|replace_with_key_alias?(k)} - ret.keys).each do |key|
-            ret[key] = hash[key] if hash[key]
-          end
-        end
-        return ret
-      end
-      def replace_with_key_alias?(key)
-        #TODO: fix
-        return key
-        if ret = GlobalKeyAliases[key.to_sym] then ret.to_s 
-        else key
-        end
-      end
-      GlobalKeyAliases = {
-        :library_library_id => :library_id,
-        :datacenter_datacenter_id => :target_id
-      }
-
-      def render_object_def__hash_def!(ret,hash,hash_def_item)
-        key = hash_def_item.keys.first.to_s
-        return unless input = hash[key]
-        hash_def_info = hash_def_item.values.first
-        nested_object_def = get_object_def(hash_def_info[:type])
-        raise_error("object def of type (#{hash_def_info[:type]||""}) does not exist") unless nested_object_def
-
-        opts = Hash.new
-        if hash_def_info[:only_explicit_cols]
-          opts.merge!(:only_explicit_cols => true)
-        end
-        if hash_def_info[:is_array]
-          raise_error("hash subpart should be an array") unless input.kind_of?(Array)
-          ret[key] = input.map{|el|render_object_def(el,nested_object_def,opts)}
-        else
-          ret[key] = render_object_def(input,nested_object_def,opts)
-        end
-      end
-    end
-    class ViewPrettyPrintHash < Common::PrettyPrintHash
-      def initialize(object_type=nil)
-        super()
-        @object_type = object_type
-      end
-      attr_accessor :object_type
-      def slice(*keys)
-        ret = super
-        ret.object_type = object_type
-        ret
-      end
-    end
-  end
-end

data/lib/view_processor/simple_list.rb

@@ -1,156 +0,0 @@
-#
-# 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.
-#
-require 'erubis'
-module DTK
-  module Client
-    class ViewProcSimpleList < ViewProcessor
-      def render(hash)                  
-        pp_adapter = ViewProcessor.get_adapter("hash_pretty_print",@command_class,@data_type_index)
-        ordered_hash = pp_adapter.render(hash)
-        if ordered_hash.size == 1
-          render_simple_assignment(ordered_hash.keys.first,ordered_hash.values.first)
-        else
-          render_ordered_hash(ordered_hash)
-        end
-      end
-     private
-      #TODO Aldin check if assembly or assembly_name
-      HIDE_FROM_VIEW = ["assembly"]
-      def render_simple_assignment(key,val)
-        key + KeyValSeperator + val.to_s + "\n" 
-      end
-      def render_ordered_hash(ordered_hash,ident_info={},index=1)
-        #find next value that is type pretty print hash or array
-        beg,nested,rest = find_first_non_scalar(ordered_hash)
-        ret = String.new
-        unless beg.empty?
-          ret = simple_value_render(beg,ident_info.merge(:index => index))
-        end
-        unless nested.empty?
-          ident_info_nested = {
-            :ident => (ident_info[:ident]||0) +IdentAdd,
-            :nested_key => nested.keys.first
-          }
-          ident_info_nested[:ident] += IdentAdd
-          ret << "#{ident_str(ident_info_nested[:ident])}#{nested.keys.first.upcase}\n"
-          vals = nested.values.first
-          vals = [vals] unless vals.kind_of?(Array)
-          vals.each_with_index{|val,i|ret << render_ordered_hash(val,ident_info_nested,i+1)}
-        end
-        unless rest.empty?
-          rest = hide_from_view(rest)
-          ret << render_ordered_hash(rest,ident_info.merge(:include_first_key => true))
-        end
-        ret
-      end
-
-      def hide_from_view(ordered_hash)
-        ordered_hash.each do |k,v|
-          ordered_hash.delete_if{|k,v| HIDE_FROM_VIEW.include?(k)}
-        end
-        return ordered_hash
-      end
-
-      # Exclude  = ["op_status","assembly_template"]
-      IdentAdd = 2
-      def find_first_non_scalar(ordered_hash)
-        found = nil
-        keys = ordered_hash.keys
-        keys.each_with_index do |k,i|
-          val = ordered_hash[k]
-          if val.kind_of?(ViewPrettyPrintHash) or 
-              (val.kind_of?(Array) and val.size > 0 and val.first.kind_of?(ViewPrettyPrintHash))
-            found = i
-            break
-          end
-        end
-        if found.nil?
-          empty_ordered_hash = ordered_hash.class.new
-          [ordered_hash,empty_ordered_hash,empty_ordered_hash]
-        else
-          [keys[0,found],keys[found,1],keys[found+1,keys.size-1]].map{|key_array|ordered_hash.slice(*key_array)}
-        end
-      end
-      def is_scalar_type?(x)
-        [String,Fixnum,Bignum].find{|t|x.kind_of?(t)}
-      end
-
-      def convert_to_string_form(val)
-        if val.kind_of?(Array)
-          "[#{val.map{|el|convert_to_string_form(el)}.join(",")}]"
-        elsif is_scalar_type?(val)
-          val.to_s
-        else #catchall
-          pp_form val
-        end
-      end
-      def pp_form(obj)
-        ret = String.new
-        PP.pp obj, ret
-        ret.chomp!
-      end
-
-      def ident_str(n)
-        Array.new(n, " ").join
-      end
-
-      #process elements that are not scalars
-      def proc_ordered_hash(ordered_hash)
-        updated_els = Hash.new
-        ordered_hash.each do |k,v|
-          unless is_scalar_type?(v)
-            updated_els[k] = convert_to_string_form(v)
-          end
-        end
-        
-        ordered_hash.merge(updated_els)
-      end
-
-      def simple_value_render(ordered_hash,ident_info)
-           
-        proc_ordered_hash = proc_ordered_hash(ordered_hash)
-
-        ident = ident_info[:ident]||0
-        first_prefix = (ident_info[:include_first_key] ?
-          (ident_str(ident+IdentAdd) + ordered_hash.keys.first + KeyValSeperator) : ident_str(ident))
-        first_suffix = ((ident_info[:include_first_key] or not ordered_hash.object_type) ? "" : " (#{ordered_hash.object_type})")
-        rest_prefix = ident_str(ident+IdentAdd)
-
-        template_bindings = {
-          :ordered_hash => proc_ordered_hash,
-          :first_prefix => first_prefix,
-          :first_suffix => first_suffix,
-          :rest_prefix => rest_prefix,
-          :sep => KeyValSeperator
-        }
-
-        SimpleListTemplate.result(template_bindings)
-      end
-      KeyValSeperator = ": "
-SimpleListTemplate = Erubis::Eruby.new <<eos
-<% keys = ordered_hash.keys %>
-<% first = keys.shift  %>
-<%= rest_prefix %><%= first_prefix.strip %><%= ordered_hash[first] %>
-<% keys.each do |k| %>
-<%= rest_prefix %><%= k %><%= sep  %><%= ordered_hash[k] %>
-<% end %>
-eos
-
-    end
-  end
-end

data/lib/view_processor/table_print.rb

@@ -1,309 +0,0 @@
-#
-# 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.
-#
-require 'hirb'
-require 'ostruct'
-require 'colorize'
-require 'rest_client'
-require 'json'
-
-dtk_require("../config/disk_cacher")
-
-# we override String here to give power to our mutators defined in TableDefintions
-class String
-  def get_date
-    DateTime.parse(self).strftime('%H:%M:%S %d/%m/%y') unless self.nil?
-  end
-end
-
-# override OpenStruct to remove defintion for id
-class DtkOpenStruct < OpenStruct
-  if RUBY_VERSION.match(/^1\.8\..*$/)
-    undef id
-    undef type
-  end
-end
-
-# [Haris]
-# Elements with action column (taks status) have been removed since they are no longer in use. In case of bug that is relying
-# on existance of element and logic, please contact me to resolve it.
-#
-
-module DTK
-  module Client
-    class ViewProcTablePrint < ViewProcessor
-      def render(data, command_clazz, data_type_clazz, forced_metadata=nil, print_error_table=false)
-        DtkResponse.new(data, data_type_clazz, forced_metadata, print_error_table).print
-      end
-    end
-
-    class DtkResponse
-
-      include Hirb::Console
-      include CommandBase
-      extend  CommandBase
-      attr_accessor :command_name, :order_defintion, :evaluated_data
-
-      # when adding class to table view you need to define mapping and order to be displayed in table
-      # this can be fixed with facets, but that is todo for now TODO: use facets with ordered hashes
-
-      def initialize(data, data_type, forced_metadata, print_error_table)
-        # if there is no custom metadata, then we use metadata predefined in meta-response.json file
-
-        if forced_metadata.nil?
-          # get all table definitions from json file
-          @table_defintions = get_metadata()
-          # e.g. data type ASSEMBLY
-          @command_name     = data_type
-          # e.g. ASSEMBLY => TableDefintions::ASSEMBLY
-          table_defintion   = get_table_defintion(@command_name)
-          # e.g. ASSEMBLY => TableDefintions::ASSEMBLY_ORDER
-          @order_definition = get_table_defintion(@command_name, true)
-        else
-          # if there is custom metadata, check if it is in valid format
-          validate_forced_metadata(forced_metadata)
-
-          table_defintion   = forced_metadata['mapping']
-          @order_definition = forced_metadata['order']
-        end
-
-        # if one defintion is missing we stop the execution
-        if table_defintion.nil? || @order_definition.nil?
-          raise DTK::Client::DtkError,"Missing table definition(s) for data type #{data_type}."
-        end
-
-        # transforms data to DtkOpenStruct
-        structured_data = []
-
-        # very important since rest of the code expect array to be used
-        data = [data] unless data.kind_of?(Array)
-
-        data.each do |data_element|
-          # special flag to filter out data not needed here
-          next if data_element['dtk_client_hidden']
-
-          structured_data << to_ostruct(data_element)
-        end
-
-        # we use array of OpenStruct to hold our evaluated values
-        @evaluated_data = []
-        @error_data     = []
-        @action_data    = []
-        structured_data.each do |structured_element|
-          evaluated_element = DtkOpenStruct.new
-          error_element     = DtkOpenStruct.new
-
-          # based on mapping we set key = eval(value)
-          table_defintion.each do |k,v|
-            begin
-              # due to problems with space we have special way of handling error columns
-              # in such a way that those error will be specially printed later on
-
-              if print_error_table && k.include?('error')
-                error_message = value_of(structured_element, v)
-                server_error = nil
-
-                # here we see if there was an error if not we will skip this
-                # if so we add it to @error_data
-
-                if error_message.empty?
-                  # no error message just add it as regular element
-                  evaluated_element.send("#{k}=",value_of(structured_element, v))
-                else
-                  error_index = ""
-                  error_type = value_of(structured_element,'errors.dtk_type') || ""
-
-                  val = value_of(structured_element,'dtk_type')||''
-                  # extract e.g. 3.1.1.1 from '3.1.1.1 action' etc.
-                  error_index = "[ #{val.scan( /\d+[,.]?\d?[,.]?\d?[,.]?\d?[,.]?\d?/ ).first} ]"
-
-                  # original table takes that index
-                  evaluated_element.send("#{k}=", error_index)
-                  # we set new error element
-                  error_element.id = error_index
-
-                  if error_type == "user_error"
-                    error_element.message = "[USER ERROR] " + error_message
-                  elsif error_type == "test_error"
-                    error_element.message = "[TEST ERROR] " + error_message
-                  else
-                    error_element.message = "[SERVER ERROR] " + error_message
-                  end
-
-                  # add it with other
-                  @error_data << error_element
-                end
-              else
-                evaluated_element.send("#{k}=", value_of(structured_element, v))
-                # eval "evaluated_element.#{k}=structured_element.#{v}"
-              end
-            rescue NoMethodError => e
-              unless e.message.include? "nil:NilClass"
-                # when chaining comands there are situations where more complex strcture
-                # e.g. external_ref.region will not be there. So we are handling that case
-                # make sure when in development to disable this TODO: better solution needed
-                raise DTK::Client::DtkError,"Error with missing metadata occurred. There is a mistake in table metadata or unexpected data presented to table view."
-              end
-            end
-          end
-
-          @order_definition.delete('errors')
-
-          @evaluated_data << evaluated_element
-        end
-      end
-
-      def get_metadata
-        content = DiskCacher.new.fetch("table_metadata", ::DTK::Configuration.get(:meta_table_ttl))
-        raise DTK::Client::DtkError, "Table metadata is empty, please contact DTK team." if content.empty?
-        return JSON.parse(content)
-      end
-
-      def to_ostruct(data)
-        result = data.inject({}) do |res, (k, v)|
-          k = safe_name(k)
-          case v
-          when Hash
-            res.store(k, to_ostruct(v))
-            res
-          when Array
-            res.store(k, v.each { |el| Hash === el ? to_ostruct(el) : el })
-            res
-          else
-            res.store(k,v)
-            res
-          end
-        end
-
-        DtkOpenStruct.new(result)
-      end
-
-      def safe_name(identifier)
-        (identifier == 'id' || identifier  == 'type') ? "dtk_#{identifier}" : identifier
-      end
-
-      def get_table_defintion(name,is_order=false)
-        begin
-          @table_defintions[name.downcase][(is_order ? 'order' : 'mapping')]
-        rescue NameError => e
-          return nil
-        end
-      end
-
-      # Check if custom metadata is sent in valid format
-      def validate_forced_metadata(forced_metadata)
-        # if custom metadata does not contain order(Array) or mapping(Hash),then it's not valid metadata
-        unless (forced_metadata['order'].nil? || forced_metadata['mapping'].nil?)
-          return if (forced_metadata['order'].class.eql?(Array) && forced_metadata['mapping'].class.eql?(Hash))
-        end
-
-        raise DTK::Client::DtkError,"Provided table definition is not valid. Please review your order and mapping for provided definition: \n #{forced_metadata.inspect}"
-      end
-
-      def filter_remove_underscore(field)
-
-      end
-
-      def print
-        filter_remove_underscore = Proc.new { |header| header.gsub('_',' ').upcase }
-        # hirb print out of our evaluated data in order defined
-        # Available options can be viewed here: http://tagaholic.me/hirb/doc/classes/Hirb/Helpers/Table.html#M000008
-        table(@evaluated_data,{:fields => @order_definition,:escape_special_chars => true, :resize => false, :vertical => false, :header_filter => filter_remove_underscore })
-
-        # in case there were error we print those errors
-        unless @error_data.empty?
-          printf "\nERRORS: \n\n"
-          #table(@error_data,{:fields => [ :id, :message ]})
-          @error_data.each do |error_row|
-            printf "%15s %s\n", error_row.id.colorize(:yellow), error_row.message.colorize(:red)
-          end
-        end
-
-        unless @action_data.empty?
-          printf " \n"
-          #table(@error_data,{:fields => [ :id, :message ]})
-          printed = []
-          @action_data.each do |action_row|
-            # printf "%15s\n"
-            # printf("  INFO: #{action_row.message.colorize(:yellow)} \n") #, action_row.id.colorize(:yellow), action_row.message.colorize(:yellow)
-            message = action_row.message
-            printf "%15s %s\n", "INFO:".colorize(:yellow), message.colorize(:yellow) unless printed.include?(message)
-            printed << message
-          end
-        end
-      end
-
-      private
-
-      # based on string sequence in mapped_command we are executing list of commands to follow
-      # so for value of "foo.bar.split('.').last" we will get 4 commands that will
-      # sequentaly be executed using values from previus results
-      def value_of(open_struct_object, mapped_command)
-        # split string by '.' delimiter keeping in mind to split when words only
-        commands = mapped_command.split(/\.(?=\w)/)
-
-        value = open_struct_object
-        commands.each do |command|
-          value = evaluate_command(value, command)
-        end
-        return value
-      end
-
-
-      def evaluate_command(value, command)
-        case
-          when command.include?('map{')
-            matched_data = command.match(/\['(.+)'\]/)
-
-            my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}}
-            value = my_lambda.call(value)
-
-            raise DTK::Client::DtkError,"There is a mistake in table metadata: #{command.inspect}" if value.nil?
-          when command.include?('(')
-            # matches command and params e.g. split('.') => [1] split, [2] '.'
-            matched_data = command.match(/(.+)\((.+)\)/)
-            command, params = matched_data[1], matched_data[2]
-            value = value.send(command,params)
-          when command.include?('[')
-            # matches command such as first['foo']
-            matched_data    = command.match(/(.+)\[(.+)\]/)
-            command, params =  matched_data[1],matched_data[2]
-
-            value = evaluate_command(value,command)
-            value = value.send('[]',params)
-          when command.start_with?("list_")
-            matched_data = command.match(/list_(.+)/)
-
-            my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}}
-            value = my_lambda.call(value)
-
-            raise DTK::Client::DtkError,"There is a mistake in table metadata: #{command.inspect}" if value.nil?
-          when command.start_with?("count_")
-            matched_data = command.match(/count_(.+)/)
-
-            my_lambda = lambda{|_x| _x.map{|r|r["#{matched_data[1]}"]||[]}.flatten.size}
-            value = my_lambda.call(value)
-
-            raise DTK::Client::DtkError,"There is a mistake in table metadata: #{command.inspect}" if value.nil?
-          else
-            value = value.send(command)
-        end
-        return value
-      end
-    end
-  end
-end