cmis_active 0.3.7

data/lib/active_cmis/policy.rb

@@ -0,0 +1,13 @@
+module ActiveCMIS
+  class Policy < ActiveCMIS::Object
+    private
+    def create_url
+      if f = parent_folders.first
+        f.items.url
+      else
+        raise "not yet"
+        # Policy collection of containing document?
+      end
+    end
+  end
+end

data/lib/active_cmis/property_definition.rb

@@ -0,0 +1,179 @@
+module ActiveCMIS
+  class PropertyDefinition
+    # @return [String]
+    attr_reader :object_type, :id, :local_name, :local_namespace, :query_name,
+      :display_name, :description, :cardinality, :property_type, :updatability,
+      :default_value
+    # @return [Boolean]
+    attr_reader :inherited, :required, :queryable, :orderable, :choices, :open_choice
+
+    # @private
+    def initialize(object_type, property_definition)
+      @object_type = object_type
+      @property_definition = property_definition
+      params = {}
+      property_type = nil
+      property_definition.map do |node|
+        next unless node.namespace
+        next unless node.namespace.href == NS::CMIS_CORE
+
+        # FIXME: add support for "choices"
+        case node.node_name
+        when "id"
+          @id = node.text
+        when "localName"
+          @local_name = node.text
+        when "localNamespace"
+          @local_namespace = node.text
+        when "displayName"
+          @display_name = node.text
+        when "queryName"
+          @query_name = node.text
+        when "propertyType"
+          # Will be post processed, but we need to know all the parameters before we can pick an atomic type
+          property_type = node.text
+        when "cardinality"
+          @cardinality = node.text
+        when "updatability"
+          @updatability = node.text
+        when "inherited"
+          @inherited = AtomicType::Boolean.xml_to_bool(node.text)
+        when "required"
+          @required = AtomicType::Boolean.xml_to_bool(node.text)
+        when "queryable"
+          @queryable = AtomicType::Boolean.xml_to_bool(node.text)
+        when "orderable"
+          @orderable = AtomicType::Boolean.xml_to_bool(node.text)
+        when "openChoice"
+          @open_choice = AtomicType::Boolean.xml_to_bool(node.text)
+        when "maxValue", "minValue", "resolution", "precision", "maxLength"
+          params[node.node_name] = node.text
+        end
+      end
+
+      if required and updatability == "readonly"
+        logger.warn "The server behaved strange: attribute #{self.inspect} required but readonly, will set required to false"
+        @required = false
+      end
+      if id == "cmis:objectTypeId" and updatability != "oncreate"
+        logger.warn "The server behaved strange: cmis:objectTypeId should be updatable on create but #{updatability}"
+        @updatability = "oncreate"
+      end
+
+      @property_type = case property_type.downcase
+      when "string"
+        max_length = params["maxLength"] ? params["maxLength"].to_i : nil
+        AtomicType::String.new(max_length)
+      when "decimal"
+        min_value = params["minValue"] ? params["minValue"].to_f : nil
+        max_value = params["maxValue"] ? params["maxValue"].to_f : nil
+        AtomicType::Decimal.new(params["precision"].to_i, min_value, max_value)
+      when "integer"
+        min_value = params["minValue"] ? params["minValue"].to_i : nil
+        max_value = params["maxValue"] ? params["maxValue"].to_i : nil
+        AtomicType::Integer.new(min_value, max_value)
+      when "datetime"
+        AtomicType::DateTime.new(params["resolution"] || (logger.warn "No resolution for DateTime #{@id}"; "time") )
+      when "html"
+        AtomicType::HTML.new
+      when "id"
+        AtomicType::ID.new
+      when "boolean"
+        AtomicType::Boolean.new
+      when "uri"
+        AtomicType::URI.new
+      else
+        raise "Unknown property type #{property_type}"
+      end
+    end
+
+    # @return [Boolean] Returns true if the attribute can have multiple values
+    def repeating
+      cardinality == "multi"
+    end
+
+    # @return [String]
+    def inspect
+      "#{object_type.display_name}:#{id} => #{property_type}#{"[]" if repeating}"
+    end
+    alias to_s inspect
+
+    # @return [String]
+    def property_name
+      "property#{property_type}"
+    end
+
+    # @private
+    def render_property(xml, value)
+      xml["c"].send(property_name, "propertyDefinitionId" => id) {
+        if repeating
+          value.each do |v|
+            property_type.rb2cmis(xml, v)
+          end
+        else
+          property_type.rb2cmis(xml, value)
+        end
+      }
+    end
+
+    # @private
+    # FIXME: should probably also raise error for out of bounds case
+    def validate_ruby_value(value)
+      if updatability == "readonly" # FIXME: what about oncreate?
+        raise "You are trying to update a readonly attribute (#{self})"
+      elsif required && value.nil?
+        raise "You are trying to unset a required attribute (#{self})"
+      elsif repeating != (Array === value)
+        raise "You are ignoring the cardinality for an attribute (#{self})"
+      else
+        if repeating && z = value.detect {|v| !property_type.can_handle?(v)}
+          raise "Can't assign attribute with type #{z.class} to attribute with type #{property_type}"
+        elsif !repeating && !property_type.can_handle?(value)
+          raise "Can't assign attribute with type #{value.class} to attribute with type #{property_type}"
+        end
+      end
+    end
+
+    # @private
+    def extract_property(properties)
+      elements = properties.children.select do |n|
+        n.node_name == property_name &&
+          n["propertyDefinitionId"] == id &&
+          n.namespace.href == NS::CMIS_CORE
+      end
+      if elements.empty?
+        if required
+          logger.warn "The server behaved strange: attribute #{self.inspect} required but not present among properties"
+          # raise ActiveCMIS::Error.new("The server behaved strange: attribute #{self.inspect} required but not present among properties")
+        end
+        if repeating
+          []
+        else
+          nil
+        end
+      elsif elements.length == 1
+        values = elements.first.children.select {|node| node.name == 'value' && node.namespace && node.namespace.href == ActiveCMIS::NS::CMIS_CORE}
+        if required && values.empty?
+          logger.warn "The server behaved strange: attribute #{self.inspect} required but not present among properties"
+          #raise ActiveCMIS::Error.new("The server behaved strange: attribute #{self.inspect} required but no values specified")
+        end
+        if !repeating && values.length > 1
+          logger.warn "The server behaved strange: attribute #{self.inspect} required but not present among properties"
+          #raise ActiveCMIS::Error.new("The server behaved strange: attribute #{self.inspect} not repeating but multiple values given")
+        end
+        values
+      else
+        raise "Property is not unique"
+      end
+    end
+
+    # @return [Logger] The logger of the repository
+    def logger
+      repository.logger
+    end
+    # @return [Repository] The repository that the CMIS type is defined in
+    def repository
+      object_type.repository
+    end
+  end
+end

