xquery 0.1.3-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 33e6fdb5a289ea9dd885be6ecb0abe3ce0db6829
+  data.tar.gz: d7759edc915b5c87dfe1ddbe92699e4fa4ba7f0a
+SHA512:
+  metadata.gz: b6e8ad5cba36841f9eab41f4c1c4f5d21481296958ed44a6f69adbe54f010e74ac22f9d6fef5d9f64ac3f8b25f876035f305cf379526fdac252cbf37b5906b17
+  data.tar.gz: ad988f2174be9ad81271da984ab14591ba6ad542421324cfb1cab68f556dfcba3232130ce0e86c6df248b7a03fc9f5090bcc3e54f35013d960e34020c0e3f30a

data/lib/xquery.rb

@@ -0,0 +1,10 @@
+require 'active_support'
+
+# XQuery is designed to replace boring method call chains and allow to easier
+# convert it in a builder classes
+# see [README.md] for more information
+module XQuery
+end
+
+require 'xquery/version'
+require 'xquery/generic'

data/lib/xquery/abstract.rb

@@ -0,0 +1,104 @@
+require 'active_support/core_ext/class/attribute.rb'
+
+require 'xquery/query_proxy'
+require 'xquery/errors'
+
+module XQuery
+  # abstract superclass, should be inherited, not used
+  class Abstract
+    class_attribute :query_superclass
+
+    # yields instance inside block. I suggest to name it `q`
+    # @param args [Array(Object)] array of arguments would be passed to
+    # @param block [#to_proc] block to witch instance would be yielded
+    def self.with(*args, &block)
+      instance = new(*args)
+      block.call(instance)
+      instance.query
+    end
+
+    class << self
+      alias_method :execute, :with
+    end
+
+    # Defines `method`, `__method` and `q.method`.
+    # Both of wich changes query to query.method
+    # @param name [#to_sym] name of method on query
+    # @param as [#to_sym] name of method defined
+    def self.wrap_method(name, as: name)
+      define_method(as) { |*args, &block| _update_query(name, *args, &block) }
+      alias_on_q(as, true)
+    end
+
+    # same as wrap_method, but hanldes multiply methods
+    # @param methods [Array(#to_sym)] names of methods defined
+    def self.wrap_methods(*methods)
+      methods.each(&method(:wrap_method))
+    end
+
+    # Aliases method to __method and q.method
+    # @param name [#to_sym] name of method
+    # @param return_self [Boolean] should defined method return self or result
+    def self.alias_on_q(name, return_self = false)
+      alias_method("__#{name}", name)
+      private("__#{name}")
+
+      query_proxy.send(:define_method, name) do |*args, &block|
+        result = instance.send("__#{name}", *args, &block)
+        return_self ? self : result
+      end
+    end
+
+    # @return [Class] query_proxy (`q`) class
+    def self.query_proxy
+      @query_proxy ||= Class.new(QueryProxy)
+    end
+
+    # inherited classes should also have their query_proxies inherited
+    def self.inherited(child)
+      child.instance_variable_set(:@query_proxy, Class.new(query_proxy))
+    end
+
+    # contains current state of wrapped query
+    attr_reader :query
+
+    # @param query [Object] generic query
+    def initialize(query)
+      self.query = query
+      @query_proxy = self.class.query_proxy.new(self)
+    end
+
+    # yields query inside block
+    # @param block [#to_proc]
+    # @return [XQuery::Abstract] self
+    def apply(&block)
+      self.query = block.call(query)
+      self
+    end
+
+    private
+
+    # @private_api
+    # updates query by calling method on it and storing the result
+    # @return [XQuery::Abstract] self
+    def _update_query(method, *args, &block)
+      apply { |x| x.public_send(method, *args, &block) }
+    end
+
+    # added constraints check
+    # @raise XQuery::QuerySuperclassChanged
+    def query=(x)
+      unless x.is_a?(query_superclass)
+        fail QuerySuperclassChanged.new(x, query_superclass)
+      end
+
+      @query = x
+    end
+
+    # @return [XQuery::QueryProxy] object could be used
+    #   to access method wrappers unchanged
+    def q
+      @query_proxy
+    end
+  end
+end

data/lib/xquery/errors.rb

@@ -0,0 +1,18 @@
+module XQuery
+  # raised when superclass of query changed
+  class QuerySuperclassChanged < StandardError
+    # query on which constraint failed
+    attr_reader :result
+
+    # expected superclass of query
+    attr_reader :expectation
+
+    # @param result [Object] query on which constraint failed
+    # @param expectation [Class] expected superclass
+    def initialize(result, expectation)
+      @result = result
+      @expectation = expectation
+      super("Expected #{result.inspect} to be an instance of #{expectation}")
+    end
+  end
+end

data/lib/xquery/generic.rb

@@ -0,0 +1,35 @@
+require 'xquery/abstract'
+
+module XQuery
+  # delegates all operations to model
+  class Generic < Abstract
+    # never used but defined in case of need
+    self.query_superclass = Object
+
+    # all missing methods would be delegated to query
+    # and processed as wrappers process them
+    def method_missing(name, *args, &block)
+      super unless respond_to_missing?(name)
+      _update_query(name, *args, &block)
+    end
+
+    # respond to all public model methods
+    def respond_to_missing?(name, *)
+      query.respond_to?(name, true)
+    end
+
+    private
+
+    # q object refers to self, not proxy
+    def q
+      self
+    end
+  end
+end
+
+# Allows you to do all query magic on a generic object
+# @param model [Object] any object
+# @param block [#to_proc] block where instance will be yielded
+def XQuery(model, &block)
+  XQuery::Generic.with(model, &block)
+end

