ldpath 1.0.0 → 1.2.0

data/lib/ldpath/selectors.rb

@@ -1,7 +1,10 @@
+# frozen_string_literal: true
+
 module Ldpath
   class Selector
     def evaluate(program, uris, context)
       return to_enum(:evaluate, program, uris, context) unless block_given?
+
       enum_wrap(uris).map do |uri|
         loading program, uri, context
         enum_flatten_one(evaluate_one(uri, context)).each do |x|
@@ -14,6 +17,10 @@ module Ldpath
       program.loading uri, context
     end
 
+    def initialize(*_args)
+      # abstract base class
+    end
+
     protected
 
     def enum_wrap(object)
@@ -29,14 +36,12 @@ module Ldpath
         [object]
       end
     end
-    
-    def enum_flatten_one(object)
+
+    def enum_flatten_one(object, &block)
       return to_enum(:enum_flatten_one, object) unless block_given?
 
       enum_wrap(object).each do |e|
-        enum_wrap(e).each do |v|
-          yield v
-        end
+        enum_wrap(e).each(&block)
       end
     end
   end
@@ -53,6 +58,8 @@ module Ldpath
     def initialize(fname, arguments = [])
       @fname = fname
       @arguments = Array(arguments)
+
+      super
     end
 
     def evaluate(program, uris, context)
@@ -77,8 +84,11 @@ module Ldpath
 
   class PropertySelector < Selector
     attr_reader :property
+
     def initialize(property)
       @property = property
+
+      super
     end
 
     def evaluate_one(uri, context)
@@ -88,8 +98,11 @@ module Ldpath
 
   class LoosePropertySelector < Selector
     attr_reader :property
+
     def initialize(property)
       @property = property
+
+      super
     end
 
     def evaluate_one(uri, context)
@@ -103,8 +116,11 @@ module Ldpath
 
   class NegatedPropertySelector < Selector
     attr_reader :properties
+
     def initialize(*properties)
       @properties = properties
+
+      super
     end
 
     def evaluate_one(uri, context)
@@ -122,8 +138,11 @@ module Ldpath
 
   class ReversePropertySelector < Selector
     attr_reader :property
+
     def initialize(property)
       @property = property
+
+      super
     end
 
     def evaluate_one(uri, context)
@@ -133,34 +152,39 @@ module Ldpath
 
   class RecursivePathSelector < Selector
     attr_reader :property, :repeat
+
     def initialize(property, repeat)
       @property = property
       @repeat = repeat
+
+      super
     end
 
-    def evaluate(program, uris, context)
+    def evaluate(program, uris, context, &block)
       return to_enum(:evaluate, program, uris, context) unless block_given?
 
       input = enum_wrap(uris)
 
-      (0..repeat.max).each_with_index do |i, idx|
-        break if input.none? || (repeat.max == Ldpath::Transform::Infinity && idx > 25) # we're probably lost..
+      (0..repeat.max).each_with_index do |_i, idx|
+        break if input.none? || (repeat.max == Ldpath::Transform::INFINITY && idx > 25) # we're probably lost..
+
         input = property.evaluate program, input, context
 
         next unless idx >= repeat.min
 
-        enum_wrap(input).each do |x|
-          yield x
-        end
+        enum_wrap(input).each(&block)
       end
     end
   end
 
   class CompoundSelector < Selector
     attr_reader :left, :right
+
     def initialize(left, right)
       @left = left
       @right = right
+
+      super
     end
   end
 
@@ -174,46 +198,41 @@ module Ldpath
   end
 
   class UnionSelector < CompoundSelector
-    def evaluate(program, uris, context)
+    def evaluate(program, uris, context, &block)
       return to_enum(:evaluate, program, uris, context) unless block_given?
 
-      enum_union(left.evaluate(program, uris, context), right.evaluate(program, uris, context)).each do |x|
-        yield x
-      end
+      enum_union(left.evaluate(program, uris, context), right.evaluate(program, uris, context)).each(&block)
     end
 
     private
 
-    def enum_union(left, right)
+    def enum_union(left, right, &block)
       return to_enum(:enum_union, left, right) unless block_given?
 
-      enum_wrap(left).each do |e|
-        yield e
-      end
+      enum_wrap(left).each(&block)
 
-      enum_wrap(right).each do |e|
-        yield e
-      end
+      enum_wrap(right).each(&block)
     end
   end
 
   class IntersectionSelector < CompoundSelector
