rdf-n3 3.1.1 → 3.1.2

data/lib/rdf/n3/reasoner.rb

@@ -11,13 +11,13 @@ module RDF::N3
     include RDF::Mutable
     include RDF::Util::Logger
 
-    # The top-level parsed formula
+    # The top-level parsed formula, including builtins and variables.
     # @return [RDF::N3::Algebra::Formula]
     attr_reader :formula
 
     # Opens a Notation-3 file, and parses it to initialize the reasoner
     #
-    # @param  [String, #to_s] filename
+    # @param  [String, #to_s] file
     # @yield  [reasoner] `self`
     # @yieldparam  [RDF::N3::Reasoner] reasoner
     # @yieldreturn [void] ignored
@@ -50,7 +50,8 @@ module RDF::N3
     #   RDF::N3::Reader.open("rules.n3") {|r| reasoner << r}
     #   reasoner.each_triple {}
     #
-    # @param  [RDF::Enumerable] input (nil)
+    # @param  [RDF::Mutable] input (nil)
+    #   Input should be parsed N3 using native lists (see `:list_terms` option to {RDF::N3::Reader#initialize})
     # @param  [Hash{Symbol => Object}] options
     # @option options [#to_s]    :base_uri     (nil)
     #   the base URI to use when resolving relative URIs (for acessing intermediate parser productions)
@@ -59,14 +60,16 @@ module RDF::N3
     # @yieldreturn [void] ignored
     # @return [RDF::N3::Reasoner]
     def initialize(input, **options, &block)
-      @options = options
+      @options = options.merge(strings: {}) # for --strings and log:outputString
       @mutable = case input
       when RDF::Mutable then input
-      when RDF::Enumerable then RDF::Repository.new {|r| r << input}
-      else RDF::Repository.new
+      when RDF::Enumerable then RDF::N3::Repository.new {|r| r << input}
+      else RDF::N3::Repository.new
       end
 
-      log_debug("reasoner: expression", **options) {SXP::Generator.string(formula.to_sxp_bin)}
+      @formula = input if input.is_a?(RDF::N3::Algebra::Formula)
+
+      log_debug("reasoner: expression") {SXP::Generator.string(formula.to_sxp_bin)}
 
       if block_given?
         case block.arity
@@ -79,7 +82,7 @@ module RDF::N3
     ##
     # Returns a copy of this reasoner
     def dup
-      repo = RDF::Repository.new {|r| r << @mutable}
+      repo = RDF::N3::Repository.new {|r| r << @mutable}
       self.class.new(repo) do |reasoner|
         reasoner.instance_variable_set(:@options, @options.dup)
         reasoner.instance_variable_set(:@formula, @formula.dup) if @formula
@@ -92,6 +95,7 @@ module RDF::N3
     # @param  [RDF::Statement] statement
     # @return [void]
     def insert_statement(statement)
+      @formula = nil
       @mutable.insert_statement(statement)
     end
 
@@ -100,6 +104,7 @@ module RDF::N3
     #
     # @param  [Hash{Symbol => Object}] options
     # @option options [Boolean] :apply
+    # @option options [Boolean] :rules
     # @option options [Boolean] :think
     # @yield  [statement]
     # @yieldparam  [RDF::Statement] statement
@@ -107,29 +112,38 @@ module RDF::N3
     def execute(**options, &block)
       @options[:logger] = options[:logger] if options.has_key?(:logger)
 
+      # The knowledge base is the non-variable portions of formula
+      knowledge_base = RDF::N3::Repository.new {|r| r << formula}
+      log_debug("reasoner: knowledge_base") {SXP::Generator.string(knowledge_base.statements.to_sxp_bin)}
+
       # If thinking, continuously execute until results stop growing
