embulk-filter-row 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1c2f1a6bc6b0e1a1e98b4240c83e879291023e5
-  data.tar.gz: 75b58ba155f1bf25eba03b33cecff456bfe2c73e
+  metadata.gz: 7b023f1b8f18e5e5e62f7d468144b2ebf93127b7
+  data.tar.gz: b90fa6ff510413308a0546cc9346bf19930f34b2
 SHA512:
-  metadata.gz: d8434a65a80f738284ef000006ade5cc3fe5e3adbd1e9888db261ec927f2060dc39fc3f68b07d9fcafa975f593c8bd1f70130ce5dc0f26888f69b8bacb8d32bf
-  data.tar.gz: c7be66ee3385b68b49bfbae72880656067030532211d670905f0618bc973dba39e1ade8ace0f8d243d63e78932898fc631a687a2f7f2b42fa1db33d87f0a8cde
+  metadata.gz: 13d3939ee6d81004330ae10a71d9ee2e48e7c0b8f5a49e2a1fba7145bad1249d3b5e8cb078977f6051c19497a8d8013edb1688ab5ca5c16e957d139045259e6b
+  data.tar.gz: d5aae69cd4a8c87eb66fb3eb4b24d451e7b5d842592b21fc6d19dc285cf3aee4a92dd547c6f844052e89e5c5253bc55e323f73c91941205c49df2089803e2bb2

data/.travis.yml

@@ -0,0 +1,6 @@
+language: java
+jdk:
+  - oraclejdk8
+script:
+  - ./gradlew test
+

data/CHANGELOG.md

@@ -1,3 +1,9 @@
+# 0.1.2
+
+Enhancements:
+
+* Support Java 1.7
+
 # 0.1.1
 
 Enhancements:

data/README.md

@@ -1,5 +1,7 @@
 # Row filter plugin for Embulk
 