data/lib/active_cmis/query_result.rb

@@ -0,0 +1,40 @@
+module ActiveCMIS
+  # QueryResults are returned when doing a query
+  # You can retrieve the values they contain either by the properties ID or by the query name.
+  #
+  # Since it is possible that a JOIN is being requested it is not guaranteed that either the query name or the object ID are unique.
+  # If that's not the case then it is impossible to retrieve one of the two values. It is therefore important to choose unique queryNames
+  #  Furthermore, it is not possible to guess which type a query is returning, and therefore it is also not possible to know whether a property is repeating or not, it is possible that a repeating property contains 0 or 1 values, in which case nil or that single value are returned. If multiple values are found for a property then an Array with those properties will be returned
+  class QueryResult
+    def initialize(atom_entry)
+      @atom_entry = atom_entry
+      properties = atom_entry.xpath("cra:object/c:properties/c:*", NS::COMBINED)
+      @properties_by_id = {}
+      @properties_by_query_name = {}
+      properties.each do |property|
+        type = ActiveCMIS::AtomicType::MAPPING[property.node_name]
+        converter = type.new
+
+        values = property.xpath("c:value", NS::COMBINED)
+        # FIXME: If attributes are repeating, but have 0-1 value they won't be in array
+        if values.length > 1
+          value = values.map {|v| converter.cmis2rb(v)}
+        elsif !values.empty?
+          value = converter.cmis2rb(values)
+        else
+          value = nil
+        end
+        @properties_by_id[property["propertyDefinitionId"]] = value
+        @properties_by_query_name[property["queryName"]] = value
+      end
+    end
+
+    def property_by_id(name)
+      @properties_by_id[name]
+    end
+
+    def property_by_query_name(name)
+      @properties_by_query_name[name]
+    end
+  end
+end