-    def evaluate(program, uris, context)
+    def evaluate(program, uris, context, &block)
       return to_enum(:evaluate, program, uris, context) unless block_given?
 
       result = left.evaluate(program, uris, context).to_a & right.evaluate(program, uris, context).to_a
 
-      result.each do |x|
-        yield x
-      end
+      result.each(&block)
     end
   end
 
   class TapSelector < Selector
     attr_reader :identifier, :tap
+
     def initialize(identifier, tap)
       @identifier = identifier
       @tap = tap
+
+      super
     end
 
     def evaluate(program, uris, context)

data/lib/ldpath/tests.rb

@@ -1,42 +1,55 @@
+# frozen_string_literal: true
+
 module Ldpath
   class TestSelector < Selector
     attr_reader :delegate, :test
 
-    def initialize(delegate, test)
+    def initialize(delegate = nil, test = nil)
       @delegate = delegate
       @test = test
+
+      super
     end
 
     def evaluate(program, uris, context)
+      return to_enum(:evaluate, program, uris, context) unless block_given?
+
       entries = delegate.evaluate program, uris, context
       entries.select do |uri|
-        enum_wrap(test.evaluate(program, uri, context)).any? do |x|
+        result = enum_wrap(test.evaluate(program, uri, context)).any? do |x|
           x
         end
+        yield uri if result
       end
     end
   end
 
   class LanguageTest < TestSelector
     attr_reader :lang
+
     def initialize(lang)
       @lang = lang
+
+      super
     end
 
     def evaluate(_program, uri, _context)
       return unless uri.literal?
 
-      uri if (lang == "none" && !uri.has_language?) || uri.language == lang
+      uri if (lang.to_s == "none" && !uri.has_language?) || uri.language.to_s == lang.to_s
     end
   end
 
   class TypeTest < TestSelector
     attr_reader :type
+
     def initialize(type)
       @type = type
+
+      super
     end
 
-    def evaluate(program, uri, _context)
+    def evaluate(_program, uri, _context)
       return unless uri.literal?
 
       uri if uri.has_datatype? && uri.datatype == type
@@ -48,10 +61,12 @@ module Ldpath
 
     def initialize(delegate)
       @delegate = delegate
+
+      super
     end
 
     def evaluate(program, uri, context)
-      !enum_wrap(delegate.evaluate(program, uri, context)).any? { |x| x }
+      enum_wrap(delegate.evaluate(program, uri, context)).none? { |x| x }
     end
   end
 
@@ -61,6 +76,8 @@ module Ldpath
     def initialize(left, right)
       @left = left
       @right = right
+
+      super
     end
 
     def evaluate(program, uri, context)
@@ -74,6 +91,8 @@ module Ldpath
     def initialize(left, right)
       @left = left
       @right = right
+
+      super
     end
 
     def evaluate(program, uri, context)
@@ -88,6 +107,8 @@ module Ldpath
     def initialize(left, right)
       @left = left
       @right = right
+
+      super
     end
 
     def evaluate(program, uri, context)

data/lib/ldpath/transform.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ldpath
   class Transform < Parslet::Transform
     attr_reader :prefixes
@@ -5,17 +7,17 @@ module Ldpath
     class << self
       def default_prefixes
         @default_prefixes ||= {
-          "rdf"  => RDF::Vocabulary.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#"),
+          "rdf" => RDF::Vocabulary.new("http://www.w3.org/1999/02/22-rdf-syntax-ns#"),
           "rdfs" => RDF::Vocabulary.new("http://www.w3.org/2000/01/rdf-schema#"),
-          "owl"  => RDF::Vocabulary.new("http://www.w3.org/2002/07/owl#"),
+          "owl" => RDF::Vocabulary.new("http://www.w3.org/2002/07/owl#"),
           "skos" => RDF::Vocabulary.new("http://www.w3.org/2004/02/skos/core#"),
-          "dc"   => RDF::Vocabulary.new("http://purl.org/dc/elements/1.1/"),
-          "xsd"  => RDF::Vocabulary.new("http://www.w3.org/2001/XMLSchema#"), #          (LMF base index datatypes/XML Schema)
-          "lmf"  => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/types/1.0/"), #    (LMF extended index datatypes)
-          "fn"   => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/functions/1.0/"), # (LMF index functions)
+          "dc" => RDF::Vocabulary.new("http://purl.org/dc/elements/1.1/"),
+          "xsd" => RDF::Vocabulary.new("http://www.w3.org/2001/XMLSchema#"), #          (LMF base index datatypes/XML Schema)
+          "lmf" => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/types/1.0/"), #    (LMF extended index datatypes)
+          "fn" => RDF::Vocabulary.new("http://www.newmedialab.at/lmf/functions/1.0/"), # (LMF index functions)
           "foaf" => RDF::Vocabulary.new("http://xmlns.com/foaf/0.1/"),
           "info" => RDF::Vocabulary.new("info:"),
-          "urn"  => RDF::Vocabulary.new("urn:")
+          "urn" => RDF::Vocabulary.new("urn:")
         }
       end
     end