data/lib/xquery/query_proxy.rb

@@ -0,0 +1,15 @@
+module XQuery
+  # This proxy can be used to access raw wrappers inside classes,
+  # inherited from XQuery::Abstract
+  class QueryProxy
+    # @param instance [Xquery::Abstract] instance to delegate methods
+    def initialize(instance)
+      self.instance = instance
+    end
+
+    private
+
+    # instance of Xquery::Abstract
+    attr_accessor :instance
+  end
+end

data/lib/xquery/version.rb

@@ -0,0 +1,4 @@
+module XQuery
+  # defines XQuery version
+  VERSION = '0.1.3'
+end

metadata

@@ -0,0 +1,247 @@
+--- !ruby/object:Gem::Specification
+name: xquery
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: java
+authors:
+- jelf
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2015-12-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  name: activesupport
+  prerelease: false
+  type: :runtime
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+  name: bundler
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.10'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  name: rspec
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+  name: pry
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.10'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  name: rake
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+  name: rubocop
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.35'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  name: yard
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+  name: simplecov
+  prerelease: false
+  type: :development
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.11'
+description: |
+  # XQuery
+  XQuery is designed to replace boring method call chains and allow to easier
+  convert it in a builder classes
+  [![Build Status](https://travis-ci.org/JelF/xquery.svg?branch=master)](https://travis-ci.org/JelF/xquery)
+  ## Usage of `XQuery` function
+  `Xquery` is a shortcat to `Xquery::Generic.with`
+
+  ```
+  r = XQuery(''.html_safe) do |q|
+    # similar to tap
+    q << 'bla bla bla'
+    q << 'bla bla bla'
+    # using truncate
+    q.truncate(15)
+    # real content (q.send(:query)) mutated
+    q << '!'
+  end
+  r # => "bla bla blab...!"
+  ```
+  ## Usage of `XQuery::Abstract`
+  I designed this gem to help me with `ActiveRecord` Queries, so i inherited
+  `XQuery::Abstract` and used it's powers. It provides the following features
+  ### `wrap_method` and `wrap_methods`
+  when you call each of this methods they became automatically wrapped
+  (`XQuery::Abstract` basically wraps all methods query `#respond_to?`)
+  It means, that there are instance methods with same name defined and will
+  change a `#query` to their call result.
+  ```
+  self.query = query.foo(x)
+  # is basically the same as
+  foo(x)
+  # when `wrap_method :foo` called
+  ```
+
+  You can also specify new name using `wrap_method :foo, as: :bar` syntax
+  ### `q` object
+  `q` is a proxy object which holds all of wrapped methods,
+  but not methods you defined inside your class.
+  E.g. i have defined `wrap_method(:foo)`, but also delegated `#foo` to some
+  another object. If i call `q.foo`, i will get wrapped method.
+  Note, that if you redefine `#__foo` method, q.foo will call it instead of
+  normal work.
+  You can add additional methods to `q` using something like `alias_on_q :foo`.
+  I used it with `kaminary` and it was useful
+  ```
+  def page=(x)
+    apply { |query| query.page(x) }
+  end
+  alias_on_q :page=
+
+  def page
+    query.current_page
+  end
+  alias_on_q :page
+  ```
+
+  ### `query_superclass`
+  You should specify `query_superclass` class_attribute to inherit
+  `XQuery::Abstract`. Whenever `query.is_a?(query_superclass)` evaluate to false,
+  you will get `XQuery::QuerySuperclassChanged` exception.
+  It can save you much time when your class misconfigured.
+  E.g. you are using `select!` and it returns `nil`, because why not?
+
+  ### `#apply` method
+  `#apply` does exact what it source tells
+  ```
+  # yields query inside block
+  # @param block [#to_proc]
+  # @return [XQuery::Abstract] self
+  def apply(&block)
+    self.query = block.call(query)
+    self
+  end
+  ```
+  It is usefull to merge different queries.
+
+  ### `with` class method
+  You can get XQuery functionality even you have not defined a specific class
+  (You are still have to inherit XQuery::Abstract to use it)
+  You can see it in this document when i described `XQuery` function.
+  Note, that it yields a class instance, not `q` object.
+  It accepts any arguments, they will be passed to a constructor (except block)
+  If you want only to call one function on an instance (e.g. `#apply`),
+  you should prefer `execute` alias
+email:
+- begdory4+xquery@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/xquery.rb
+- lib/xquery/abstract.rb
+- lib/xquery/errors.rb
+- lib/xquery/generic.rb
+- lib/xquery/query_proxy.rb
+- lib/xquery/version.rb
+homepage: https://github.com/JelF/xquery
+licenses:
+- WTFPL
+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: '0'
+requirements: []
+rubyforge_project:
+rubygems_version: 2.4.8
+signing_key:
+specification_version: 4
+summary: XQuery is designed to replace boring method call chains and allow to easier convert it in a builder classes see README.md for more information
+test_files: []
+has_rdoc: