Class: Ridgepole::DSLParser::Context

Inherits:
Object
  • Object
show all
Defined in:
lib/ridgepole/dsl_parser/context.rb

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(opts = {}) ⇒ Context

Returns a new instance of Context.



8
9
10
11
12
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 8

def initialize(opts = {})
  @__working_dir = File.expand_path(opts[:path] ? File.dirname(opts[:path]) : Dir.pwd)
  @__definition = {}
  @__execute = []
end

Instance Attribute Details

#__definition ⇒ Object (readonly)

Returns the value of attribute __definition.



6
7
8
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 6

def __definition
  @__definition
end

#__execute ⇒ Object (readonly)

Returns the value of attribute __execute.



6
7
8
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 6

def __execute
  @__execute
end

Class Method Details

.eval(dsl, opts = {}) ⇒ Object 



14
15
16
17
18
19
20
21
22
23
24
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 14

def self.eval(dsl, opts = {})
  ctx = new(opts)

  if opts[:path]
    ctx.instance_eval(dsl, opts[:path])
  else
    ctx.instance_eval(dsl)
  end

  [ctx.__definition, ctx.__execute]
end

Instance Method Details

#add_foreign_key(from_table, to_table, options = {}) ⇒ Object 



76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 76

def add_foreign_key(from_table, to_table, options = {})
  from_table = from_table.to_s
  to_table = to_table.to_s
  options[:name] = options[:name].to_s if options[:name]
  options[:primary_key] = options[:primary_key].to_s if options[:primary_key]
  options[:column] = options[:column].to_s if options[:column]
  @__definition[from_table] ||= {}
  @__definition[from_table][:foreign_keys] ||= {}
  idx = options[:name] || [from_table, to_table, options[:column]]

  raise "Foreign Key `#{from_table}(#{idx})` already defined" if @__definition[from_table][:foreign_keys][idx]

  @__definition[from_table][:foreign_keys][idx] = {
    to_table: to_table,
    options: options,
  }
end

#add_index(table_name, column_name, options = {}) ⇒ Object 



47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 47

def add_index(table_name, column_name, options = {})
  table_name = table_name.to_s
  # Keep column_name for expression index support
  # https://github.com/rails/rails/pull/23393
  column_name = [column_name].flatten.map(&:to_s) unless column_name.is_a?(String) && /\W/ === column_name # rubocop:disable Style/CaseEquality
  options[:name] = options[:name].to_s if options[:name]
  @__definition[table_name] ||= {}
  @__definition[table_name][:indices] ||= {}
  idx = options[:name] || column_name

  raise "Index `#{table_name}(#{idx})` already defined" if @__definition[table_name][:indices][idx]

  if options[:length].is_a?(Numeric)
    index_length = options[:length]
    options[:length] = {}

    column_name.each do |col|
      options[:length][col] = index_length
    end
  end

  options[:length] = options[:length].compact.symbolize_keys if options[:length]

  @__definition[table_name][:indices][idx] = {
    column_name: column_name,
    options: options,
  }
end

#add_partition(table_name, type, columns, partition_definitions: []) ⇒ Object 



94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 94

def add_partition(table_name, type, columns, partition_definitions: [])
  partition_definitions.each do |partition_definition|
    values = partition_definition.fetch(:values)
    raise ArgumentError unless values.is_a?(Hash)

    values[:in] = Array.wrap(values[:in]) if values.key?(:in)
    values[:to] = Array.wrap(values[:to]) if values.key?(:to)
    values[:from] = Array.wrap(values[:from]) if values.key?(:from)
  end
  @__definition[table_name][:partition] = {
    type: type,
    columns: Array.wrap(columns),
    partition_definitions: partition_definitions,
  }
end

#create_table(table_name, options = {}) {|table_definition| ... } ⇒ Object

Yields:

  • (table_definition) 


26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 26

def create_table(table_name, options = {})
  table_name = table_name.to_s
  table_definition = TableDefinition.new(table_name, self)

  options[:primary_key] = options[:primary_key].to_s if options[:primary_key].is_a?(Symbol)
  if options[:id] && TableDefinition::ALIAS_TYPES.key?(options[:id])
    type, type_default_opts = TableDefinition::ALIAS_TYPES[options[:id]]
    options[:id] = type
    options = type_default_opts.merge(options)
  end

  yield(table_definition)
  @__definition[table_name] ||= {}

  raise "Table `#{table_name}` already defined" if @__definition[table_name][:definition]

  @__definition[table_name][:definition] = table_definition.__definition
  options.delete(:force)
  @__definition[table_name][:options] = options
end

#execute(sql, _name = nil, &cond) ⇒ Object 



126
127
128
129
130
131
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 126

def execute(sql, _name = nil, &cond)
  @__execute << {
    sql: sql,
    condition: cond,
  }
end

#require(file) ⇒ Object 



110
111
112
113
114
115
116
117
118
119
120
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 110

def require(file)
  schemafile = %r{\A/}.match?(file) ? file : File.join(@__working_dir, file)

  if File.exist?(schemafile)
    instance_eval(File.read(schemafile), schemafile)
  elsif File.exist?(schemafile + '.rb')
    instance_eval(File.read(schemafile + '.rb'), schemafile + '.rb')
  else
    Kernel.require(file)
  end
end

#require_relative(relative_path) ⇒ Object 



122
123
124
 
# File 'lib/ridgepole/dsl_parser/context.rb', line 122

def require_relative(relative_path)
  require(File.expand_path(relative_path, File.dirname(caller[0])))
end