@@ -29,8 +31,8 @@ module Ldpath
     end
 
     # Core types
-    rule(true: simple(:true)) { true }
-    rule(false: simple(:false)) { false }
+    rule(true => simple(true)) { true }
+    rule(false => simple(false)) { false }
     rule(integer: simple(:integer)) { integer.to_i }
     rule(double: simple(:double)) { double.to_f }
     rule(decimal: simple(:decimal)) { decimal.to_f }
@@ -71,7 +73,7 @@ module Ldpath
     # Mappings
 
     rule(mapping: subtree(:mapping)) do
-      FieldMapping.new mapping
+      FieldMapping.new(**mapping)
     end
 
     ## Selectors
@@ -106,11 +108,11 @@ module Ldpath
     end
 
     rule(range: subtree(:range)) do
-      range.fetch(:min, 0).to_i..range.fetch(:max, Infinity).to_f
+      range.fetch(:min, 0).to_i..range.fetch(:max, INFINITY).to_f
     end
 
-    rule(range: '*') { 0..Infinity }
-    rule(range: '+') { 1..Infinity }
+    rule(range: '*') { 0..INFINITY }
+    rule(range: '+') { 1..INFINITY }
     rule(range: '?') { 0..1 }
 
     rule(delegate: subtree(:delegate), repeat: simple(:repeat)) do
@@ -177,6 +179,6 @@ module Ldpath
       IntersectionSelector.new left, right
     end
 
-    Infinity = 1.0 / 0.0
+    INFINITY = 1.0 / 0.0
   end
 end

data/lib/ldpath/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Ldpath
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.2.0'
 end

data/lib/ldpath.rb

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
 require "ldpath/version"
-require 'linkeddata'
 require 'logger'
+require 'nokogiri'
+require 'rdf'
+require 'rdf/vocab'
+# require rdf/ntriples may not be necessary, may only really be necessary
+# for ldpath_program_spec.rb tests, but I'm not certain, and I don't think it hurts
+# to do it here.
+require 'rdf/ntriples'
 
 module Ldpath
   require 'ldpath/field_mapping'
@@ -11,6 +19,7 @@ module Ldpath
   require 'ldpath/functions'
   require 'ldpath/program'
   require 'ldpath/result'
+  require 'ldpath/loaders'
 
   class << self
     attr_writer :logger
@@ -20,13 +29,11 @@ module Ldpath
     end
 
     def logger
-      @logger ||= begin
-        if defined? Rails
-          Rails.logger
-        else
-          Logger.new(STDERR)
-        end
-      end
+      @logger ||= if defined? Rails
+                    Rails.logger
+                  else
+                    Logger.new($stderr)
+                  end
     end
   end
 end

data/spec/ldpath_parser_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 require 'pp'
 require 'parslet/convenience'
@@ -228,10 +230,10 @@ describe Ldpath::Parser do
 
     describe "integration tests" do
       it "should parse a simple example" do
-        tree = subject.parse <<-EOF
-@prefix dcterms : <http://purl.org/dc/terms/> ;
-topic = <http://xmlns.com/foaf/0.1/primaryTopic> :: xsd:string ;
-EOF
+        tree = subject.parse <<~EOF
+          @prefix dcterms : <http://purl.org/dc/terms/> ;
+          topic = <http://xmlns.com/foaf/0.1/primaryTopic> :: xsd:string ;
+        EOF
         expect(tree.length).to eq 2
         expect(tree.first).to include :prefixID
         expect(tree.first[:prefixID]).to include id: 'dcterms'