Class: PfrpgSkills::Skill

Inherits:
Object
  • Object
show all
Defined in:
lib/pfrpg_skills/skill.rb

Defined Under Namespace

Classes: Acrobatics, Appraise, Bluff, Climb, Craft, Diplomacy, DisableDevice, Disguise, EscapeArtist, Fly, HandleAnimal, Heal, Intimidate, Knowledge, Linguistics, Perception, Perform, Profession, Ride, SenseMotive, SleightOfHand, Spellcraft, Stealth, Survival, Swim, UseMagicDevice

Class Method Summary collapse

Class Method Details

.camelize(term, uppercase_first_letter = true) ⇒ Object

By default, camelize converts strings to UpperCamelCase. If the argument to camelize is set to :lower then camelize produces lowerCamelCase.

camelize will also convert ‘/’ to ‘::’ which is useful for converting paths to namespaces.

'active_model'.camelize                # => "ActiveModel"
'active_model'.camelize(:lower)        # => "activeModel"
'active_model/errors'.camelize         # => "ActiveModel::Errors"
'active_model/errors'.camelize(:lower) # => "activeModel::Errors"

As a rule of thumb you can think of camelize as the inverse of underscore, though there are cases where that does not hold:

'SSLError'.underscore.camelize # => "SslError"



113
114
115
116
117
 
# File 'lib/pfrpg_skills/skill.rb', line 113

def self.camelize(term, uppercase_first_letter = true)
  string = term.to_s
  string = string.sub(/^[a-z\d]*/) { $&.capitalize }
  string.gsub(/(?:_|(\/))([a-z\d]*)/i) { "#{$1}#{$2.capitalize}" }.gsub('/', '::')
end

.class_from_name(name) ⇒ Object 



93
94
95
 
# File 'lib/pfrpg_skills/skill.rb', line 93

def self.class_from_name(name)
  "PfrpgSkills::Skill::#{self.camelize(name.gsub(/\s+/, ""))}"
end

.class_from_name_with_type(name) ⇒ Object 



89
90
91
 
# File 'lib/pfrpg_skills/skill.rb', line 89

def self.class_from_name_with_type(name)
  "PfrpgSkills::Skill::#{self.camelize(name.split(':')[0].gsub(/\s+/, ""))}"
end

.class_with_type(name) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/pfrpg_skills/skill.rb', line 59

def self.class_with_type(name)
  begin
    type = type_from_name(name)
    classname = class_from_name_with_type(name)
    skill = self.constantize(classname).new(type)

    return skill if skill.supported_types.include?(type)
  rescue NameError => e
  end
  return false
end

.constantize(term) ⇒ Object

:nodoc:



119
120
121
122
123
124
125
126
127
128
 
# File 'lib/pfrpg_skills/skill.rb', line 119

def self.constantize(term) #:nodoc:
  names = term.split('::')
  names.shift if names.empty? || names.first.empty?

  constant = Object
  names.each do |name|
    constant = constant.const_defined?(name, false) ? constant.const_get(name) : constant.const_missing(name)
  end
  constant
end

.contains_type?(name) ⇒ Boolean

Returns:

  • (Boolean) 


81
82
83
 
# File 'lib/pfrpg_skills/skill.rb', line 81

def self.contains_type?(name)
  name[':']
end

.fetch_by_name(name) ⇒ Object

TODO : raise a smarter error /w invalid type



54
55
56
57
 
# File 'lib/pfrpg_skills/skill.rb', line 54

def self.fetch_by_name(name)
  return class_with_type(name) if contains_type?(name)
  return typeless_class(name)
end

.skill_list ⇒ Object 



4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
 
# File 'lib/pfrpg_skills/skill.rb', line 4

def self.skill_list
  skills = [
    Skill::Acrobatics.new,
    Skill::Appraise.new,
    Skill::Bluff.new,
    Skill::Climb.new,
    Skill::Diplomacy.new,
    Skill::DisableDevice.new,
    Skill::Disguise.new,
    Skill::EscapeArtist.new,
    Skill::Fly.new,
    Skill::HandleAnimal.new,
    Skill::Heal.new,
    Skill::Intimidate.new,
    Skill::Knowledge.new('Arcana'),
    Skill::Knowledge.new('Dungeoneering'),
    Skill::Knowledge.new('Engineering'),
    Skill::Knowledge.new('Geography'),
    Skill::Knowledge.new('History'),
    Skill::Knowledge.new('Local'),
    Skill::Knowledge.new('Nature'),
    Skill::Knowledge.new('Nobility'),
    Skill::Knowledge.new('Planes'),
    Skill::Knowledge.new('Religion'),
    Skill::Linguistics.new,
    Skill::Perception.new,
    Skill::Ride.new,
    Skill::SenseMotive.new,
    Skill::SleightOfHand.new,
    Skill::Spellcraft.new,
    Skill::Stealth.new,
    Skill::Survival.new,
    Skill::Swim.new,
    Skill::UseMagicDevice.new
  ]
  [Skill::Craft,Skill::Profession, Skill::Perform].each do |skil|
    s = skil.new('NONE')
    s.supported_types.each do |stype|
      skills << skil.new(stype)
    end
  end
  return skills
end

.stringify_skill(name, attribute, ac_penalty) ⇒ Object 



48
49
50
51
 
# File 'lib/pfrpg_skills/skill.rb', line 48

def self.stringify_skill(name, attribute, ac_penalty)
  ac_penalty_str = ac_penalty ? "*" : ""
  return "#{name} (#{attribute})#{ac_penalty_str}"
end

.type_from_name(name) ⇒ Object 



85
86
87
 
# File 'lib/pfrpg_skills/skill.rb', line 85

def self.type_from_name(name)
  name.split(':')[1].strip.capitalize
end

.typeless_class(name) ⇒ Object 



71
72
73
74
75
76
77
78
79
 
# File 'lib/pfrpg_skills/skill.rb', line 71

def self.typeless_class(name)
  begin
    classname = class_from_name(name)
    skill = self.constantize(classname).new
    return skill
  rescue NameError => e
  end
  return false
end