isomorfeus-operation 1.0.0.delta11

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 823378aa4e9344b3db0a2b709f4111852bae0e5652aae247e523150c99b0a16d
+  data.tar.gz: 2be7f1482ce6784d16e6c8bc43076b71b0b4e200f774e177ec9fb0cf895610cc
+SHA512:
+  metadata.gz: c299c24e21f3e48ab506ef300947d1e6effa73658b7e65d18d5a4fccf29658f81d6022a05cd1ea02a1f5a4c82092cfbbfd3240a39262e2c402fecb58c3d13eb8
+  data.tar.gz: 8173fe8f26a00fb9c2bdcb145c7f3f1e35fccf223a7eaa76af15ae519842efd18189a72cfbc404213a99b0145ce01dfb317b8dc2efcb6f6d40b9405beb5569bb

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Jan Biedermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,44 @@
+# isomorfeus-operation
+
+there are 3 kinds of Operations:
+- LucidQuickOp
+- LucidOperation
+- LucidLocalOperation
+
+```ruby
+class MyQuickOp < LucidQuickOp::Base
+  prop :a_prop
+
+  op do
+    props.a_prop == 'a_value'
+    # do something
+  end
+end
+
+MyQuickOp.promise_run(a_prop: 'a_value')
+```
+
+Quick remote procedure call, always executed on the server.
+LucidOperation too is always executed on the Server. It allows to define Operations in gherkin human language style:
+```
+class MyOperation < LucidOperation::Base
+  prop :a_prop
+
+  procedure <<~TEXT
+     Given a bird
+     When it flies
+     Then be happy
+  TEXT
+
+  Given /a bird/ do
+     props.a_prop == 'a_value'
+  end
+
+  # etc ...
+end
+
+MyOperation.promise_run(a_prop: 'a_value')
+```
+
+LucidLocalOperation is the same as LucidOperation, except its always executed locally, wherever that may be.
+Its barely tested so far and no other docs.

data/lib/isomorfeus/operation/config.rb

@@ -0,0 +1,28 @@
+module Isomorfeus
+  class << self
+    def cached_operation_classes
+      @cached_operation_classes ||= {}
+    end
+
+    def cached_operation_class(class_name)
+      return cached_operation_classes[class_name] if cached_operation_classes.key?(class_name)
+      cached_operation_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    if RUBY_ENGINE != 'opal'
+      def valid_operation_class_names
+        @valid_operation_class_names ||= Set.new
+      end
+
+      def valid_operation_class_name?(class_name)
+        valid_operation_class_names.include?(class_name)
+      end
+
+      def add_valid_operation_class(klass)
+        class_name = klass.name
+        class_name = class_name.split('>::').last if class_name.start_with?('#<')
+        valid_operation_class_names << class_name
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/gherkin.rb

@@ -0,0 +1,65 @@
+module Isomorfeus
+  module Operation
+    module Gherkin
+      FIRST_EXCEPTION = "First must be the first one that is used and can only used once!"
+      FINALLY_EXCEPTION = "Finally, except for Ensure and Failed, must be the last one to be used and can only be used once!"
+
+      NEWLINE = /\r?\n/
+      OPERATION = /^\s*Operation: (.*)$/
+      PROCEDURE = /^\s*Procedure: (.*)$/
+      STAR = /^\s*\* (.*)$/
+      GIVEN = /^\s*Given (.*)$/
+      WHEN = /^\s*When (.*)$/
+      THEN = /^\s*Then (.*)$/
+      AND = /^\s*And (.*)$/
+      FIRST = /^\s*First (.*)$/
+      ENSURE = /^\s*Ensure (.*)$/
+      FINALLY = /^\s*Finally (.*)$/
+      IW_FAILING = /^\s*(?:When|If) failing (.*)$/
+      IF_ITT_FAILED = /^\s*If (?:that|this|it) failed (.*)$/
+      FAILED = /^\s*Failed (.*)$/
+      COMMENT = /^\s*# (.*)$/
+      WHITE_SPACE = /^\s*$/
+
+      def self.parse(gherkin_text)
+        operation = { operation: '', procedure: '', steps: [], failure: [], ensure: [] }
+        has_finally = false
+        lines = gherkin_text.split(NEWLINE)
+
+        lines.each do |line|
+          case line
+          when STAR, GIVEN, WHEN, THEN, AND
+            raise FINALLY_EXCEPTION if has_finally
+            operation[:steps] << $1.strip
+          when ENSURE
+            operation[:ensure] << $1.strip
+          when IW_FAILING, IF_ITT_FAILED, FAILED
+            operation[:failure] << $1.strip
+          when FIRST
+            raise FIRST_EXCEPTION if operation[:steps].size > 0
+            operation[:steps] << $1.strip
+          when FINALLY
+            raise FINALLY_EXCEPTION if has_finally
+            operation[:steps] << $1.strip
+            has_finally = true
+          when PROCEDURE
+            raise 'No Operation defined!' if operation[:operation].empty?
+            raise 'Procedure already defined!' unless operation[:procedure].empty?
+            operation[:procedure] = $1.strip
+          when OPERATION
+            raise 'Operation already defined!' unless operation[:operation].empty?
+            operation[:operation] = $1.strip
+          when WHITE_SPACE, COMMENT
+            # nothing, just skip
+          else
+            raise "Unknown key word(s) at the beginning of the line: #{line}" unless operation[:procedure].empty?
+            operation[:description] = [] unless operation.key?(:description)
+            operation[:description] << line.strip
+          end
+        end
+
+        operation
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/handler/operation_handler.rb

@@ -0,0 +1,54 @@
+module Isomorfeus
+  module Operation
+    module Handler
+      class OperationHandler < LucidHandler::Base
+        on_request do |pub_sub_client, session_id, current_user, request, response|
+          result = { error: 'No such thing' }
+          # promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.to_s, props_hash)
+          request.keys.each do |operation_class_name|
+            if Isomorfeus.valid_operation_class_name?(operation_class_name)
+              operation_class = Isomorfeus.cached_operation_class(operation_class_name)
+              if operation_class
+                props_json = request[operation_class_name]
+                begin
+                  props = Oj.load(props_json, mode: :strict)
+                  props.merge!({pub_sub_client: pub_sub_client, session_id: session_id, current_user: current_user})
+                  operation_promise = operation_class.promise_run(props)
+                  if operation_promise.realized?
+                    result = { success: 'ok' , result: operation_promise.value }
+                  else
+                    start = Time.now
+                    timeout = false
+                    while !operation_promise.realized?
+                      if (Time.now - start) > 20
+                        timeout = true
+                        break
+                      end
+                      sleep 0.01
+                    end
+                    if timeout
+                      result = { error: 'Timeout' }
+                    else
+                      result = { success: 'ok' , result: operation_promise.value }
+                    end
+                  end
+                rescue Exception => e
+                  result = if Isomorfeus.production?
+                             { error: { operation_class_name => 'No such thing!' }}
+                           else
+                             { error: { operation_class_name => "Isomorfeus::Operation::Handler::OperationHandler: #{e.message}" }}
+                           end
+                end
+              else
+                result = { error: { operation_class_name => 'No such thing!' }}
+              end
+            else
+              result = { error: { operation_class_name => 'No such thing!' }}
+            end
+          end
+          result
+        end
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/mixin.rb