+[![Build Status](https://secure.travis-ci.org/sonots/embulk-filter-row.png?branch=master)](http://travis-ci.org/sonots/embulk-filter-row)
+
 A filter plugin for Embulk to filter out rows
 
 ## Configuration
@@ -52,6 +54,7 @@ NOTE: column type is automatically retrieved from input data (inputSchema)
 
 * Support OR condition
   * It should be better to think using Query engine like [Apache Drill](https://drill.apache.org/) or [Presto](https://prestodb.io/)
+  * With them, it is possible to send a query to local files, even to S3 files.
 
 ## ChangeLog
 

data/build.gradle

@@ -12,7 +12,9 @@ configurations {
     provided
 }
 
-version = "0.1.1"
+version = "0.1.2"
+sourceCompatibility = 1.7
+targetCompatibility = 1.7
 
 dependencies {
     compile  "org.embulk:embulk-core:0.6.16"

data/src/main/java/org/embulk/filter/RowFilterPlugin.java

@@ -43,8 +43,13 @@ import org.embulk.filter.row.ConditionFactory;
 
 public class RowFilterPlugin implements FilterPlugin
 {
-    public interface PluginTask
-            extends Task, TimestampParser.Task
+    private static final Logger logger = Exec.getLogger(RowFilterPlugin.class);
+
+    public RowFilterPlugin()
+    {
+    }
+
+    public interface PluginTask extends Task, TimestampParser.Task
     {
         @Config("conditions")
         public List<ConditionConfig> getConditions();
@@ -61,20 +66,13 @@ public class RowFilterPlugin implements FilterPlugin
         control.run(task.dump(), outputSchema);
     }
 
-    private final Logger log;
-
-    public RowFilterPlugin()
-    {
-        log = Exec.getLogger(RowFilterPlugin.class);
-    }
-
     @Override
-    public PageOutput open(TaskSource taskSource, Schema inputSchema,
-            Schema outputSchema, PageOutput output)
+    public PageOutput open(TaskSource taskSource, final Schema inputSchema,
+            final Schema outputSchema, final PageOutput output)
     {
         PluginTask task = taskSource.loadTask(PluginTask.class);
 
-        HashMap<String, List<Condition>> conditionMap = new HashMap<String, List<Condition>>();
+        final HashMap<String, List<Condition>> conditionMap = new HashMap<String, List<Condition>>();
         for (Column column : outputSchema.getColumns()) {
             String columnName = column.getName();
             conditionMap.put(columnName, new ArrayList<Condition>());

data/src/main/java/org/embulk/filter/row/BooleanCondition.java

@@ -4,37 +4,51 @@ public class BooleanCondition implements Condition
 {
     private BooleanComparator comparator;
 
-    @FunctionalInterface
+    // @FunctionalInterface
     interface BooleanComparator {
         boolean compare(Boolean subject);
     }
 
-    public BooleanCondition(String operator, Boolean argument, boolean not) {
-        BooleanComparator comparator;
+    public BooleanCondition(final String operator, final Boolean argument, final boolean not) {
+        final BooleanComparator comparator;
         switch (operator.toUpperCase()) {
             case "IS NULL":
-                comparator = (Boolean subject) -> {
-                    return subject == null;
+                comparator = new BooleanComparator() {
+                    public boolean compare(Boolean subject) {
+                        return subject == null;
+                    }
                 };
                 break;
             case "IS NOT NULL":
-                comparator = (Boolean subject) -> {
-                    return subject != null;
+                comparator = new BooleanComparator() {
+                    public boolean compare(Boolean subject) {
+                        return subject != null;
+                    }
                 };
                 break;
             case "!=":
-                comparator = (Boolean subject) -> {
-                    return subject == null ? true : !subject.equals(argument);
+                comparator = new BooleanComparator() {
+                    public boolean compare(Boolean subject) {
+                        return subject == null ? true : !subject.equals(argument);
+                    }
                 };
                 break;
             default: // case "==":
-                comparator = (Boolean subject) -> {
-                    return subject == null ? false : subject.equals(argument);
+                comparator = new BooleanComparator() {
+                    public boolean compare(Boolean subject) {
+                        return subject == null ? false : subject.equals(argument);
+                    }
                 };
                 break;
         }
         this.comparator = comparator;
-        if (not) this.comparator = (Boolean subject) -> { return !comparator.compare(subject); };
+        if (not) {
+            this.comparator = new BooleanComparator() {
+                public boolean compare(Boolean subject) {
+                    return !comparator.compare(subject);
+                }
+            };
+        }
     }
 
     public boolean compare(Boolean subject) {

data/src/main/java/org/embulk/filter/row/ConditionFactory.java

@@ -44,6 +44,7 @@ public class ConditionFactory
         this.columnType      = column.getType();
         this.conditionConfig = conditionConfig;
         this.operator        = conditionConfig.getOperator().get().toUpperCase(); // default: ==
+        System.out.println(conditionConfig.getNot().get().getClass());
         this.not             = conditionConfig.getNot().get().booleanValue(); // default: false
     }
 

data/src/main/java/org/embulk/filter/row/DoubleCondition.java

@@ -4,57 +4,79 @@ public class DoubleCondition implements Condition
 {
     private DoubleComparator comparator;
 
-    @FunctionalInterface
+    // @FunctionalInterface
     interface DoubleComparator {
         boolean compare(Double subject);
     }
 
-    public DoubleCondition(String operator, Double argument, boolean not) {
-        DoubleComparator comparator;
+    public DoubleCondition(final String operator, final Double argument, final boolean not) {
+        final DoubleComparator comparator;
         switch (operator.toUpperCase()) {
             case "IS NULL":
-                comparator = (Double subject) -> {
-                    return subject == null;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null;
+                    }
                 };
                 break;
             case "IS NOT NULL":
-                comparator = (Double subject) -> {
-                    return subject != null;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject != null;
+                    }
                 };
                 break;
             case ">":
-                comparator = (Double subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) > 0;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? false : subject.compareTo(argument) > 0;
+                    }
                 };
                 break;
             case ">=":
-                comparator = (Double subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) >= 0;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? false : subject.compareTo(argument) >= 0;
+                    }
                 };
                 break;
             case "<":
-                comparator = (Double subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) < 0;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? false : subject.compareTo(argument) < 0;
+                    }
                 };
                 break;
             case "<=":
-                comparator = (Double subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) <= 0;
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? false : subject.compareTo(argument) <= 0;
+                    }
                 };
                 break;
             case "!=":
-                comparator = (Double subject) -> {
-                    return subject == null ? true : !subject.equals(argument);
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? true : !subject.equals(argument);
+                    }
                 };
                 break;
             default: // case "==":
-                comparator = (Double subject) -> {
-                    return subject == null ? false : subject.equals(argument);
+                comparator = new DoubleComparator() {
+                    public boolean compare(Double subject) {
+                        return subject == null ? false : subject.equals(argument);
+                    }
                 };
                 break;
         }
         this.comparator = comparator;
-        if (not) this.comparator = (Double subject) -> { return !comparator.compare(subject); };
+        if (not) {
+            this.comparator = new DoubleComparator() {
+                public boolean compare(Double subject) {
+                    return !comparator.compare(subject);
+                }
+            };
+        }
     }
 
     public boolean compare(Double subject) {

data/src/main/java/org/embulk/filter/row/LongCondition.java

@@ -4,57 +4,79 @@ public class LongCondition implements Condition
 {
     private LongComparator comparator;
 
-    @FunctionalInterface
+    // @FunctionalInterface
     interface LongComparator {
         boolean compare(Long subject);
     }
 
-    public LongCondition(String operator, Long argument, boolean not) {
-        LongComparator comparator;
+    public LongCondition(final String operator, final Long argument, final boolean not) {
+        final LongComparator comparator;
         switch (operator.toUpperCase()) {
             case "IS NULL":
-                comparator = (Long subject) -> {
-                    return subject == null;
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null;
+                    }
                 };
                 break;
             case "IS NOT NULL":
-                comparator = (Long subject) -> {
-                    return subject != null;
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject != null;
+                    }
                 };
                 break;
             case ">":
-                comparator = (Long subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) > 0;
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? false : subject.compareTo(argument) > 0;
+                    }
                 };
                 break;
             case ">=":
-                comparator = (Long subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) >= 0;
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? false : subject.compareTo(argument) >= 0;
+                    }
                 };
                 break;
             case "<":
-                comparator = (Long subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) < 0;
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? false : subject.compareTo(argument) < 0;
+                    }
                 };
                 break;
             case "<=":
-                comparator = (Long subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) <= 0; 
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? false : subject.compareTo(argument) <= 0; 
+                    }
                 };
                 break;
             case "!=":
