norikra-udf-uri_parser 0.1.0-java

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 84040cec8187bf2c449640917eaa8df8e51f9003
+  data.tar.gz: 3a6331305b82d9640448ba8c6cf7c9a0692c6543
+SHA512:
+  metadata.gz: 8c0e5a916b24cf31812e830c976a80cd971769c7b7011a1df1f546d7ad8cbbce05fa91a276417d228b3ab3c311dd46dd001a563a99f155abd385dfa8184e230e
+  data.tar.gz: 93c178ae6dab24d1481c7ca8e295e70e1543eb951fb5d7230c2bccf1369773475484a7a423d03ef0c26c8077e5a59d672891412b23ffda2e8c477ab1dae9ff11

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/vendor/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.ruby-version

@@ -0,0 +1 @@
+jruby-1.7.16

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - jruby-19mode
+jdk:
+  - oraclejdk8
+  - oraclejdk7
+  - openjdk7

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/README.md

@@ -0,0 +1,189 @@
+# Norikra::Udf::UriParser
+
+This is [Norikra](http://norikra.github.io/) UDF.
+
+`splituri` UDF return value corresponds to specified element in uri string like `http://example.com/hoge`.
+
+`splitquery` UDF return value corresponds to target key in query string like `hoge=foo`.
+
+[![Build Status](https://travis-ci.org/mia-0032/norikra-udf-uri_parser.svg)](https://travis-ci.org/mia-0032/norikra-udf-uri_parser)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'norikra-udf-uri_parser'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install norikra-udf-uri_parser
+
+## Usage
+
+```sql
+SELECT
+  -- path is like "/hoge?foo=bar"
+  splitquery(splituri(path, 'query'), 'foo') AS val
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "val":"bar"
+}
+```
+
+### splituri(expression, string)
+
+Second argument accepts `scheme`,`userinfo`,`host`,`port`,`path`,`opaque`,`query`,`fragment`.
+
+#### Example queries:
+
+##### 1. Using path field.
+
+```sql
+SELECT
+  -- path is like "/hoge?foo=bar#top"
+  splituri(path, 'scheme')   AS scheme,
+  splituri(path, 'userinfo') AS userinfo,
+  splituri(path, 'host')     AS host,
+  splituri(path, 'port')     AS port,
+  splituri(path, 'path')     AS path,
+  splituri(path, 'opaque')   AS opaque,
+  splituri(path, 'query')    AS query,
+  splituri(path, 'fragment') AS fragment
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "port":"",
+  "host":"",
+  "scheme":"",
+  "query":"foo=bar",
+  "opaque":"",
+  "path":"/hoge",
+  "userinfo":"",
+  "fragment":"top"
+}
+```
+
+##### 2. Using URL filed.
+
+```sql
+SELECT
+  -- referer is like "http://example.com/hoge?foo=bar#top"
+  splituri(referer, 'scheme')   AS scheme,
+  splituri(referer, 'userinfo') AS userinfo,
+  splituri(referer, 'host')     AS host,
+  splituri(referer, 'port')     AS port,
+  splituri(referer, 'path')     AS path,
+  splituri(referer, 'opaque')   AS opaque,
+  splituri(referer, 'query')    AS query,
+  splituri(referer, 'fragment') AS fragment
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "port":"",
+  "host":"example.com",
+  "scheme":"http",
+  "query":"foo=bar",
+  "opaque":"",
+  "path":"/hoge",
+  "userinfo":"",
+  "fragment":"top"
+}
+```
+
+### splitquery(expression, string)
+
+Second argument is the key that you want to get the value.
+
+#### Example queries:
+
+##### 1. key=value parameter.
+
+```sql
+SELECT
+  -- query is like "foo1=bar1&foo2=bar2&foo3=bar3"
+  splitquery(query, 'foo1') AS foo1,
+  splitquery(query, 'foo2') AS foo2,
+  splitquery(query, 'foo3') AS foo3
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "foo3":"bar3",
+  "foo2":"bar2",
+  "foo1":"bar1"
+}
+```
+
+##### 2. key\[\]=values parameter.
+
+```sql
+SELECT
+  -- query is like "foo[]=bar1&foo[]=bar2&foo[]=bar3"
+  splitquery(query, 'foo[]') AS foo
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "foo":[
+    "bar1",
+    "bar2",
+    "bar3"
+  ]
+}
+```
+
+##### 3. Only key parameter.
+
+```sql
+SELECT
+  -- query is like "test&foo1=bar1&foo2=bar2"
+  splitquery(query, 'test') AS test,
+  splitquery(query, 'other') AS other
+FROM access_log
+```
+
+This query returns below.
+
+```javascript
+{
+  "other":null,
+  "test":""
+}
+```
+
+## TODO
+
+- Add method returns all query value as hash. (ex. `splitquery("foo=bar&buzz=123")` return `{"foo":"bar","buzz":123}`)
+
+## Contributing
+
+1. Fork it ( https://github.com/mia-0032/norikra-udf-uri_parser/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,37 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = ["-Ijar", "-Ilib", "-c", "-f progress"] # '--format specdoc'
+  t.pattern = 'spec/**/*_spec.rb'
+end
+
+task :compile do
+  require 'rubygems'
+
+  jarname = FileList['norikra-udf-*.gemspec'].first.gsub(/\.gemspec$/, '.jar')
+
+  jarfiles = FileList['jar/**/*.jar'].select{|f| not f.end_with?('/' + jarname)}
+  jarfiles << Gem.find_latest_files('esper-*.jar').first
+
+  java_classpath = "-classpath src:java:#{jarfiles.join(':')}"
+  FileList['src/**/*.java'].each do |fn|
+    sh "env LC_ALL=C javac -J-Duser.language=en #{java_classpath} -d java #{fn}"
+  end
+
+  jruby_classpath = "--classpath java:#{jarfiles.join(':')}"
+  FileList['lib/esper_plugin/**/*.rb'].each do |fn|
+    sh "env LC_ALL=C jrubyc --javac --target java #{jruby_classpath} #{fn}"
+  end
+
+  sh "env LC_ALL=C jar -J-Duser.language=en -cf jar/#{jarname} -C java ."
+end
+
+task :clean do
+  sh "rm -rf java/*"
+end
+
+task :test => [:compile, :spec]
+task :default => :test
+
+task :all => [:clean, :compile, :spec, :build]

data/lib/esper_plugin/uri_parser.rb

@@ -0,0 +1,55 @@
+require 'cgi'
+require 'java'
+require 'uri'
+
+java_package 'jp.ys.mia.norikra.udf'
+
+class UriParser
+  @@elements = {
+      :scheme => 0,
+      :userinfo => 1,
+      :host => 2,
+      :port => 3,
+      :path => 5,
+      :opaque => 6,
+      :query => 7,
+      :fragment => 8
+  }
+
+  def self.split_uri(uri, element_key)
+    element_key = element_key.to_sym
+    unless @@elements.has_key?(element_key)
+      return nil
+    end
+
+    begin
+      parsed_uri = URI.split(uri)
+    rescue URI::InvalidURIError => e
+      return nil
+    end
+
+    result = parsed_uri[@@elements[element_key]]
+    if result.nil?
+      ''
+    else
+      result
+    end
+  end
+
+  def self.split_query(query_text, key)
+    query = CGI::parse(query_text)
+
+    unless query.has_key?(key)
+      return nil
+    end
+
+    case query[key].length
+    when 0 then
+      ''
+    when 1 then
+      query[key][0]
+    else
+      query[key]
+    end
+  end
+end

data/lib/norikra/udf/uri_parser.rb

@@ -0,0 +1,26 @@
+require 'java'
+require 'norikra/udf'
+
+module Norikra
+  module UDF
+    class SplitUri < Norikra::UDF::SingleRow
+      def self.init
+        require 'norikra-udf-uri_parser.jar'
+      end
+
+      def definition
+        ["splituri", "jp.ys.mia.norikra.udf.UriParser", "split_uri"]
+      end
+    end
+
+    class SplitQuery < Norikra::UDF::SingleRow
+      def self.init
+        require 'norikra-udf-uri_parser.jar'
+      end
+
+      def definition
+        ["splitquery", "jp.ys.mia.norikra.udf.UriParser", "split_query"]
+      end
+    end
+  end
+end

data/norikra-udf-uri_parser.gemspec

@@ -0,0 +1,26 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+Gem::Specification.new do |spec|
+  spec.name          = "norikra-udf-uri_parser"
+  spec.version       = "0.1.0"
+  spec.authors       = ["Yoshihiro MIYAI"]
+  spec.email         = ["msparrow17@gmail.com"]
+  spec.summary       = %q{Norikra UDF splituri() and splitquery().}
+  spec.description   = %q{Parse URI and query and return value specified key.}
+  spec.homepage      = "https://github.com/mia-0032/norikra-udf-uri_parser"
+  spec.license       = "GPL v2"
+
+  spec.platform      = "java"
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib","jar"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_runtime_dependency     "norikra", "~> 1.0.8"
+end
+

data/spec/uri_parser_spec.rb

@@ -0,0 +1,64 @@
+require 'norikra/udf_spec_helper'
+
+include Norikra::UDFSpecHelper
+
+require 'norikra/udf/uri_parser'
+
+describe Norikra::UDF::SplitUri do
+  udf_function Norikra::UDF::SplitUri
+
+  it 'returns value corresponds to target element if url given' do
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "scheme")).to eql("http")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "userinfo")).to eql("")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "host")).to eql("example.com")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "port")).to eql("")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "path")).to eql("/hogehoge")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "opaque")).to eql("")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "query")).to eql("foo=bar")
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar#frgmt", "fragment")).to eql("frgmt")
+
+    expect(fcall(:splituri, "http://hoge-san:password@example.com/hogehoge?foo=bar", "userinfo")).to eql("hoge-san:password")
+    expect(fcall(:splituri, "http://example.com:80/hogehoge?foo=bar", "port")).to eql("80")
+    expect(fcall(:splituri, "mailto:nospam@localhost", "opaque")).to eql("nospam@localhost")
+  end
+
+  it 'returns value corresponds to target element if path given' do
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "scheme")).to eql("")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "userinfo")).to eql("")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "host")).to eql("")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "port")).to eql("")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "path")).to eql("/hogehoge")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "opaque")).to eql("")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "query")).to eql("foo=bar")
+    expect(fcall(:splituri, "/hogehoge?foo=bar", "fragment")).to eql("")
+  end
+
+  it 'returns nil if invalid element specified.' do
+    expect(fcall(:splituri, "http://example.com/hogehoge?foo=bar", "test")).to be_nil
+  end
+
+  it 'returns nil if invalid uri specified.' do
+    expect(fcall(:splituri, "http://example com/hogehoge?foo=bar", "host")).to be_nil
+  end
+end
+
+describe Norikra::UDF::SplitQuery do
+  udf_function Norikra::UDF::SplitQuery
+
+  it 'returns value corresponds to target key' do
+    expect(fcall(:splitquery, "hoge=foo", "hoge")).to eql("foo")
+    expect(fcall(:splitquery, "hoge1=foo&hoge2=bar", "hoge1")).to eql("foo")
+    expect(fcall(:splitquery, "hoge[]=foo&hoge[]=bar", "hoge[]")).to match_array(["foo", "bar"])
+  end
+
+  it 'returns nil if query does not contain target key' do
+    expect(fcall(:splitquery, "", "hoge")).to be_nil
+    expect(fcall(:splitquery, "hoge=foo", "hoge1")).to be_nil
+    expect(fcall(:splitquery, "hoge1=foo&hoge2=bar", "hoge3")).to be_nil
+  end
+
+  it 'returns empty string if target key does not have value' do
+    expect(fcall(:splitquery, "hoge", "hoge")).to eql('')
+    expect(fcall(:splitquery, "hoge1=foo&hoge2=bar&hoge3", "hoge3")).to eql('')
+  end
+end

metadata

@@ -0,0 +1,114 @@
+--- !ruby/object:Gem::Specification
+name: norikra-udf-uri_parser
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: java
+authors:
+- Yoshihiro MIYAI
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2014-11-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: rspec
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  prerelease: false
+  type: :development
+- !ruby/object:Gem::Dependency
+  name: norikra
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.8
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.8
+  prerelease: false
+  type: :runtime
+description: Parse URI and query and return value specified key.
+email:
+- msparrow17@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .ruby-version
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- jar/norikra-udf-uri_parser.jar
+- java/.gitignore
+- lib/esper_plugin/uri_parser.rb
+- lib/norikra/udf/uri_parser.rb
+- norikra-udf-uri_parser.gemspec
+- spec/uri_parser_spec.rb
+homepage: https://github.com/mia-0032/norikra-udf-uri_parser
+licenses:
+- GPL v2
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+- jar
+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.1.9
+signing_key:
+specification_version: 4
+summary: Norikra UDF splituri() and splitquery().
+test_files:
+- spec/uri_parser_spec.rb