@@ -0,0 +1,58 @@
+module Isomorfeus
+  module Operation
+    module Mixin
+      def procedure(gherkin_text)
+        feature_line = gherkin_text.include?('Operation: ') ? '' : "Operation: #{self.name}\n"
+        scenario_line = feature_line == '' || gherkin_text.include?('Procedure: ') ? '' : "  Procedure: #{self.name} executing\n"
+        @procedure = feature_line + scenario_line + gherkin_text
+      end
+
+      def gherkin
+        @gherkin ||= Isomorfeus::Operation::Gherkin.parse(@procedure)
+      end
+
+      def ensure_steps
+        @ensure_steps ||= []
+      end
+
+      def failure_steps
+        @failure_steps ||= []
+      end
+
+      def steps
+        @steps ||= []
+      end
+
+      def First(regular_expression, &block)
+        raise "#{self}: First already defined, can only be defined once!" if @first_defined
+        @first_defined = true
+        steps << [regular_expression, block]
+      end
+
+      def Given(regular_expression, &block)
+        steps << [regular_expression, block]
+      end
+      alias :And :Given
+      alias :Then :Given
+      alias :When :Given
+
+      def Finally(regular_expression, &block)
+        raise "#{self}: Finally already defined, can only be defined once!" if @finally_defined
+        @finally_defined = true
+        steps << [regular_expression, block]
+      end
+
+      def Ensure(regular_expression, &block)
+        ensure_steps << [regular_expression, block]
+      end
+
+      def Failed(regular_expression, &block)
+        failure_steps << [regular_expression, block]
+      end
+      alias :If_failing :Failed
+      alias :When_failing :Failed
+      alias :If_this_failed :Failed
+      alias :If_that_failed :Failed
+    end
+  end
+end

data/lib/isomorfeus/operation/promise_run.rb

@@ -0,0 +1,76 @@
+module Isomorfeus
+  module Operation
+    module PromiseRun
+      def initialize(validated_props_hash)
+        @props = Isomorfeus::Data::Props.new(validated_props_hash)
+      end
+
+      def promise_run
+        promise = Promise.new
+        original_promise = promise
+        operation = self
+
+        # steps
+        self.class.gherkin[:steps].each do |gherkin_step|
+          matched = false
+          self.class.steps.each do |step|
+            # step[0] -> regular_expression
+            # step[1] -> block
+            match_data = gherkin_step.match(step[0])
+            if match_data
+              matched = true
+              promise = promise.then do |result|
+                operation.step_result = result
+                operation.instance_exec(*match_data, &step[1])
+              end
+            end
+          end
+          raise "No match found for step #{gherkin_step}!" unless matched
+        end
+
+        # fail track
+        self.class.gherkin[:failure].each do |gherkin_step|
+          matched = false
+          self.class.failure_steps.each do |step|
+            # step[0] -> regular_expression
+            # step[1] -> block
+            match_data = gherkin_step.match(step[0])
+            if match_data
+              matched = true
+              promise = promise.fail do |result|
+                operation.step_result = result
+                operation.instance_exec(*match_data, &step[1])
+              end
+            end
+          end
+          raise "No match found for failure step #{gherkin_step}!" unless matched
+        end
+
+        # ensure
+        self.class.gherkin[:ensure].each do |gherkin_step|
+          matched = false
+          self.class.ensure_steps.each do |step|
+            # step[0] -> regular_expression
+            # step[1] -> block
+            match_data = gherkin_step.match(step[0])
+            if match_data
+              matched = true
+
+              promise = promise.then do |result|
+                operation.step_result = result
+                operation.instance_exec(*match_data, &step[1])
+              end.fail do |result|
+                operation.step_result = result
+                operation.instance_exec(*match_data, &step[1])
+              end
+            end
+          end
+          raise "No match found for ensure step #{gherkin_step}!" unless matched
+        end
+
+        original_promise.resolve
+        promise
+      end
+    end
+  end
+end

data/lib/isomorfeus/operation/version.rb

@@ -0,0 +1,5 @@
+module Isomorfeus
+  module Operation
+    VERSION = '1.0.0.delta11'
+  end
+end

data/lib/isomorfeus-operation.rb