-      if options[:think]
-        count = 0
-        log_info("reasoner: think start") { "count: #{count}"}
-        while @mutable.count > count
-          count = @mutable.count
-          dataset = RDF::Graph.new << @mutable.project_graph(nil)
-          log_depth {formula.execute(dataset, **options)}
-          @mutable << formula
+      count = -1
+      log_info("reasoner: start") { "count: #{count}"}
+      solutions = RDF::Query::Solutions(RDF::Query::Solution.new)
+      while knowledge_base.count > count
+        log_info("reasoner: do") { "count: #{count}"}
+        count = knowledge_base.count
+        log_depth {formula.execute(knowledge_base, solutions: solutions, **options)}
+        knowledge_base << formula
+        solutions = RDF::Query::Solutions(RDF::Query::Solution.new) if solutions.empty?
+        log_debug("reasoner: solutions") {SXP::Generator.string solutions.to_sxp_bin}
+        log_debug("reasoner: datastore") {SXP::Generator.string knowledge_base.statements.to_sxp_bin}
+        log_info("reasoner: inferred") {SXP::Generator.string knowledge_base.statements.select(&:inferred?).to_sxp_bin}
+        log_info("reasoner: formula") do
+          SXP::Generator.string RDF::N3::Algebra::Formula.from_enumerable(knowledge_base).to_sxp_bin
+        end
+        @formula = nil # cause formula to be re-calculated from knowledge-base
+        unless options[:think]
+          count = knowledge_base.count
+          break
         end
-        log_info("reasoner: think end") { "count: #{count}"}
-      else
-        # Run one iteration
-        log_info("reasoner: apply start") { "count: #{count}"}
-        dataset = RDF::Graph.new << @mutable.project_graph(nil)
-        log_depth {formula.execute(dataset, **options)}
-        @mutable << formula
-        log_info("reasoner: apply end") { "count: #{count}"}
       end
+      log_info("reasoner: end") { "count: #{count}"}
 
-      log_debug("reasoner: datastore") {@mutable.to_sxp}
+      # Add updates back to mutable, containg builtins and variables.
+      @mutable << knowledge_base
 
-      conclusions(&block) if block_given?
+      each(&block) if block_given?
       self
     end
     alias_method :reason!, :execute
@@ -137,7 +151,7 @@ module RDF::N3
     ##
     # Reason with results in a duplicate datastore
     #
-    # @see {execute}
+    # @see execute
     def reason(**options, &block)
       self.dup.reason!(**options, &block)
     end
@@ -180,7 +194,7 @@ module RDF::N3
     alias_method :each_datum, :data
 
     ##
-    # Returns an enumerator for {#conclusions}.
+    # Returns an enumerator for {#data}.
     # FIXME: enum_for doesn't seem to be working properly
     # in JRuby 1.7, so specs are marked pending
     #
@@ -234,49 +248,24 @@ module RDF::N3
     end
 
     ##
-    # Returns the top-level formula for this file
+    # Returns the concatenated strings from log:outputString
+    #
+    # @return [String]
+    def strings
+      @options[:strings].
+        sort_by {|k, v| k}.
+        map {|(k,v)| v.join("")}.
+        join("")
+    end
+
+    ##
+    # Returns the top-level formula for this file.
+    #
+    # Transforms an RDF dataset into a recursive formula structure.
     #
     # @return [RDF::N3::Algebra::Formula]
     def formula
-      # SPARQL used for SSE and algebra functionality
-      require 'sparql' unless defined?(:SPARQL)
-
-      @formula ||= begin
-        # Create formulae from statement graph_names
-        formulae = (@mutable.graph_names.unshift(nil)).inject({}) do |memo, graph_name|
-          memo.merge(graph_name => Algebra::Formula.new(graph_name: graph_name, **@options))
-        end
-
-        # Add patterns to appropiate formula based on graph_name,
-        # and replace subject and object bnodes which identify
-        # named graphs with those formula
-        @mutable.each_statement do |statement|
-          pattern = statement.variable? ? RDF::Query::Pattern.from(statement) : statement
-
-          # A graph name indicates a formula.
-          form = formulae[pattern.graph_name]
-
-          # Formulae may be the subject or object of a known operator
-          if klass = Algebra.for(pattern.predicate)
-            fs = formulae.fetch(pattern.subject, pattern.subject)
-            fo = formulae.fetch(pattern.object, pattern.object)
-            form.operands << klass.new(fs, fo, parent: form, **@options)
-          else
-            # Add formulae as direct operators
-            if formulae.has_key?(pattern.subject)
-              form.operands << formulae[pattern.subject]
-            end
-            if formulae.has_key?(pattern.object)
-              form.operands << formulae[pattern.object]
-            end
-            pattern.graph_name = nil
-            form.operands << pattern
-          end
-        end
-
-        # Formula is that without a graph name
-        formulae[nil]
-      end
+      @formula ||= RDF::N3::Algebra::Formula.from_enumerable(@mutable, **@options)
     end
 
     ##

