ehon 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 26332159b5ba10a4e88371c85265c39a3a088f8a
+  data.tar.gz: a7a7588f7a1b3fd8fea85c18464eec0f750957cc
+SHA512:
+  metadata.gz: da617d040c65e82e0b3e6c569a27855baa70509b35cd2bf91bf173e07ba7336b6c61664a04f4efc1538af2dc419094f96408366f59913b2a88471dff2a24929d
+  data.tar.gz: 77abcc82ffabafec73fb62fb2181df3a31d65a25465d46c9d420a5207cc669b882b01d1149328c2ebe6ea9de960a21025183ca8dd7cb263f59a93054760a2aa2

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.0

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ehon.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Tomohiro Nishimura
+
+MIT License
+
+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,75 @@
+
+# Ehon
+[![Build Status](https://travis-ci.org/hekk/ehon.png?branch=master)](https://travis-ci.org/hekk/ehon)
+
+Ehon is a simple `enum` library.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ehon'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ehon
+
+## Usage
+
+You can create your enum class easily.
+
+```ruby
+class DeviceType
+  include Ehon
+
+  default user_agent_regexp: //
+
+  UNKNOWN = enum 0, name: 'unknown'
+  IOS     = enum 1, name: 'iOS',     user_agent_regexp: /(iPhone|iPad|iPod)/
+  ANDROID = enum 2, name: 'Android', user_agent_regexp: /Android/
+end
+```
+
+Using `DeviceType` class.
+
+```ruby
+DeviceType::IOS.id #=> 1
+DeviceType::ANDROID.user_agent_regexp #=> /Android/
+```
+
+Finding.
+
+```ruby
+DeviceType[1, 2] #=> [#<DeviceType:...(iOS)>, #<DeviceType:...(Android)>]
+DeviceType.find(name: 'iOS') #=> #<DeviceType:...(iOS)>
+```
+
+Custom method.
+
+```ruby
+class DeviceType
+  %w[iOS Android unknown].each do |name|
+    define_method :"#{name.downcase}?" do
+      self.name == name
+    end
+  end
+end
+```
+
+```ruby
+DeviceTypel::IOS.ios? #=> true
+DeviceTypel::IOS.android? #=> false
+```
+
+## Contributing
+
+1. Fork it ( http://github.com/<my-github-username>/ehon/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 new Pull Request
+

data/Rakefile

@@ -0,0 +1,15 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec
+
+task :console do
+  require 'irb'
+  require 'irb/completion'
+  require 'ehon'
+  ARGV.clear
+  IRB.start
+end
+

data/ehon.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ehon/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ehon"
+  spec.version       = Ehon::VERSION
+  spec.authors       = ["Tomohiro Nishimura"]
+  spec.email         = ["tomohiro68@gmail.com"]
+  spec.summary       = %q{Ehon is a simple `enum` library.}
+  spec.description   = %q{Ehon is a simple `enum` library.}
+  spec.homepage      = "https://github.com/hekk/ehon"
+  spec.license       = "MIT"
+
+  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"]
+
+  spec.add_development_dependency "bundler", "~> 1.5"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/lib/ehon.rb

@@ -0,0 +1,63 @@
+require "ehon/version"
+
+module Ehon
+  def self.included(base)
+    base.extend ClassMethods
+    base.contents        = {}
+    base.default_options = {}
+  end
+
+  def initialize(id, options = {})
+    @options = options.merge(id: id)
+  end
+
+  def options
+    self.class.default_options.merge(@options)
+  end
+
+  def ==(other)
+    (self.class == other.class) && (self.id == other.id)
+  end
+
+  def respond_to_missing?(symbol, include_private = false)
+    self.options.has_key?(symbol)
+  end
+
+  def method_missing(symbol, *args)
+    return self.options[symbol] if respond_to?(symbol)
+    super
+  end
+
+  module ClassMethods
+    attr_accessor :contents, :default_options
+
+    def page(id, options = {}, &block)
+      instance = new(id, options)
+      instance.instance_eval(&block) if block_given?
+      self.contents[id] = instance
+      instance
+    end
+    alias enum page
+
+    def default(options = {})
+      self.default_options.merge!(options)
+    end
+
+    def all
+      self.contents.values
+    end
+
+    def find(*queries)
+      queries.flatten!
+      findeds = queries.map {|query|
+        next self.contents[query] unless query.is_a?(Hash)
+        self.contents.values.find {|instance|
+          query.all? {|key, value| instance.options[key] == value }
+        }
+      }.compact
+      queries.size == 1 ? findeds.first : findeds
+    end
+    alias [] find
+  end
+end
+

data/lib/ehon/version.rb

@@ -0,0 +1,3 @@
+module Ehon
+  VERSION = "0.1.0"
+end

data/spec/ehon_spec.rb

@@ -0,0 +1,284 @@
+require 'spec_helper'
+
+describe Ehon do
+  it 'should have a version number' do
+    expect(Ehon::VERSION).to_not be_nil
+  end
+
+  subject { Item }
+
+  before :all do
+    class Item
+      include Ehon
+    end
+  end
+
+  after do
+    Item.contents = {}
+    Item.default_options = {}
+  end
+
+  describe '.page' do
+
+    shared_examples_for 'a page' do
+      it 'should create one instance' do
+        expect(subject.contents.size).to eq(1)
+      end
+
+      it 'instance id equals to argument' do
+        expect(@instance.id).to eq(expected_id)
+      end
+    end
+
+    context 'without options' do
+      3.times do
+        random_id = rand(10)
+
+        before { @instance = subject.page(expected_id) }
+
+        context "id is #{random_id}" do
+          let(:expected_id) { random_id }
+          it_behaves_like "a page"
+        end
+      end
+    end
+
+    context 'with options' do
+      before { @instance = subject.page(expected_id, expected_options) }
+
+      let(:expected_id) { 3 }
+      let(:expected_options) { {name: 'potion', value: 5} }
+
+      it_behaves_like "a page"
+
+      it 'instance options equals to argument with id: 3' do
+        expect(@instance.options).to eq(expected_options.merge(id: 3))
+      end
+
+      3.times do
+        random_key   = ('a'..'z').to_a.shuffle.take(5).join.to_sym
+        random_value = rand(100)
+
+        context "with {#{random_key}: #{random_value}}" do
+          let(:expected_options) { {random_key => random_value} }
+
+          it "responds to #{random_key}" do
+            expect(@instance).to be_respond_to(random_key)
+          end
+
+          it "instance should return #{random_value} when call #{random_key}" do
+            expect(@instance.__send__(random_key)).to eq(random_value)
+          end
+        end
+      end
+    end
+
+    context 'with default options' do
+      before do
+        class Item
+          default key: 'value'
+        end
+        @instance = subject.page(1)
+      end
+
+      it "should has default option {key: 'value'}" do
+        expect(Item.default_options).to eq({key: 'value'})
+      end
+
+      it "instacne should respond to key and return 'value'" do
+        expect(@instance.key).to eq('value')
+      end
+    end
+
+    context 'with block' do
+      before do
+        @instance_with_block = subject.page(1, name: 'potion') {
+          def potion?
+            true
+          end
+        }
+        @instance_without_block = subject.page(2, name: 'pass')
+      end
+
+      it 'instance_with_block should respond to `potion?`' do
+        expect(@instance_with_block).to be_respond_to(:potion?)
+      end
+
+      it 'instance_with_block should *not* respond to `potion?`' do
+        expect(@instance_without_block).to_not be_respond_to(:potion?)
+      end
+    end
+  end
+
+  describe '#==(other)' do
+    context 'same class' do
+      before do
+        @instance = Item.page(1)
+        @other    = @instance.dup
+      end
+      it 'instance should equal to cpy' do
+        expect(@instance).to eq(@other)
+      end
+    end
+
+    context 'same id but other class' do
+      before do
+        class Other
+          include Ehon
+        end
+        @instance = Item.page(1)
+        @other    = Other.page(1)
+      end
+      it "instance should not equal to other" do
+        expect(@instance).to_not eq(@other)
+      end
+    end
+
+    context 'with case' do
+      before do
+        class Difficulty
+          include Ehon
+
+          EASY   = enum 1, name: 'Easy mode'
+          NORMAL = enum 2, name: 'Normal mode'
+          HARD   = enum 3, name: 'Hard mode'
+        end
+        @selected = Difficulty::HARD
+      end
+
+      it 'selected mode should be hard' do
+        should satisfy {
+          case @selected
+            when Difficulty::EASY   then false
+            when Difficulty::NORMAL then false
+            when Difficulty::HARD   then true
+            else;                        false
+          end
+        }
+      end
+    end
+  end
+
+  describe '.all' do
+    before do
+      subject.page 1
+      subject.page 2
+      subject.page 3
+    end
+
+    it 'should has 3 pages' do
+      expect(subject.all.size).to eq(3)
+    end
+
+    # FIXME: it depends an implementation
+    it 'all should return contents.values' do
+      expect(subject.all).to eq(subject.contents.values)
+    end
+  end
+
+  describe '.find(id_or_query)' do
+    before do
+      subject.page 1,   name: 'potion',      value: 5
+      subject.page 2,   name: 'high potion', value: 10
+      subject.page '3', name: 'scroll'
+    end
+
+    context 'with key' do
+      it 'find with id 1 should return potion' do
+        finded = subject.find(1)
+        expect(finded.name).to eq('potion')
+      end
+
+      it "find with id '3' should return scroll" do
+        finded = subject.find('3')
+        expect(finded.name).to eq('scroll')
+      end
+
+      it 'find with id 12 should return nil' do
+        finded = subject.find(12)
+        expect(finded).to be_nil
+      end
+    end
+
+    context 'with multiple id' do
+      it 'find with id 1 and 2 should return `potion` and `high potion`' do
+        finded = subject.find(1, 2)
+        expect(finded.map(&:name)).to eq(['potion', 'high potion'])
+      end
+
+      it 'find with id 1 and 9 should return `potion` only but array' do
+        finded = subject.find(1, 9)
+        expect(finded.map(&:name)).to eq(['potion'])
+      end
+
+      it 'find with id [1, 2] should return `potion` only but array' do
+        finded = subject.find([1, 2])
+        expect(finded.map(&:name)).to eq(['potion', 'high potion'])
+      end
+
+      it 'find with id [4, 8] should return empty array' do
+        finded = subject.find([4, 8])
+        expect(finded).to eq([])
+      end
+    end
+
+    context 'with query' do
+      it "find with `{name: 'high potion'}` should return item id 2" do
+        finded = subject.find(name: 'high potion')
+        expect(finded.id).to eq(2)
+      end
+
+      it "find with `{value: 5}` should return item id 1" do
+        finded = subject.find(value: 5)
+        expect(finded.id).to eq(1)
+      end
+
+      it "find with `{id: '3'}` should return item id '3'" do
+        finded = subject.find(id: '3')
+        expect(finded.id).to eq('3')
+      end
+
+      it "find with `{name: 'food'}` should return nil" do
+        finded = subject.find(name: 'food')
+        expect(finded).to be_nil
+      end
+
+      context 'AND search' do
+        it "find with `{name: 'potion', value: 5}` should return item id 1" do
+          finded = subject.find(name: 'potion', value: 5)
+          expect(finded.id).to eq(1)
+        end
+
+        it "find with `{name: 'potion', value: 10}` should return nil" do
+          finded = subject.find(name: 'potion', value: 10)
+          expect(finded).to be_nil
+        end
+      end
+
+      context 'OR search' do
+        it "find with `[{name: 'potion'}, {value: 10}]` should return item id `potion` and `high potion`" do
+          finded = subject.find([{name: 'potion'}, {value: 10}])
+          expect(finded.map(&:name)).to eq(['potion', 'high potion'])
+        end
+
+        it "find with `{name: 'potion', value: 20}` should return potion only but array" do
+          finded = subject.find([{name: 'potion'}, {value: 20}])
+          expect(finded.map(&:name)).to eq(['potion'])
+        end
+
+        it "find with `{name: 'fire potion', value: 20}` should return empty array" do
+          finded = subject.find([{name: 'fire potion'}, {value: 20}])
+          expect(finded).to eq([])
+        end
+      end
+    end
+
+    context 'with id and query' do
+        it "find with `[1, {value: 10}]` should return item id `potion` and `high potion`" do
+          finded = subject.find([1, {value: 10}])
+          expect(finded.map(&:name)).to eq(['potion', 'high potion'])
+        end
+    end
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'ehon'

metadata

@@ -0,0 +1,100 @@
+--- !ruby/object:Gem::Specification
+name: ehon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Tomohiro Nishimura
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-02-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !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: Ehon is a simple `enum` library.
+email:
+- tomohiro68@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ehon.gemspec
+- lib/ehon.rb
+- lib/ehon/version.rb
+- spec/ehon_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/hekk/ehon
+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: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.1
+signing_key: 
+specification_version: 4
+summary: Ehon is a simple `enum` library.
+test_files:
+- spec/ehon_spec.rb
+- spec/spec_helper.rb