-                comparator = (Long subject) -> {
-                    return subject == null ? true : !subject.equals(argument);
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? true : !subject.equals(argument);
+                    }
                 };
                 break;
             default: // case "==":
-                comparator = (Long subject) -> {
-                    return subject == null ? false : subject.equals(argument);
+                comparator = new LongComparator() {
+                    public boolean compare(Long subject) {
+                        return subject == null ? false : subject.equals(argument);
+                    }
                 };
                 break;
         }
         this.comparator = comparator;
-        if (not) this.comparator = (Long subject) -> { return !comparator.compare(subject); };
+        if (not) {
+            this.comparator = new LongComparator() {
+                public boolean compare(Long subject) {
+                    return !comparator.compare(subject);
+                }
+            };
+        }
     }
 
     public boolean compare(Long subject) {

data/src/main/java/org/embulk/filter/row/StringCondition.java

@@ -4,55 +4,75 @@ public class StringCondition implements Condition
 {
     private StringComparator comparator;
 
-    @FunctionalInterface
+    // @FunctionalInterface
     interface StringComparator {
         boolean compare(String subject);
     }
 
-    public StringCondition(String operator, String argument, boolean not) {
-        StringComparator comparator;
+    public StringCondition(final String operator, final String argument, final boolean not) {
+        final StringComparator comparator;
         switch (operator.toUpperCase()) {
             case "START_WITH":
             case "STARTSWITH":
-                comparator = (String subject) -> {
-                    return subject == null ? false : subject.startsWith(argument);
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null ? false : subject.startsWith(argument);
+                    }
                 };
                 break;
             case "END_WITH":
             case "ENDSWITH":
-                comparator = (String subject) -> {
-                    return subject == null ? false : subject.endsWith(argument);
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null ? false : subject.endsWith(argument);
+                    }
                 };
                 break;
             case "INCLUDE":
             case "CONTAINS":
-                comparator = (String subject) -> {
-                    return subject == null ? false : subject.contains(argument);
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null ? false : subject.contains(argument);
+                    }
                 };
                 break;
             case "IS NULL":
-                comparator = (String subject) -> {
-                    return subject == null;
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null;
+                    }
                 };
                 break;
             case "IS NOT NULL":
-                comparator = (String subject) -> {
-                    return subject != null;
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject != null;
+                    }
                 };
                 break;
             case "!=":
