str2duck 1.7.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8f4f9a373147c408c3f581d43655a3c5e61a6bff
-  data.tar.gz: ed6247261947a62288897bd3688b198e6ed0d776
+  metadata.gz: 9407d3d02dc0761903619a86237ef5b7564c50f0
+  data.tar.gz: e6a69d843d5b3863e61ce43ab6f70f58412a4870
 SHA512:
-  metadata.gz: 82cd3d2589d8043d979284708f97ab9e21ff471cc31d7e65c4af301aa36b0df51cbe3b1ad1d624f8cf24a5ee39cd313f58f3f27850f3b4057481787e44a89335
-  data.tar.gz: ba4368bfbb05f9c00df02c11d4a718c1a0de5644cde3e02ab5b9c0be79ad173e744791da1da3fb8596a1c3c7f16cf8c65d4c9063262e8b0758242eedd84b46ac
+  metadata.gz: 85745683941860a35e9501d24e99a291eac6c378fc0de8dacb478e6b1c0f06d386e74332454c9cebe52a1ef18f1eb8fd309c15aa48c9f213d8d993d30537f775
+  data.tar.gz: 3ddd22c3dcbcc7722d6d4665474496749231b8c8a77d569afe97a38d291ed8bb2c3e39a0d9699d1148b5b4f3bdc2b090cbbc91a0905a97291205035de8bde399

data/README.md

@@ -47,17 +47,12 @@ like:
 
 ```
 
-If you dont want one or more parser to be active on parse, you can simply config th str2duck parser like this
+If you dont want one or more parser to be active on parse, pass the strategie names you want to be used on parsing
 
 ```ruby
 