@@ -0,0 +1,34 @@
+require 'opal'
+require 'opal-autoloader'
+require 'opal-activesupport'
+require 'isomorfeus-redux'
+require 'isomorfeus-transport'
+require 'isomorfeus/operation/config'
+require 'isomorfeus/operation/gherkin'
+require 'isomorfeus/operation/mixin'
+require 'isomorfeus/operation/promise_run'
+require 'lucid_local_operation/mixin'
+require 'lucid_local_operation/base'
+require 'lucid_quick_op/mixin'
+require 'lucid_quick_op/base'
+require 'lucid_operation/mixin'
+require 'lucid_operation/base'
+
+if RUBY_ENGINE == 'opal'
+  Opal::Autoloader.add_load_path('data')
+else
+  require 'oj'
+  require 'isomorfeus/operation/handler/operation_handler'
+
+  Opal.append_path(__dir__.untaint) unless Opal.paths.include?(__dir__.untaint)
+
+  require 'active_support/dependencies'
+
+  path = File.expand_path(File.join('isomorfeus', 'operations'))
+
+  ActiveSupport::Dependencies.autoload_paths << path
+  # we also need to require them all, so classes are registered accordingly
+  Dir.glob("#{path}/**/*.rb").each do |file|
+    require file
+  end
+end

data/lib/lucid_local_operation/base.rb

@@ -0,0 +1,11 @@
+module LucidLocalOperation
+  class Base
+    include LucidLocalOperation::Mixin
+
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_operation_class(base)
+      end
+    end
+  end
+end

data/lib/lucid_local_operation/mixin.rb

@@ -0,0 +1,23 @@
+module LucidLocalOperation
+  module Mixin
+    def self.included(base)
+      if RUBY_ENGINE != 'opal'
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidLocalOperation::Base
+      end
+
+      base.extend(Isomorfeus::Data::PropDeclaration)
+      base.extend(Isomorfeus::Operation::Mixin)
+      base.include(Isomorfeus::Operation::PromiseRun)
+
+      base.instance_exec do
+        def promise_run(props_hash)
+          validate_props(props_hash)
+          self.new(props_hash).promise_run
+        end
+      end
+    end
+
+    attr_accessor :props
+    attr_accessor :step_result
+  end
+end

data/lib/lucid_operation/base.rb

@@ -0,0 +1,15 @@
+module LucidOperation
+  class Base
+    include LucidOperation::Mixin
+
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_operation_class(base)
+
+        base.prop :pub_sub_client, default: nil
+        base.prop :session_id, default: nil
+        base.prop :current_user, default: nil
+      end
+    end
+  end
+end

data/lib/lucid_operation/mixin.rb

@@ -0,0 +1,72 @@
+module LucidOperation
+  module Mixin
+    def self.included(base)
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def procedure(gherkin_text)
+          end
+
+          def steps
+          end
+          alias :gherkin :steps
+          alias :ensure_steps :steps
+          alias :failure_steps :steps
+          alias :Given :steps
+          alias :And :steps
+          alias :Then :steps
+          alias :When :steps
+          alias :Ensure :steps
+          alias :Failed :steps
+          alias :If_failing :steps
+          alias :When_failing :steps
+          alias :If_this_failed :steps
+          alias :If_that_failed :steps
+
+          def First(regular_expression, &block)
+            raise "#{self}: First already defined, can only be defined once!" if @first_defined
+            @first_defined = true
+          end
+
+          def Finally(regular_expression, &block)
+            raise "#{self}: Finally already defined, can only be defined once!" if @finally_defined
+            @finally_defined = true
+          end
+
+          def promise_run(props_hash)
+            validate_props(props_hash)
+            props_json = Isomorfeus::Data::Props.new(props_hash).to_json
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props_json).then do |response|
+              if response[:agent_response].key?(:error)
+                `console.error(#{response[:agent_response][:error].to_n})`
+                raise response[:agent_response][:error]
+              end
+              response[:agent_response][:result]
+            end
+          end
+        end
+      else
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidOperation::Base
+        base.extend(Isomorfeus::Operation::Mixin)
+        base.include(Isomorfeus::Operation::PromiseRun)
+
+        unless base == LucidOperation::Base
+          base.prop :pub_sub_client, default: nil
+          base.prop :session_id, default: nil
+          base.prop :current_user, default: nil
+        end
+
+        base.instance_exec do
+          def promise_run(props_hash)
+            validate_props(props_hash)
+            self.new(props_hash).promise_run
+          end
+        end
+
+        attr_accessor :props
+        attr_accessor :step_result
+      end
+    end
+  end
+end

