rubicure 0.0.1

data/lib/rubicure/series.rb

@@ -0,0 +1,105 @@
+module Rubicure
+  class Series < Hash
+    include Hashie::Extensions::MethodAccess
+
+    @@cache = {}
+    @@config = nil
+
+    # @param [Time,Date,String] arg Time, Date or date like String (ex. "2013-12-16")
+    def on_air?(arg)
+      date = to_date(arg)
+      if respond_to?(:started_date)
+        if respond_to?(:ended_date)
+          # ended title
+          return (started_date .. ended_date).cover?(date)
+        else
+          # on air title
+          return started_date <= date
+        end
+      end
+
+      false
+    end
+
+    # @return [Array<Rubicure::Girl>]
+    def girls
+      unless @girls
+        @girls = []
+        if has_key?(:girls)
+          fetch(:girls).each do |girl_name|
+            @girls << Rubicure::Girl.find(girl_name.to_sym)
+          end
+        end
+      end
+
+      @girls
+    end
+
+    # @return [Array<Symbol>]
+    def self.names
+      config.keys
+    end
+
+    # @return [Array<Symbol>]
+    def self.uniq_names
+      uniq_names = []
+      config.each do |name, series|
+        uniq_names << name unless uniq_names.any?{|uniq_name| config[uniq_name][:title] == series[:title] }
+      end
+      uniq_names
+    end
+
+    # @return [Hash] content of config/series.yml
+    def self.config
+      unless @@config
+        config_file = "#{File.dirname(__FILE__)}/../../config/series.yml"
+        @@config = YAML.load_file(config_file).deep_symbolize_keys
+      end
+      @@config
+    end
+
+    # @return [Hash] content of config/precure.yml
+    def self.reload_config!
+      @@cache = {}
+      @@config = nil
+      config
+    end
+
+    # @param [Symbol] series_name
+    def self.valid?(series_name)
+      names.include?(series_name)
+    end
+
+    # @param series_name [Symbol]
+    # @return [Rubicure::Series]
+    # @raise arg is not precure
+    def self.find(series_name)
+      raise "unknown series: #{series_name}" unless valid?(series_name)
+
+      unless @@cache[series_name]
+        series_config = config[series_name] || {}
+        series_config.reject! { |k, v| v.nil? }
+
+        @@cache[series_name] = Rubicure::Series[series_config]
+      end
+
+      @@cache[series_name]
+    end
+
+    private
+      # @param arg
+      # @return [Date] arg is String or Date
+      # @return [Time] arg is Time
+      # @return [nil] arg is other
+      def to_date(arg)
+        case arg
+          when Date, Time
+            arg
+          when String
+            Date.parse(arg)
+          else
+            nil
+        end
+      end
+  end
+end

data/lib/rubicure/version.rb

@@ -0,0 +1,3 @@
+module Rubicure
+  VERSION = "0.0.1"
+end

data/lib/rubicure.rb

@@ -0,0 +1,41 @@
+require "active_support/core_ext"
+require 'yaml'
+require 'hashie'
+require "rubicure/version"
+require "rubicure/series"
+require "rubicure/girl"
+require "rubicure/core"
+
+module Rubicure
+  def self.core
+    Rubicure::Core.instance
+  end
+end
+
+module Precure
+  def self.method_missing(name, *args)
+    Rubicure.core.send(name, *args)
+  end
+end
+
+module Cure
+  def self.method_missing(name, *args)
+    if Rubicure::Girl.valid?(name)
+      Rubicure::Girl.find(name)
+    else
+      super
+    end
+  end
+end
+
+module Shiny
+  def self.luminous
+    Rubicure::Girl.find(:luminous)
+  end
+end
+
+module Milky
+  def self.rose
+    Rubicure::Girl.find(:rose)
+  end
+end

data/rubicure.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rubicure/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rubicure"
+  spec.version       = Rubicure::VERSION
+  spec.authors       = ["sue445"]
+  spec.email         = ["sue445@sue445.net"]
+  spec.description   = %q{All about Japanese battle heroine "Pretty Cure (Precure)".}
+  spec.summary       = %q{All about Japanese battle heroine "Pretty Cure (Precure)".}
+  spec.homepage      = "https://github.com/sue445/rubicure"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = '>= 2.0.0'
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "activesupport", "~> 4.0.1"
+  spec.add_dependency "hashie", "~> 2.0.5"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec", "~> 3.0.0.beta1"
+  #spec.add_development_dependency "rspec-parameterized"
+  spec.add_development_dependency "delorean"
+  spec.add_development_dependency "yard"
+  spec.add_development_dependency "codeclimate-test-reporter"
+  spec.add_development_dependency "coveralls"
+end

data/spec/core_spec.rb