data/lib/rdf/n3/refinements.rb

@@ -0,0 +1,178 @@
+# Refinements on core RDF class behavior for RDF::N3.
+module RDF::N3::Refinements
+  # @!parse
+  #   # Refinements on RDF::Term
+  #   module RDF::Term
+  #   ##
+  #   # As a term is constant, this returns itself.
+  #   #
+  #   # @param  [Hash{Symbol => RDF::Term}] bindings
+  #   #   a query solution containing zero or more variable bindings
+  #   # @param [Hash{Symbol => Object}] options ({})
+  #   #   options passed from query
+  #   # @return [RDF::Term]
+  #   # @see SPARQL::Algebra::Expression.evaluate
+  #   def evaluate(bindings, formulae: nil, **options); end
+  #   end
+  refine ::RDF::Term do
+    def evaluate(bindings, formulae:, **options)
+      self
+    end
+  end
+
+  # @!parse
+  #   # Refinements on RDF::Node
+  #   module RDF::Term
+  #     ##
+  #     # Blank node may refer to a formula.
+  #     #
+  #     # @param  [Hash{Symbol => RDF::Term}] bindings
+  #     #   a query solution containing zero or more variable bindings
+  #     # @param [Hash{Symbol => Object}] options ({})
+  #     #   options passed from query
+  #     # @return [RDF::Node, RDF::N3::Algebra::Formula]
+  #     # @see SPARQL::Algebra::Expression.evaluate
+  #     def evaluate(bindings, formulae:, **options); end
+  #   end
+  refine ::RDF::Node do
+    ##
+    # @return [RDF::Node, RDF::N3::Algebra::Formula]
+    def evaluate(bindings, formulae:, **options)
+      node? ? formulae.fetch(self, self) : self
+    end
+  end
+
+  # @!parse
+  #   # Refinements on RDF::Statement
+  #   class ::RDF::Statement
+  #     # Refines `valid?` to allow literal subjects and BNode predicates.
+  #     # @return [Boolean]
+  #     def valid?; end
+  #
+  #     # Refines `invalid?` to allow literal subjects and BNode predicates.
+  #     # @return [Boolean]
+  #     def invalid?; end
+  #
+  #     # Refines `validate!` to allow literal subjects and BNode predicates.
+  #     # @return [RDF::Value] `self`
+  #     # @raise  [ArgumentError] if the value is invalid
+  #     def validate!; end
+  #
+  #     ##
+  #     # As a statement is constant, this returns itself.
+  #     #
+  #     # @param  [Hash{Symbol => RDF::Term}] bindings
+  #     #   a query solution containing zero or more variable bindings
+  #     # @param [Hash{Symbol => Object}] options ({})
+  #     #   options passed from query
+  #     # @return [RDF::Statement]
+  #     # @see SPARQL::Algebra::Expression.evaluate
+  #     def evaluate(bindings, formulae:, **options); end
+  #   end
+  refine ::RDF::Statement do
+    ##
+    # Override `valid?` terms as subjects and resources as predicates.
+    #
+    # @return [Boolean]
+    def valid?
+      has_subject?    && subject.term? && subject.valid? &&
+      has_predicate?  && predicate.term? && predicate.valid? &&
+      has_object?     && object.term? && object.valid? &&
+      (has_graph?      ? (graph_name.resource? && graph_name.valid?) : true)
+    end
+
+    ##
+    # @return [Boolean]
+    def invalid?
+      !valid?
+    end
+
+    ##
+    # Default validate! implementation, overridden in concrete classes
+    # @return [RDF::Value] `self`
+    # @raise  [ArgumentError] if the value is invalid
+    def validate!
+      raise ArgumentError, "#{self.inspect} is not valid" if invalid?
+      self
+    end
+    alias_method :validate, :validate!
+
+    ##
+    # @return [RDF::Statement]
+    def evaluate(bindings, formulae:, **options)
+      self
+    end
+  end
+
+  # @!parse
+  #   # Refinements on RDF::Query::Pattern
+  #   class ::RDF::Query::Pattern
+  #     # Refines `#valid?` to allow literal subjects and BNode predicates.
+  #     # @return [Boolean]
+  #     def valid?; end
+  #
+  #     ##
+  #     # Evaluates the pattern using the given variable `bindings` by cloning the pattern replacing variables with their bindings recursively. If the resulting pattern is constant, it is cast as a statement.
+  #     #
+  #     # @param  [Hash{Symbol => RDF::Term}] bindings
+  #     #   a query solution containing zero or more variable bindings
+  #     # @param [Hash{Symbol => Object}] options ({})
+  #     #   options passed from query
+  #     # @return [RDF::Statement, RDF::N3::Algebra::Formula]
+  #     # @see SPARQL::Algebra::Expression.evaluate
+  #     def evaluate(bindings, formulae:, **options); end
+  #   end
+  refine ::RDF::Query::Pattern do
+    ##
+    # Is this pattern composed only of valid components?
+    #
+    # @return [Boolean] `true` or `false`
+    def valid?
+      (has_subject?   ? (subject.term? || subject.variable?) && subject.valid? : true) && 
+      (has_predicate? ? (predicate.term? || predicate.variable?) && predicate.valid? : true) &&
+      (has_object?    ? (object.term? || object.variable?) && object.valid? : true) &&
+      (has_graph?     ? (graph_name.resource? || graph_name.variable?) && graph_name.valid? : true)
+    rescue NoMethodError
+      false
+    end
+
+    # @return [RDF::Statement, RDF::N3::Algebra::Formula]
+    def evaluate(bindings, formulae:, **options)
+      elements = self.to_quad.map do |term|
+        term.evaluate(bindings, formulae: formulae, **options)
+      end.compact.map do |term|
+        term.node? ? formulae.fetch(term, term) : term
+      end
+
+      self.class.from(elements)
+    end
+  end
+
+  # @!parse
+  #   # Refinements on RDF::Query::Variable
+  #   class RDF::Query::Variable
+  #     ##
+  #     # If variable is bound, replace with the bound value, otherwise, returns itself
+  #     #
+  #     # @param  [Hash{Symbol => RDF::Term}] bindings
+  #     #   a query solution containing zero or more variable bindings
+  #     # @param [Hash{Symbol => Object}] options ({})
+  #     #   options passed from query
+  #     # @return [RDF::Term]
+  #     # @see SPARQL::Algebra::Expression.evaluate
+  #     def evaluate(bindings, formulae:, **options); end
+  #   end
+  refine ::RDF::Query::Variable do
+    ##
+    # @return [RDF::Term]
+    def evaluate(bindings, formulae:, **options)
+      value = bindings.has_key?(name) ? bindings[name] : self
+      value.node? ? formulae.fetch(value, value) : value
+    end
+  end
+
+  refine ::RDF::Graph do
+    # Allow a graph to be treated as a term in a statement.
+    include ::RDF::Term
+  end
+end