-                comparator = (String subject) -> {
-                    return subject == null ? true : !subject.equals(argument);
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null ? true : !subject.equals(argument);
+                    }
                 };
                 break;
             default: // case "==":
-                comparator = (String subject) -> {
-                    return subject == null ? false : subject.equals(argument);
+                comparator = new StringComparator() {
+                    public boolean compare(String subject) {
+                        return subject == null ? false : subject.equals(argument);
+                    }
                 };
                 break;
         }
         this.comparator = comparator;
-        if (not) this.comparator = (String subject) -> { return !comparator.compare(subject); };
+        if (not) {
+            this.comparator = new StringComparator() {
+                public boolean compare(String subject) {
+                    return !comparator.compare(subject);
+                }
+            };
+        }
     }
 
     public boolean compare(String subject) {

data/src/main/java/org/embulk/filter/row/TimestampCondition.java

@@ -5,57 +5,79 @@ public class TimestampCondition implements Condition
 {
     private TimestampComparator comparator;
 
-    @FunctionalInterface
+    // @FunctionalInterface
     interface TimestampComparator {
         boolean compare(Timestamp subject);
     }
 
-    public TimestampCondition(String operator, Timestamp argument, boolean not) {
-        TimestampComparator comparator;
+    public TimestampCondition(final String operator, final Timestamp argument, final boolean not) {
+        final TimestampComparator comparator;
         switch (operator.toUpperCase()) {
             case ">":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) > 0;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? false : subject.compareTo(argument) > 0;
+                    }
                 };
                 break;
             case ">=":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) >= 0;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? false : subject.compareTo(argument) >= 0;
+                    }
                 };
                 break;
             case "<":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) < 0;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? false : subject.compareTo(argument) < 0;
+                    }
                 };
                 break;
             case "<=":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? false : subject.compareTo(argument) <= 0;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? false : subject.compareTo(argument) <= 0;
+                    }
                 };
                 break;
             case "IS NULL":
-                comparator = (Timestamp subject) -> {
-                    return subject == null;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null;
+                    }
                 };
                 break;
             case "IS NOT NULL":
-                comparator = (Timestamp subject) -> {
-                    return subject != null;
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject != null;
+                    }
                 };
                 break;
             case "!=":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? true : !subject.equals(argument);
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? true : !subject.equals(argument);
+                    }
                 };
                 break;
             default: // case "==":
-                comparator = (Timestamp subject) -> {
-                    return subject == null ? false : subject.equals(argument);
+                comparator = new TimestampComparator() {
+                    public boolean compare(Timestamp subject) {
+                        return subject == null ? false : subject.equals(argument);
+                    }
                 };
                 break;
         }
         this.comparator = comparator;