@@ -0,0 +1,47 @@
+describe Rubicure::Core do
+  let(:instance){ Rubicure::Core.instance }
+
+  describe "#now" do
+    subject{ instance.now }
+
+    context "when on air" do
+      before do
+        time_travel_to "2013-01-01"
+      end
+
+      it{ expect(subject.title).to eq "スマイルプリキュア！" }
+    end
+
+    context "when not on air" do
+      before do
+        time_travel_to "2013-02-01"
+      end
+
+      it{ expect{ subject.title }.to raise_error }
+    end
+  end
+
+  it "output all precure methods", category: :verbose do
+    Rubicure::Series.names.each do |series_name|
+      puts "[#{series_name}] ===================="
+      series = Rubicure::Series.find(series_name)
+      puts <<EOS
+title:     #{series.title}
+broadcast: #{series.started_date} - #{series.ended_date}
+girls:     #{series.girls.count}
+EOS
+
+      series.girls.each do |girl|
+        puts <<EOS
+------------------------
+  human_name:   #{girl.human_name}
+  precure_name: #{girl.precure_name}
+  extra_names:  #{girl.extra_names}
+  state_names:  #{girl.state_names}
+  transform_message:
+#{girl.transform_message}
+EOS
+      end
+    end
+  end
+end

data/spec/girl_spec.rb

@@ -0,0 +1,83 @@
+describe Rubicure::Girl do
+  describe "#name" do
+    let(:girl){
+      Rubicure::Girl.new(
+          human_name:        human_name,
+          precure_name:      precure_name,
+          extra_names:       extra_names,
+          transform_message: transform_message
+      )
+    }
+
+    let(:human_name)     { "黄瀬やよい" }
+    let(:precure_name)   { "キュアピース" }
+    let(:extra_names)    { %w(プリンセスピース ウルトラピース) }
+    let(:transform_message){
+      <<EOF
+プリキュアスマイルチャージ！
+GO! GO! Let's GO ピース！
+ピカピカピカリンジャンケンポン！ キュアピース！
+EOF
+    }
+
+    context "when before transform" do
+      it{ expect(girl.name).to eq human_name }
+    end
+
+    context "when after 1st transform" do
+      before do
+        girl.transform!
+      end
+
+      it{ expect(girl.name).to eq precure_name }
+    end
+
+    context "when after 2nd transform" do
+      before do
+        girl.transform!
+        girl.transform!
+      end
+
+      it{ expect(girl.name).to eq extra_names[0] }
+    end
+
+    context "when after 3nd transform" do
+      before do
+        girl.transform!
+        girl.transform!
+        girl.transform!
+      end
+
+      it{ expect(girl.name).to eq extra_names[1] }
+    end
+
+    context "when after final transform" do
+      before do
+        girl.transform!
+        girl.transform!
+        girl.transform!
+        girl.transform!
+      end
+
+      # return to human
+      it{ expect(girl.name).to eq human_name }
+    end
+  end
+
+  describe "#find" do
+    subject{ Rubicure::Girl.find(girl_name) }
+
+    let(:girl_name){ :peace }
+
+    it{ should be_an_instance_of Rubicure::Girl }
+    it{ expect(subject.precure_name).to eq "キュアピース" }
+  end
+
+  describe "#uniq_names" do
+    subject{ Rubicure::Girl.uniq_names }
+
+    let(:all_stars_count){ Rubicure.core.all_stars.count }
+
+    it{ expect(subject.count).to eq all_stars_count }
+  end
+end