data/lib/lucid_quick_op/base.rb

@@ -0,0 +1,15 @@
+module LucidQuickOp
+  class Base
+    include LucidQuickOp::Mixin
+
+    if RUBY_ENGINE != 'opal'
+      def self.inherited(base)
+        Isomorfeus.add_valid_operation_class(base)
+
+        base.prop :pub_sub_client, default: nil
+        base.prop :session_id, default: nil
+        base.prop :current_user, default: nil
+      end
+    end
+  end
+end

data/lib/lucid_quick_op/mixin.rb

@@ -0,0 +1,64 @@
+module LucidQuickOp
+  module Mixin
+    def self.included(base)
+      base.extend(Isomorfeus::Data::PropDeclaration)
+
+      if RUBY_ENGINE == 'opal'
+        base.instance_exec do
+          def op
+          end
+
+          def promise_run(props_hash)
+            validate_props(props_hash)
+            props_json = Isomorfeus::Data::Props.new(props_hash).to_json
+            Isomorfeus::Transport.promise_send_path('Isomorfeus::Operation::Handler::OperationHandler', self.name, props_json).then do |response|
+              if response[:agent_response].key?(:error)
+                `console.error(#{response[:agent_response][:error].to_n})`
+                raise response[:agent_response][:error]
+              end
+              response[:agent_response][:result]
+            end
+          end
+        end
+      else
+        Isomorfeus.add_valid_operation_class(base) unless base == LucidQuickOp::Base
+
+        unless base == LucidQuickOp::Base
+          base.prop :pub_sub_client, default: nil
+          base.prop :session_id, default: nil
+          base.prop :current_user, default: nil
+        end
+
+        base.instance_exec do
+          def op(&block)
+            @op = block
+          end
+
+          def promise_run(props_hash)
+            validate_props(props_hash)
+            self.new(props_hash).promise_run
+          end
+        end
+      end
+    end
+
+    attr_accessor :props
+
+    def initialize(validated_props_hash)
+      @props = Isomorfeus::Data::Props.new(validated_props_hash)
+      @on_fail_track = false
+    end
+
+    def promise_run
+      original_promise = Promise.new.then
+
+      operation = self
+      promise = original_promise.then do |result|
+        operation.instance_exec(&self.class.instance_variable_get(:@op))
+      end
+
+      original_promise.resolve(true)
+      promise
+    end
+  end
+end

metadata

@@ -0,0 +1,155 @@
+--- !ruby/object:Gem::Specification
+name: isomorfeus-operation
+version: !ruby/object:Gem::Version
+  version: 1.0.0.delta11
+platform: ruby
+authors:
+- Jan Biedermann
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.2'
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.8.0
+- !ruby/object:Gem::Dependency
+  name: opal
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.11.0
+- !ruby/object:Gem::Dependency
+  name: opal-activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.3
+- !ruby/object:Gem::Dependency
+  name: opal-autoloader
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-redux
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.11
+- !ruby/object:Gem::Dependency
+  name: isomorfeus-transport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.0.0.delta11
+description: Write operations for Isomorfeus in your natural language.
+email: jan@kursator.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/isomorfeus-operation.rb
+- lib/isomorfeus/operation/config.rb
+- lib/isomorfeus/operation/gherkin.rb
+- lib/isomorfeus/operation/handler/operation_handler.rb
+- lib/isomorfeus/operation/mixin.rb
+- lib/isomorfeus/operation/promise_run.rb
+- lib/isomorfeus/operation/version.rb
+- lib/lucid_local_operation/base.rb
+- lib/lucid_local_operation/mixin.rb
+- lib/lucid_operation/base.rb
+- lib/lucid_operation/mixin.rb
+- lib/lucid_quick_op/base.rb
+- lib/lucid_quick_op/mixin.rb
+homepage: http://isomorfeus.com
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">"
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Natural language operations for Isomorfeus.
+test_files: []