-        if (not) this.comparator = (Timestamp subject) -> { return !comparator.compare(subject); };
+        if (not) {
+            this.comparator = new TimestampComparator() {
+                public boolean compare(Timestamp subject) {
+                    return !comparator.compare(subject);
+                }
+            };
+        }
     }
 
     public boolean compare(Timestamp subject) {

data/src/test/java/org/embulk/filter/row/TestConditionFactory.java

@@ -71,14 +71,14 @@ public class TestConditionFactory
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
         };
         condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Boolean(true)));
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Long(10)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Long(10)); }
         };
         try {
             condition = (BooleanCondition)new ConditionFactory(jruby, column, config).createCondition();
@@ -111,14 +111,14 @@ public class TestConditionFactory
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Double(10)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Double(10)); }
         };
         condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Double(10)));
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
         };
         try {
             condition = (DoubleCondition)new ConditionFactory(jruby, column, config).createCondition();
@@ -151,14 +151,14 @@ public class TestConditionFactory
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Long(10)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Long(10)); }
         };
         condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare(new Long(10)));
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
         };
         try {
             condition = (LongCondition)new ConditionFactory(jruby, column, config).createCondition();
@@ -191,14 +191,14 @@ public class TestConditionFactory
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of("foo"); }
+            public Optional<Object> getArgument() { return Optional.of((Object)"foo"); }
         };
         condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
         assertTrue(condition.compare("foo"));
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
         };
         try {
             condition = (StringCondition)new ConditionFactory(jruby, column, config).createCondition();
@@ -232,14 +232,14 @@ public class TestConditionFactory
         //ToDo: How to create jruby object correctly?
         //config = new DefaultConditionConfig() {
         //    public Optional<String> getOperator() { return Optional.of("=="); }
-        //    public Optional<Object> getArgument() { return Optional.of("2015-07-15"); }
+        //    public Optional<Object> getArgument() { return Optional.of((Object)"2015-07-15"); }
         //    public Optional<String> getFormat()   { return Optional.of("%Y-%m-%d"); }
         //};
         //condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();
 
         config = new DefaultConditionConfig() {
             public Optional<String> getOperator() { return Optional.of("=="); }
-            public Optional<Object> getArgument() { return Optional.of(new Boolean(true)); }
+            public Optional<Object> getArgument() { return Optional.of((Object)new Boolean(true)); }
         };
         try {
             condition = (TimestampCondition)new ConditionFactory(jruby, column, config).createCondition();

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: embulk-filter-row
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Naotoshi Seo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2015-07-18 00:00:00.000000000 Z
+date: 2015-07-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: bundler
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
-  name: bundler
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.0'
+  prerelease: false
+  type: :development
 - !ruby/object:Gem::Dependency
-  requirement: !ruby/object:Gem::Requirement
+  name: rake
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '10.0'
-  name: rake
-  prerelease: false
-  type: :development
-  version_requirements: !ruby/object:Gem::Requirement
+  requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '>='
       - !ruby/object:Gem::Version
         version: '10.0'
+  prerelease: false
+  type: :development
 description: A filter plugin for Embulk to filter out rows with conditions.
 email:
 - sonots@gmail.com
@@ -46,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .travis.yml
 - CHANGELOG.md
 - LICENSE.txt
 - README.md
@@ -72,7 +73,7 @@ files:
 - src/test/java/org/embulk/filter/row/TestLongCondition.java
 - src/test/java/org/embulk/filter/row/TestStringCondition.java
 - src/test/java/org/embulk/filter/row/TestTimestampCondition.java
-- classpath/embulk-filter-row-0.1.1.jar
+- classpath/embulk-filter-row-0.1.2.jar
 homepage: https://github.com/sonots/embulk-filter-row
 licenses:
 - MIT