data/spec/rubicure_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe Rubicure do
+  it 'should have a version number' do
+    expect(Rubicure::VERSION).not_to be_nil
+  end
+
+  describe "Precure." do
+    context "When Precure.#<title>" do
+      where(:title) do
+        [
+            [:unmarked],
+            [:futari_wa_pretty_cure],
+
+            [:max_heart],
+            [:futari_wa_pretty_cure_max_heart],
+
+            [:splash_star],
+            [:futari_wa_pretty_cure_splash_star],
+
+            [:yes],
+            [:yes_precure_five],
+            [:yes_precure5],
+
+            [:yes_gogo],
+            [:yes_precure_five_gogo],
+            [:yes_precure5_gogo],
+
+            [:flesh],
+            [:flesh_precure],
+
+            [:heart_catch],
+            [:heart_catch_precure],
+
+            [:suite],
+            [:suite_precure],
+
+            [:smile],
+            [:smile_precure],
+
+            [:dokidoki],
+            [:dokidoki_precure],
+
+        #[:happiness_charge],
+        #[:happiness_charge_precure],
+        ]
+      end
+
+      with_them do
+        it{ expect{ Precure.send(title) }.not_to raise_error }
+        it{ expect{ Precure.send(title).girls }.not_to raise_error }
+      end
+    end
+
+    context "When Precure#<unmarked_precure_method>" do
+      let(:futari_wa_pretty_cure){ Rubicure::Series.find(:unmarked) }
+
+      it{ expect(Precure.title).to       eq futari_wa_pretty_cure.title }
+      it{ expect(Precure.girls.count).to eq futari_wa_pretty_cure.girls.count }
+    end
+  end
+
+  describe "Cure." do
+    where(:name) do
+      [
+          [:black],
+          [:white],
+
+          [:bloom],
+          [:egret],
+
+          [:dream],
+          [:rouge],
+          [:lemonade],
+          [:mint],
+          [:aqua],
+
+          [:peach],
+          [:berry],
+          [:pine],
+          [:passion],
+
+          [:melody],
+          [:rhythm],
+          [:beat],
+          [:muse],
+
+          [:happy],
+          [:sunny],
+          [:peace],
+          [:march],
+          [:beauty],
+
+          [:heart],
+          [:diamond],
+          [:rosetta],
+          [:sword],
+          [:ace],
+      ]
+    end
+
+    with_them do
+      it{ expect( Cure.send(name) ).to be_an_instance_of Rubicure::Girl }
+      it{ expect( Cure.send(name).precure_name ).to be_start_with "キュア" }
+    end
+
+    context "When precure who not starting 'cure'" do
+      it{ expect( Shiny.luminous.precure_name ).to eq "シャイニールミナス"}
+      it{ expect( Milky.rose.precure_name ).to eq "ミルキィローズ"}
+    end
+  end
+
+  describe "#all_stars" do
+    subject{ Precure.all_stars }
+
+    before do
+      @precure_count = 0
+      config_file = "#{File.dirname(__FILE__)}/../config/girls.yml"
+      Pathname(config_file).each_line do |line|
+        @precure_count += 1 if line =~ /[a-z_]+:\s*&[a-z_]+/
+      end
+    end
+
+    it{ expect(subject.count).to eq @precure_count }
+  end
+end

data/spec/series_spec.rb

@@ -0,0 +1,101 @@
+describe Rubicure::Series do
+  describe "#on_air?" do
+    subject{ series.on_air?(date) }
+
+    context "when ended title" do
+      let(:series) {
+        Rubicure::Series[
+            started_date: Date.parse("2012-02-05"),
+            ended_date:   Date.parse("2013-01-27"),
+        ]
+      }
+
+      context "when Date arg" do
+        let(:date){ Date.parse("2013-01-01") }
+
+        it{ should be true }
+      end
+
+      context "when date like String arg" do
+        let(:date){ "2013-01-01" }
+
+        it{ should be true }
+      end
+    end
+
+    context "when live title" do
+      let(:series) {
+        Rubicure::Series[
+            started_date: Date.parse("2013-02-03"),
+        ]
+      }
+
+      let(:date){ Date.parse("2013-12-01") }
+
+      it{ should be true }
+    end
+  end
+
+  describe "#girls" do
+    subject{ series.girls }
+
+    let(:series) {
+      Rubicure::Series[
+        girls: %w(cure_happy cure_sunny cure_peace cure_march cure_beauty)
+      ]
+    }
+
+    it'has 5 girls' do
+      expect(subject.size).to eq(5)
+    end
+
+    it{ should array_instance_of Rubicure::Girl }
+  end
+
+  let(:series_names) {
+    [
+        :unmarked,
+        :max_heart,
+        :splash_star,
+        :yes,
+        :yes_gogo,
+        :flesh,
+        :heart_catch,
+        :suite,
+        :smile,
+        :dokidoki,
+        #:happiness_charge,
+    ]
+  }
+
+  describe "#names" do
+    subject{ Rubicure::Series.names }
+
+    it{ should include *series_names }
+  end
+
+  describe "#uniq_names" do
+    subject{ Rubicure::Series.uniq_names }
+
+    it{ should include *series_names }
+    it{ expect(subject.count).to eq series_names.count }
+  end
+
+  describe "#find" do
+    subject(:series){ Rubicure::Series.find(series_name) }
+
+    context "when exists" do
+      let(:series_name){ :smile }
+
+      it{ expect(series.title).to eq "スマイルプリキュア！" }
+      it{ expect(series.girls.count).to eq 5 }
+    end
+
+    context "when not exists" do
+      let(:series_name){ :ashita_no_nadja  }
+
+      it{ expect{subject}.to raise_error }
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,23 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
+require 'coveralls'
+Coveralls.wear!
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'rubicure'
+require 'rspec'
+require 'rspec-parameterized'
+require 'delorean'
+
+# Requires supporting ruby files with custom matchers and macros, etc,
+# in spec/support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.include Delorean
+
+  config.after(:each) do
+    back_to_the_present
+  end
+end

data/spec/support/array_instance_of.rb

@@ -0,0 +1,12 @@
+require "rspec"
+
+=begin
+example)
+[1, 2, 3].should array_instance_of Fixnum
+=end
+
+RSpec::Matchers.define :array_instance_of do |element_class|
+  match do |array|
+    array.class == Array && array.all? {|element| element.class == element_class}
+  end
+end