-  # This will turn of yaml string parsing for example.
-  # From this point parsing will not check for yaml but return a string instead if none match
-  Str2Duck::Config.yaml = false
-
-  # This will return the implemented parsers, so you dont have to bingo
-  puts Str2Duck::Config.list
-
+  Str2Duck.parse('string',:datetime,:date)
+  
 ```
 
 Now it has a new object syntax sugar patch that allow you to call the duck methods on any class if you not sure,

data/VERSION

@@ -1 +1 @@
-1.7.1
+2.0.0

data/examples/sample.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift(File.join(__dir__,'..','lib'))
 require "str2duck"
 
 [

data/lib/str2duck.rb

@@ -1,8 +1,13 @@
-#encoding: UTF-8
+module Str2Duck
 
-require 'str2duck/regexp'
-require 'str2duck/format'
-require 'str2duck/config'
-require 'str2duck/parser'
+  require 'str2duck/matcher'
+  require 'str2duck/converter'
+  require 'str2duck/parser'
 
-require 'str2duck/mpatch/object'
+  require 'str2duck/core_ext'
+
+  def self.parse(str,*parse_strategies)
+    self::Parser.new(*parse_strategies).parse(str)
+  end
+
+end

data/lib/str2duck/converter.rb

@@ -0,0 +1,73 @@
+module Str2Duck::Converter
+
+  extend self
+
+  def datetime(obj)
+    if Str2Duck::Matcher.datetime?(obj)
+      if defined?(DateTime) && DateTime.respond_to?(:parse)
+        return DateTime.parse(obj)
+      # else
+      #   if time_parts.count == 8
+      #     2.times { time_parts.pop }
+      #   elsif time_parts.count == 6
+      #     return nil
+      #   end
+      #   return Time.new(*time_parts)
+      end
+    end; nil
+  end
+
+  def date(obj)
+    if Str2Duck::Matcher.date?(obj)
+      begin
+        return Date.parse(obj)
+      rescue NoMethodError
+        time_parts= obj.scan(/\d+/).map(&:to_i)
+        return Time.new(*time_parts)
+      end
+    end; nil
+  end
+
+  def time(obj)
+    if Str2Duck::Matcher.time?(obj)
+      begin
+        return Time.parse(obj)
+      rescue NoMethodError
+        time_parts= obj.scan(/\d+/).map(&:to_i)
+        1.times { time_parts.pop }
+        return Time.new(*time_parts)
+      end
+    end; nil
+  end
+
+  def true(obj)
+    if Str2Duck::Matcher.true?(obj)
+      return true
+    end; nil
+  end
+
+  def false(obj)
+    if Str2Duck::Matcher.false?(obj)
+      return false
+    end; nil
+  end
+
+  def float(obj)
+    if Str2Duck::Matcher.float?(obj)
+      return obj.sub(',', '.').to_f
+    end; nil
+  end
+
+  def integer(obj)
+    if Str2Duck::Matcher.integer?(obj)
+      return obj.to_i
+    end; nil
+  end
+
+  def json(obj)
+    if Str2Duck::Matcher.json?(obj)
+      return JSON.parse(obj)
+    end; nil
+  end
+
+end

data/lib/str2duck/core_ext.rb

@@ -0,0 +1,3 @@
+module Str2Duck::CoreExt
+  require 'str2duck/core_ext/object'
+end

data/lib/str2duck/core_ext/object.rb

@@ -0,0 +1,11 @@
+module Str2Duck::CoreExt::Object
+
+  def to_duck
+    (self.class <= String) ? Str2Duck.parse(self) : self
+  end
+
+  alias :duck :to_duck
+
+end
+
+Object.__send__ :include, Str2Duck::CoreExt::Object

data/lib/str2duck/matcher.rb

@@ -0,0 +1,79 @@
+module Str2Duck::Matcher
+
+  extend self
+
+  def datetime?(obj)
+
+    answer_value= nil
+    [
+        /^\w+, \d+ \w+ \d+ \d\d:\d\d:\d\d \+\d+$/,
+        /^-?\d+-\d\d-\d\d\w\d\d:\d\d:\d\d\+\d\d:\d\d$/,
+        /\w+ \w+ \d+ \d+ \d+:\d+:\d+ \w+\+\d+ \(\w+\)/,
+        /^-?\d+-\d\d?-\d\d?\w\d\d?:\d\d?:\d\d?\w$/
+    ].each do |regexp|
+      answer_value ||= obj =~ regexp
+    end
+
+    return !!answer_value
+
+  end
+
+  def date?(obj)
+
+    answer_value= nil
+    [
+        /^\d+-\d\d-\d\d$/,
+        /^\w+, \d+ \w+ \d+$/
+    ].each do |regexp|
+      answer_value ||= obj =~ regexp
+    end
+
+    return !!answer_value
+
+  end
+
+  def time?(obj)
+
+    answer_value= nil
+    [
+        /^\d+-\d\d-\d\d \d\d:\d\d:\d\d \+\d+$/
+    ].each do |regexp|
+      answer_value ||= obj =~ regexp
+    end
+
+    return !!answer_value
+
+  end
+
+  def true?(obj)
+    return !!(obj =~ /^true$/)
+  end
+
+  def false?(obj)
+    return !!(obj =~ /^false$/)
+  end
+
+  def float?(obj)
+    case obj.to_s
+      when /^\d+\.\d+$/, /^\d+,\d+$/
+        return true
+      else
+        return false
+    end
+  end
+
+  def integer?(obj)
+    return !!(obj =~ /^\d+$/)
+  end
+
+  def json?(obj)
+    return false unless defined?(JSON)
+    begin
+      JSON.parse(obj)
+      return true
+    rescue ::JSON::ParserError
+      return false
+    end
+  end
+
+end

data/lib/str2duck/parser.rb

@@ -1,24 +1,36 @@
-#encoding: UTF-8
-module Str2Duck
+class Str2Duck::Parser
+
+  DEFAULT_STRATEGIES = [:datetime, :date, :time, :true, :false, :float, :integer, :json].freeze
+
+  def initialize(*parse_strategies)
+
+    @parse_strategies = parse_strategies.map(&:to_s).map(&:to_sym)
+    @parse_strategies.push(*DEFAULT_STRATEGIES) if @parse_strategies.empty?
+
+    require_activesupport
 
-  def self.activesupport
-    require(File.join 'active_support','time')
-  rescue LoadError
-    return true
   end
 
-  def self.parse str
-    raise(ArgumentError,"invalid input, must be string like") unless str.class <= String
-    @activesupport ||= activesupport
-    [ :datetime, :date, :time, :true, :false, :float, :integer, :json, :yaml ].each do |method_name|
-      if ::Str2Duck::Config.public_send(method_name)
-        var = Str2Duck::Format.public_send method_name, str
-        return var unless var.nil?
-      end
+  def parse(str)
+
+    raise(ArgumentError, 'invalid input, must be string like') unless str.class <= String
+
+    @parse_strategies.each do |method_name|
+      var = Str2Duck::Converter.public_send(method_name, str)
+      return var unless var.nil?
     end
 
     return str
 
   end
 
-end
+  protected
+
+  def require_activesupport
+    require(File.join 'active_support', 'time') unless @activesupport_required
+  rescue LoadError
+  ensure
+    @activesupport_required = true
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
+require 'str2duck'

data/spec/str2duc_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+describe Str2Duck do
+
+  describe '.parse' do
+
+    let(:str){'123'}
+    let(:args){[]}
+    subject{ described_class.parse(str,*args) }
+
+    context 'when no strategy passed only object to be parsed' do
+      it { is_expected.to eq 123 }
+    end
+
+    context 'when args is limited to datetime type' do
+      let(:args){[:datetime]}
+
+      it { is_expected.to eq '123' }
+    end
+
+  end
+
+end

data/spec/str2duck/converter_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+describe Str2Duck::Converter do
+
+  let(:str) { 'duck' }
+
+  describe '#datetime' do
+    subject { described_class.datetime(str) }
+
+    context 'when the format is like \w+, \d+ \w+ \d+ \d\d:\d\d:\d\d \+\d+' do
+      let(:str) { "Fri, 25 Jan 2013 20:02:15 +0100" }
+
+      it { is_expected.to be_a DateTime }
+    end
+
+    context 'when the format is like /^-?\d+-\d\d-\d\d\w\d\d:\d\d:\d\d\+\d\d:\d\d$/' do
+      let(:str) { "2012-09-12T14:49:50+02:00" }
+
+      it { is_expected.to be_a DateTime }
+    end
+
+    context 'when the format is like /^-?\d+-\d\d?-\d\d?\w\d\d?:\d\d?:\d\d?\w$/' do
+      let(:str) { "2012-09-12T14:49:50" }
+
+      it { is_expected.to be_a DateTime }
+    end
+
+    context 'when invalid value given' do
+      let(:str) { 'not-a-validTdatetime' }
+
+      it { is_expected.to be nil }
+    end
+
+  end
+
+  describe '#date' do
+
+    subject { described_class.date(str) }
+
+    context 'when the date format is like /^\d+-\d\d-\d\d$/' do
+      let(:str) { "2011-03-12" }
+
+      it { is_expected.to be_a Date }
+    end
+
+    context 'when the date format is like /^\w+, \d+ \w+ \d+$/' do
+      let(:str) { "Sun, 28 Aug 2005" }
+
+      it { is_expected.to be_a Date }
+    end
+
+  end
+
+  describe '#time' do
+
+    subject { described_class.time(str) }
+
+    context 'when time format is like: /^\d+-\d\d-\d\d \d\d:\d\d:\d\d \+\d+$/' do
+      let(:str) { "2010-10-30 18:02:56 +0200" }
+
+      it { is_expected.to be_a Time }
+    end
+
+  end
+
+  describe '#true' do
+    it { expect(subject.true('true')).to be_a TrueClass }
+    it { expect(subject.true('else')).to be nil }
+  end
+
+  describe '#false' do
+    it { expect(subject.false('false')).to be_a FalseClass }
+    it { expect(subject.false('else')).to be nil }
+  end
+
+  describe '#float' do
+    it { expect(subject.float('123.5')).to be_a Float }
+    it { expect(subject.float('123')).to be nil }
+  end
+
+  describe '#integer' do
+    it { expect(subject.integer('123')).to be_a Integer }
+    it { expect(subject.integer('123.1')).to be nil }
+  end
+
+  describe '#json' do
+    before { require 'json' }
+    it { expect(subject.json(JSON.dump({hello: :world}))).to be_a Hash }
+    it { expect(subject.json('{not: "json"}')).to be nil }
+  end
+
+end

data/spec/str2duck/core_ext/object_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+describe Str2Duck::CoreExt::Object do
+  subject { Object.new }
+
+  describe '#to_duck' do
+    context 'when string given' do
+      it { expect('123'.to_duck).to eq 123 }
+    end
+
+    context 'when not string given' do
+      subject{ Object.new }
+      it 'should return the object back' do
+        expect(subject.to_duck).to equal subject
+      end
+    end
+
+  end
+
+end

data/spec/str2duck/matcher_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+describe Str2Duck::Matcher do
+
+  let(:str) { 'duck' }
+
+  describe '#datetime?' do
+    subject { described_class.datetime?(str) }
+
+    context 'when the format is like \w+, \d+ \w+ \d+ \d\d:\d\d:\d\d \+\d+' do
+      let(:str) { "Fri, 25 Jan 2013 20:02:15 +0100" }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'when the format is like /^-?\d+-\d\d-\d\d\w\d\d:\d\d:\d\d\+\d\d:\d\d$/' do
+      let(:str) { "2012-09-12T14:49:50+02:00" }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'when the format is like /^-?\d+-\d\d?-\d\d?\w\d\d?:\d\d?:\d\d?\w$/' do
+      let(:str) { "2012-09-12T14:49:50" }
+
+      it { is_expected.to eq true }
+    end
+
+    #todo clean up code
+
+  end
+
+  describe '#date?' do
+
+    subject { described_class.date?(str) }
+
+    context 'when the date format is like /^\d+-\d\d-\d\d$/' do
+      let(:str) { "2011-03-12" }
+
+      it { is_expected.to eq true }
+    end
+
+    context 'when the date format is like /^\w+, \d+ \w+ \d+$/' do
+      let(:str) { "Sun, 28 Aug 2005" }
+
+      it { is_expected.to eq true }
+    end
+
+  end
+
+  describe '#time?' do
+
+    subject { described_class.time?(str) }
+
+    context 'when time format is like: /^\d+-\d\d-\d\d \d\d:\d\d:\d\d \+\d+$/' do
+      let(:str) { "2010-10-30 18:02:56 +0200" }
+
+      it { is_expected.to eq true }
+    end
+
+  end
+
+  describe '#true?' do
+    it { expect(subject.true?('true')).to eq true }
+    it { expect(subject.true?('else')).to eq false }
+  end
+
+  describe '#false?' do
+    it { expect(subject.false?('false')).to eq true }
+    it { expect(subject.false?('else')).to eq false }
+  end
+
+  describe '#float?' do
+    it { expect(subject.float?('123.5')).to eq true }
+    it { expect(subject.float?('123')).to eq false }
+  end
+
+  describe '#integer?' do
+    it { expect(subject.integer?('123')).to eq true }
+    it { expect(subject.integer?('123.1')).to eq false }
+  end
+
+  describe '#json?' do
+    before { require 'json' }
+    it { expect(subject.json?(JSON.dump({hello: :world}))).to eq true }
+    it { expect(subject.json?('{not: "json"}')).to eq false }
+  end
+
+end

data/str2duck.gemspec

@@ -17,5 +17,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   spec.add_development_dependency 'activesupport'
+  spec.add_development_dependency 'rspec'
 
 end

data/test/test_parse.rb

@@ -1,3 +1,4 @@
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
 require "str2duck"
 require 'minitest/autorun'
 describe 'StringParse' do
@@ -5,26 +6,30 @@ describe 'StringParse' do
   specify 'parse objects into the right format' do
 
     {
-        "2011-03-12"                =>  Date,
-        "2007-07-20 18:59:27 +0200" =>  Time,
-        "2010-10-30 18:02:56 +0200" =>  Time,
-        "2012-09-12T14:49:50+02:00" =>  DateTime,
-        "123"                       =>  Fixnum,
-        "asd"                       =>  String,
-        "123.432"                   =>  Float,
-        "123,432"                   =>  Float,
-        "true"                      =>  TrueClass,
-        "false"                     =>  FalseClass,
-        "some string data"          =>  String,
-        "{\"hello\":\"json\"}"      =>  Hash,
-        "--- hello\n..."            =>  String,
-        "hello: yaml"               =>  Hash,
-        "2014-11-04T15:46:06Z"      =>  DateTime
-    }.each_pair do |str,klass|
+        "2011-03-12" => Date,
+        "2007-07-20 18:59:27 +0200" => Time,
+        "2010-10-30 18:02:56 +0200" => Time,
+        "2012-09-12T14:49:50+02:00" => DateTime,
+        "123" => Fixnum,
+        "asd" => String,
+        "123.432" => Float,
+        "123,432" => Float,
+        "true" => TrueClass,
+        "false" => FalseClass,
+        "some string data" => String,
+        "--- hello\n..." => String,
+        "2014-11-04T15:46:06Z" => DateTime
+    }.each_pair do |str, klass|
       str.to_duck.must_be_instance_of klass
     end
 
   end
 
+  specify 'when checking json' do
+    require 'json'
+    "{\"hello\":\"json\"}".to_duck.must_be_instance_of Hash
+    '["dog","cat"]'.to_duck.must_be_instance_of Array
+  end
+
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: str2duck
 version: !ruby/object:Gem::Version
-  version: 1.7.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Adam Luzsi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-19 00:00:00.000000000 Z
+date: 2015-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -24,6 +24,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: " Parse string into obj "
 email:
 - adamluzsi@gmail.com
@@ -38,15 +52,18 @@ files:
 - Rakefile
 - VERSION
 - examples/sample.rb
-- examples/test.rb
 - lib/str2duck.rb
-- lib/str2duck/config.rb
-- lib/str2duck/format.rb
-- lib/str2duck/mpatch/object.rb
+- lib/str2duck/converter.rb
+- lib/str2duck/core_ext.rb
+- lib/str2duck/core_ext/object.rb
+- lib/str2duck/matcher.rb
 - lib/str2duck/parser.rb
-- lib/str2duck/regexp.rb
+- spec/spec_helper.rb
+- spec/str2duc_spec.rb
+- spec/str2duck/converter_spec.rb
+- spec/str2duck/core_ext/object_spec.rb
+- spec/str2duck/matcher_spec.rb
 - str2duck.gemspec
-- test/test_obj.rb
 - test/test_parse.rb
 homepage: https://github.com/adamluzsi/str2duck
 licenses: []
@@ -72,6 +89,10 @@ signing_key:
 specification_version: 4
 summary: String to Obj, Duck type parser
 test_files:
-- test/test_obj.rb
+- spec/spec_helper.rb
+- spec/str2duc_spec.rb
+- spec/str2duck/converter_spec.rb
+- spec/str2duck/core_ext/object_spec.rb
+- spec/str2duck/matcher_spec.rb
 - test/test_parse.rb
 has_rdoc: 

data/examples/test.rb

@@ -1,13 +0,0 @@
-require "str2duck"
-
-puts "false".to_duck.class
-
-# puts 123.duck.class
-# puts ["hello","world"].duck.class
-# puts '{"hello":"world"}'.duck.class
-# puts "hello: world".duck.class,"","---"
-#
-#
-# Str2Duck::Config.yaml = false
-# puts Str2Duck::Config.list,"","---"
-# puts "hello: world".duck.class

data/lib/str2duck/config.rb

@@ -1,27 +0,0 @@
-#encoding: UTF-8
-module Str2Duck
-  module Config
-
-    ::Str2Duck::Format.singleton_methods.each do |method|
-
-      self.define_singleton_method "#{method}=" do |boolean|
-        unless !!boolean == boolean
-          raise( ArgumentError,"invalid value given #{boolean.inspect},input must be a boolean!" )
-        end
-        self.class_variable_set("@@#{method.to_s}",boolean)
-      end
-
-      self.define_singleton_method(method) do
-        self.class_variable_get("@@#{method.to_s}")
-      end
-
-      self.class_variable_set("@@#{method.to_s}",true)
-
-    end
-
-    def self.list
-      ::Str2Duck::Format.singleton_methods
-    end
-
-  end
-end

data/lib/str2duck/format.rb

@@ -1,90 +0,0 @@
-#encoding: UTF-8
-require 'yaml'
-require 'json'
-
-module Str2Duck
-  module Format
-    class << self
-
-      def datetime obj
-        if Str2Duck::Regexp.datetime?(obj)
-          if defined?(DateTime) && DateTime.respond_to?(:parse)
-            return DateTime.parse obj
-          else
-            if time_parts.count == 8
-              2.times{time_parts.pop}
-            elsif time_parts.count == 6
-              return nil
-            end
-            return Time.new(*time_parts)
-          end
-        end;nil
-      end
-
-      def date obj
-        if Str2Duck::Regexp.date?(obj)
-          begin
-            return Date.parse obj
-          rescue NoMethodError
-            time_parts= obj.scan(/\d+/).map(&:to_i)
-            return Time.new(*time_parts)
-          end
-        end;nil
-      end
-
-      def time obj
-        if Str2Duck::Regexp.time?(obj)
-          begin
-            return Time.parse obj
-          rescue NoMethodError
-            time_parts= obj.scan(/\d+/).map(&:to_i)
-            1.times{time_parts.pop}
-            return Time.new(*time_parts)
-          end
-        end;nil
-      end
-
-      def true obj
-        if Str2Duck::Regexp.true?(obj)
-          return true
-        end;nil
-      end
-
-      def false obj
-        if Str2Duck::Regexp.false?(obj)
-          return false
-        end;nil
-      end
-
-      def float obj
-        if Str2Duck::Regexp.float?(obj)
-          return obj.sub(',','.').to_f
-        end;nil
-      end
-
-      def integer obj
-        if Str2Duck::Regexp.integer?(obj)
-          return obj.to_i
-        end;nil
-      end
-
-      def json obj
-        if Str2Duck::Regexp.json?(obj)
-          return JSON.parse(obj)
-        end;nil
-      end
-
-      # damn, this thing eats almost everything...
-      def yaml obj
-        if Str2Duck::Regexp.yaml?(obj)
-          if YAML.respond_to?(:safe_load)
-            return YAML.safe_load(obj)
-          else
-            return YAML.load(obj)
-          end
-        end;nil
-      end
-
-    end
-  end
-end

data/lib/str2duck/mpatch/object.rb

@@ -1,20 +0,0 @@
-module Str2Duck
-  module MPatch
-    module ObjectEXT
-
-      def to_duck
-        if self.class <= String
-          Str2Duck.parse(self)
-        else
-          return self
-        end
-
-      end
-
-      alias :duck :to_duck
-
-    end
-  end
-end
-
-Object.__send__ :include, Str2Duck::MPatch::ObjectEXT

data/lib/str2duck/regexp.rb

@@ -1,90 +0,0 @@
-#encoding: UTF-8
-module Str2Duck
-  module Regexp
-
-    @@year  = '\d+'
-    class << self
-
-      def datetime? obj
-
-        answer_value= nil
-        [
-            /^\w+, \d+ \w+ #{@@year} \d\d:\d\d:\d\d \+\d+$/,
-            /^-?#{@@year}-\d\d-\d\d\w\d\d:\d\d:\d\d\+\d\d:\d\d$/,
-            /\w+ \w+ \d+ #{@@year} \d+:\d+:\d+ \w+\+\d+ \(\w+\)/,
-            /^-?\d+-\d\d?-\d\d?\w\d\d?:\d\d?:\d\d?\w$/
-        ].each do |regexp|
-          answer_value ||= obj =~ regexp
-        end
-
-        return !!answer_value
-
-      end
-
-      def date? obj
-
-        answer_value= nil
-        [
-            /^#{@@year}-\d\d-\d\d$/,
-            /^\w+, \d+ \w+ #{@@year}$/
-        ].each do |regexp|
-          answer_value ||= obj =~ regexp
-        end
-
-        return !!answer_value
-
-      end
-
-      def time? obj
-
-        answer_value= nil
-        [
-            /^#{@@year}-\d\d-\d\d \d\d:\d\d:\d\d \+\d+$/
-        ].each do |regexp|
-          answer_value ||= obj =~ regexp
-        end
-
-        return !!answer_value
-
-      end
-
-      def true? obj
-        return !!obj =~ /^true$/
-      end
-
-      def false? obj
-        return !!obj =~ /^false$/
-      end
-
-      def float? obj
-        case obj.to_s
-          when /^\d+\.\d+$/,/^\d+,\d+$/
-            return true
-          else
-            return false
-        end
-      end
-
-      def integer? obj
-        return !!obj =~ /^\d+$/
-      end
-
-      def json? obj
-        begin
-          JSON.parse(obj)
-          return true
-        rescue ::JSON::ParserError
-          return false
-        end
-      end
-
-      def yaml? obj
-        YAML.safe_load(obj)
-        return true
-      rescue ::Exception
-        return false
-      end
-
-    end
-  end
-end

data/test/test_obj.rb

@@ -1,13 +0,0 @@
-require "str2duck"
-require 'minitest/autorun'
-describe 'StringParse' do
-
-  specify 'test a specific object' do
-
-      puts "2014-11-04T15:46:06Z".to_duck
-      puts "2014-11-04T15:46:06Z".to_duck.class
-
-  end
-
-end
-