data/lib/active_cmis/rel.rb

@@ -0,0 +1,17 @@
+module ActiveCMIS
+  module Rel
+    def self.[](version)
+      if version == '1.0'
+        prefix = "http://docs.oasis-open.org/ns/cmis/link/200908/"
+        {
+          :allowableactions => "#{prefix}allowableactions",
+          :acl => "#{prefix}acl",
+          :relationships => "#{prefix}relationships",
+          :changes => "#{prefix}changes",
+        }
+      else
+        raise ActiveCMIS::Error.new("ActiveCMIS only works with CMIS 1.0, requested version was #{version}")
+      end
+    end
+  end
+end

data/lib/active_cmis/relationship.rb

@@ -0,0 +1,49 @@
+module ActiveCMIS
+  class Relationship < ::ActiveCMIS::Object
+    # @return [Object]
+    def source
+      Internal::Utils.string_or_id_to_object(repository, attribute("cmis:sourceId"))
+    end
+    cache :source
+
+    # @return [Object]
+    def target
+      Internal::Utils.string_or_id_to_object(repository, attribute("cmis:targetId"))
+    end
+    cache :target
+
+    # Remove the relationship
+    # @return [void]
+    def delete
+      conn.delete(self_link)
+    end
+
+    # @see Object#update
+    # @param (see ActiveCMIS::Object#update)
+    # @return [void]
+    def update(updates = {})
+      super
+      # Potentially necessary if repositories support it
+      # Probably not though
+
+      # Note: we use remove_instance_variable because of the way I implemented the caching
+      if updates["cmis:sourceId"] && instance_variable_defined?("@source")
+        remove_instance_variable "@source"
+      end
+      if updates["cmis:targetId"] && instance_variable_defined?("@target")
+        remove_instance_variable "@target"
+      end
+    end
+
+    # Return [], a relationship is not fileable
+    # @return [Array()]
+    def parent_folders
+      []
+    end
+
+    private
+    def create_url
+      source.source_relations.url
+    end
+  end
+end

data/lib/active_cmis/rendition.rb

@@ -0,0 +1,86 @@
+module ActiveCMIS
+  class Rendition
+    # @return [Repository]
+    attr_reader :repository
+    # @return [Numeric,nil] Size of the rendition, may not be given or misleading
+    attr_reader :size
+    # @return [String,nil]
+    attr_reader :rendition_kind
+    # @return [String,nil] The format is equal to the mime type, but may be unset or misleading
+    attr_reader :format
+    # @return [ActiveCMIS::Document] The document to which the rendition belongs
+    attr_reader :document
+
+    # @private
+    def initialize(repository, document, link)
+      @repository = repository
+      @document = document
+
+      @rel = link['rel'] == "alternate"
+      @rendition_kind = link['renditionKind'] if rendition?
+      @format = link['type']
+      if link['href']
+        @url = URI(link['href'])
+      else # For inline content streams
+        @data = link['data']
+      end
+      @size = link['length'] ? link['length'].to_i : nil
+
+
+      @link = link # FIXME: For debugging purposes only, remove
+    end
+
+    # Used to differentiate between rendition and primary content
+    def rendition?
+      @rel == "alternate"
+    end
+    # Used to differentiate between rendition and primary content
+    def primary?
+      @rel.nil?
+    end
+
+    # Returns a hash with the name of the file to which was written, the length, and the content type
+    #
+    # *WARNING*: this loads the complete file in memory and dumps it at once, this should be fixed
+    # @param [String] file_name Location to store the content.
+    # @return [Hash]
+    def get_file(file_name)
+      response = get_data
+      File.open(file_name, "w") {|f| f.syswrite response.delete(:data) }
+      response.merge!(:file_name => file_name)
+    end
+
+    # Returns a hash with the data of te rendition, the length and the content type
+    #
+    # *WARNING*: this loads all the data in memory
+    # Possible future enhancement could be to allow a block to which data is passed in chunks?r
+    # Not sure that is possible with Net::HTTP though.
+    # @param [String] filename Location to store the content.
+    # @return [Hash]
+    def get_data
+      if @url
+        response = repository.conn.get_response(@url)
+        status = response.code.to_i
+        if 200 <= status && status < 300
+          data = response.body
+        elsif 300 <= status && status < 400
+          location = response["location"]
+          new_url = URI.parse(location)
+          new_url = @url + location if new_url.relative?
+          @url = new_url
+          get_data
+        else
+          raise HTTPError.new("Problem downloading rendition: status: #{status}, message: #{response.body}")
+        end
+        content_type = response.content_type
+        content_length = response.content_length || response.body.length # In case content encoding is chunked? ??
+      else
+        data = @data
+        content_type = @format
+        content_length = @data.length
+      end
+
+      {:data => data, :content_type => content_type, :content_length => content_length}
+    end
+  end
+end