data/lib/rdf/n3/repository.rb

@@ -0,0 +1,332 @@
+module RDF::N3
+  ##
+  # Sub-class of RDF::Repository which allows for native lists in different positions.
+  class Repository < RDF::Repository
+    DEFAULT_GRAPH = false
+
+    ##
+    # Initializes this repository instance.
+    #
+    # @param [URI, #to_s]    uri (nil)
+    # @param [String, #to_s] title (nil)
+    # @param [Hash{Symbol => Object}] options
+    # @option options [Boolean]   :with_graph_name (true)
+    #   Indicates that the repository supports named graphs, otherwise,
+    #   only the default graph is supported.
+    # @option options [Boolean]   :with_validity (true)
+    #   Indicates that the repository supports named validation.
+    # @option options [Boolean]   :transaction_class (DEFAULT_TX_CLASS)
+    #   Specifies the RDF::Transaction implementation to use in this Repository.
+    # @yield  [repository]
+    # @yieldparam [Repository] repository
+    def initialize(uri: nil, title: nil, **options, &block)
+      @data = options.delete(:data) || {}
+      super do
+        if block_given?
+          case block.arity
+            when 1 then block.call(self)
+            else instance_eval(&block)
+          end
+        end
+      end
+    end
+
+    ##
+    # Returns `true` if this respository supports the given `feature`.
+    #
+    # This repository supports list_terms.
+    def supports?(feature)
+      case feature.to_sym
+      when :list_terms       then true
+      when :rdfstar          then true
+      when :snapshots        then false
+      else super
+      end
+    end
+
+    ##
+    # Creates a query from the statements in this repository, turning blank nodes into non-distinguished variables. This can be used to determine if this repository is logically a subset of another repository.
+    #
+    # @return [RDF::Query]
+    def to_query
+      RDF::Query.new do |query|
+        each do |statement|
+          query.pattern RDF::Query::Pattern.from(statement, ndvars: true)
+        end
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Countable#count
+    def count
+      count = 0
+      @data.each do |_, ss|
+        ss.each do |_, ps|
+          ps.each { |_, os| count += os.size }
+        end
+      end
+      count
+    end
+    
+    ##
+    # @private
+    # @see RDF::Enumerable#has_graph?      
+    def has_graph?(graph)
+      @data.has_key?(graph)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_graph
+    def graph_names(options = nil, &block)        
+      @data.keys.reject { |g| g == DEFAULT_GRAPH }.to_a
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_graph
+    def each_graph(&block)
+      if block_given?
+        @data.each_key do |gn|
+          yield RDF::Graph.new(graph_name: (gn == DEFAULT_GRAPH ? nil : gn), data: self)
+        end
+      end
+      enum_graph
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#has_statement?
+    def has_statement?(statement)
+      has_statement_in?(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Enumerable#each_statement
+    def each_statement(&block)
+      if block_given?
+        @data.each do |g, ss|
+          ss.each do |s, ps|
+            ps.each do |p, os|
+              os.each do |o, object_options|
+                yield RDF::Statement.new(s, p, o, object_options.merge(graph_name: g.equal?(DEFAULT_GRAPH) ? nil : g))
+              end
+            end
+          end
+        end
+      end
+      enum_statement
+    end
+    alias_method :each, :each_statement
+
+    ##
+    # Projects statements with lists expanded to first/rest chains
+    #
+    # @yield [RDF::Statement]
+    def each_expanded_statement(&block)
+      if block_given?
+        each_statement do |st|
+          if st.subject.list?
+            st.subject.each_statement(&block)
+            st.subject = st.subject.subject
+          end
+          if st.object.list?
+            st.object.each_statement(&block)
+            st.object = st.object.subject
+          end
+          block.call(st)
+        end
+      end
+      enum_for(:each_expanded_statement) unless block_given?
+    end
+
+    ##
+    # Returns the expanded statements for this repository
+    #
+    # @return [Array<RDF::Statement>]
+    def expanded_statements
+      each_expanded_statement.to_a
+    end
+
+    ##
+    # @see Mutable#apply_changeset
+    def apply_changeset(changeset)
+      data = @data
+      changeset.deletes.each do |del|
+        if del.constant?
+          data = delete_from(data, del)
+        else
+          # we need this condition to handle wildcard statements
+          query_pattern(del) { |stmt| data = delete_from(data, stmt) }
+        end
+      end
+      changeset.inserts.each { |ins| data = insert_to(data, ins) }
+      @data = data
+    end
+
+    ##
+    # @see RDF::Dataset#isolation_level
+    def isolation_level
+      :serializable
+    end
+
+    protected
+
+    ##
+    # Match elements with `eql?`, not `==`
+    #
+    # `graph_name` of `false` matches default graph. Unbound variable matches
+    # non-false graph name.
+    #
+    # Matches terms which are native lists.
+    #
+    # @private
+    # @see RDF::Queryable#query_pattern
+    def query_pattern(pattern, **options, &block)
+      if block_given?
+        graph_name  = pattern.graph_name
+        subject     = pattern.subject
+        predicate   = pattern.predicate
+        object      = pattern.object
+
+        cs = @data.has_key?(graph_name) ? { graph_name => @data[graph_name] } : @data
+
+        cs.each do |c, ss|
+          next unless graph_name.nil? ||
+                      graph_name == DEFAULT_GRAPH && !c ||
+                      graph_name.eql?(c)
+
+          ss = if subject.nil? || subject.is_a?(RDF::Query::Variable)
+            ss
+          elsif subject.is_a?(RDF::N3::List)
+            # Match subjects which are eql lists
+            ss.keys.select {|s| s.list? && subject.eql?(s)}.inject({}) do |memo, li|
+              memo.merge(li => ss[li])
+            end
+          elsif subject.is_a?(RDF::Query::Pattern)
+            # Match subjects which are statements matching this pattern
+            ss.keys.select {|s| s.statement? && subject.eql?(s)}.inject({}) do |memo, st|
+              memo.merge(st => ss[st])
+            end
+          elsif ss.has_key?(subject)
+            { subject => ss[subject] }
+          else
+            []
+          end
+          ss.each do |s, ps|
+            ps = if predicate.nil? || predicate.is_a?(RDF::Query::Variable)
+              ps
+            elsif predicate.is_a?(RDF::N3::List)
+              # Match predicates which are eql lists
+              ps.keys.select {|p| p.list? && predicate.eql?(p)}.inject({}) do |memo, li|
+                memo.merge(li => ps[li])
+              end
+            elsif ps.has_key?(predicate)
+              { predicate => ps[predicate] }
+            else
+              []
+            end
+            ps.each do |p, os|
+              os.each do |o, object_options|
+                next unless object.nil? || object.eql?(o)
+                yield RDF::Statement.new(s, p, o, object_options.merge(graph_name: c.equal?(DEFAULT_GRAPH) ? nil : c))
+              end
+            end
+          end
+        end
+      else
+        enum_for(:query_pattern, pattern, **options)
+      end
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#insert
+    def insert_statement(statement)
+      @data = insert_to(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#delete
+    def delete_statement(statement)
+      @data = delete_from(@data, statement)
+    end
+
+    ##
+    # @private
+    # @see RDF::Mutable#clear
+    def clear_statements
+      @data = @data.clear
+    end
+
+    ##
+    # @private
+    # @return [Hash]
+    def data
+      @data
+    end
+
+    ##
+    # @private
+    # @return [Hash]
+    def data=(hash)
+      @data = hash
+    end
+
+    private
+
+    ##
+    # @private
+    # @see #has_statement
+    def has_statement_in?(data, statement)
+      s, p, o, g = statement.to_quad
+      g ||= DEFAULT_GRAPH
+
+      data.has_key?(g) &&
+        data[g].has_key?(s) &&
+        data[g][s].has_key?(p) &&
+        data[g][s][p].has_key?(o)
+    end
+
+    ##
+    # @private
+    # @return [Hash] a new, updated hash 
+    def insert_to(data, statement)
+      raise ArgumentError, "Statement #{statement.inspect} is incomplete" if statement.incomplete?
+
+      s, p, o, c = statement.to_quad
+      c ||= DEFAULT_GRAPH
+      unless has_statement_in?(data, statement)
+        data          = data.has_key?(c)       ? data.dup       : data.merge(c => {})
+        data[c]       = data[c].has_key?(s)    ? data[c].dup    : data[c].merge(s => {})
+        data[c][s]    = data[c][s].has_key?(p) ? data[c][s].dup : data[c][s].merge(p => {})
+        data[c][s][p] = data[c][s][p].merge(o => statement.options)
+      end
+
+      # If statement is inferred, make sure that it is marked as inferred in the dataset.
+      data[c][s][p][o][:inferred] = true if statement.options[:inferred]
+
+      data
+    end
+    
+    ##
+    # @private
+    # @return [Hash] a new, updated hash 
+    def delete_from(data, statement)
+      if has_statement_in?(data, statement)
+        s, p, o, g = statement.to_quad
+        g = DEFAULT_GRAPH unless supports?(:graph_name)
+        g ||= DEFAULT_GRAPH
+
+        os   = data[g][s][p].dup.delete_if {|k,v| k == o}
+        ps   = os.empty? ? data[g][s].dup.delete_if {|k,v| k == p} : data[g][s].merge(p => os)
+        ss   = ps.empty? ? data[g].dup.delete_if    {|k,v| k == s} : data[g].merge(s => ps)
+        return ss.empty? ? data.dup.delete_if       {|k,v| k == g} : data.merge(g => ss)
+      end
+      data
+    end
+  end
+end