data/lib/active_cmis/repository.rb

@@ -0,0 +1,327 @@
+module ActiveCMIS
+  class Repository
+    # @return [Logger] A logger to which debug output and so on is sent
+    attr_reader :logger
+
+    # @return [ActiveCMIS::Server] The server from which the repository was
+    #     requested
+    attr_reader :server
+
+    # @private
+    def initialize(server, connection, logger, initial_data, authentication_info) #:nodoc:
+      @server = server
+      @conn = connection
+      @data = initial_data
+      @logger = logger
+      method, *params = authentication_info
+      if method
+        conn.authenticate(method, *params)
+      end
+    end
+
+    # Use authentication to access the CMIS repository
+    # This returns a new Repository object, the existing repository will still
+    # use the previous authentication info.
+    # If the used authentication info (method, username, password) is the same
+    # as for the current Repository object, then self will be returned (unless
+    # the server repository cache is cleared first)
+    #
+    # e.g.: authenticated = repo.authenticate(:basic, "username", "password")
+    # @param method [:basic, :ntlm]
+    # @param username [String]
+    # @param password [String]
+    # @return [Repository]
+    def authenticate(*authentication_info)
+      server.repository(key, authentication_info)
+    end
+
+    # The identifier of the repository
+    # @return [String]
+    def key
+      @key ||= data.xpath('cra:repositoryInfo/c:repositoryId', NS::COMBINED).text
+    end
+
+    # @return [String]
+    def inspect
+      "<#ActiveCMIS::Repository #{key}>"
+    end
+
+    # The version of the CMIS standard supported by this repository
+    # @return [String]
+    def cmis_version
+      # NOTE: we might want to "version" our xml namespaces depending on the CMIS version
+      # If we do that we need to make this method capable of not using the predefined namespaces
+      #
+      # On the other hand breaking the XML namespace is probably going to break other applications too so the might not change them even when the spec is updated
+      @cmis_version ||= data.xpath("cra:repositoryInfo/c:cmisVersionSupported", NS::COMBINED).text
+    end
+
+    # The name of the repository, meant for display purposes
+    # @return [String]
+    def name
+      @name ||= data.xpath("cra:repositoryInfo/c:repositoryName", NS::COMBINED).text
+    end
+
+    # A description of the repository
+    # @return [String]
+    def description
+      @name ||= data.xpath("cra:repositoryInfo/c:repositoryDescription", NS::COMBINED).text
+    end
+
+    # The name of the vendor of this Repository
+    # @return [String]
+    def vendor
+      @vendor ||= data.xpath("cra:repositoryInfo/c:vendorName", NS::COMBINED).text
+    end
+
+    # The name of the product behind this Repository
+    # @return [String]
+    def product_name
+      @product_name ||= data.xpath("cra:repositoryInfo/c:productName", NS::COMBINED).text
+    end
+
+    # The version of the product behind this Repository
+    # @return [String]
+    def product_version
+      @product_version ||= data.xpath("cra:repositoryInfo/c:productVersion", NS::COMBINED).text
+    end
+
+    # Changelog token representing the most recent change to this repository (will
+    # represent the most recent change at the time that this ActiveCMIS::Repository
+    # was created
+    # @return [String]
+    def latest_changelog_token
+      @changelog_token ||= data.xpath("cra:repositoryInfo/c:latestChangeLogToken", NS::COMBINED).text
+    end
+
+    # A URI that points to a web service for this repository. May not be present
+    # @return [URI, nil]
+    def thin_client_uri
+      @thin_client_uri ||= begin
+                             string = data.xpath("cra:repositoryInfo/c:thinClientURI", NS::COMBINED).text
+                             URI.parse(string) if string && string != ""
+                           end
+    end
+
+    # Finds the object with a given ID in the repository
+    #
+    # @param [String] id
+    # @param parameters A list of parameters used to get (defaults are what you should use)
+    # @return [Object]
+    def object_by_id(id, parameters = {"renditionFilter" => "*", "includeAllowableActions" => "true", "includeACL" => true})
+      ActiveCMIS::Object.from_parameters(self, parameters.merge("id" => id))
+    end
+
+    # @private
+    def object_by_id_url(parameters)
+      template = pick_template("objectbyid")
+      raise "Repository does not define required URI-template 'objectbyid'" unless template
+      url = fill_in_template(template, parameters)
+    end
+
+    # Finds the type with a given ID in the repository
+    # @return [Class]
+    def type_by_id(id)
+      @type_by_id ||= {}
+      if result = @type_by_id[id]
+        result
+      else
+        template = pick_template("typebyid")
+        raise "Repository does not define required URI-template 'typebyid'" unless template
+        url = fill_in_template(template, "id" => id)
+
+        @type_by_id[id] = Type.create(conn, self, conn.get_atom_entry(url))
+      end
+    end
+
+    %w[root checkedout unfiled].each do |coll_name|
+      define_method coll_name do
+        iv = :"@#{coll_name}"
+        if instance_variable_defined?(iv)
+          instance_variable_get(iv)
+        else
+          href = data.xpath("app:collection[cra:collectionType[child::text() = '#{coll_name}']]/@href", NS::COMBINED)
+          if href.first
+            result = Collection.new(self, href.first)
+          else
+            result = nil
+          end
+          instance_variable_set(iv, result)
+        end
+      end
+    end
+
+    # A collection containing the CMIS base types supported by this repository
+    # @return [Collection<Class>]
+    def base_types
+      @base_types ||= begin
+                        query = "app:collection[cra:collectionType[child::text() = 'types']]/@href"
+                        href = data.xpath(query, NS::COMBINED)
+                        if href.first
+                          url = href.first.text
+                          Collection.new(self, url) do |entry|
+                            id = entry.xpath("cra:type/c:id", NS::COMBINED).text
+                            type_by_id id
+                          end
+                        else
+                          raise "Repository has no types collection, this is strange and wrong"
+                        end
+                      end
+    end
+
+    # An array containing all the types used by this repository
+    # @return [<Class>]
+    def types
+      @types ||= base_types.map do |t|
+        t.all_subtypes
+      end.flatten
+    end
+
+    # Returns a collection with the changes since the given changeLogToken.
+    #
+    # Completely uncached so use with care
+    #
+    # @param options Keys can be Symbol or String, all options are optional
+    # @option options [String] filter
+    # @option options [String] changeLogToken A token indicating which changes you already know about
+    # @option options [Integer] maxItems For paging
+    # @option options [Boolean] includeAcl
+    # @option options [Boolean] includePolicyIds
+    # @option options [Boolean] includeProperties
+    # @return [Collection]
+    def changes(options = {})
+      query = "at:link[@rel = '#{Rel[cmis_version][:changes]}']/@href"
+      link = data.xpath(query, NS::COMBINED)
+      if link = link.first
+        link = Internal::Utils.append_parameters(link.to_s, options)
+        Collection.new(self, link)
+      end
+    end
+
+    # Returns a collection with the results of a query (if supported by the repository)
+    #
+    # @param [#to_s] query_string A query in the CMIS SQL format (unescaped in any way)
+    # @param [{Symbol => ::Object}] options Optional configuration for the query
+    # @option options [Boolean] :searchAllVersions (false)
+    # @option options [Boolean] :includeAllowableActions (false)
+    # @option options ["none","source","target","both"] :includeRelationships
+    # @option options [String] :renditionFilter ('cmis:none') Possible values: 'cmis:none', '*' (all), comma-separated list of rendition kinds or mimetypes
+    # @option options [Integer] :maxItems used for paging
+    # @option options [Integer] :skipCount (0) used for paging
+    # @return [Collection] A collection with each return value wrapped in a QueryResult
+    def query(query_string, options = {})
+      raise "This repository does not support queries" if capabilities["Query"] == "none"
+      # For the moment we make no difference between metadataonly,fulltextonly,bothseparate and bothcombined
+      # Nor do we look at capabilities["Join"] (none, inneronly, innerandouter)
+
+      # For searchAllVersions need to check capabilities["AllVersionsSearchable"]
+      # includeRelationships, includeAllowableActions and renditionFilter only work if SELECT only contains attributes from 1 object
+      valid_params = ["searchAllVersions", "includeAllowableActions", "includeRelationships", "renditionFilter", "maxItems", "skipCount"]
+      invalid_params = options.keys - valid_params
+      unless invalid_params.empty?
+        raise "Invalid parameters for query: #{invalid_params.join ', '}"
+      end
+
+      # FIXME: options are not respected yet by pick_template
+      url = pick_template("query", :mimetype => "application/atom+xml", :type => "feed")
+      url = fill_in_template(url, options.merge("q" => query_string))
+      Collection.new(self, url) do |entry|
+        QueryResult.new(entry)
+      end
+    end
+
+    # The root folder of the repository (as defined in the CMIS standard)
+    # @return [Folder]
+    def root_folder(reload = false)
+      if reload
+        @root_folder = object_by_id(data.xpath("cra:repositoryInfo/c:rootFolderId", NS::COMBINED).text)
+      else
+        @root_folder ||= object_by_id(data.xpath("cra:repositoryInfo/c:rootFolderId", NS::COMBINED).text)
+      end
+    end
+
+    # Returns an Internal::Connection object, normally you should not use this directly
+    # @return [Internal::Connection]
+    def conn
+      @conn ||= Internal::Connection.new
+    end
+
+    # Describes the capabilities of the repository
+    # @return [Hash{String => String,Boolean}] The hash keys have capability cut of their name
+    def capabilities
+      @capabilities ||= begin
+                          capa = {}
+                          data.xpath("cra:repositoryInfo/c:capabilities/*", NS::COMBINED).map do |node|
+                            # FIXME: conversion should be based on knowledge about data model + transforming bool code should not be duplicated
+                            capa[node.name.sub("capability", "")] = case t = node.text
+                                              when "true", "1"; true
+                                              when "false", "0"; false
+                                              else t
+                                              end
+                          end
+                          capa
+                        end
+    end
+
+    # Responds with true if Private Working Copies are updateable, false otherwise
+    # (if false the PWC object can only be updated during the checkin)
+    def pwc_updatable?
+      capabilities["PWCUpdatable"]
+    end
+
+    # Responds with true if different versions of the same document can
+    # be filed in different folders
+    def version_specific_filing?
+      capabilities["VersionSpecificFiling"]
+    end
+
+    # returns true if ACLs can at least be viewed
+    def acls_readable?
+      ["manage", "discover"].include? capabilities["ACL"]
+    end
+
+    # You should probably not use this directly, use :anonymous instead where a user name is required
+    # @return [String]
+    def anonymous_user
+      if acls_readable?
+        data.xpath('cra:repositoryInfo/c:principalAnonymous', NS::COMBINED).text
+      end
+    end
+
+    # You should probably not use this directly, use :world instead where a user name is required
+    # @return [String]
+    def world_user
+      if acls_readable?
+        data.xpath('cra:repositoryInfo/c:principalAnyone', NS::COMBINED).text
+      end
+    end
+
+    private
+    # @private
+    attr_reader :data
+
+    def pick_template(name, options = {})
+      # FIXME: we can have more than 1 template with differing media types
+      #        I'm not sure how to pick the right one in the most generic/portable way though
+      #        So for the moment we pick the 1st and hope for the best
+      #        Options are ignored for the moment
+      data.xpath("n:uritemplate[n:type[child::text() = '#{name}']][1]/n:template", "n" => NS::CMIS_REST).text
+    end
+
+
+    # The type parameter should contain the type of the uri-template
+    #
+    # The keys of the values hash should be strings,
+    # if a key is not in the hash it is presumed to be equal to the empty string
+    # The values will be percent-encoded in the fill_in_template method
+    # If a given key is not present in the template it will be ignored silently
+    #
+    # e.g. fill_in_template("objectbyid", "id" => "@root@", "includeACL" => true)
+    #      -> 'http://example.org/repo/%40root%40?includeRelationships&includeACL=true'
+    def fill_in_template(template, values)
+      result = template.gsub(/\{([^}]+)\}/) do |match|
+        Internal::Utils.percent_encode(values[$1].to_s)
+      end
+    end
+  end
+end