hexsha
stringlengths 40
40
| size
int64 2
1.01M
| content
stringlengths 2
1.01M
| avg_line_length
float64 1.5
100
| max_line_length
int64 2
1k
| alphanum_fraction
float64 0.25
1
|
|---|---|---|---|---|---|
28b0387f7e3f17461df4fd4a8ecf7dc306add3db | 2,559 | require 'rspec'
require 'pry'
require 'word_definer'
require 'definition'
describe '#Word' do
before(:each) do
Word.clear
Definition.clear
end
describe('#save') do
it("saves a word") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word2 = Word.new({:name => "House", :id => nil})
word2.save
expect(Word.all).to(eq([word, word2]))
end
end
describe('.all') do
it("returns an empty array when there are no words") do
expect(Word.all).to(eq([]))
end
end
describe('.clear') do
it("clears all words") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word2 = Word.new({:name => "House", :id => nil})
word2.save
Word.clear
expect(Word.all).to(eq([]))
end
end
describe('#==') do
it("is the same word if it has the same attributes as another word") do
word = Word.new({:name => "Tree", :id => nil})
word2 = Word.new({:name => "Tree", :id => nil})
expect(word).to(eq(word2))
end
end
describe('.find') do
it("finds an word by id") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word2 = Word.new({:name => "House", :id => nil})
word2.save
expect(Word.find(word.id)).to(eq(word))
end
end
describe('#update') do
it("updates a word by id") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word.update("House")
expect(word.name).to(eq("House"))
end
end
describe('#delete') do
it("deletes a word by id") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word2 = Word.new({:name => "House", :id => nil})
word2.save
word.delete
expect(Word.all).to(eq([word2]))
end
end
describe('.search') do
it("allows user to search for a word") do
word = Word.new({:name => "Tree", :id => nil})
word.save
word2 = Word.new({:name => "House", :id => nil})
word2.save
expect(Word.search(word.name)).to(eq([word]))
end
end
describe('#definitions') do
it("returns a word's definitions") do
word = Word.new({:name => "Tree", :id => nil})
word.save
definition = Definition.new({:definition => "a large plant with leaves", :word_id => word.id, :id => nil})
definition.save
definition2 = Definition.new({:definition => "a four-legged canine", :word_id => word.id, :id => nil})
definition2.save
expect(word.definitions).to(eq([definition, definition2]))
end
end
end | 25.848485 | 112 | 0.558812 |
0399b6cc557e08238c57c25e82d374c8690f0ce4 | 338 | elasticsearch_user 'elasticsearch'
elasticsearch_install 'elasticsearch' do
type 'package'
end
elasticsearch_configure 'elasticsearch' do
allocated_memory '512m'
configuration ({
'cluster.name' => node['elasticsearch']['cluster']['name']
})
end
elasticsearch_service 'elasticsearch' do
service_actions [:enable, :start]
end
| 24.142857 | 62 | 0.766272 |
f72e8fdb138010eb35eceb3294dd79c409c95d75 | 21,002 | # frozen_string_literal: true
require 'carrierwave/orm/activerecord'
class Issue < ApplicationRecord
include AtomicInternalId
include IidRoutes
include Issuable
include Noteable
include Referable
include Spammable
include FasterCacheKeys
include RelativePositioning
include TimeTrackable
include ThrottledTouch
include LabelEventable
include IgnorableColumns
include MilestoneEventable
include WhereComposite
include StateEventable
include IdInOrdered
include Presentable
include IssueAvailableFeatures
include Todoable
include FromUnion
include EachBatch
extend ::Gitlab::Utils::Override
DueDateStruct = Struct.new(:title, :name).freeze
NoDueDate = DueDateStruct.new('No Due Date', '0').freeze
AnyDueDate = DueDateStruct.new('Any Due Date', '').freeze
Overdue = DueDateStruct.new('Overdue', 'overdue').freeze
DueThisWeek = DueDateStruct.new('Due This Week', 'week').freeze
DueThisMonth = DueDateStruct.new('Due This Month', 'month').freeze
DueNextMonthAndPreviousTwoWeeks = DueDateStruct.new('Due Next Month And Previous Two Weeks', 'next_month_and_previous_two_weeks').freeze
SORTING_PREFERENCE_FIELD = :issues_sort
# Types of issues that should be displayed on lists across the app
# for example, project issues list, group issues list and issue boards.
# Some issue types, like test cases, should be hidden by default.
TYPES_FOR_LIST = %w(issue incident).freeze
belongs_to :project
has_one :namespace, through: :project
belongs_to :duplicated_to, class_name: 'Issue'
belongs_to :closed_by, class_name: 'User'
belongs_to :iteration, foreign_key: 'sprint_id'
belongs_to :moved_to, class_name: 'Issue'
has_one :moved_from, class_name: 'Issue', foreign_key: :moved_to_id
has_internal_id :iid, scope: :project, track_if: -> { !importing? }
has_many :events, as: :target, dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
has_many :merge_requests_closing_issues,
class_name: 'MergeRequestsClosingIssues',
dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
has_many :issue_assignees
has_many :issue_email_participants
has_many :assignees, class_name: "User", through: :issue_assignees
has_many :zoom_meetings
has_many :user_mentions, class_name: "IssueUserMention", dependent: :delete_all # rubocop:disable Cop/ActiveRecordDependent
has_many :sent_notifications, as: :noteable
has_many :designs, class_name: 'DesignManagement::Design', inverse_of: :issue
has_many :design_versions, class_name: 'DesignManagement::Version', inverse_of: :issue do
def most_recent
ordered.first
end
end
has_one :issuable_severity
has_one :sentry_issue
has_one :alert_management_alert, class_name: 'AlertManagement::Alert'
has_and_belongs_to_many :self_managed_prometheus_alert_events, join_table: :issues_self_managed_prometheus_alert_events # rubocop: disable Rails/HasAndBelongsToMany
has_and_belongs_to_many :prometheus_alert_events, join_table: :issues_prometheus_alert_events # rubocop: disable Rails/HasAndBelongsToMany
has_many :prometheus_alerts, through: :prometheus_alert_events
accepts_nested_attributes_for :issuable_severity, update_only: true
accepts_nested_attributes_for :sentry_issue
validates :project, presence: true
validates :issue_type, presence: true
enum issue_type: {
issue: 0,
incident: 1,
test_case: 2, ## EE-only
requirement: 3 ## EE-only
}
alias_method :issuing_parent, :project
alias_attribute :external_author, :service_desk_reply_to
scope :in_projects, ->(project_ids) { where(project_id: project_ids) }
scope :not_in_projects, ->(project_ids) { where.not(project_id: project_ids) }
scope :with_due_date, -> { where.not(due_date: nil) }
scope :without_due_date, -> { where(due_date: nil) }
scope :due_before, ->(date) { where('issues.due_date < ?', date) }
scope :due_between, ->(from_date, to_date) { where('issues.due_date >= ?', from_date).where('issues.due_date <= ?', to_date) }
scope :due_tomorrow, -> { where(due_date: Date.tomorrow) }
scope :not_authored_by, ->(user) { where.not(author_id: user) }
scope :order_due_date_asc, -> { reorder(::Gitlab::Database.nulls_last_order('due_date', 'ASC')) }
scope :order_due_date_desc, -> { reorder(::Gitlab::Database.nulls_last_order('due_date', 'DESC')) }
scope :order_closest_future_date, -> { reorder(Arel.sql('CASE WHEN issues.due_date >= CURRENT_DATE THEN 0 ELSE 1 END ASC, ABS(CURRENT_DATE - issues.due_date) ASC')) }
scope :order_relative_position_asc, -> { reorder(::Gitlab::Database.nulls_last_order('relative_position', 'ASC')) }
scope :order_relative_position_desc, -> { reorder(::Gitlab::Database.nulls_first_order('relative_position', 'DESC')) }
scope :order_closed_date_desc, -> { reorder(closed_at: :desc) }
scope :order_created_at_desc, -> { reorder(created_at: :desc) }
scope :order_severity_asc, -> { includes(:issuable_severity).order('issuable_severities.severity ASC NULLS FIRST') }
scope :order_severity_desc, -> { includes(:issuable_severity).order('issuable_severities.severity DESC NULLS LAST') }
scope :preload_associated_models, -> { preload(:assignees, :labels, project: :namespace) }
scope :with_web_entity_associations, -> { preload(:author, project: [:project_feature, :route, namespace: :route]) }
scope :preload_awardable, -> { preload(:award_emoji) }
scope :with_label_attributes, ->(label_attributes) { joins(:labels).where(labels: label_attributes) }
scope :with_alert_management_alerts, -> { joins(:alert_management_alert) }
scope :with_prometheus_alert_events, -> { joins(:issues_prometheus_alert_events) }
scope :with_self_managed_prometheus_alert_events, -> { joins(:issues_self_managed_prometheus_alert_events) }
scope :with_api_entity_associations, -> {
preload(:timelogs, :closed_by, :assignees, :author, :labels,
milestone: { project: [:route, { namespace: :route }] },
project: [:route, { namespace: :route }])
}
scope :with_issue_type, ->(types) { where(issue_type: types) }
scope :public_only, -> { where(confidential: false) }
scope :confidential_only, -> { where(confidential: true) }
scope :counts_by_state, -> { reorder(nil).group(:state_id).count }
scope :service_desk, -> { where(author: ::User.support_bot) }
scope :inc_relations_for_view, -> { includes(author: :status, assignees: :status) }
# An issue can be uniquely identified by project_id and iid
# Takes one or more sets of composite IDs, expressed as hash-like records of
# `{project_id: x, iid: y}`.
#
# @see WhereComposite::where_composite
#
# e.g:
#
# .by_project_id_and_iid({project_id: 1, iid: 2})
# .by_project_id_and_iid([]) # returns ActiveRecord::NullRelation
# .by_project_id_and_iid([
# {project_id: 1, iid: 1},
# {project_id: 2, iid: 1},
# {project_id: 1, iid: 2}
# ])
#
scope :by_project_id_and_iid, ->(composites) do
where_composite(%i[project_id iid], composites)
end
after_commit :expire_etag_cache, unless: :importing?
after_save :ensure_metrics, unless: :importing?
after_create_commit :record_create_action, unless: :importing?
attr_spammable :title, spam_title: true
attr_spammable :description, spam_description: true
state_machine :state_id, initial: :opened, initialize: false do
event :close do
transition [:opened] => :closed
end
event :reopen do
transition closed: :opened
end
state :opened, value: Issue.available_states[:opened]
state :closed, value: Issue.available_states[:closed]
before_transition any => :closed do |issue, transition|
args = transition.args
issue.closed_at = issue.system_note_timestamp
next if args.empty?
next unless args.first.is_a?(User)
issue.closed_by = args.first
end
before_transition closed: :opened do |issue|
issue.closed_at = nil
issue.closed_by = nil
end
end
class << self
extend ::Gitlab::Utils::Override
# Alias to state machine .with_state_id method
# This needs to be defined after the state machine block to avoid errors
alias_method :with_state, :with_state_id
alias_method :with_states, :with_state_ids
override :order_upvotes_desc
def order_upvotes_desc
reorder(upvotes_count: :desc)
end
override :order_upvotes_asc
def order_upvotes_asc
reorder(upvotes_count: :asc)
end
end
def self.relative_positioning_query_base(issue)
projects = issue.project.group&.root_ancestor&.all_projects || issue.project
in_projects(projects)
end
def self.relative_positioning_parent_column
:project_id
end
def self.reference_prefix
'#'
end
# Pattern used to extract `#123` issue references from text
#
# This pattern supports cross-project references.
def self.reference_pattern
@reference_pattern ||= %r{
(#{Project.reference_pattern})?
#{Regexp.escape(reference_prefix)}#{Gitlab::Regex.issue}
}x
end
def self.link_reference_pattern
@link_reference_pattern ||= super("issues", Gitlab::Regex.issue)
end
def self.reference_valid?(reference)
reference.to_i > 0 && reference.to_i <= Gitlab::Database::MAX_INT_VALUE
end
def self.project_foreign_key
'project_id'
end
def self.simple_sorts
super.merge(
{
'closest_future_date' => -> { order_closest_future_date },
'closest_future_date_asc' => -> { order_closest_future_date },
'due_date' => -> { order_due_date_asc.with_order_id_desc },
'due_date_asc' => -> { order_due_date_asc.with_order_id_desc },
'due_date_desc' => -> { order_due_date_desc.with_order_id_desc },
'relative_position' => -> { order_relative_position_asc.with_order_id_desc },
'relative_position_asc' => -> { order_relative_position_asc.with_order_id_desc }
}
)
end
def self.sort_by_attribute(method, excluded_labels: [])
case method.to_s
when 'closest_future_date', 'closest_future_date_asc' then order_closest_future_date
when 'due_date', 'due_date_asc' then order_due_date_asc.with_order_id_desc
when 'due_date_desc' then order_due_date_desc.with_order_id_desc
when 'relative_position', 'relative_position_asc' then order_relative_position_asc.with_order_id_desc
when 'severity_asc' then order_severity_asc.with_order_id_desc
when 'severity_desc' then order_severity_desc.with_order_id_desc
else
super
end
end
# `with_cte` argument allows sorting when using CTE queries and prevents
# errors in postgres when using CTE search optimisation
def self.order_by_position_and_priority(with_cte: false)
order = Gitlab::Pagination::Keyset::Order.build([column_order_relative_position, column_order_highest_priority, column_order_id_desc])
order_labels_priority(with_cte: with_cte)
.reorder(order)
end
def self.column_order_relative_position
Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
attribute_name: 'relative_position',
column_expression: arel_table[:relative_position],
order_expression: Gitlab::Database.nulls_last_order('issues.relative_position', 'ASC'),
reversed_order_expression: Gitlab::Database.nulls_last_order('issues.relative_position', 'DESC'),
order_direction: :asc,
nullable: :nulls_last,
distinct: false
)
end
def self.column_order_highest_priority
Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
attribute_name: 'highest_priority',
column_expression: Arel.sql('highest_priorities.label_priority'),
order_expression: Gitlab::Database.nulls_last_order('highest_priorities.label_priority', 'ASC'),
reversed_order_expression: Gitlab::Database.nulls_last_order('highest_priorities.label_priority', 'DESC'),
order_direction: :asc,
nullable: :nulls_last,
distinct: false
)
end
def self.column_order_id_desc
Gitlab::Pagination::Keyset::ColumnOrderDefinition.new(
attribute_name: 'id',
order_expression: arel_table[:id].desc
)
end
def self.to_branch_name(*args)
branch_name = args.map(&:to_s).each_with_index.map do |arg, i|
arg.parameterize(preserve_case: i == 0).presence
end.compact.join('-')
if branch_name.length > 100
truncated_string = branch_name[0, 100]
# Delete everything dangling after the last hyphen so as not to risk
# existence of unintended words in the branch name due to mid-word split.
branch_name = truncated_string.sub(/-[^-]*\Z/, '')
end
branch_name
end
# Temporary disable moving null elements because of performance problems
# For more information check https://gitlab.com/gitlab-com/gl-infra/production/-/issues/4321
def check_repositioning_allowed!
if blocked_for_repositioning?
raise ::Gitlab::RelativePositioning::IssuePositioningDisabled, "Issue relative position changes temporarily disabled."
end
end
def blocked_for_repositioning?
resource_parent.root_namespace&.issue_repositioning_disabled?
end
def hook_attrs
Gitlab::HookData::IssueBuilder.new(self).build
end
# `from` argument can be a Namespace or Project.
def to_reference(from = nil, full: false)
reference = "#{self.class.reference_prefix}#{iid}"
"#{project.to_reference_base(from, full: full)}#{reference}"
end
def suggested_branch_name
return to_branch_name unless project.repository.branch_exists?(to_branch_name)
start_counting_from = 2
Uniquify.new(start_counting_from).string(-> (counter) { "#{to_branch_name}-#{counter}" }) do |suggested_branch_name|
project.repository.branch_exists?(suggested_branch_name)
end
end
# Returns boolean if a related branch exists for the current issue
# ignores merge requests branchs
def has_related_branch?
project.repository.branch_names.any? do |branch|
/\A#{iid}-(?!\d+-stable)/i =~ branch
end
end
# To allow polymorphism with MergeRequest.
def source_project
project
end
def moved?
!moved_to_id.nil?
end
def duplicated?
!duplicated_to_id.nil?
end
def can_move?(user, to_project = nil)
if to_project
return false unless user.can?(:admin_issue, to_project)
end
!moved? && persisted? &&
user.can?(:admin_issue, self.project)
end
alias_method :can_clone?, :can_move?
def to_branch_name
if self.confidential?
"#{iid}-confidential-issue"
else
self.class.to_branch_name(iid, title)
end
end
def related_issues(current_user, preload: nil)
related_issues = ::Issue
.select(['issues.*', 'issue_links.id AS issue_link_id',
'issue_links.link_type as issue_link_type_value',
'issue_links.target_id as issue_link_source_id',
'issue_links.created_at as issue_link_created_at',
'issue_links.updated_at as issue_link_updated_at'])
.joins("INNER JOIN issue_links ON
(issue_links.source_id = issues.id AND issue_links.target_id = #{id})
OR
(issue_links.target_id = issues.id AND issue_links.source_id = #{id})")
.preload(preload)
.reorder('issue_link_id')
related_issues = yield related_issues if block_given?
cross_project_filter = -> (issues) { issues.where(project: project) }
Ability.issues_readable_by_user(related_issues,
current_user,
filters: { read_cross_project: cross_project_filter })
end
def can_be_worked_on?
!self.closed? && !self.project.forked?
end
# Returns `true` if the current issue can be viewed by either a logged in User
# or an anonymous user.
def visible_to_user?(user = nil)
return false unless project && project.feature_available?(:issues, user)
return publicly_visible? unless user
return false unless readable_by?(user)
user.can_read_all_resources? ||
::Gitlab::ExternalAuthorization.access_allowed?(
user, project.external_authorization_classification_label)
end
def check_for_spam?(user:)
# content created via support bots is always checked for spam, EVEN if
# the issue is not publicly visible and/or confidential
return true if user.support_bot? && spammable_attribute_changed?
# Only check for spam on issues which are publicly visible (and thus indexed in search engines)
return false unless publicly_visible?
# Only check for spam if certain attributes have changed
spammable_attribute_changed?
end
def as_json(options = {})
super(options).tap do |json|
if options.key?(:labels)
json[:labels] = labels.as_json(
project: project,
only: [:id, :title, :description, :color, :priority],
methods: [:text_color]
)
end
end
end
def etag_caching_enabled?
true
end
def discussions_rendered_on_frontend?
true
end
# rubocop: disable CodeReuse/ServiceClass
def update_project_counter_caches
Projects::OpenIssuesCountService.new(project).refresh_cache
end
# rubocop: enable CodeReuse/ServiceClass
def merge_requests_count(user = nil)
::MergeRequestsClosingIssues.count_for_issue(self.id, user)
end
def labels_hook_attrs
labels.map(&:hook_attrs)
end
def previous_updated_at
previous_changes['updated_at']&.first || updated_at
end
def banzai_render_context(field)
super.merge(label_url_method: :project_issues_url)
end
def design_collection
@design_collection ||= ::DesignManagement::DesignCollection.new(self)
end
def from_service_desk?
author.id == User.support_bot.id
end
def issue_link_type
return unless respond_to?(:issue_link_type_value) && respond_to?(:issue_link_source_id)
type = IssueLink.link_types.key(issue_link_type_value) || IssueLink::TYPE_RELATES_TO
return type if issue_link_source_id == id
IssueLink.inverse_link_type(type)
end
def relocation_target
moved_to || duplicated_to
end
def supports_assignee?
issue_type_supports?(:assignee)
end
def supports_time_tracking?
issue_type_supports?(:time_tracking)
end
def email_participants_emails
issue_email_participants.pluck(:email)
end
def email_participants_emails_downcase
issue_email_participants.pluck(IssueEmailParticipant.arel_table[:email].lower)
end
def issue_assignee_user_ids
issue_assignees.pluck(:user_id)
end
def update_upvotes_count
self.lock!
self.update_column(:upvotes_count, self.upvotes)
end
private
def spammable_attribute_changed?
title_changed? ||
description_changed? ||
# NOTE: We need to check them for spam when issues are made non-confidential, because spam
# may have been added while they were confidential and thus not being checked for spam.
confidential_changed?(from: true, to: false)
end
# Ensure that the metrics association is safely created and respecting the unique constraint on issue_id
override :ensure_metrics
def ensure_metrics
if !association(:metrics).loaded? || metrics.blank?
metrics_record = Issue::Metrics.safe_find_or_create_by(issue: self)
self.metrics = metrics_record
end
metrics.record!
end
def record_create_action
Gitlab::UsageDataCounters::IssueActivityUniqueCounter.track_issue_created_action(author: author)
end
# Returns `true` if the given User can read the current Issue.
#
# This method duplicates the same check of issue_policy.rb
# for performance reasons, check commit: 002ad215818450d2cbbc5fa065850a953dc7ada8
# Make sure to sync this method with issue_policy.rb
def readable_by?(user)
if user.can_read_all_resources?
true
elsif project.owner == user
true
elsif confidential? && !assignee_or_author?(user)
project.team.member?(user, Gitlab::Access::REPORTER)
else
project.public? ||
project.internal? && !user.external? ||
project.team.member?(user)
end
end
# Returns `true` if this Issue is visible to everybody.
def publicly_visible?
project.public? && !confidential? && !::Gitlab::ExternalAuthorization.enabled?
end
def expire_etag_cache
key = Gitlab::Routing.url_helpers.realtime_changes_project_issue_path(project, self)
Gitlab::EtagCaching::Store.new.touch(key)
end
def could_not_move(exception)
# Symptom of running out of space - schedule rebalancing
IssueRebalancingWorker.perform_async(nil, *project.self_or_root_group_ids)
end
end
Issue.prepend_mod_with('Issue')
| 34.599671 | 168 | 0.71617 |
1dbacece23d28c53f6c2c030ad95e859500cba7f | 1,122 | class Climgur::CLI
attr_accessor :climgur
def initialize
@climgur = nil
end
def start
@climgur = Climgur::ImgurGet.new.scrape_main_page
puts "welcome to CLIMGUR, the command line imgur browser."
commands
end
def commands
puts "\ncommands:\n 'start' loads previews of the most popular images right now \n enter the number of a image to see it in full size \n 'exit' exits the program\n"
input = get_input
if input == 'start'
climgur.display_top_images
commands
elsif input == 'exit'
goodbye
elsif input == 'billions'
billions
else
climgur.display_large_image(input)
commands
end
end
def get_input
input = 0
while input != 'start' && input !='exit' && !input.to_i.between?(1, climgur.images.count) && input != 'billions'
puts "\nenter command: "
input = gets.strip
end
input
end
def billions
puts climgur.large_image("//6336-presscdn-26-82.pagely.netdna-cdn.com/wp-content/uploads/2013/11/carl-sagan.jpg")
commands
end
def goodbye
puts "goodbye!"
end
end
| 22.897959 | 168 | 0.64795 |
6ae2f2b0a0ea7d6c3395c341ea3ce2b524fefc97 | 291 | # frozen_string_literal: true
require_relative "production.rb"
Rails.application.configure do
# Overwrite any production settings here, or if you want to start from
# scratch then remove line 1.
# Use AWS for active storage for staging
config.active_storage.service = :amazon
end
| 24.25 | 72 | 0.776632 |
bb894abb590a71f4c559ac9837f3f28f42a9655e | 1,750 | #
# Cookbook Name:: mongodb
# Recipe:: configserver
#
# Copyright 2011, edelight GmbH
# Authors:
# Markus Korn <[email protected]>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
#Removed to stop the mongod service from being created.
#include_recipe "mongodb"
package node[:mongodb][:package_name] do
action :install
version node[:mongodb][:package_version]
end
chef_gem 'bson_ext'
chef_gem 'mongo'do
version '1.10.2'
end
if not node['mongodb']['dbpath'].empty?
directory node['mongodb']['dbpath'] do
owner 'mongodb'
group 'mongodb'
recursive true
mode '0755'
action :create
end
execute "set ownership" do
command "chown -Rf mongodb:mongodb #{node['mongodb']['dbpath']}"
end
end
# we are not starting the configserver service with the --configsvr
# commandline option because right now this only changes the port it's
# running on, and we are overwriting this port anyway.
mongodb_instance "configserver" do
mongodb_type "configserver"
port node['mongodb']['port']
logpath node['mongodb']['logpath']
dbpath node['mongodb']['dbpath']
enable_rest node['mongodb']['enable_rest']
smallfiles node['mongodb']['smallfiles']
auth node['mongodb']['auth']
end
| 29.166667 | 74 | 0.716571 |
1c4aa048d8efc2ac8022a2a1ef440cffa42902a9 | 590 | require_relative 'cocoapods/mixbox_spec'
Mixbox::FrameworkSpec.new do |s|
s.name = 'MixboxIpcSbtuiClient'
s.platforms = [:ios]
s.dependency 'MixboxIpc'
s.dependency 'MixboxSBTUITestTunnelClient'
# for network mocks, kind of a kludge, but SBTUITestTunnel should be removed soon:
s.dependency 'MixboxTestsFoundation'
s.dependency 'MixboxUiTestsFoundation'
s.framework = "XCTest"
s.user_target_xcconfig = {
'FRAMEWORK_SEARCH_PATHS' => '$(PLATFORM_DIR)/Developer/Library/Frameworks'
}
s.xcconfig = {
'ENABLE_TESTING_SEARCH_PATHS' => 'YES'
}
end | 25.652174 | 85 | 0.723729 |
ace28426d68774f95be4b5d9fc2ddca37681f97a | 1,118 | require File.join(%W[#{File.dirname(__FILE__)} lib yard-appendix version])
Gem::Specification.new do |s|
s.name = 'yard-appendix'
s.summary = "A YARD plugin that adds support for Appendix sections."
s.description = <<-eof
yard-appendix is a plugin for YARD, the Ruby documentation generation tool,
that defines a special directive @!appendix for writing appendixes for your
code documentation, similar to appendixes you find in books.
Appendix entries can be referenced to by methods and classes in your docs
using the @see tag and inline-references, just like any other object.
eof
s.version = YARD::AppendixPlugin::VERSION
s.date = Time.now.strftime('%Y-%m-%d')
s.authors = ["Ahmad Amireh"]
s.email = '[email protected]'
s.homepage = 'https://github.com/amireh/yard-appendix'
s.files = Dir.glob("{lib,spec,templates}/**/*.{rb,erb}") +
['LICENSE', 'README.md', '.rspec', __FILE__]
s.has_rdoc = 'yard'
s.license = 'MIT'
s.add_dependency('yard', '>= 0.8.0')
s.add_development_dependency 'rspec'
end
| 43 | 79 | 0.663685 |
7ab1687f8ba3f486ee2f4b369f0615e4028b8b70 | 295 | # frozen_string_literal: true
class MockDeploymentService < DeploymentService
def title
'Mock deployment'
end
def description
'Mock deployment service'
end
def self.to_param
'mock_deployment'
end
# No terminals support
def terminals(environment)
[]
end
end
| 14.047619 | 47 | 0.715254 |
f89235d8f9a80058e64a0b16f21d3c6f06086cbd | 4,883 | require 'spec_helper'
describe SS::SortEmulator, dbscope: :example do
let!(:site) { cms_site }
let(:now) { Time.zone.now.change(usec: 0) }
shared_examples "sort enumerator (released) is" do
it do
array1 = ruby.to_a
array2 = mongo.to_a
expect(array1.length).to eq array2.length
array1.each_with_index do |item1, index|
item2 = array2[index]
expect(item1.id).to eq item2.id
end
end
end
context "with released" do
let!(:node) { create :cms_node_page, cur_site: site }
let!(:page1) do
created = now - rand(3.months..6.months)
first_released = created + rand(7.days..14.days)
updated = first_released + rand(7.days..14.days)
page = nil
Timecop.freeze(created) do
page = create(:cms_page, cur_site: site, cur_node: node, released_type: released_type, state: "closed")
end
Timecop.freeze(first_released) do
page.state = "public"
page.released = first_released
page.save!
end
Timecop.freeze(updated) do
page.description = Array.new(2) { unique_id }.join("\n")
page.save!
end
page
end
let!(:page2) do
created = now - rand(3.months..6.months)
first_released = created + rand(7.days..14.days)
updated = first_released + rand(7.days..14.days)
page = nil
Timecop.freeze(created) do
page = create(:cms_page, cur_site: site, cur_node: node, released_type: released_type, state: "closed")
end
Timecop.freeze(first_released) do
page.state = "public"
page.released = first_released
page.save!
end
Timecop.freeze(updated) do
page.description = Array.new(2) { unique_id }.join("\n")
page.save!
end
page
end
let!(:page3) do
created = page2.created
first_released = page2.first_released
updated = page2.updated
page = nil
Timecop.freeze(created) do
page = create(:cms_page, cur_site: site, cur_node: node, released_type: released_type, state: "closed")
end
Timecop.freeze(first_released) do
page.state = "public"
page.released = first_released
page.save!
end
Timecop.freeze(updated) do
page.description = Array.new(2) { unique_id }.join("\n")
page.save!
end
page
end
let!(:page4) { create :cms_page, cur_site: site, cur_node: node, released_type: released_type }
let(:criteria) { Cms::Page.all }
before do
page4.unset(:released, :first_released, :created, :updated)
end
context "when released_type is 'fixed'" do
let(:released_type) { "fixed" }
context "with asc" do
let(:ruby) { described_class.new(criteria, { "released" => 1 }) }
let(:mongo) { criteria.reorder(released: 1) }
it_behaves_like "sort enumerator (released) is"
end
context "with desc" do
let(:ruby) { described_class.new(criteria, { "released" => -1 }) }
let(:mongo) { criteria.reorder(released: -1) }
it_behaves_like "sort enumerator (released) is"
end
end
context "when released_type is 'same_as_updated'" do
let(:released_type) { "same_as_updated" }
context "with asc" do
let(:ruby) { described_class.new(criteria, { "released" => 1 }) }
let(:mongo) { criteria.reorder(updated: 1) }
it_behaves_like "sort enumerator (released) is"
end
context "with desc" do
let(:ruby) { described_class.new(criteria, { "released" => -1 }) }
let(:mongo) { criteria.reorder(updated: -1) }
it_behaves_like "sort enumerator (released) is"
end
end
context "when released_type is 'same_as_created'" do
let(:released_type) { "same_as_created" }
context "with asc" do
let(:ruby) { described_class.new(criteria, { "released" => 1 }) }
let(:mongo) { criteria.reorder(created: 1) }
it_behaves_like "sort enumerator (released) is"
end
context "with desc" do
let(:ruby) { described_class.new(criteria, { "released" => -1 }) }
let(:mongo) { criteria.reorder(created: -1) }
it_behaves_like "sort enumerator (released) is"
end
end
context "when released_type is 'same_as_first_released'" do
let(:released_type) { "same_as_first_released" }
context "with asc" do
let(:ruby) { described_class.new(criteria, { "released" => 1 }) }
let(:mongo) { criteria.reorder(first_released: 1) }
it_behaves_like "sort enumerator (released) is"
end
context "with desc" do
let(:ruby) { described_class.new(criteria, { "released" => -1 }) }
let(:mongo) { criteria.reorder(first_released: -1) }
it_behaves_like "sort enumerator (released) is"
end
end
end
end
| 30.329193 | 111 | 0.611305 |
b93ecb746e699699431ebe515cadd4e0b08e09f7 | 3,709 | require 'net/imap'
require "getoptlong"
$stdout.sync = true
$port = nil
$user = ENV["USER"] || ENV["LOGNAME"]
$auth = "login"
$ssl = false
$starttls = false
def usage
<<EOF
usage: #{$0} [options] <host>
--help print this message
--port=PORT specifies port
--user=USER specifies user
--auth=AUTH specifies auth type
--starttls use starttls
--ssl use ssl
EOF
end
begin
require 'io/console'
rescue LoadError
def _noecho(&block)
system("stty", "-echo")
begin
yield STDIN
ensure
system("stty", "echo")
end
end
else
def _noecho(&block)
STDIN.noecho(&block)
end
end
def get_password
print "password: "
begin
return _noecho(&:gets).chomp
ensure
puts
end
end
def get_command
printf("%s@%s> ", $user, $host)
if line = gets
return line.strip.split(/\s+/)
else
return nil
end
end
parser = GetoptLong.new
parser.set_options(['--debug', GetoptLong::NO_ARGUMENT],
['--help', GetoptLong::NO_ARGUMENT],
['--port', GetoptLong::REQUIRED_ARGUMENT],
['--user', GetoptLong::REQUIRED_ARGUMENT],
['--auth', GetoptLong::REQUIRED_ARGUMENT],
['--starttls', GetoptLong::NO_ARGUMENT],
['--ssl', GetoptLong::NO_ARGUMENT])
begin
parser.each_option do |name, arg|
case name
when "--port"
$port = arg
when "--user"
$user = arg
when "--auth"
$auth = arg
when "--ssl"
$ssl = true
when "--starttls"
$starttls = true
when "--debug"
Net::IMAP.debug = true
when "--help"
usage
exit
end
end
rescue
abort usage
end
$host = ARGV.shift
unless $host
abort usage
end
imap = Net::IMAP.new($host, :port => $port, :ssl => $ssl)
begin
imap.starttls if $starttls
class << password = method(:get_password)
alias to_str call
end
imap.authenticate($auth, $user, password)
while true
cmd, *args = get_command
break unless cmd
begin
case cmd
when "list"
for mbox in imap.list("", args[0] || "*")
if mbox.attr.include?(Net::IMAP::NOSELECT)
prefix = "!"
elsif mbox.attr.include?(Net::IMAP::MARKED)
prefix = "*"
else
prefix = " "
end
print prefix, mbox.name, "\n"
end
when "select"
imap.select(args[0] || "inbox")
print "ok\n"
when "close"
imap.close
print "ok\n"
when "summary"
unless messages = imap.responses["EXISTS"][-1]
puts "not selected"
next
end
if messages > 0
for data in imap.fetch(1..-1, ["ENVELOPE"])
print data.seqno, ": ", data.attr["ENVELOPE"].subject, "\n"
end
else
puts "no message"
end
when "fetch"
if args[0]
data = imap.fetch(args[0].to_i, ["RFC822.HEADER", "RFC822.TEXT"])[0]
puts data.attr["RFC822.HEADER"]
puts data.attr["RFC822.TEXT"]
else
puts "missing argument"
end
when "logout", "exit", "quit"
break
when "help", "?"
print <<EOF
list [pattern] list mailboxes
select [mailbox] select mailbox
close close mailbox
summary display summary
fetch [msgno] display message
logout logout
help, ? display help message
EOF
else
print "unknown command: ", cmd, "\n"
end
rescue Net::IMAP::Error
puts $!
end
end
ensure
imap.logout
imap.disconnect
end
| 22.077381 | 78 | 0.535724 |
793541eb17664c4ace365ef5a007835351f799e3 | 2,389 | RSpec.describe Api::V1::GeographicalAreasController, 'GET #countries' do
render_views
let!(:geographical_area1) do
create :geographical_area,
:with_description,
:country
end
let!(:geographical_area2) do
create :geographical_area,
:with_description,
:country
end
let!(:geographical_area3) do
create :geographical_area,
:with_description,
geographical_code: '2'
end
let(:pattern) do
[
{ id: String, description: String },
{ id: String, description: String },
{ id: String, description: String },
]
end
it 'returns rendered records' do
get :countries, format: :json
expect(response.body).to match_json_expression pattern
end
it 'includes geographical areas with code 2' do
get :countries, format: :json
expect(response.body.to_s).to include(
geographical_area3.geographical_area_id,
)
end
describe 'machine timed' do
let!(:geographical_area1) do
create :geographical_area,
:with_description,
:country,
validity_start_date: '2014-12-31 00:00:00',
validity_end_date: '2015-12-31 00:00:00'
end
let!(:geographical_area2) do
create :geographical_area,
:with_description,
:country,
validity_start_date: '2014-12-01 00:00:00',
validity_end_date: '2015-12-01 00:00:00'
end
let!(:geographical_area3) do
create :geographical_area,
:with_description,
geographical_code: '2',
validity_start_date: '2014-12-31 00:00:00',
validity_end_date: '2015-12-31 00:00:00'
end
let(:pattern) do
[
{ id: String, description: String },
{ id: String, description: String },
]
end
before do
get :countries,
params: { as_of: '2015-12-04' },
format: :json
end
it 'finds one area' do
expect(response.body).to match_json_expression pattern
end
it 'includes area 1' do
expect(response.body.to_s).to include(
"\"id\":\"#{geographical_area1.geographical_area_id}\"",
)
end
it "doesn't include area 2" do
expect(response.body.to_s).not_to include(
"\"id\":\"#{geographical_area2.geographical_area_id}\"",
)
end
end
end
| 25.147368 | 72 | 0.603181 |
010613b2be03ca749e807309f7073b2b84addfc9 | 734 | module Questionnaires::Validations
extend ActiveSupport::Concern
included do
validates :name, :organization, :email_subject, :email_text, :email_link,
presence: true
validates :name, uniqueness: true, allow_nil: true, allow_blank: true
validates :name, :email_subject, :email_text, :email_link,
:email_clarification, pdf_encoding: true
validates :name, :email_subject, :email_link, length: { maximum: 255 },
allow_nil: true, allow_blank: true
before_destroy :check_for_answered_polls, prepend: true
end
private
def check_for_answered_polls
if polls.answered(true).any?
errors.add(:base, :cannot_destroy_with_answered_poll)
throw :abort
end
end
end
| 29.36 | 77 | 0.716621 |
b9c4988194047ea8261c0a3f28958669b85000ae | 2,000 | class UsersController < ApplicationController
before_action :error_if_not_logged_in, only: [:update, :friend, :messages]
def create
user = User.new(user_params)
user.save
session[:user_id] = user.id
render json: user, status: 200
end
def update
user = User.find(params[:id].to_i)
user.update(user_params)
render json: user, status: 200
end
def show
user = User.find(params[:id])
render json: user, status: 200
end
def recipes
pagy, recipes = pagy_resp(params)
render json: recipes,
meta: pagy,
status: 200
end
def favorites
pagy, favorites = pagy_resp(params)
render json: favorites,
root: :favorites,
meta: pagy,
status: 200
end
def friends
pagy, friends = pagy_resp(params)
render json: friends,
root: :friends,
meta: pagy,
status: 200
end
def messages
message_scope = MessagesService.new(params, current_user)
pagy, messages = pagy(message_scope.filter, {items:10,
assets:params[:action],
scope: params[:scope]})
render json: messages,
include: "**",
meta: pagy,
status: 200
end
def search
meta, users = pagy(User.from_identifier(params[:query]), {
items: 2,
query:params[:query]
})
render json: users,
meta: meta,
status: 200
end
private
def user_params
params.permit(:username, :email, :password, :avatar)
end
def pagy_resp(params)
user = User.find(params[:user_id])
assets, items = if params[:preview]
[user.send(params[:action]).preview, {}]
else
[user.send(params[:action]), {items:5}]
end
pagy(assets, items)
end
end
| 22.222222 | 76 | 0.535 |
1a3895068adfceaa5e73f04e46ba3158c87fbeab | 1,366 | # frozen_string_literal: true
require 'application_system_test_case'
class Bookmark::PageTest < ApplicationSystemTestCase
setup do
@page = pages(:page1)
end
test 'show page bookmark on lists' do
visit_with_auth '/current_user/bookmarks', 'kimura'
assert_text @page.title
end
test 'show active button when bookmarked page' do
visit_with_auth "/pages/#{@page.id}", 'kimura'
assert_selector '#bookmark-button.is-active'
assert_no_selector '#bookmark-button.is-inactive'
end
test 'show inactive button when not bookmarked page' do
visit_with_auth "/pages/#{@page.id}", 'komagata'
assert_selector '#bookmark-button.is-inactive'
assert_no_selector '#bookmark-button.is-active'
end
test 'bookmark page' do
visit_with_auth "/pages/#{@page.id}", 'komagata'
find('#bookmark-button').click
assert_selector '#bookmark-button.is-active'
assert_no_selector '#bookmark-button.is-inactive'
visit '/current_user/bookmarks'
assert_text @page.title
end
test 'unbookmark page' do
visit_with_auth "/pages/#{@page.id}", 'kimura'
assert_selector '#bookmark-button.is-active'
find('#bookmark-button').click
assert_selector '#bookmark-button.is-inactive'
assert_no_selector '#bookmark-button.is-active'
visit '/current_user/bookmarks'
assert_no_text @page.title
end
end
| 28.458333 | 57 | 0.72328 |
79387a1d144ebef2c2b0c93d540fefb99c9801cd | 1,366 | require 'net/ssh'
module Sitefull
module Cloud
class Provider
include Mock
PROVIDERS = %w(amazon azure google)
attr_reader :type, :options
def initialize(type, options = {})
@type = type || 'base'
extend(provider_module)
@options = respond_to?(:process) ? process(options) : options
end
class << self
def all_required_options
PROVIDERS.map { |type| required_options_for(type) }.flatten
end
def required_options_for(type)
provider_class(type).const_get(:REQUIRED_OPTIONS)
end
def provider_class(type)
require "sitefull-cloud/provider/#{type}"
Kernel.const_get "Sitefull::Provider::#{type.capitalize}"
end
end
def auth
@auth ||= Sitefull::Cloud::Auth.new(type, options)
end
protected
def credentials
@credentials ||= auth.credentials
end
def key_data
@key_data ||= generate_key_data
end
private
def provider_module
return self.class.provider_class(:mock) if mocked?
@provider_module ||= self.class.provider_class(type)
end
def generate_key_data
key = OpenSSL::PKey::RSA.new 2048
{ public_key: [ key.to_blob ].pack('m0'), private_key: key.to_s }
end
end
end
end
| 22.766667 | 73 | 0.601757 |
f72273f142aef968fb398ab3aa64611f7ea2cc0a | 66 | FactoryGirl.define do
factory :category_item do
end
end
| 9.428571 | 27 | 0.712121 |
d5a12f75c6a346551b2b5e2b160ca5cc017a0e55 | 141 | # frozen_string_literal: true
$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
require "show_and_tell"
require "minitest/autorun"
| 23.5 | 58 | 0.77305 |
1cbb87ac60fbb2f4a4098f1c85caeb6b37eb5a88 | 1,181 | # Copyright 2018 Noragh Analytics, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
# express or implied.
#
# See the License for the specific language governing permissions and
# limitations under the License.
#
require 'test/unit'
require 'mocha/test_unit'
# DO NOT MODIFY THIS FILE
require_relative '../lib/armagh/custom_actions'
class TestCustomActions < Test::Unit::TestCase
def setup
end
def teardown
end
def test_name
assert_not_empty(Armagh::CustomActions::NAME, 'No NAME defined for CustomActions')
end
def test_version
assert_not_empty(Armagh::CustomActions::VERSION, 'No VERSION defined for CustomActions')
end
def test_defined_actions
assert_not_empty(Armagh::Actions.defined_actions, 'No available custom actions or dividers were discovered')
end
end | 27.465116 | 112 | 0.762066 |
622d9011e90e8b9f7c7151e9f720125ba62b383a | 215 | # frozen_string_literal: true
# NB: Keep this file here as it is executed by the "book-secure-move-metrics" container in each pod
require File.expand_path('../../config/environment', __dir__) unless defined? Rails
| 43 | 99 | 0.767442 |
1cd105aa9b0bc3057a21ea761939aa01c59f9762 | 707 | RSpec.describe Tatami::Models::HttpRequest do
describe '#to_s' do
let(:sut) { Tatami::Models::HttpRequest.new(
name: 'name',
base_uri: 'base_uri',
method: 'method',
user_agent: 'user_agent',
uri: 'uri',
headers: 'headers',
cookies: 'cookies',
path_infos: 'path_infos',
query_strings: 'query_strings',
fragment: 'fragment',
content: 'content'
) }
subject { sut.to_s }
it { is_expected.to eq 'name=name, base_uri=base_uri, method=method, user_agent=user_agent, uri=uri, headers=headers, cookies=cookies, path_infos=path_infos, query_strings=query_strings, fragment=fragment, content=content' }
end
end | 37.210526 | 228 | 0.640736 |
ab23e9500fb92691eb4fe4e8272f67ade60c4ef8 | 1,260 | ###############################################################################
# tc_isdst.rb
#
# Test case for the Time#isdst instance method, and the Time#dst? alias.
###############################################################################
require 'test/unit'
require 'test/helper'
class TC_Time_Isdst_InstanceMethod < Test::Unit::TestCase
include Test::Helper
def setup
@time = Time.local(2000, 1, 1)
end
def test_isdst_basic
assert_respond_to(@time, :isdst)
assert_nothing_raised{ @time.isdst }
assert_kind_of(Boolean, @time.isdst)
end
def test_dst_basic
assert_respond_to(@time, :dst?)
assert_nothing_raised{ @time.dst? }
assert_kind_of(Boolean, @time.dst?)
end
def test_isdst
#assert_equal(true, Time.local(2000, 7, 1).isdst)
#assert_equal(false, Time.local(2000, 1, 1).isdst)
end
def test_dst?
#assert_equal(true, Time.local(2000, 7, 1).dst?)
#assert_equal(false, Time.local(2000, 1, 1).dst?)
end
def test_isdst_expected_errors
assert_raise(ArgumentError){ @time.isdst(1) }
assert_raise(ArgumentError){ @time.dst?(1) }
assert_raise(NoMethodError){ @time.isdst = 1 }
end
def teardown
@time = nil
end
end
| 26.25 | 79 | 0.580952 |
6285586716c0bf2a8c1bad8c20012fcc9ea618d1 | 4,114 | # frozen_string_literal: true
require 'spec_helper'
require 'bolt/pal/yaml_plan'
require 'bolt/util'
require 'bolt_spec/files'
describe Bolt::Util do
include BoltSpec::Files
context "when creating a typed name from a modulepath" do
it "removes init from the typed name" do
expect(Bolt::Util.module_name('mymod/plans/init.pp')).to eq('mymod')
expect(Bolt::Util.module_name('mymod/tasks/init.html.erb')).to eq('mymod')
end
it "supports extended paths" do
expect(Bolt::Util.module_name('mymod/plans/subdir/plan.pp')).to eq('mymod::subdir::plan')
end
it "splits on the first plans or tasks directory" do
expect(Bolt::Util.module_name('mymod/plans/plans/myplan.pp')).to eq('mymod::plans::myplan')
expect(Bolt::Util.module_name('mymod/tasks/plans/mytask.rb')).to eq('mymod::plans::mytask')
end
context "#to_code" do
it "turns DoubleQuotedString types into code strings" do
string = Bolt::PAL::YamlPlan::DoubleQuotedString.new('doublebubble')
expect(Bolt::Util.to_code(string)).to eq("\"doublebubble\"")
end
context "turns BareString types into code strings" do
it 'with a preceding variable' do
string = Bolt::PAL::YamlPlan::BareString.new('$variable')
expect(Bolt::Util.to_code(string)).to eq('$variable')
end
it 'with no variable' do
string = Bolt::PAL::YamlPlan::BareString.new('nonvariable')
expect(Bolt::Util.to_code(string)).to eq("'nonvariable'")
end
end
it "turns CodeLiteral types into code strings" do
string = Bolt::PAL::YamlPlan::CodeLiteral.new('[$codelit].join()')
expect(Bolt::Util.to_code(string)).to eq('[$codelit].join()')
end
it "turns EvaluableString types into code strings" do
string = Bolt::PAL::YamlPlan::EvaluableString.new('ev@l$tr1ng')
expect(Bolt::Util.to_code(string)).to eq('ev@l$tr1ng')
end
it "turns Hashes into code strings" do
hash = { 'hash' => Bolt::PAL::YamlPlan::BareString.new('$brown') }
expect(Bolt::Util.to_code(hash)).to eq("{'hash' => $brown}")
end
it "turns Arrays into code string" do
array = ['a', 'r', 'r', Bolt::PAL::YamlPlan::BareString.new('$a'), 'y']
expect(Bolt::Util.to_code(array)).to eq("['a', 'r', 'r', $a, 'y']")
end
end
end
context "when parsing a yaml file with read_yaml_hash" do
it "raises an error with line and column number if the YAML has a syntax error" do
contents = <<-YAML
---
version: 2
config:
transport: winrm
ssl-verify: false
ssl: true
YAML
with_tempfile_containing('config_file_test', contents) do |file|
expect {
Bolt::Util.read_yaml_hash(file, 'inventory')
}.to raise_error(Bolt::FileError, /Error at line 2 column 14/)
end
end
it "returns an empty hash when the yaml file is empty" do
with_tempfile_containing('empty', '') do |file|
expect(Bolt::Util.read_yaml_hash(file, 'config')).to eq({})
end
end
it "errors when file does not exist and is required" do
expect {
Bolt::Util.read_yaml_hash('does-not-exist', 'config')
}.to raise_error(Bolt::FileError)
end
it "errors when a non-hash object is read from a yaml file" do
contents = <<-YAML
---
foo
YAML
with_tempfile_containing('config_file_test', contents) do |file|
expect {
Bolt::Util.read_yaml_hash(file, 'inventory')
}.to raise_error(Bolt::FileError, /should be a Hash or empty, not String/)
end
end
end
context "when parsing a yaml file with read_optional_yaml_hash" do
it "returns an empty hash when the yaml file does not exist" do
expect(Bolt::Util.read_optional_yaml_hash('does-not-exist', 'config')).to eq({})
end
end
describe '#deep_clone' do
it 'works with frozen hashes' do
hash = { key: 'value', boolean: true }
hash.freeze
expect(Bolt::Util.deep_clone(hash)).to eq(hash)
end
end
end
| 33.721311 | 97 | 0.631988 |
abe308dac5ef06584c5e14fd2d7fade93481c294 | 228 | class CreateInspectionFindings < ActiveRecord::Migration
def change
create_table :inspection_findings do |t|
t.integer :inspection_id
t.text :finding
t.string :label
t.timestamps
end
end
end
| 19 | 56 | 0.692982 |
e2642443fb12a6c37bd6561927e2cfadc7dabfd1 | 2,937 | require "jwt"
class ApplicationController < ActionController::Base
skip_before_action :verify_authenticity_token
before_action :snake_case_params
# Handle OPTIONS preflight checks
# Credit to jpbalarini https://gist.github.com/jpbalarini/54a1aa22ebb261af9d8bfd9a24e811f0
before_action :cors_set_access_control_headers
def cors_preflight_check
return unless request.method == "OPTIONS"
cors_set_access_control_headers
render json: {}
end
def auth_header
request.headers["Authorization"]
end
# check that the token is a real JWT
def validate_token_integrity(token)
/^[\w-]+\.[\w-]+\.[\w-]+$/.match?(token)
end
def decoded_token
if !auth_header
raise "Invalid Authorization Token"
end
auth = auth_header.split(" ")
# Header must be prefixed with "Bearer"
if auth[0] != "Bearer"
raise "Invalid Authorization Token"
end
token = auth[1]
if !validate_token_integrity(token)
logger.error "Invalid token: #{token}"
return {valid: "false"}
end
secret = Rails.application.credentials.twitch[:extension_secret]
algorithm = Rails.application.credentials.jwt_algorithm
node_path = Rails.application.credentials.node_path
begin
token_json = `#{node_path} app/javascript/verify_jwt.js #{token} #{secret}`
rescue
logger.error "Invalid token: #{token}"
return { valid: false }
end
verify = JSON.parse(token_json)
if !verify["valid"]
logger.error "Invalid token: #{token}"
end
return verify
end
def jwt_auth
begin
token = decoded_token
rescue
logger.error "Failed to decode token: #{token}"
return false
end
if !token["valid"]
return false
end
return token["result"]
end
def sign(payload)
secret = Rails.application.credentials.twitch[:extension_secret]
algorithm = Rails.application.credentials.jwt_algorithm
JWT.encode payload, secret, algorithm
end
protected
def cors_set_access_control_headers
response.headers["Access-Control-Allow-Origin"] = "*"
response.headers["Access-Control-Allow-Methods"] = "POST, GET, PUT, PATCH, DELETE, OPTIONS"
response.headers["Access-Control-Allow-Headers"] = "Origin, Content-Type, Accept, Authorization, Token, " \
"Auth-Token, Email, X-User-Token, X-User-Email, x-xsrf-token"
response.headers["Access-Control-Max-Age"] = "1728000"
response.headers["Access-Control-Allow-Credentials"] = true
end
def restrict_to_development
head(:bad_request) unless Rails.env.development?
end
private
# snake_case the query params and all other params
# This is probably more hacky than it needs to be
# TODO: investigate ActionController::Parameters class and see if we can override
def snake_case_params
params.deep_transform_keys!(&:underscore)
request.parameters.deep_transform_keys!(&:underscore)
end
end
| 25.763158 | 111 | 0.705482 |
bbebbfffe0e28128b4a7e579133765060388b52f | 1,300 | # frozen_string_literal: true
class PostReplacement < ApplicationRecord
belongs_to :post
belongs_to :creator, class_name: "User"
before_validation :initialize_fields, on: :create
before_create :process!
attr_accessor :replacement_file, :final_source, :tags
attribute :replacement_url, default: ""
def initialize_fields
self.original_url = post.source
self.old_file_ext = post.file_ext
self.old_file_size = post.file_size
self.old_image_width = post.image_width
self.old_image_height = post.image_height
self.old_md5 = post.md5
end
concerning :Search do
class_methods do
def search(params = {})
q = search_attributes(params, :id, :created_at, :updated_at, :md5, :old_md5, :file_ext, :old_file_ext, :original_url, :replacement_url, :creator, :post)
q.apply_default_order(params)
end
end
end
def process!
PostReplacementProcessor.new(post: post, replacement: self).process!
end
def suggested_tags_for_removal
tags = post.tag_array.select do |tag|
Danbooru.config.post_replacement_tag_removals.any? do |pattern|
tag.match?(/\A#{pattern}\z/i)
end
end
tags = tags.map { |tag| "-#{tag}" }
tags.join(" ")
end
def self.available_includes
[:creator, :post]
end
end
| 26 | 160 | 0.702308 |
181c46ef64e856d89d6b60b5df01ad0d7083ff75 | 152 | # Command to reload module/alias/etc. configs
# Use like "%admin/reload"
require 'java'
ctx.pctx.reload_configs
puts 'Configs successfully reloaded'
| 16.888889 | 45 | 0.769737 |
79796e67baec502da3037df5e0d0293d8c0eab91 | 3,167 | describe Bindl::Entry do
include FakeFS::SpecHelpers
before(:each) { @store = Bindl::Store.new('/test/').create! }
describe '.initialize' do
it 'should demand that the store exist' do
expect do
Bindl::Entry.new(Bindl::Store.new('/dne/'), 'entry.ext')
end.to raise_error Bindl::Store::StoreDoesNotExistError
end
it 'should demand a path that produces a valid name' do
FileUtils.touch 'invalid.'
expect do
Bindl::Entry.new @store, 'invalid.'
end.to raise_error Bindl::Name::NameError
end
it 'should require that the file exists' do
expect do
Bindl::Entry.new @store, 'dne.ext'
end.to raise_error Bindl::Entry::EntryDoesNotExistError
FileUtils.touch 'exists.ext'
expect do
Bindl::Entry.new @store, 'exists.ext'
end.to_not raise_error
end
end
describe '.create!' do
it 'should raise if the store does not exist' do
expect do
Bindl::Entry.create! Bindl::Store.new('/dne/'), 'entry'
end.to raise_error Bindl::Store::StoreDoesNotExistError
end
it 'should raise if the file exists' do
path = '/test/entry.yml'
FileUtils.touch path
expect do
Bindl::Entry.create! @store, 'entry'
end.to raise_error Bindl::Entry::EntryExistsError
end
it 'should raise if the entry would have an invalid name' do
path = '/test/entry.invalid.'
FileUtils.touch path
expect do
Bindl::Entry.create! @store, path
end.to raise_error Bindl::Name::NameError
end
it 'should create the file' do
name = 'entry'
expect do
Bindl::Entry.create! @store, name
end.to_not raise_error
expect(File.file?('/test/entry.yml')).to be true
end
it 'should encrypt if asked, but fail without a key' do
@store.meta.set(Bindl::ID_KEYPATH, 'nonsense')
# It should raise, since encrypted files need a key to exist.
expect do
Bindl::Entry.create! @store, 'enctest', encrypt: true
end.to raise_error Bindl::Encrypt::GPGError
end
end
describe '#delete!' do
it 'should delete the file' do
path = '/entry.ext'
FileUtils.touch path
entry = Bindl::Entry.new @store, path
expect(File.file?(path)).to be true
entry.delete!
expect(File.file?(path)).to be false
end
it 'should set path to nil' do
path = '/entry.ext'
FileUtils.touch path
entry = Bindl::Entry.new @store, path
expect(File.file?(path)).to be true
entry.delete!
expect(entry.path).to be nil
end
end
describe 'data' do
it 'should return the contents of the file' do
path = '/entry.ext'
data = 'this is a test string!'
File.write(path, data)
entry = Bindl::Entry.new @store, path
expect(entry.data).to eq data
end
end
describe 'data=' do
it 'should overwrite the file with the new data' do
path = '/entry.ext'
data = 'this is new data'
File.write(path, 'old data')
entry = Bindl::Entry.new @store, path
entry.data = data
expect(File.read(path)).to eq data.to_yaml
end
end
end
| 31.989899 | 67 | 0.629302 |
1ca3a037a7d5ba2c9ac8449030830e1b22269077 | 7,212 | class IvlNotices::IvlToCoverallTransitionNoticeBuilder < IvlNotice
include ApplicationHelper
def initialize(consumer_role, args = {})
@family = Family.find(args[:options][:family])
find_transition_people(args[:options][:result][:people])
args[:recipient] = @family.primary_applicant.person
args[:notice] = PdfTemplates::ConditionalEligibilityNotice.new
args[:market_kind] = 'individual'
args[:recipient_document_store]= @family.primary_applicant.person
args[:to] = @family.primary_applicant.person.work_email_or_best
self.header = "notices/shared/header_ivl.html.erb"
super(args)
end
def attach_required_documents
generate_custom_notice('notices/ivl/documents_section')
attach_blank_page(custom_notice_path)
join_pdfs [notice_path, custom_notice_path]
clear_tmp(custom_notice_path)
end
def deliver
append_hbe
build
generate_pdf_notice
attach_blank_page(notice_path)
attach_docs
attach_appeals
attach_non_discrimination
attach_taglines
upload_and_send_secure_message
if recipient.consumer_role.can_receive_electronic_communication?
send_generic_notice_alert
end
if recipient.consumer_role.can_receive_paper_communication?
store_paper_notice
end
clear_tmp(notice_path)
end
def attach_docs
attach_required_documents
end
def notice_filename
"#{subject.titleize.gsub("Dc", "DC").gsub(/[^0-9a-z]/i,'')}"
end
def build
notice.notification_type = self.event_name
notice.mpi_indicator = self.mpi_indicator
notice.primary_identifier = recipient.hbx_id
check_for_transitioned_individuals
check_for_unverified_individuals
append_unverified_individuals
notice.primary_fullname = recipient.full_name.titleize || ""
notice.primary_firstname = recipient.first_name.titleize || ""
notice.past_due_text = "PAST DUE"
if recipient.mailing_address
append_address(recipient.mailing_address)
else
raise 'mailing address not present'
end
end
def find_transition_people(people_ids)
@transition_people = []
people_ids.each do |person_id|
@transition_people << Person.find(person_id)
end
end
def check_for_transitioned_individuals
@transition_people.each do |person|
notice.individuals << PdfTemplates::Individual.new({
:first_name => person.first_name.titleize,
:last_name => person.last_name.titleize,
:age => calculate_age_by_dob(person.dob),
})
end
end
def check_for_unverified_individuals
family = recipient.primary_family
date = TimeKeeper.date_of_record
enrollments = HbxEnrollment.where(family_id: family.id).select do |hbx_en|
(!hbx_en.is_shop?) && (!["coverage_canceled", "shopping", "inactive"].include?(hbx_en.aasm_state)) &&
(hbx_en.terminated_on.blank? || hbx_en.terminated_on >= TimeKeeper.date_of_record)
end
enrollments.reject!{|e| e.coverage_terminated? }
hbx_enrollments = []
en = enrollments.select{ |en| HbxEnrollment::ENROLLED_STATUSES.include?(en.aasm_state)}
health_enrollments = en.select{ |e| e.coverage_kind == "health"}.sort_by(&:effective_on)
dental_enrollments = en.select{ |e| e.coverage_kind == "dental"}.sort_by(&:effective_on)
hbx_enrollments << health_enrollments
hbx_enrollments << dental_enrollments
hbx_enrollments.flatten!
hbx_enrollments.compact!
hbx_enrollments.each do |enrollment|
notice.enrollments << append_enrollment_information(enrollment)
end
notice.coverage_year = hbx_enrollments.compact.first.effective_on.year
end
def append_unverified_individuals
@transition_people.each do |person|
person.consumer_role.expired_verification_types.each do |verification_type|
case verification_type.type_name
when "Social Security Number"
notice.ssa_unverified << PdfTemplates::Individual.new({ full_name: person.full_name.titleize, past_due_text: "PAST DUE", age: person.age_on(TimeKeeper.date_of_record) })
when "Immigration status"
notice.immigration_unverified << PdfTemplates::Individual.new({ full_name: person.full_name.titleize, past_due_text: "PAST DUE", age: person.age_on(TimeKeeper.date_of_record) })
when "Citizenship"
notice.dhs_unverified << PdfTemplates::Individual.new({ full_name: person.full_name.titleize, past_due_text: "PAST DUE", age: person.age_on(TimeKeeper.date_of_record) })
when "American Indian Status"
notice.american_indian_unverified << PdfTemplates::Individual.new({ full_name: person.full_name.titleize, past_due_text: "PAST DUE", age: person.age_on(TimeKeeper.date_of_record) })
when EnrollRegistry[:enroll_app].setting(:state_residency).item
notice.residency_inconsistency << PdfTemplates::Individual.new({ full_name: person.full_name.titleize, past_due_text: "PAST DUE", age: person.age_on(TimeKeeper.date_of_record) })
end
end
end
end
def append_enrollment_information(enrollment)
plan = PdfTemplates::Plan.new({
plan_name: enrollment.product.title,
is_csr: enrollment.product.is_csr?,
coverage_kind: enrollment.product.kind,
plan_carrier: enrollment.product.issuer_profile.organization.legal_name,
family_deductible: enrollment.product.family_deductible.split("|").last.squish,
deductible: enrollment.product.deductible
})
PdfTemplates::Enrollment.new({
created_at: enrollment.created_at,
premium: enrollment.total_premium.round(2),
aptc_amount: enrollment.applied_aptc_amount.round(2),
responsible_amount: (enrollment.total_premium - enrollment.applied_aptc_amount.to_f).round(2),
phone: phone_number(enrollment.product.issuer_profile.legal_name),
is_receiving_assistance: enrollment.applied_aptc_amount > 0 || enrollment.product.is_csr? ? true : false,
coverage_kind: enrollment.coverage_kind,
kind: enrollment.kind,
effective_on: enrollment.effective_on,
plan: plan,
enrollees: enrollment.hbx_enrollment_members.inject([]) do |enrollees, member|
enrollee = PdfTemplates::Individual.new({
full_name: member.person.full_name.titleize,
age: member.person.age_on(TimeKeeper.date_of_record)
})
enrollees << enrollee
end
})
end
def phone_number(legal_name)
case legal_name
when "BestLife"
"(800) 433-0088"
when "CareFirst"
"(855) 444-3119"
when "Delta Dental"
"(800) 471-0236"
when "Dominion"
"(855) 224-3016"
when "Kaiser"
"(844) 524-7370"
end
end
end | 40.745763 | 191 | 0.672629 |
e212552e303c5af632ef5d736671e51c60f25f89 | 2,668 | module Google # deviates from other bin stuff to accomodate gem
class << self
def class_for(key)
case key
when :compute
Fog::Compute::Google
when :dns
Fog::DNS::Google
when :monitoring
Fog::Google::Monitoring
when :storage
Fog::Storage::Google
when :sql
Fog::Google::SQL
else
raise ArgumentError, "Unsupported #{self} service: #{key}"
end
end
def [](service)
@@connections ||= Hash.new do |hash, key|
hash[key] = case key
when :compute
Fog::Logger.warning("Google[:compute] is not recommended, use Compute[:google] for portability")
Fog::Compute.new(:provider => 'Google')
when :dns
Fog::Logger.warning("Google[:dns] is not recommended, use DNS[:google] for portability")
Fog::DNS.new(:provider => 'Google')
when :monitoring
Fog::Google::Monitoring.new
when :sql
Fog::Google::SQL.new
when :storage
Fog::Logger.warning("Google[:storage] is not recommended, use Storage[:google] for portability")
Fog::Storage.new(:provider => 'Google')
else
raise ArgumentError, "Unrecognized service: #{key.inspect}"
end
end
@@connections[service]
end
def account
@@connections[:compute].account
end
def services
Fog::Google.services
end
# based off of virtual_box.rb
def available?
# Make sure the gem we use is enabled.
availability = if Gem::Specification.respond_to?(:find_all_by_name)
!Gem::Specification.find_all_by_name('google-api-client').empty? # newest rubygems
else
!Gem.source_index.find_name('google-api-client').empty? # legacy
end
# Then make sure we have all of the requirements
for service in services
begin
service = self.class_for(service)
availability &&= service.requirements.all? { |requirement| Fog.credentials.include?(requirement) }
rescue ArgumentError => e
Fog::Logger.warning(e.message)
availability = false
rescue => e
availability = false
end
end
if availability
for service in services
for collection in self.class_for(service).collections
unless self.respond_to?(collection)
self.class_eval <<-EOS, __FILE__, __LINE__
def self.#{collection}
self[:#{service}].#{collection}
end
EOS
end
end
end
end
availability
end
end
end
| 29.644444 | 108 | 0.584708 |
393ebe4d08ef978a5d4e9b76fd890f8401ae1861 | 328 | Peatio::Blockchain.registry[:bitcoin] = Bitcoin::Blockchain
Peatio::Blockchain.registry[:geth] = Ethereum::Eth::Blockchain
Peatio::Blockchain.registry[:parity] = Ethereum::Eth::Blockchain
Peatio::Blockchain.registry[:"geth-bsc"] = Ethereum::Bsc::Blockchain
Peatio::Blockchain.registry[:"geth-heco"] = Ethereum::Heco::Blockchain
| 54.666667 | 70 | 0.77439 |
01dda4de844bd9976856bfb68158e4c79176d14f | 319 | require 'net/http'
puts ((ARGV.length != 1) ? "Usage: #$0 <zip code>" : (["The temperature
in"] + (/Weather<\/b> for <b>(.*)<\/b>.*\D(\d+)°F/.match(Net::HTTP.get(
URI.parse("http://www.google.com/search?hl=en&q=temperature+#{ARGV[0]}")))[1,2].collect!
{|x| " is " + x})).to_s.gsub!(/in is /, "in ") + " degree F")
| 53.166667 | 88 | 0.554859 |
ff81fe968d7232833738de345de1253172809ce3 | 5,394 | # frozen_string_literal: true
require "cose/algorithm"
require "cose/error"
require "cose/rsapkcs1_algorithm"
require "openssl"
require "webauthn/authenticator_data/attested_credential_data"
require "webauthn/error"
module WebAuthn
module AttestationStatement
class UnsupportedAlgorithm < Error; end
ATTESTATION_TYPE_NONE = "None"
ATTESTATION_TYPE_BASIC = "Basic"
ATTESTATION_TYPE_SELF = "Self"
ATTESTATION_TYPE_ATTCA = "AttCA"
ATTESTATION_TYPE_BASIC_OR_ATTCA = "Basic_or_AttCA"
ATTESTATION_TYPES_WITH_ROOT = [
ATTESTATION_TYPE_BASIC,
ATTESTATION_TYPE_BASIC_OR_ATTCA,
ATTESTATION_TYPE_ATTCA
].freeze
class Base
AAGUID_EXTENSION_OID = "1.3.6.1.4.1.45724.1.1.4"
def initialize(statement)
@statement = statement
end
def valid?(_authenticator_data, _client_data_hash)
raise NotImplementedError
end
def format
WebAuthn::AttestationStatement::FORMAT_TO_CLASS.key(self.class)
end
def attestation_certificate
certificates&.first
end
def certificate_chain
if certificates
certificates[1..-1]
end
end
def attestation_certificate_key_id
raw_subject_key_identifier&.unpack("H*")&.[](0)
end
private
attr_reader :statement
def matching_aaguid?(attested_credential_data_aaguid)
extension = attestation_certificate&.extensions&.detect { |ext| ext.oid == AAGUID_EXTENSION_OID }
if extension
# `extension.value` mangles data into ASCII, so we must manually compare bytes
# see https://github.com/ruby/openssl/pull/234
extension.to_der[-WebAuthn::AuthenticatorData::AttestedCredentialData::AAGUID_LENGTH..-1] ==
attested_credential_data_aaguid
else
true
end
end
def certificates
@certificates ||=
raw_certificates&.map do |raw_certificate|
OpenSSL::X509::Certificate.new(raw_certificate)
end
end
def algorithm
statement["alg"]
end
def raw_certificates
statement["x5c"]
end
def signature
statement["sig"]
end
def attestation_trust_path
if certificates&.any?
certificates
end
end
def trustworthy?(aaguid: nil, attestation_certificate_key_id: nil)
if ATTESTATION_TYPES_WITH_ROOT.include?(attestation_type)
configuration.acceptable_attestation_types.include?(attestation_type) &&
valid_certificate_chain?(aaguid: aaguid, attestation_certificate_key_id: attestation_certificate_key_id)
else
configuration.acceptable_attestation_types.include?(attestation_type)
end
end
def valid_certificate_chain?(aaguid: nil, attestation_certificate_key_id: nil)
attestation_root_certificates_store(
aaguid: aaguid,
attestation_certificate_key_id: attestation_certificate_key_id
).verify(attestation_certificate, attestation_trust_path)
end
def attestation_root_certificates_store(aaguid: nil, attestation_certificate_key_id: nil)
OpenSSL::X509::Store.new.tap do |store|
root_certificates(
aaguid: aaguid,
attestation_certificate_key_id: attestation_certificate_key_id
).each do |cert|
store.add_cert(cert)
end
end
end
def root_certificates(aaguid: nil, attestation_certificate_key_id: nil)
root_certificates =
configuration.attestation_root_certificates_finders.reduce([]) do |certs, finder|
if certs.empty?
finder.find(
attestation_format: format,
aaguid: aaguid,
attestation_certificate_key_id: attestation_certificate_key_id
) || []
else
certs
end
end
if root_certificates.empty? && respond_to?(:default_root_certificates, true)
default_root_certificates
else
root_certificates
end
end
def raw_subject_key_identifier
extension = attestation_certificate.extensions.detect { |ext| ext.oid == "subjectKeyIdentifier" }
return unless extension
ext_asn1 = OpenSSL::ASN1.decode(extension.to_der)
ext_value = ext_asn1.value.last
OpenSSL::ASN1.decode(ext_value.value).value
end
def valid_signature?(authenticator_data, client_data_hash, public_key = attestation_certificate.public_key)
raise("Incompatible algorithm and key") unless cose_algorithm.compatible_key?(public_key)
cose_algorithm.verify(
public_key,
signature,
verification_data(authenticator_data, client_data_hash)
)
rescue COSE::Error
false
end
def verification_data(authenticator_data, client_data_hash)
authenticator_data.data + client_data_hash
end
def cose_algorithm
@cose_algorithm ||=
COSE::Algorithm.find(algorithm).tap do |alg|
alg && configuration.algorithms.include?(alg.name) ||
raise(UnsupportedAlgorithm, "Unsupported algorithm #{algorithm}")
end
end
def configuration
WebAuthn.configuration
end
end
end
end
| 29.47541 | 116 | 0.661661 |
ab44c2c6dbc8eb8fe6b1500d0737d55bbc1fef3c | 1,750 | # frozen_string_literal: true
FactoryBot.define do
factory :deposit do
member { create(:member, :level_3) }
amount { Kernel.rand(100..10_000).to_d }
factory :deposit_btc, class: 'Deposits::Coin' do
currency { find_or_create :currency, :btc, id: :btc }
address { create(:payment_address, :btc_address).address }
txid { Faker::Lorem.characters(64) }
txout { 0 }
block_number { rand(1..1_349_999) }
end
factory :deposit_usd, class: 'Deposits::Fiat' do
currency { find_or_create :currency, :usd, id: :usd }
end
trait :deposit_btc do
type { Deposits::Coin }
currency { find_or_create :currency, :btc, id: :btc }
address { create(:payment_address, :btc_address).address }
txid { Faker::Lorem.characters(64) }
txout { 0 }
end
trait :deposit_eth do
type { Deposits::Coin }
currency { find_or_create :currency, :eth, id: :eth }
member { create(:member, :level_3, :barong) }
address { create(:payment_address, :eth_address).address }
txid { Faker::Lorem.characters(64) }
txout { 0 }
end
trait :deposit_trst do
type { Deposits::Coin }
currency { find_or_create :currency, :trst, id: :trst }
member { create(:member, :level_3, :barong) }
address { create(:payment_address, :trst_address).address }
txid { Faker::Lorem.characters(64) }
txout { 0 }
end
trait :deposit_ring do
type { Deposits::Coin }
currency { find_or_create :currency, :ring, id: :ring }
member { create(:member, :level_3, :barong) }
address { create(:payment_address, :trst_address).address }
txid { Faker::Lorem.characters(64) }
txout { 0 }
end
end
end
| 31.25 | 65 | 0.624 |
ff925cac387a9ef5826cb119734fc35eb873336c | 3,164 | Rails.application.configure do
# Settings specified here will take precedence over those in config/application.rb.
# Code is not reloaded between requests.
config.cache_classes = true
# Eager load code on boot. This eager loads most of Rails and
# your application in memory, allowing both threaded web servers
# and those relying on copy on write to perform better.
# Rake tasks automatically ignore this option for performance.
config.eager_load = true
# Full error reports are disabled and caching is turned on.
config.consider_all_requests_local = false
config.action_controller.perform_caching = true
# Enable Rack::Cache to put a simple HTTP cache in front of your application
# Add `rack-cache` to your Gemfile before enabling this.
# For large-scale production use, consider using a caching reverse proxy like nginx, varnish or squid.
# config.action_dispatch.rack_cache = true
# Disable Rails's static asset server (Apache or nginx will already do this).
config.serve_static_assets = false
# Compress JavaScripts and CSS.
config.assets.js_compressor = :uglifier
# config.assets.css_compressor = :sass
# Do not fallback to assets pipeline if a precompiled asset is missed.
config.assets.compile = false
# Generate digests for assets URLs.
config.assets.digest = true
# `config.assets.precompile` and `config.assets.version` have moved to config/initializers/assets.rb
# Specifies the header that your server uses for sending files.
# config.action_dispatch.x_sendfile_header = "X-Sendfile" # for apache
# config.action_dispatch.x_sendfile_header = 'X-Accel-Redirect' # for nginx
# Force all access to the app over SSL, use Strict-Transport-Security, and use secure cookies.
# config.force_ssl = true
# Set to :debug to see everything in the log.
config.log_level = :debug
# Prepend all log lines with the following tags.
# config.log_tags = [ :subdomain, :uuid ]
# Use a different logger for distributed setups.
# config.logger = ActiveSupport::TaggedLogging.new(SyslogLogger.new)
# Use a different cache store in production.
# config.cache_store = :mem_cache_store
# Enable serving of images, stylesheets, and JavaScripts from an asset server.
# config.action_controller.asset_host = "http://assets.example.com"
# Ignore bad email addresses and do not raise email delivery errors.
# Set this to true and configure the email server for immediate delivery to raise delivery errors.
# config.action_mailer.raise_delivery_errors = false
# Enable locale fallbacks for I18n (makes lookups for any locale fall back to
# the I18n.default_locale when a translation cannot be found).
config.i18n.fallbacks = true
# Send deprecation notices to registered listeners.
config.active_support.deprecation = :notify
# Disable automatic flushing of the log to improve performance.
# config.autoflush_log = false
# Use default logging formatter so that PID and timestamp are not suppressed.
config.log_formatter = ::Logger::Formatter.new
# Do not dump schema after migrations.
config.active_record.dump_schema_after_migration = false
end
| 40.050633 | 104 | 0.762642 |
d59c932c6f23e73c3b73c7bc53a3897988bcf855 | 206 | class Category < ApplicationRecord
has_many :workouts
scope :filter_duplicates, -> { group(:name).having("count(*) >= 1")}
def self.order_by_size
order(workouts: :desc)
end
end
| 15.846154 | 72 | 0.640777 |
18f6a95566aae347ac23f5c9a83c62979b0d1074 | 660 | require 'yaml'
class MinitestQueryHook < Mumukit::Templates::FileHook
isolated true
line_number_offset 2, include_extra: true
def tempfile_extension
'_test.yml'
end
def compile_file_content(request)
if request.query.strip != 'rake test'
raise Mumukit::CompilationError, t(:unrecognized_command)
end
"require 'minitest/autorun'\n#{request.extra}\n#{request.content}"
end
def command_line(filename)
"ruby #{filename} --seed 0 2>&1"
end
def post_process_file(file, result, status)
if result =~ /^.+\n\n(# Running\:\n\n.+?\n\n).+?\n\n(.+)$/m
["#{$1}#{$2}", status]
else
super
end
end
end
| 21.290323 | 70 | 0.651515 |
280aa52318a214d26e97add4af7431f83bb488b7 | 194 | class CreateAirlines < ActiveRecord::Migration[6.0]
def change
create_table :airlines do |t|
t.string :name
t.string :icao_code, limit: 4
t.timestamps
end
end
end
| 17.636364 | 51 | 0.654639 |
017690c9cc2e152d9fb0f433b7975bf1367980a8 | 552 | class CreateBridgeCacheDomains < ActiveRecord::Migration[5.0]
def change
return unless BridgeCache.use_internal_database
create_table :bridge_cache_domains do |t|
t.integer :bridge_id, limit: 8
t.string :name
t.integer :parent_id, limit: 8
t.datetime :created_at
t.datetime :updated_at
t.datetime :deleted_at
t.text :config
t.integer :owner_id, limit: 8
t.boolean :active
t.integer :users_count
t.integer :course_templates_count
t.integer :domain_type
end
end
end
| 27.6 | 61 | 0.684783 |
f7cb08bfc2c262892eca8c533b64fed9cf276bd2 | 594 | module Spina
class Blog::CategoriesController < ApplicationController
before_action :set_page
before_action :find_category
before_action :find_posts
def show
end
private
def find_category
@category = Spina::Blog::Category.friendly.find params[:id]
end
def find_posts
@posts = @category.posts.available.live.order(published_at: :desc).page(params[:page])
end
def set_page
@page = Spina::Page.find_or_create_by name: 'blog' do |page|
page.link_url = '/blog'
page.deletable = false
end
end
end
end
| 19.8 | 92 | 0.664983 |
1dd95805c3de220b3668983f54ea1186e99c4749 | 146 | module OrigenTesters
MAJOR = 0
MINOR = 49
BUGFIX = 0
DEV = 0
VERSION = [MAJOR, MINOR, BUGFIX].join(".") + (DEV ? ".pre#{DEV}" : '')
end
| 18.25 | 72 | 0.561644 |
26cec0d333e0dd2791479186140d01aa7cac5439 | 261 | #!/usr/bin/ruby
# Install with 'gem install droplet_kit'
require 'droplet_kit'
require './config.rb'
client = DropletKit::Client.new(access_token: @docean_token_v2)
client.ssh_keys.all().each { |x|
puts "[SSHKey] id: " + x.id.to_s + " , name: " + x.name
}
| 20.076923 | 63 | 0.678161 |
e99813d1cdef619ed848d9fba390261133a91d46 | 948 | # This file is auto-generated from the current state of the database. Instead
# of editing this file, please use the migrations feature of Active Record to
# incrementally modify your database, and then regenerate this schema definition.
#
# This file is the source Rails uses to define your schema when running `rails
# db:schema:load`. When creating a new database, `rails db:schema:load` tends to
# be faster and is potentially less error prone than running all of your
# migrations from scratch. Old migrations may fail to apply correctly if those
# migrations use external dependencies or application code.
#
# It's strongly recommended that you check this file into your version control system.
ActiveRecord::Schema.define(version: 2021_01_18_133130) do
create_table "products", force: :cascade do |t|
t.string "name"
t.string "tagline"
t.datetime "created_at", null: false
t.datetime "updated_at", null: false
end
end
| 41.217391 | 86 | 0.767932 |
abf874ba4a2dec27e58e391ec3e63eb6c6faa5ba | 423 | module ExecutableHooks
module Specification
def self.find
@executable_hooks_spec ||=
if Gem::Specification.respond_to?(:find_by_name)
Gem::Specification.find_by_name("executable-hooks")
else
Gem.source_index.find_name("executable-hooks").last
end
rescue Gem::LoadError
nil
end
def self.version
find ? find.version.to_s : nil
end
end
end
| 23.5 | 61 | 0.647754 |
28855cadd76a81a6958d0912e775621aa9f5b1f8 | 4,870 | # This file was generated by the `rails generate rspec:install` command. Conventionally, all
# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
# The generated `.rspec` file contains `--require spec_helper` which will cause
# this file to always be loaded, without a need to explicitly require it in any
# files.
#
# Given that it is always loaded, you are encouraged to keep this file as
# light-weight as possible. Requiring heavyweight dependencies from this file
# will add to the boot time of your test suite on EVERY test run, even for an
# individual file that may not need all of that loaded. Instead, consider making
# a separate helper file that requires the additional dependencies and performs
# the additional setup, and require it from the spec files that actually need
# it.
#
# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
require 'simplecov'
require 'codecov'
SimpleCov.start
SimpleCov.formatter = SimpleCov::Formatter::Codecov
RSpec.configure do |config|
# rspec-expectations config goes here. You can use an alternate
# assertion/expectation library such as wrong or the stdlib/minitest
# assertions if you prefer.
config.expect_with :rspec do |expectations|
# This option will default to `true` in RSpec 4. It makes the `description`
# and `failure_message` of custom matchers include text for helper methods
# defined using `chain`, e.g.:
# be_bigger_than(2).and_smaller_than(4).description
# # => "be bigger than 2 and smaller than 4"
# ...rather than:
# # => "be bigger than 2"
expectations.include_chain_clauses_in_custom_matcher_descriptions = true
end
# rspec-mocks config goes here. You can use an alternate test double
# library (such as bogus or mocha) by changing the `mock_with` option here.
config.mock_with :rspec do |mocks|
# Prevents you from mocking or stubbing a method that does not exist on
# a real object. This is generally recommended, and will default to
# `true` in RSpec 4.
mocks.verify_partial_doubles = true
end
# This option will default to `:apply_to_host_groups` in RSpec 4 (and will
# have no way to turn it off -- the option exists only for backwards
# compatibility in RSpec 3). It causes shared context metadata to be
# inherited by the metadata hash of host groups and examples, rather than
# triggering implicit auto-inclusion in groups with matching metadata.
config.shared_context_metadata_behavior = :apply_to_host_groups
# The settings below are suggested to provide a good initial experience
# with RSpec, but feel free to customize to your heart's content.
=begin
# This allows you to limit a spec run to individual examples or groups
# you care about by tagging them with `:focus` metadata. When nothing
# is tagged with `:focus`, all examples get run. RSpec also provides
# aliases for `it`, `describe`, and `context` that include `:focus`
# metadata: `fit`, `fdescribe` and `fcontext`, respectively.
config.filter_run_when_matching :focus
# Allows RSpec to persist some state between runs in order to support
# the `--only-failures` and `--next-failure` CLI options. We recommend
# you configure your source control system to ignore this file.
config.example_status_persistence_file_path = "spec/examples.txt"
# Limits the available syntax to the non-monkey patched syntax that is
# recommended. For more details, see:
# - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
# - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
# - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
config.disable_monkey_patching!
# Many RSpec users commonly either run the entire suite or an individual
# file, and it's useful to allow more verbose output when running an
# individual spec file.
if config.files_to_run.one?
# Use the documentation formatter for detailed output,
# unless a formatter has already been configured
# (e.g. via a command-line flag).
config.default_formatter = "doc"
end
# Print the 10 slowest examples and example groups at the
# end of the spec run, to help surface which specs are running
# particularly slow.
config.profile_examples = 10
# Run specs in random order to surface order dependencies. If you find an
# order dependency and want to debug it, you can fix the order by providing
# the seed, which is printed after each run.
# --seed 1234
config.order = :random
# Seed global randomization in this process using the `--seed` CLI option.
# Setting this allows you to use `--seed` to deterministically reproduce
# test failures related to randomization by passing the same `--seed` value
# as the one that triggered the failure.
Kernel.srand config.seed
=end
end
| 46.826923 | 92 | 0.744969 |
bb20812851e634687f829d4b747f6550b1d0c1ae | 172 | include_recipe "curl"
package "python"
package "python-dev"
execute "curl http://python-distribute.org/distribute_setup.py | python" do
not_if "which easy_install"
end
| 19.111111 | 75 | 0.773256 |
ab99e5f5338828b8b25cd4709e71268b0eded9d7 | 722 | Pod::Spec.new do |s|
s.name = "DacteevMusic"
s.version = "0.0.1"
s.summary = "Dacteev Music SDK"
s.homepage = "https://github.com/Dacteev/dacteev-music-sdk-swift"
s.license = { :type => "MIT", :file => "LICENSE.md" }
s.authors = { "Axel Etcheverry" => "[email protected]" }
s.social_media_url = "http://twitter.com/euskadi31"
s.ios.deployment_target = "9.0"
s.osx.deployment_target = "10.11"
s.tvos.deployment_target = "9.0"
s.watchos.deployment_target = "2.0"
s.source = {
:git => "https://github.com/Dacteev/dacteev-music-sdk-swift.git",
:tag => "v#{s.version}"
}
s.source_files = "Sources/*.swift"
s.dependency "Alamofire", "~> 4.0"
end
| 30.083333 | 73 | 0.603878 |
e90096335040e28beb23f1cac9d20347a498e63b | 6,071 | # frozen_string_literal: true
require "openssl"
require "bundler/settings"
RSpec.describe Bundler::Env do
let(:git_proxy_stub) { Bundler::Source::Git::GitProxy.new(nil, nil, nil) }
describe "#report" do
it "prints the environment" do
out = described_class.report
expect(out).to include("Environment")
expect(out).to include(Bundler::VERSION)
expect(out).to include(Gem::VERSION)
expect(out).to include(described_class.send(:ruby_version))
expect(out).to include(described_class.send(:git_version))
expect(out).to include(OpenSSL::OPENSSL_VERSION)
end
describe "rubygems paths" do
it "prints gem home" do
with_clear_paths("GEM_HOME", "/a/b/c") do
out = described_class.report
expect(out).to include("Gem Home /a/b/c")
end
end
it "prints gem path" do
with_clear_paths("GEM_PATH", "/a/b/c#{File::PATH_SEPARATOR}d/e/f") do
out = described_class.report
expect(out).to include("Gem Path /a/b/c#{File::PATH_SEPARATOR}d/e/f")
end
end
it "prints user home" do
skip "needs to use a valid HOME" if Gem.win_platform? && RUBY_VERSION < "2.6.0"
with_clear_paths("HOME", "/a/b/c") do
out = described_class.report
expect(out).to include("User Home /a/b/c")
end
end
it "prints user path" do
skip "needs to use a valid HOME" if Gem.win_platform? && RUBY_VERSION < "2.6.0"
with_clear_paths("HOME", "/a/b/c") do
allow(File).to receive(:exist?)
allow(File).to receive(:exist?).with("/a/b/c/.gem").and_return(true)
out = described_class.report
expect(out).to include("User Path /a/b/c/.gem")
end
end
it "prints bin dir" do
with_clear_paths("GEM_HOME", "/a/b/c") do
out = described_class.report
expect(out).to include("Bin Dir /a/b/c/bin")
end
end
private
def with_clear_paths(env_var, env_value)
old_env_var = ENV[env_var]
ENV[env_var] = env_value
Gem.clear_paths
yield
ensure
ENV[env_var] = old_env_var
end
end
context "when there is a Gemfile and a lockfile and print_gemfile is true" do
before do
gemfile "gem 'rack', '1.0.0'"
lockfile <<-L
GEM
remote: #{file_uri_for(gem_repo1)}/
specs:
rack (1.0.0)
DEPENDENCIES
rack
BUNDLED WITH
1.10.0
L
allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
end
let(:output) { described_class.report(:print_gemfile => true) }
it "prints the Gemfile" do
expect(output).to include("Gemfile")
expect(output).to include("'rack', '1.0.0'")
end
it "prints the lockfile" do
expect(output).to include("Gemfile.lock")
expect(output).to include("rack (1.0.0)")
end
end
context "when there no Gemfile and print_gemfile is true" do
let(:output) { described_class.report(:print_gemfile => true) }
it "prints the environment" do
expect(output).to start_with("## Environment")
end
end
context "when Gemfile contains a gemspec and print_gemspecs is true" do
let(:gemspec) do
strip_whitespace(<<-GEMSPEC)
Gem::Specification.new do |gem|
gem.name = "foo"
gem.author = "Fumofu"
end
GEMSPEC
end
before do
gemfile("gemspec")
File.open(bundled_app.join("foo.gemspec"), "wb") do |f|
f.write(gemspec)
end
allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
end
it "prints the gemspec" do
output = described_class.report(:print_gemspecs => true)
expect(output).to include("foo.gemspec")
expect(output).to include(gemspec)
end
end
context "when eval_gemfile is used" do
it "prints all gemfiles" do
create_file bundled_app("other/Gemfile-other"), "gem 'rack'"
create_file bundled_app("other/Gemfile"), "eval_gemfile 'Gemfile-other'"
create_file bundled_app("Gemfile-alt"), <<-G
source "#{file_uri_for(gem_repo1)}"
eval_gemfile "other/Gemfile"
G
gemfile "eval_gemfile #{bundled_app("Gemfile-alt").to_s.dump}"
allow(Bundler::SharedHelpers).to receive(:find_gemfile).and_return(bundled_app_gemfile)
allow(Bundler::SharedHelpers).to receive(:pwd).and_return(bundled_app)
output = described_class.report(:print_gemspecs => true)
expect(output).to include(strip_whitespace(<<-ENV))
## Gemfile
### Gemfile
```ruby
eval_gemfile #{bundled_app("Gemfile-alt").to_s.dump}
```
### Gemfile-alt
```ruby
source "#{file_uri_for(gem_repo1)}"
eval_gemfile "other/Gemfile"
```
### other/Gemfile
```ruby
eval_gemfile 'Gemfile-other'
```
### other/Gemfile-other
```ruby
gem 'rack'
```
### Gemfile.lock
```
<No #{bundled_app_lock} found>
```
ENV
end
end
context "when the git version is OS specific" do
it "includes OS specific information with the version number" do
expect(git_proxy_stub).to receive(:git).with("--version").
and_return("git version 1.2.3 (Apple Git-BS)")
expect(Bundler::Source::Git::GitProxy).to receive(:new).and_return(git_proxy_stub)
expect(described_class.report).to include("Git 1.2.3 (Apple Git-BS)")
end
end
end
describe ".version_of" do
let(:parsed_version) { described_class.send(:version_of, "ruby") }
it "strips version of new line characters" do
expect(parsed_version).to_not end_with("\n")
end
end
end
| 28.502347 | 95 | 0.589853 |
d5637e5482f91aecf24a4b35357dbe39656615dc | 861 | class CreateBandEvents < ActiveRecord::Migration
def change
create_table :band_events do |t|
t.integer :band_id
t.integer :event_id
t.boolean :confirmed #(y/n) (validate when confirmed)
t.time :load_time
t.time :doors_time
t.time :show_time
t.time :set_time
t.integer :tour_id
t.boolean :food_comp
t.boolean :drink_comp
t.boolean :hotel_comp
# COMP: (tied to event, pull from most recent event at that venue, if it exists, and make it editable)
t.float :flat_rate
t.boolean :door_deal #(y/n)
t.string :door_deal_details #(if door deal, sub form appears.)
t.integer :stay_id
t.string :event_notes
# (make available after event ends:)
t.float :merch_total
t.float :tips_total
t.timestamps null: false
end
end
end
| 25.323529 | 108 | 0.641115 |
7abd5ca8772b26e17caba59e0fcc553b6ea05397 | 1,459 | # frozen_string_literal: true
require 'spec_helper'
RSpec.describe 'PipelineDestroy' do
include GraphqlHelpers
let_it_be(:project) { create(:project) }
let_it_be(:user) { project.first_owner }
let_it_be(:pipeline) { create(:ci_pipeline, :success, project: project, user: user) }
let(:mutation) do
variables = {
id: pipeline.to_global_id.to_s
}
graphql_mutation(:pipeline_destroy, variables, 'errors')
end
it 'returns an error if the user is not allowed to destroy the pipeline' do
post_graphql_mutation(mutation, current_user: create(:user))
expect(graphql_errors).not_to be_empty
end
it 'destroys a pipeline' do
post_graphql_mutation(mutation, current_user: user)
expect(response).to have_gitlab_http_status(:success)
expect { pipeline.reload }.to raise_error(ActiveRecord::RecordNotFound)
end
context 'when project is undergoing stats refresh' do
before do
create(:project_build_artifacts_size_refresh, :pending, project: pipeline.project)
end
it 'returns an error and does not destroy the pipeline' do
expect(Gitlab::ProjectStatsRefreshConflictsLogger)
.to receive(:warn_request_rejected_during_stats_refresh)
.with(pipeline.project.id)
post_graphql_mutation(mutation, current_user: user)
expect(graphql_mutation_response(:pipeline_destroy)['errors']).not_to be_empty
expect(pipeline.reload).to be_persisted
end
end
end
| 29.77551 | 88 | 0.740918 |
39f8c7667c13278338aabf664a9803f918d9a1dc | 1,352 | class RbacSetup < ActiveRecord::Migration
def self.up
create_table "permissions" do |t|
t.string "provider"
t.string "operation"
t.string "rule"
t.timestamps
end
create_table "permissions_roles", :id => false do |t|
t.integer "permission_id"
t.integer "role_id"
end
add_index "permissions_roles", ["permission_id"], :name => "index_permissions_roles_on_permission_id"
add_index "permissions_roles", ["role_id"], :name => "index_permissions_roles_on_role_id"
create_table "roles" do |t|
t.string "name"
end
create_table "roles_users", :id => false do |t|
t.integer "role_id"
t.integer "user_id"
end
add_index "roles_users", ["role_id"], :name => "index_roles_users_on_role_id"
add_index "roles_users", ["user_id"], :name => "index_roles_users_on_user_id"
create_table "users", :force => true do |t|
t.string "login"
t.string "email"
t.string "crypted_password", :limit => 40
t.string "salt", :limit => 40
t.datetime "created_at"
t.datetime "updated_at"
t.string "remember_token"
t.datetime "remember_token_expires_at"
t.string "prs_id"
t.string "first_name"
t.string "last_name"
end
end
def self.down
end
end
| 27.591837 | 105 | 0.620562 |
79de989621c4e59df2f3fd604a6c8a68d35b75f5 | 110 | Rails.application.routes.draw do
post '/graphql', to: 'graphql#execute'
devise_for :users, skip: :all
end | 22 | 40 | 0.727273 |
5de6ef88a864371c3fd435ecd9a478c2134b7a5b | 87 | $LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
require 'ld4l_browser_data'
| 29 | 58 | 0.758621 |
6ae7fa3abed07f9cb1a51191358916e491bf1825 | 650 | Pod::Spec.new do |s|
s.name = 'QEDSDK'
s.version = '1.1.4'
s.summary = 'The QED REST API provides an easy way to leverage blockchain technology attaching immutable timestamps to your files.'
s.homepage = 'http://qed.digital/'
s.author = { 'Name' => '[email protected]' }
s.license = { :type => 'Apache-2.0', :file => 'LICENSE' }
s.platform = :ios
s.source = { :git => 'https://github.com/buzztechno/QEDSDK_POD.git', :tag => 'v1.1.4' }
s.ios.deployment_target = '11.0'
s.ios.vendored_frameworks = 'QEDSDK.framework'
end
| 40.625 | 145 | 0.550769 |
e25d5f8347394c3db4b2637ed11e6a3f90bbe1d4 | 689 | cask "font-iosevka-ss09" do
version "7.0.4"
sha256 "9749448e5b37d2fb7549b10a45b86e708d4c491a956a2abba57493d9359b4935"
url "https://github.com/be5invis/Iosevka/releases/download/v#{version}/ttc-iosevka-ss09-#{version}.zip"
name "Iosevka SS09"
desc "Sans-serif, slab-serif, monospace and quasi‑proportional typeface family"
homepage "https://github.com/be5invis/Iosevka/"
font "iosevka-ss09-bold.ttc"
font "iosevka-ss09-extrabold.ttc"
font "iosevka-ss09-extralight.ttc"
font "iosevka-ss09-heavy.ttc"
font "iosevka-ss09-light.ttc"
font "iosevka-ss09-medium.ttc"
font "iosevka-ss09-regular.ttc"
font "iosevka-ss09-semibold.ttc"
font "iosevka-ss09-thin.ttc"
end
| 34.45 | 105 | 0.756168 |
1d8ec850582bdf2473822a9cf57ae191b5e31af6 | 739 | # Copyright 2012, Dell
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
class BarclampImportHive < ActiveRecord::Migration
def up
Barclamp.import_1x 'hive'
end
def down
Barclamp.delete(Barclamp.find_by_name 'hive')
end
end
| 29.56 | 74 | 0.753721 |
1d62ceea1731e3df5f401f21345e260634cbeb22 | 189 | class TokyoMetro::Factory::Seed::Static::RailwayDirection::Hash < TokyoMetro::Factory::Seed::Static::MetaClass::Hash
include ::TokyoMetro::ClassNameLibrary::Static::RailwayDirection
end | 37.8 | 116 | 0.793651 |
6a3f948427fd2ffe764d18de16739868cd90d991 | 210 | require "test_helper"
class HttpclientxTest < Minitest::Test
def test_that_it_has_a_version_number
refute_nil ::Httpclientx::VERSION
end
def test_it_does_something_useful
assert false
end
end
| 17.5 | 39 | 0.790476 |
ff2b0672f7b6d0b207a5cde3fc05500382fe0aef | 1,553 | class Roda
module RodaPlugins
# The content_for plugin is designed to be used with the
# render plugin, allowing you to store content inside one
# template, and retrieve that content inside a separate
# template. Most commonly, this is so view templates
# can set content for the layout template to display outside
# of the normal content pane.
#
# The content_for template probably only works with erb
# templates, and requires that you don't override the
# +:outvar+ render option. In the template in which you
# want to store content, call content_for with a block:
#
# <% content_for :foo do %>
# Some content here.
# <% end %>
#
# In the template in which you want to retrieve content,
# call content_for without the block:
#
# <%= content_for :foo %>
module ContentFor
module InstanceMethods
# If called with a block, store content enclosed by block
# under the given key. If called without a block, retrieve
# stored content with the given key, or return nil if there
# is no content stored with that key.
def content_for(key, &block)
if block
@_content_for ||= {}
buf_was = @_out_buf
@_out_buf = ''
yield
@_content_for[key] = @_out_buf
@_out_buf = buf_was
elsif @_content_for
@_content_for[key]
end
end
end
end
register_plugin(:content_for, ContentFor)
end
end
| 33.042553 | 67 | 0.619446 |
0153a1e6c15eccd45159c1b275d8ce28fc17ae62 | 194 | require "test_helper"
class AlpsTest < Minitest::Test
def test_casually
Alps.x(:test)
a = Class.new do
def a
1 + 1
end
end
a.new.a
sleep 2
end
end
| 11.411765 | 31 | 0.556701 |
08bf33c288cab6a59ec79e8bc079d2fb747f96dc | 173 | module ErrnoKnows
def knows? error
@constants ||= constants.map{|n| const_get(n)}
@constants.include? error.class
end
end
module Errno
extend ErrnoKnows
end
| 14.416667 | 50 | 0.710983 |
18048f0858434176acecbfdc694caf558e97c52f | 698 | # This migration comes from refinery_guides (originally 1)
class CreateGuidesGuides < ActiveRecord::Migration
def up
create_table :refinery_guides do |t|
t.string :title
t.text :description
t.text :raw_source
t.text :html
t.string :author
t.string :category
t.string :source_url
t.string :sha
t.integer :position
t.timestamps
end
end
def down
if defined?(::Refinery::UserPlugin)
::Refinery::UserPlugin.destroy_all({:name => "refinerycms-guides"})
end
if defined?(::Refinery::Page)
::Refinery::Page.delete_all({:link_url => "/guides/guides"})
end
drop_table :refinery_guides
end
end
| 19.942857 | 73 | 0.646132 |
f861dd0da199e248dd32bd1518a738ed0c296414 | 1,611 | # frozen_string_literal: true
class CommentsController < ApplicationController
before_action :authenticate_user!
before_action :set_comment, only: %i[show edit update destroy]
before_action :set_idea, only: %i[new create show edit update destroy]
# GET /comments
def index
@comments = Comment.includes(:user).where('idea_id = ?', params[:idea_id])
end
def show; end
def new
authorize @idea, policy_class: CommentPolicy
@comment = @idea.comments.build
end
def edit; end
def update
authorize @comment
if @comment.update(comment_params)
redirect_to idea_comment_path(@comment.idea, @comment), notice: 'Comment was successfully updated.'
else
render :edit
end
end
def destroy
authorize @comment
@comment.redacted = true
@comment.save!
redirect_to idea_path(@comment.idea), notice: 'Comment was successfully deleted.'
end
def create
authorize @idea, policy_class: CommentPolicy
create_comment
return if performed?
redirect_to idea_comment_path(@comment.idea, @comment), notice: 'Comment created'
end
private
def create_comment
@comment = @idea.comments.build(comment_params)
@comment.status_at_comment_time = Comment.status_at_comment_times[@idea.status.to_sym]
@comment.user = current_user
render :new unless @comment.save
end
def set_comment
@comment = Comment.includes(:user).find(params[:id])
end
def set_idea
@idea = Idea.includes(:votes).find(params[:idea_id])
end
def comment_params
params.require(:comment).permit(
:body
)
end
end
| 22.375 | 105 | 0.711359 |
f8ac9ba6fb9f5881f5cd9706f37155103985bbd6 | 336 | require 'test_helper'
class ProjectTest < ActiveSupport::TestCase
context 'associations' do
should have_many(:positions)
should belong_to(:organization)
end
context 'validations' do
should validate_length_of(:title).
is_at_least(3).is_at_most(20)
should validate_presence_of(:organization_id)
end
end
| 21 | 49 | 0.744048 |
e2ea5b7c38105fe201e091c32ac65799c8158be3 | 557 | class IGVTools < FPM::Cookery::Recipe
description 'The igvtools utility provides a set of tools for pre-processing data files. '
name 'igvtools'
version '2.3.94'
revision 0
homepage 'https://www.broadinstitute.org/igv/igvtools'
source "http://data.broadinstitute.org/igv/projects/downloads/igvtools_#{version}.zip"
md5 'b7faea83f121246a1e9bf03f26ba52ee'
# Let's install build dependencies first.
depends ['default-jre', 'default-jdk']
# Build:
def build
end
# Install:
def install
bin.install Dir["IGVTools/*"]
end
end
| 25.318182 | 92 | 0.723519 |
28ca93188ce6a5d9d71d70ba1cf2c59872365474 | 527 | module AwsAlertMonitor
class Config
attr_accessor :logger, :file
def initialize(args={})
@opts = args[:opts] ||= Hash.new
log_level = args[:log_level]
self.logger = AwsAlertMonitor::Logger.new :log_level => log_level
self.file = load_config_file
end
private
def load_config_file
config_file = "#{ENV['HOME']}/.aws-alert-monitor.yml"
if File.exists? config_file
YAML::load File.open config_file
else
{ }
end
end
end
end
| 19.518519 | 71 | 0.607211 |
e8420586ecdf7e753bae3ea9ee4ba41dee111f9e | 180 | class AddListenersToAlbumsAndArtists < ActiveRecord::Migration[7.0]
def change
add_column :artists, :listeners, :bigint
add_column :albums, :listeners, :bigint
end
end
| 25.714286 | 67 | 0.755556 |
8736b1af21e793d0441fe90f48cfd33f48b63122 | 365 | require 'twitter/geo'
module Twitter
class Geo
class Point < Twitter::Geo
# @return [Integer]
def latitude
coordinates[0]
end
alias_method :lat, :latitude
# @return [Integer]
def longitude
coordinates[1]
end
alias_method :long, :longitude
alias_method :lng, :longitude
end
end
end
| 17.380952 | 36 | 0.59726 |
039ee0bb76e7b80b65a54e359e49f950a74fadea | 760 | $:.unshift File.expand_path("../lib", __FILE__)
require "deb/s3"
Gem::Specification.new do |gem|
gem.name = "deb-s3"
gem.version = Deb::S3::VERSION
gem.author = "Ken Robertson"
gem.email = "[email protected]"
gem.homepage = "http://invalidlogic.com/"
gem.summary = "Easily create and manage an APT repository on S3."
gem.description = gem.summary
gem.license = "MIT"
gem.executables = "deb-s3"
gem.files = Dir["**/*"].select { |d| d =~ %r{^(README|bin/|ext/|lib/)} }
gem.required_ruby_version = '>= 1.9.3'
gem.add_dependency "thor", "~> 0.19.0"
gem.add_dependency "aws-sdk", "~> 1.66"
gem.add_development_dependency "minitest", "~> 5"
gem.add_development_dependency "rake", "~> 11"
end
| 30.4 | 74 | 0.625 |
d5d6ef5a37633711ff89eab4ed9cf1709258f9dd | 2,100 | module Sudoku
class Generator
include PeersAndUnits
VALID_DIFFICULTIES = ["easy", "medium", "hard", "samuraj"]
attr_reader :difficulty_analyzer
def initialize
@difficulty_analyzer = DifficultyAnalyzer.new
end
def generate(difficulty = "easy")
check_difficulty!(difficulty)
grid = start_grid
keys = Hamster.list(randomized_keys)
search(grid, difficulty, keys)
end
def check_difficulty!(difficulty)
raise "Invalid difficulty" unless VALID_DIFFICULTIES.include?(difficulty)
end
def search(grid, difficulty, keys)
raise "Could not generate a grid" if keys.empty?
return grid if done_generating?(grid, difficulty)
keys.reduce(nil) do |found_grid, key|
new_grid = grid.clone
new_grid.reset(key)
if uniquely_solvable? new_grid
new_keys = Hamster.list(*new_grid.assigned_keys.to_a.shuffle)
return search(new_grid, difficulty, new_keys)
else
return false
end
end
end
def done_generating?(grid, difficulty)
enough_empty_squares?(grid) && correct_difficulty?(difficulty, grid) && uniquely_solvable?(grid)
end
def enough_empty_squares?(grid)
grid.empty_values.size > 40
end
def uniquely_solvable?(grid)
solver = Solver.new(grid.to_propagating_grid)
solver.solve && solver.unique_solution?
end
def randomized_keys
keys = SORTED_KEYS.clone
keys.shuffle
end
def correct_difficulty?(difficulty, grid)
difficulty_analyzer.grid = grid
difficulty_analyzer.difficulty == difficulty
end
def start_grid
solve(seed).to_non_propagating_grid
end
def solve(grid)
solver = Solver.new(grid)
solver.solve(check_uniqueness: false)
solver.solution
end
def seed
grid = NonPropagatingGrid.new
grid.set(linear_random_key, linear_random)
grid
end
def linear_random_key
ROW_KEYS[linear_random] + linear_random.to_s
end
def linear_random
rand(8) + 1
end
end
end | 24.418605 | 102 | 0.67 |
bf704ebef87d1f69f77052904bc4ab680fb7ea1a | 126 | class AddIndexesToIncidents < ActiveRecord::Migration[6.0]
def change
add_index :incidents, :occurred_on_date
end
end
| 21 | 58 | 0.777778 |
26b66df074d172491b749ba78e8498771db75ca4 | 2,379 | require "test_helper"
class PasswordResetsTest < ActionDispatch::IntegrationTest
def setup
ActionMailer::Base.deliveries.clear
@user = users(:user_a)
end
test "password resets" do
get new_password_reset_path
assert_template "password_resets/new"
assert_select "input[name=?]", "password_reset[email]"
# Invalid email
post password_resets_path, params: { password_reset: { email: "" } }
assert_not flash.empty?
assert_template "password_resets/new"
# Valid email
post password_resets_path,
params: { password_reset: { email: @user.email } }
assert_not_equal @user.reset_digest, @user.reload.reset_digest
assert_equal 1, ActionMailer::Base.deliveries.size
assert_not flash.empty?
assert_redirected_to root_url
# Password reset form
user = assigns(:user)
# Wrong email
get edit_password_reset_path(user.reset_token, email: "")
assert_redirected_to root_url
# Inactive user
user.toggle!(:activated)
get edit_password_reset_path(user.reset_token, email: user.email)
assert_redirected_to root_url
user.toggle!(:activated)
# Right email, wrong token
get edit_password_reset_path("wrong token", email: user.email)
assert_redirected_to root_url
# Right email, right token
get edit_password_reset_path(user.reset_token, email: user.email)
assert_template "password_resets/edit"
assert_select "input[name=email][type=hidden][value=?]", user.email
# Invalid password & confirmation
patch password_reset_path(user.reset_token),
params: { email: user.email,
user: { password: "foobaz",
password_confirmation: "barquux" } }
assert_select "div#error_explanation"
# Empty password
patch password_reset_path(user.reset_token),
params: { email: user.email,
user: { password: "",
password_confirmation: "" } }
assert_select "div#error_explanation"
# Valid password & confirmation
patch password_reset_path(user.reset_token),
params: { email: user.email,
user: { password: "foobaz",
password_confirmation: "foobaz" } }
assert logged_in?
assert_not flash.empty?
assert_redirected_to user
end
end
| 37.171875 | 72 | 0.664985 |
d54d20cc1c5b50741b8f7c1b2de024779a21db52 | 1,670 | # -*- coding: utf-8 -*- #
# frozen_string_literal: true
describe Rouge::Lexers::ConsoleLexer do
let(:subject) { Rouge::Lexers::ConsoleLexer.new }
let(:klass) { Rouge::Lexers::ConsoleLexer }
include Support::Lexing
it 'parses a basic prompt' do
assert_tokens_equal '$ foo',
['Generic.Prompt', '$'],
['Text.Whitespace', ' '],
['Text', 'foo']
end
it 'parses a custom prompt' do
subject_with_options = klass.new({ prompt: '%' })
assert_tokens_equal '% foo', subject_with_options,
['Generic.Prompt', '%'],
['Text.Whitespace', ' '],
['Text', 'foo']
end
it 'parses a custom error' do
subject_with_options = klass.new({ error: 'No command,Unhandled' })
assert_tokens_equal 'No command \'foo\' found, did you mean:', subject_with_options,
['Generic.Error', 'No command \'foo\' found, did you mean:']
assert_tokens_equal 'Unhandled condition in test.lisp', subject_with_options,
['Generic.Error', 'Unhandled condition in test.lisp']
assert_tokens_equal 'foo', subject_with_options,
['Generic.Output', 'foo']
end
it 'parses single-line comments' do
subject_with_options = klass.new({ comments: true })
assert_tokens_equal '# this is a comment', subject_with_options,
['Comment', '# this is a comment']
end
it 'ignores single-line comments' do
assert_tokens_equal '# this is not a comment',
['Generic.Prompt', '#'],
['Text.Whitespace', ' '],
['Text', 'this is not a comment']
end
describe 'guessing' do
include Support::Guessing
it 'guesses by filename' do
assert_guess :filename => 'foo.cap'
end
end
end
| 29.821429 | 88 | 0.643713 |
1abce1a79c7477224459790420fc73dfe5cd8d07 | 4,071 | require 'exact_target_client/exact_target_rest_client'
require 'exact_target_client/exact_target_soap_client'
module ExactTargetClient
class ExactTargetAPI
attr_accessor :oauth_token, :refresh_token
class TimeOut < Exception;
end
class TokenExpired < Exception;
end
class ClientException < Exception;
end
def initialize
yield self if block_given?
raise ArgumentError, 'block not given' unless block_given?
init_clients
end
def refresh_oauth_token
results = @rest_client.get_oauth_token(Conf.client_id, Conf.client_secret, refresh_token)
if results
@oauth_token = results['accessToken']
@refresh_token = results['refreshToken']
refresh_clients(results['accessToken'])
results
end
end
def get_emails(ids = nil)
properties = %w(ID Name HTMLBody)
if ids.present?
filter = {property: 'ID', value: ids}
end
response = soap_client.retrieve('Email', properties, filter)
check_response(response)
end
def create_email(email_name, subject, html_template)
response = soap_client.create('Email',
{'Name' => email_name,
'Subject' => subject,
'HTMLBody' => html_template}
)
check_response(response)
end
def update_email(email_id, name, html_template, subject = nil)
properties = {'ID' => email_id, 'Name' => name, 'HTMLBody' => html_template}
if subject.present?
properties['Subject'] = subject
end
response = soap_client.update('Email', properties)
check_response(response)
end
def delete_email(email_id)
response = soap_client.delete('Email', {'ID' => email_id})
check_response(response)
end
def create_content_area(name, content)
response = soap_client.create('ContentArea',
{'Name' => name,
'Content' => content}
)
check_response(response)
end
def update_content_area(content_area_id, name, content)
response = soap_client.update('ContentArea', {'ID' => content_area_id, 'Name' => name, 'Content' => content})
check_response(response)
end
def delete_content_area(content_area_id)
response = soap_client.delete('ContentArea', {'ID' => content_area_id})
check_response(response)
end
def create_data_extension(properties)
response = soap_client.create('DataExtension', properties)
check_response(response)
end
def upsert_data_extension_row(data_extension_customer_key, primary_key_name, primary_key_value, object_hash)
rest_client.upsert_data_extension_row(data_extension_customer_key, primary_key_name, primary_key_value, object_hash)
end
def increment_data_extension_row(data_extension_customer_key, primary_key_name, primary_key_value, column, step = 1)
rest_client.increment_data_extension_row(data_extension_customer_key, primary_key_name, primary_key_value, column, step)
end
def get_subscribers_by_email(email, properties)
response = soap_client.retrieve('Subscriber', properties, {property: 'EmailAddress', value: email})
check_response(response)
end
private
attr_accessor :soap_client, :rest_client
def init_clients
@soap_client = ExactTargetClient::ExactTargetSoapClient.new do |c|
c.oauth_token = oauth_token
c.wsdl = Conf.wsdl % {:instance => oauth_token[0]} # WSDL instance is determined by first char of token
end
@rest_client = ExactTargetClient::ExactTargetRestClient.new do |c|
c.oauth_token = oauth_token
end
end
def refresh_clients(token)
@soap_client.set_oauth_token(token)
@rest_client.set_oauth_token(token)
end
def check_response(response)
if response.success?
response.results
else
raise ClientException.new(response.message)
end
end
end
end
| 31.55814 | 126 | 0.669369 |
7936ad19689a9fae82da8ac5bf84fada7e9bdaa0 | 8,960 | require 'action_view'
require 'fileutils'
require 'cucumber/formatter/io'
require 'cucumber/formatter/duration'
require 'cucumber/core/ast/scenario'
require 'cucumber/multiline_argument/data_table'
require File.join(File.dirname(__FILE__), 'view_helper')
require File.join(File.dirname(__FILE__), 'report')
# Starting with ActionPack 4.1.1, the module Mime doesn't get initialized before it's needed by PrettyFace and so
# it would blow up with errors about uninitialized constants. We need to explicitly load it to prevent this problem.
require 'action_dispatch/http/mime_type'
module PrettyFace
module Formatter
class Html
include Cucumber::Formatter::Io
include Cucumber::Formatter::Duration
include ViewHelper
attr_reader :report, :logo
def initialize(step_mother, path_or_io, options)
@path = path_or_io
set_path_and_file(path_or_io)
@path_to_erb = File.join(File.dirname(__FILE__), '..', 'templates')
@step_mother = step_mother
@options = options
# The expand option is set to true by RubyMine and cannot be turned off using the IDE. This option causes
# a test run while using this gem to terminate.
@options[:expand] = false unless @options.nil?
@report = Report.new
@img_id = 0
@logo = 'face.png'
end
def set_path_and_file(path_or_io)
return if path_or_io.nil?
dir = File.dirname(path_or_io)
FileUtils.mkdir_p dir unless File.directory? dir
@io = ensure_io(path_or_io)
end
def embed(src, mime_type, label)
case(mime_type)
when /^image\/(png|gif|jpg|jpeg)/
embed_image(src, label)
end
end
def embed_image(src, label)
@report.current_scenario.image << src.split(separator).last
@report.current_scenario.image_label << label
@report.current_scenario.image_id << "img_#{@img_id}"
@img_id += 1
filename = "#{File.dirname(@path)}#{separator}images"
FileUtils.cp src, filename
end
def before_features(features)
make_output_directories
@tests_started = Time.now
end
def features_summary_file
parts = @io.path.split(separator)
parts[parts.length - 1]
end
def before_feature(feature)
@report.add_feature ReportFeature.new(feature, features_summary_file)
end
def after_feature(feature)
@report.current_feature.close(feature)
end
def before_background(background)
@report.begin_background
end
def after_background(background)
@report.end_background
@report.current_feature.background << ReportStep.new(background)
end
def before_feature_element(feature_element)
@report.add_scenario ReportScenario.new(feature_element)
end
def after_feature_element(feature_element)
process_scenario(feature_element)
end
def before_table_row(example_row)
@before_example_row = example_row
@report.add_scenario ReportScenario.new(example_row) unless info_row?(example_row)
end
def after_table_row(example_row)
unless info_row?(example_row)
@report.current_scenario.populate(example_row)
build_scenario_outline_steps(example_row)
end
populate_cells(example_row) if example_row.instance_of? Cucumber::Core::Ast::DataTable
end
def before_step(step)
@step_timer = Time.now
end
def after_step(step)
step = process_step(step) unless step_belongs_to_outline? step
if @cells
step.table = @cells
@cells = nil
end
end
def after_features(features)
@features = features
@duration = format_duration(Time.now - @tests_started)
copy_images
copy_stylesheets
generate_report
end
def features
@report.features
end
def custom_suite_header?
return false unless customization_directory
Dir.foreach(customization_directory) do |file|
return true if file == '_suite_header.erb'
end
false
end
def custom_feature_header?
return false unless customization_directory
Dir.foreach(customization_directory) do |file|
return true if file == '_feature_header.erb'
end
false
end
private
def generate_report
paths = [@path_to_erb, customization_directory.to_s]
renderer = ActionView::Base.new(paths)
filename = File.join(@path_to_erb, 'main')
@io.puts renderer.render(:file => filename, :locals => {:report => self, :logo => @logo})
features.each do |feature|
write_feature_file(feature)
end
end
def write_feature_file(feature)
paths = [@path_to_erb, customization_directory.to_s]
renderer = ActionView::Base.new(paths)
filename = File.join(@path_to_erb, 'feature')
output_file = "#{File.dirname(@path)}#{separator}#{feature.file}"
to_cut = output_file.split(separator).last
directory = output_file.sub("#{separator}#{to_cut}", '')
FileUtils.mkdir_p directory unless File.directory? directory
file = File.new(output_file, Cucumber.file_mode('w'))
file.puts renderer.render(:file => filename, :locals => {:feature => feature, :logo => @logo, :customize => custom_feature_header?})
file.flush
file.close
end
def make_output_directories
make_directory 'images'
make_directory 'stylesheets'
end
def make_directory(dir)
path = "#{File.dirname(@path)}#{separator}#{dir}"
FileUtils.mkdir_p path unless File.directory? path
end
def copy_directory(dir, file_names, file_extension)
path = "#{File.dirname(@path)}#{separator}#{dir}"
file_names.each do |file|
copy_file File.join(File.dirname(__FILE__), '..', 'templates', "#{file}.#{file_extension}"), path
end
end
def copy_file(source, destination)
FileUtils.cp source, destination
end
def copy_images
copy_directory 'images', %w(failed passed pending undefined skipped table_failed table_passed table_pending table_undefined table_skipped), "png"
logo = logo_file
copy_file logo, "#{File.join(File.dirname(@path), 'images')}" if logo
copy_directory 'images', ['face'], 'png' unless logo
end
def copy_stylesheets
copy_directory 'stylesheets', ['style'], 'css'
end
def logo_file
dir = customization_directory
Dir.foreach(dir) do |file|
if file =~ /^logo\.(png|gif|jpg|jpeg)$/
@logo = file
return File.join(dir, file)
end
end if dir
end
def customization_directory
dir = File.join(File.expand_path('features'), 'support', 'pretty_face')
return dir if File.exists? dir
end
def process_scenario(scenario)
@report.current_scenario.populate(scenario)
end
def process_step(step, status=nil)
duration = Time.now - @step_timer
report_step = ReportStep.new(step)
report_step.duration = duration
report_step.status = status unless status.nil?
if step.background
@report.current_feature.background << report_step if @report.processing_background_steps?
else
@report.add_step report_step
end
report_step
end
def scenario_outline?(feature_element)
feature_element.is_a? Cucumber::Core::Ast::ScenarioOutline
end
def info_row?(example_row)
return example_row.scenario_outline.nil? if example_row.respond_to? :scenario_outline
return true if example_row.instance_of? Cucumber::Formatter::LegacyApi::Ast::DataTableRow
false
end
def step_belongs_to_outline?(step)
scenario = step.instance_variable_get "@feature_element"
not scenario.nil?
end
def build_scenario_outline_steps(example_row)
si = example_row.cells
si.each do |row|
duration = Time.now - @step_timer
report_step = ReportStep.new(@before_example_row, example_row)
report_step.duration = duration
@report.add_step report_step
# process_step(row, row.status)
end
end
def step_error(exception)
return nil if exception.nil?
exception.backtrace[-1] =~ /^#{step.file_colon_line}/ ? exception : nil
end
def populate_cells(example_row)
@cells ||= []
values = []
example_row.to_a.each do |cell|
values << cell.value
end
@cells << values
end
def separator
File::ALT_SEPARATOR || File::SEPARATOR
end
end
end
end
| 31.111111 | 153 | 0.643527 |
e99a245e41e73b579b56c2d31ef2f63561c8c0c1 | 107 | require 'rails_i18n/common_pluralizations/one_other'
::RailsI18n::Pluralization::OneOther.with_locale(:sw) | 35.666667 | 53 | 0.841121 |
b9671884ab478be44ef2a38979b13275084828cf | 481 | module FeaturesHelper
def ensure_on(path)
visit(path) unless current_path == path
end
def verify(call)
expect(call).to be_truthy
end
def refute(call)
expect(call).to be_falsey
end
def dom_id_for(model)
ActionView::RecordIdentifier.dom_id(model)
end
def dom_id_selector(model)
"##{dom_id_for(model)}"
end
def pagination_params(options = {})
{
page: 1,
per_page: 20,
total_count: 0,
}.merge(options)
end
end
| 16.033333 | 46 | 0.654886 |
e9351cf1ee6805be86668d3612126d3637f8357e | 383 | cask "font-digital-numbers" do
version :latest
sha256 :no_check
# github.com/google/fonts/ was verified as official when first introduced to the cask
url "https://github.com/google/fonts/raw/master/ofl/digitalnumbers/DigitalNumbers-Regular.ttf"
name "Digital Numbers"
homepage "https://fonts.google.com/specimen/Digital+Numbers"
font "DigitalNumbers-Regular.ttf"
end
| 31.916667 | 96 | 0.772846 |
266991b180443c71dea6b3c64c407b495c8c74de | 701 | # Read about factories at https://github.com/thoughtbot/factory_girl
FactoryGirl.define do
factory :team_question_bet, class: QuestionBet do
answer '42'
association :bet, factory: :bet, strategy: :build
association :question, factory: :team_question, strategy: :build
end
factory :player_question_bet, class: QuestionBet do
answer '42'
association :bet, factory: :bet, strategy: :build
association :question, factory: :player_question, strategy: :build
end
factory :boolean_question_bet, class: QuestionBet do
answer 'true'
association :bet, factory: :bet, strategy: :build
association :question, factory: :boolean_question, strategy: :build
end
end
| 31.863636 | 71 | 0.736091 |
21f3c2f09c9a93cafe221c57061ce15054eae4ae | 7,589 | =begin
#Adobe Experience Manager (AEM) API
#Swagger AEM is an OpenAPI specification for Adobe Experience Manager (AEM) API
The version of the OpenAPI document: 3.2.0
Contact: [email protected]
Generated by: https://openapi-generator.tech
OpenAPI Generator version: 4.3.1-SNAPSHOT
=end
require 'date'
module SwaggerAemClient
class SamlConfigurationPropertyItemsString
# property name
attr_accessor :name
# True if optional
attr_accessor :optional
# True if property is set
attr_accessor :is_set
# Property type, 1=String, 3=long, 11=boolean, 12=Password
attr_accessor :type
# Property value
attr_accessor :value
# Property description
attr_accessor :description
# Attribute mapping from ruby-style variable name to JSON key.
def self.attribute_map
{
:'name' => :'name',
:'optional' => :'optional',
:'is_set' => :'is_set',
:'type' => :'type',
:'value' => :'value',
:'description' => :'description'
}
end
# Attribute type mapping.
def self.openapi_types
{
:'name' => :'String',
:'optional' => :'Boolean',
:'is_set' => :'Boolean',
:'type' => :'Integer',
:'value' => :'String',
:'description' => :'String'
}
end
# List of attributes with nullable: true
def self.openapi_nullable
Set.new([
])
end
# Initializes the object
# @param [Hash] attributes Model attributes in the form of hash
def initialize(attributes = {})
if (!attributes.is_a?(Hash))
fail ArgumentError, "The input argument (attributes) must be a hash in `SwaggerAemClient::SamlConfigurationPropertyItemsString` initialize method"
end
# check to see if the attribute exists and convert string to symbol for hash key
attributes = attributes.each_with_object({}) { |(k, v), h|
if (!self.class.attribute_map.key?(k.to_sym))
fail ArgumentError, "`#{k}` is not a valid attribute in `SwaggerAemClient::SamlConfigurationPropertyItemsString`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
end
h[k.to_sym] = v
}
if attributes.key?(:'name')
self.name = attributes[:'name']
end
if attributes.key?(:'optional')
self.optional = attributes[:'optional']
end
if attributes.key?(:'is_set')
self.is_set = attributes[:'is_set']
end
if attributes.key?(:'type')
self.type = attributes[:'type']
end
if attributes.key?(:'value')
self.value = attributes[:'value']
end
if attributes.key?(:'description')
self.description = attributes[:'description']
end
end
# Show invalid properties with the reasons. Usually used together with valid?
# @return Array for valid properties with the reasons
def list_invalid_properties
invalid_properties = Array.new
invalid_properties
end
# Check to see if the all the properties in the model are valid
# @return true if the model is valid
def valid?
true
end
# Checks equality by comparing each attribute.
# @param [Object] Object to be compared
def ==(o)
return true if self.equal?(o)
self.class == o.class &&
name == o.name &&
optional == o.optional &&
is_set == o.is_set &&
type == o.type &&
value == o.value &&
description == o.description
end
# @see the `==` method
# @param [Object] Object to be compared
def eql?(o)
self == o
end
# Calculates hash code according to all attributes.
# @return [Integer] Hash code
def hash
[name, optional, is_set, type, value, description].hash
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def self.build_from_hash(attributes)
new.build_from_hash(attributes)
end
# Builds the object from hash
# @param [Hash] attributes Model attributes in the form of hash
# @return [Object] Returns the model itself
def build_from_hash(attributes)
return nil unless attributes.is_a?(Hash)
self.class.openapi_types.each_pair do |key, type|
if type =~ /\AArray<(.*)>/i
# check to ensure the input is an array given that the attribute
# is documented as an array but the input is not
if attributes[self.class.attribute_map[key]].is_a?(Array)
self.send("#{key}=", attributes[self.class.attribute_map[key]].map { |v| _deserialize($1, v) })
end
elsif !attributes[self.class.attribute_map[key]].nil?
self.send("#{key}=", _deserialize(type, attributes[self.class.attribute_map[key]]))
end # or else data not found in attributes(hash), not an issue as the data can be optional
end
self
end
# Deserializes the data based on type
# @param string type Data type
# @param string value Value to be deserialized
# @return [Object] Deserialized data
def _deserialize(type, value)
case type.to_sym
when :DateTime
DateTime.parse(value)
when :Date
Date.parse(value)
when :String
value.to_s
when :Integer
value.to_i
when :Float
value.to_f
when :Boolean
if value.to_s =~ /\A(true|t|yes|y|1)\z/i
true
else
false
end
when :Object
# generic object (usually a Hash), return directly
value
when /\AArray<(?<inner_type>.+)>\z/
inner_type = Regexp.last_match[:inner_type]
value.map { |v| _deserialize(inner_type, v) }
when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
k_type = Regexp.last_match[:k_type]
v_type = Regexp.last_match[:v_type]
{}.tap do |hash|
value.each do |k, v|
hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
end
end
else # model
SwaggerAemClient.const_get(type).build_from_hash(value)
end
end
# Returns the string representation of the object
# @return [String] String presentation of the object
def to_s
to_hash.to_s
end
# to_body is an alias to to_hash (backward compatibility)
# @return [Hash] Returns the object in the form of hash
def to_body
to_hash
end
# Returns the object in the form of hash
# @return [Hash] Returns the object in the form of hash
def to_hash
hash = {}
self.class.attribute_map.each_pair do |attr, param|
value = self.send(attr)
if value.nil?
is_nullable = self.class.openapi_nullable.include?(attr)
next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
end
hash[param] = _to_hash(value)
end
hash
end
# Outputs non-array value in the form of hash
# For object, use to_hash. Otherwise, just return the value
# @param [Object] value Any valid value
# @return [Hash] Returns the value in the form of hash
def _to_hash(value)
if value.is_a?(Array)
value.compact.map { |v| _to_hash(v) }
elsif value.is_a?(Hash)
{}.tap do |hash|
value.each { |k, v| hash[k] = _to_hash(v) }
end
elsif value.respond_to? :to_hash
value.to_hash
else
value
end
end
end
end
| 29.414729 | 232 | 0.613783 |
26c50bca38e8cc9954471c76b725a4b4724446c0 | 1,834 | require 'test_helper'
class UsersControllerTest < ActionDispatch::IntegrationTest
def setup
@user = users(:michael)
@second_user = users(:archer)
end
test "should get new" do
get signup_path
assert_response :success
end
test "should redirect index when not logged in" do
get users_path
assert_redirected_to login_url
end
test "should redirect edit when not logged in" do
get edit_user_path(@user)
assert_not flash.empty?
assert_redirected_to login_url
end
test "should redirect update when not logged in" do
patch user_path(@user), params: { user: { name: @user.name,
email: @user.email } }
assert_not flash.empty?
assert_redirected_to login_url
end
test "should redirect edit when logged in as wrong user" do
log_in_as(@second_user)
get edit_user_path(@user)
assert flash.empty?
assert_redirected_to root_url
end
test "should redirect update when logged in as wrong user" do
log_in_as(@second_user)
patch user_path(@user), params: { user: { name: @user.name,
email: @user.email } }
assert flash.empty?
assert_redirected_to root_url
end
test "should redirect destroy when not logged in" do
assert_no_difference "User.count" do
delete user_path(@user)
end
assert_redirected_to login_url
end
test "should redirect destroy when logged in as non-admin" do
log_in_as(@second_user)
assert_no_difference "User.count" do
delete user_path(@user)
end
assert_redirected_to root_url
end
test "should redirect following when not logged in" do
get following_user_path(@user)
assert_redirected_to login_url
end
test "should redirect followers when not logged in" do
get followers_user_path(@user)
assert_redirected_to login_url
end
end
| 25.123288 | 63 | 0.715921 |
b96ef796e741845ab755f59cd155c0648e0cec16 | 591 | require File.dirname(__FILE__) + '/../test_helper'
class CoffeeStatusTest < Test::Unit::TestCase
def setup
@room = Tinder::Room.new(stub, 1, 'Test room')
@bot = Scout::Bot.new(@room)
@command = Scout::Commands::CoffeeStatus.new("ma", @bot, "coffeestatus", [])
end
def test_update_status
@command.stubs(:args).returns(["ya plz"])
@command.process
assert_not_nil @command.statuses["ma"]
end
def test_clear
test_update_status
@command.stubs(:args).returns(%w(clear))
@command.process
assert_equal Hash.new, @command.statuses
end
end | 25.695652 | 80 | 0.670051 |
8759e92e2ad024c59a981ffa4a371196957262f4 | 44 | require 'cocoapods-usource/command/usource'
| 22 | 43 | 0.840909 |
ed348ca67ae5cfd5da96c135acda8bbf34246839 | 170 | # frozen_string_literal: true
require "spec_helper"
RSpec.describe Code do
it "#foo returns :foo being passed 42" do
expect(subject.foo(42)).to eq :foo
end
end
| 17 | 43 | 0.723529 |
5daa8ffceb0ccc52d652c2dd35d1afcdbd07ada0 | 518 | require "test_helper"
require "generators/markerb/mailer/mailer_generator"
class GeneratorTest < Rails::Generators::TestCase
tests Markerb::Generators::MailerGenerator
destination File.expand_path("../tmp", __FILE__)
setup :prepare_destination
test "assert all views are properly created with given name" do
run_generator %w(notifier foo bar baz)
assert_file "app/views/notifier/foo.markerb"
assert_file "app/views/notifier/bar.markerb"
assert_file "app/views/notifier/baz.markerb"
end
end | 32.375 | 65 | 0.776062 |
1d8cf052e5fbc1a62fe80de219dbff735d1628b7 | 2,622 | describe Unidom::Shipment::Shipment, type: :model do
before :each do
end
after :each do
end
context do
model_attributes = {
sender_party_id: SecureRandom.uuid,
sender_party_type: 'Unidom::Shipment::SenderParty::Mock',
sender_agent_id: SecureRandom.uuid,
sender_agent_type: 'Unidom::Shipment::SenderAgent::Mock',
sender_location_id: SecureRandom.uuid,
sender_location_type: 'Unidom::Shipment::SenderLocation::Mock',
sender_contact_id: SecureRandom.uuid,
sender_contact_type: 'Unidom::Shipment::SenderContact::Mock',
receiver_party_id: SecureRandom.uuid,
receiver_party_type: 'Unidom::Shipment::ReceiverParty::Mock',
receiver_agent_id: SecureRandom.uuid,
receiver_agent_type: 'Unidom::Shipment::ReceiverAgent::Mock',
receiver_location_id: SecureRandom.uuid,
receiver_location_type: 'Unidom::Shipment::ReceiverLocation::Mock',
receiver_contact_id: SecureRandom.uuid,
receiver_contact_type: 'Unidom::Shipment::ReceiverContact::Mock',
conveyance_code: 'CSSP',
estimated_ready_on: Date.current+2.days,
estimated_shipped_on: Date.current+3.days,
estimated_arrived_on: Date.current+9.days,
last_cancellable_at: Time.now+2.days,
shipped_at: Time.now+3.days,
received_at: Time.now+9.days,
cancelled_at: nil,
estimated_amount: 1_000.00,
actual_amount: 1_050.00
}
it_behaves_like 'Unidom::Common::Concerns::ModelExtension', model_attributes
it_behaves_like 'validates numericality', model_attributes, :estimated_amount,
range: 0..1_000_000_000, minimum_inclusive: true, maximum_inclusive: true
it_behaves_like 'validates numericality', model_attributes, :actual_amount,
range: 0..1_000_000_000, minimum_inclusive: true, maximum_inclusive: true
shipment_item_1_attributes = {
shipped_id: SecureRandom.uuid,
shipped_type: 'Unidom::Shipment::Shipped::Mock',
ordinal: 1,
quantity: 10.00
}
shipment_item_2_attributes = {
shipped_id: SecureRandom.uuid,
shipped_type: 'Unidom::Shipment::Shipped::Mock',
ordinal: 2,
quantity: 20.00
}
it_behaves_like 'has_many', model_attributes, :items, Unidom::Shipment::ShipmentItem, [ shipment_item_1_attributes, shipment_item_2_attributes ]
it_behaves_like 'ProgneTapera::EnumCode', described_class.new(model_attributes), :conveyance, Unidom::Shipment::Conveyance
end
end
| 38.558824 | 148 | 0.683829 |
1177425a6a67a5ac0ef6c859a74836718e319dbe | 79 | Rails.application.routes.draw do
mount SwellBot::Engine => "/swell_bot"
end
| 15.8 | 40 | 0.746835 |
5d0a4a0aa1a875c48315604665e0970103d07945 | 2,262 | require 'alert_parser'
require 'faker'
require 'open-uri'
Dir[Pathname(__FILE__).dirname.join('shared/*.rb').to_s].each { |f| require f }
Dir["./spec/support/**/*.rb"].each {|f| require f }
# This file was generated by the `rspec --init` command. Conventionally, all
# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
# The generated `.rspec` file contains `--require spec_helper` which will cause
# this file to always be loaded, without a need to explicitly require it in any
# files.
#
# Given that it is always loaded, you are encouraged to keep this file as
# light-weight as possible. Requiring heavyweight dependencies from this file
# will add to the boot time of your test suite on EVERY test run, even for an
# individual file that may not need all of that loaded. Instead, consider making
# a separate helper file that requires the additional dependencies and performs
# the additional setup, and require it from the spec files that actually need
# it.
#
# The `.rspec` file also contains a few flags that are not defaults but that
# users commonly want.
#
# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
RSpec.configure do |config|
# rspec-expectations config goes here. You can use an alternate
# assertion/expectation library such as wrong or the stdlib/minitest
# assertions if you prefer.
config.expect_with :rspec do |expectations|
# This option will default to `true` in RSpec 4. It makes the `description`
# and `failure_message` of custom matchers include text for helper methods
# defined using `chain`, e.g.:
# be_bigger_than(2).and_smaller_than(4).description
# # => "be bigger than 2 and smaller than 4"
# ...rather than:
# # => "be bigger than 2"
expectations.include_chain_clauses_in_custom_matcher_descriptions = true
end
# rspec-mocks config goes here. You can use an alternate test double
# library (such as bogus or mocha) by changing the `mock_with` option here.
config.mock_with :rspec do |mocks|
# Prevents you from mocking or stubbing a method that does not exist on
# a real object. This is generally recommended, and will default to
# `true` in RSpec 4.
mocks.verify_partial_doubles = false
end
end
| 44.352941 | 80 | 0.733864 |
ed1c20e1641435554d027008e7c03b27243b1708 | 1,476 | # Copyright (c) 2021 Target Brands, Inc. All rights reserved.
#
# Use of this source code is governed by the LICENSE file in this repository.
class Vela < Formula
# repository information
head "https://github.com/go-vela/cli.git"
homepage 'https://github.com/go-vela/cli'
# utility information
version 'v0.10.2'
# macOS
on_macos do
if Hardware::CPU.arm?
url "#{homepage}/releases/download/#{version}/vela_darwin_arm64.tar.gz"
sha256 '29c93600dd09975c30e67bc6134627f206fd543b6d1edfc397e9af090a818870'
else
url "#{homepage}/releases/download/#{version}/vela_darwin_amd64.tar.gz"
sha256 '4c2d467769b61ed16e930c9ed036422a68e60cc5e406a112d9598f29036d42d1'
end
end
# linux
on_linux do
if Hardware::CPU.arm?
if Hardware::CPU.is_64_bit?
url "#{homepage}/releases/download/#{version}/vela_linux_arm64.tar.gz"
sha256 '5e793ec30155dbe29df3c6822018f6e812e243c219f0dc14371106044919eae4'
else
url "#{homepage}/releases/download/#{version}/vela_linux_arm.tar.gz"
sha256 '22d7a12b819a195f674b26d81fa4d415da0b63457fe0f4edb35b1a4523b07dd6'
end
else
url "#{homepage}/releases/download/#{version}/vela_linux_amd64.tar.gz"
sha256 '295b40efcf0dd3f602bd562734ea2657edbb4a1bd0a88a532bacab7e343a13ed'
end
end
# install information
def install
bin.install 'vela'
end
# test information
test do
system "#{bin}/vela", "--version"
end
end
| 29.52 | 81 | 0.72019 |
2198310da7d2ca3bff4e5e6d15b91681fa0ddfff | 3,876 | # frozen_string_literal: true
require 'rails/generators/active_record'
require 'generators/devise/orm_helpers'
module ActiveRecord
module Generators
class DeviseGenerator < ActiveRecord::Generators::Base
argument :attributes, type: :array, default: [], banner: "field:type field:type"
class_option :primary_key_type, type: :string, desc: "The type for primary key"
include Devise::Generators::OrmHelpers
source_root File.expand_path("../templates", __FILE__)
def copy_devise_migration
if (behavior == :invoke && model_exists?) || (behavior == :revoke && migration_exists?(table_name))
migration_template "migration_existing.rb", "#{migration_path}/add_devise_to_#{table_name}.rb", migration_version: migration_version
else
migration_template "migration.rb", "#{migration_path}/devise_create_#{table_name}.rb", migration_version: migration_version
end
end
def generate_model
invoke "active_record:model", [name], migration: false unless model_exists? && behavior == :invoke
end
def inject_devise_content
content = model_contents
class_path = if namespaced?
class_name.to_s.split("::")
else
[class_name]
end
indent_depth = class_path.size - 1
content = content.split("\n").map { |line| " " * indent_depth + line } .join("\n") << "\n"
inject_into_class(model_path, class_path.last, content) if model_exists?
end
def migration_data
<<RUBY
## Database authenticatable
t.string :email, null: false, default: ""
t.string :encrypted_password, null: false, default: ""
## Recoverable
t.string :reset_password_token
t.datetime :reset_password_sent_at
## Rememberable
t.datetime :remember_created_at
## Trackable
# t.integer :sign_in_count, default: 0, null: false
# t.datetime :current_sign_in_at
# t.datetime :last_sign_in_at
# t.#{ip_column} :current_sign_in_ip
# t.#{ip_column} :last_sign_in_ip
## Confirmable
# t.string :confirmation_token
# t.datetime :confirmed_at
# t.datetime :confirmation_sent_at
# t.string :unconfirmed_email # Only if using reconfirmable
## Lockable
# t.integer :failed_attempts, default: 0, null: false # Only if lock strategy is :failed_attempts
# t.string :unlock_token # Only if unlock strategy is :email or :both
# t.datetime :locked_at
RUBY
end
def ip_column
# Padded with spaces so it aligns nicely with the rest of the columns.
"%-8s" % (inet? ? "inet" : "string")
end
def inet?
postgresql?
end
def rails5_and_up?
Rails::VERSION::MAJOR >= 5
end
def rails61_and_up?
Rails::VERSION::MAJOR > 6 || (Rails::VERSION::MAJOR == 6 && Rails::VERSION::MINOR >= 1)
end
def postgresql?
ar_config && ar_config['adapter'] == 'postgresql'
end
def ar_config
if ActiveRecord::Base.configurations.respond_to?(:configs_for)
if rails61_and_up?
ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, name: "primary").configuration_hash
else
ActiveRecord::Base.configurations.configs_for(env_name: Rails.env, spec_name: "primary").config
end
else
ActiveRecord::Base.configurations[Rails.env]
end
end
def migration_version
if rails5_and_up?
"[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
end
end
def primary_key_type
primary_key_string if rails5_and_up?
end
def primary_key_string
key_string = options[:primary_key_type]
", id: :#{key_string}" if key_string
end
end
end
end
| 30.761905 | 142 | 0.640093 |
1ae39c9af549db632c35d3c1ae956b08723326d5 | 1,502 | # app/models/mismo_enum/project_legal_structure_type.rb
# enum
class MismoEnum::ProjectLegalStructureType < MismoEnum::Base
validates_presence_of :name
validates_uniqueness_of :name
def self.description
'Specifies the form of ownership that defines the quality and quantity of'+
' ownership and rights to the individual unit owner.'
end
def self.seed
[[1, 'Condominium', 'A project that is legally formed as a condominium '+
'under the Condominium-Enabling Legislation of the state in which the'+
' project is located.'],
[2, 'Cooperative', 'A project in which a corporation or business trust '+
'holds title to the property and issues shares of stock as evidence '+
'of ownership in the corporation or business trust. The corporation or'+
' business trust grants occupancy rights to the shareholder tenants '+
'through proprietary leases. '],
[3, 'CommonInterestApartment', 'Any project or building that is owned by '+
'several owners as tenants in common or by a home owners association '+
'in which individuals have an undivided interest in a residential '+
'apartment building and land, and are the rights of exclusive '+
'occupancy of a specific apartment in the building.'],
[4, 'Unknown', '']
].each { |id, entry, desc| create(id: id,
name: entry,
description: desc) }
end
end
| 45.515152 | 80 | 0.659121 |
5dde8d38e3e564f3f5f87b0f8fdfbb838c6f66c8 | 342 | class CreateServiceManagers < ActiveRecord::Migration[6.1]
def change
create_table :service_managers do |t|
t.references :service, null: false, foreign_key: true
t.string :name
t.string :identify
t.integer :update_count
t.string :created_by
t.string :updated_by
t.timestamps
end
end
end
| 22.8 | 59 | 0.675439 |
4a83198c7bd3d032f1ed98c55015404048153653 | 90,048 | # frozen_string_literal: true
# WARNING ABOUT GENERATED CODE
#
# This file is generated. See the contributing guide for more information:
# https://github.com/aws/aws-sdk-ruby/blob/master/CONTRIBUTING.md
#
# WARNING ABOUT GENERATED CODE
require 'seahorse/client/plugins/content_length.rb'
require 'aws-sdk-core/plugins/credentials_configuration.rb'
require 'aws-sdk-core/plugins/logging.rb'
require 'aws-sdk-core/plugins/param_converter.rb'
require 'aws-sdk-core/plugins/param_validator.rb'
require 'aws-sdk-core/plugins/user_agent.rb'
require 'aws-sdk-core/plugins/helpful_socket_errors.rb'
require 'aws-sdk-core/plugins/retry_errors.rb'
require 'aws-sdk-core/plugins/global_configuration.rb'
require 'aws-sdk-core/plugins/regional_endpoint.rb'
require 'aws-sdk-core/plugins/endpoint_discovery.rb'
require 'aws-sdk-core/plugins/endpoint_pattern.rb'
require 'aws-sdk-core/plugins/response_paging.rb'
require 'aws-sdk-core/plugins/stub_responses.rb'
require 'aws-sdk-core/plugins/idempotency_token.rb'
require 'aws-sdk-core/plugins/jsonvalue_converter.rb'
require 'aws-sdk-core/plugins/client_metrics_plugin.rb'
require 'aws-sdk-core/plugins/client_metrics_send_plugin.rb'
require 'aws-sdk-core/plugins/transfer_encoding.rb'
require 'aws-sdk-core/plugins/http_checksum.rb'
require 'aws-sdk-core/plugins/signature_v4.rb'
require 'aws-sdk-core/plugins/protocols/rest_json.rb'
Aws::Plugins::GlobalConfiguration.add_identifier(:mediapackage)
module Aws::MediaPackage
# An API client for MediaPackage. To construct a client, you need to configure a `:region` and `:credentials`.
#
# client = Aws::MediaPackage::Client.new(
# region: region_name,
# credentials: credentials,
# # ...
# )
#
# For details on configuring region and credentials see
# the [developer guide](/sdk-for-ruby/v3/developer-guide/setup-config.html).
#
# See {#initialize} for a full list of supported configuration options.
class Client < Seahorse::Client::Base
include Aws::ClientStubs
@identifier = :mediapackage
set_api(ClientApi::API)
add_plugin(Seahorse::Client::Plugins::ContentLength)
add_plugin(Aws::Plugins::CredentialsConfiguration)
add_plugin(Aws::Plugins::Logging)
add_plugin(Aws::Plugins::ParamConverter)
add_plugin(Aws::Plugins::ParamValidator)
add_plugin(Aws::Plugins::UserAgent)
add_plugin(Aws::Plugins::HelpfulSocketErrors)
add_plugin(Aws::Plugins::RetryErrors)
add_plugin(Aws::Plugins::GlobalConfiguration)
add_plugin(Aws::Plugins::RegionalEndpoint)
add_plugin(Aws::Plugins::EndpointDiscovery)
add_plugin(Aws::Plugins::EndpointPattern)
add_plugin(Aws::Plugins::ResponsePaging)
add_plugin(Aws::Plugins::StubResponses)
add_plugin(Aws::Plugins::IdempotencyToken)
add_plugin(Aws::Plugins::JsonvalueConverter)
add_plugin(Aws::Plugins::ClientMetricsPlugin)
add_plugin(Aws::Plugins::ClientMetricsSendPlugin)
add_plugin(Aws::Plugins::TransferEncoding)
add_plugin(Aws::Plugins::HttpChecksum)
add_plugin(Aws::Plugins::SignatureV4)
add_plugin(Aws::Plugins::Protocols::RestJson)
# @overload initialize(options)
# @param [Hash] options
# @option options [required, Aws::CredentialProvider] :credentials
# Your AWS credentials. This can be an instance of any one of the
# following classes:
#
# * `Aws::Credentials` - Used for configuring static, non-refreshing
# credentials.
#
# * `Aws::InstanceProfileCredentials` - Used for loading credentials
# from an EC2 IMDS on an EC2 instance.
#
# * `Aws::SharedCredentials` - Used for loading credentials from a
# shared file, such as `~/.aws/config`.
#
# * `Aws::AssumeRoleCredentials` - Used when you need to assume a role.
#
# When `:credentials` are not configured directly, the following
# locations will be searched for credentials:
#
# * `Aws.config[:credentials]`
# * The `:access_key_id`, `:secret_access_key`, and `:session_token` options.
# * ENV['AWS_ACCESS_KEY_ID'], ENV['AWS_SECRET_ACCESS_KEY']
# * `~/.aws/credentials`
# * `~/.aws/config`
# * EC2 IMDS instance profile - When used by default, the timeouts are
# very aggressive. Construct and pass an instance of
# `Aws::InstanceProfileCredentails` to enable retries and extended
# timeouts.
#
# @option options [required, String] :region
# The AWS region to connect to. The configured `:region` is
# used to determine the service `:endpoint`. When not passed,
# a default `:region` is searched for in the following locations:
#
# * `Aws.config[:region]`
# * `ENV['AWS_REGION']`
# * `ENV['AMAZON_REGION']`
# * `ENV['AWS_DEFAULT_REGION']`
# * `~/.aws/credentials`
# * `~/.aws/config`
#
# @option options [String] :access_key_id
#
# @option options [Boolean] :active_endpoint_cache (false)
# When set to `true`, a thread polling for endpoints will be running in
# the background every 60 secs (default). Defaults to `false`.
#
# @option options [Boolean] :adaptive_retry_wait_to_fill (true)
# Used only in `adaptive` retry mode. When true, the request will sleep
# until there is sufficent client side capacity to retry the request.
# When false, the request will raise a `RetryCapacityNotAvailableError` and will
# not retry instead of sleeping.
#
# @option options [Boolean] :client_side_monitoring (false)
# When `true`, client-side metrics will be collected for all API requests from
# this client.
#
# @option options [String] :client_side_monitoring_client_id ("")
# Allows you to provide an identifier for this client which will be attached to
# all generated client side metrics. Defaults to an empty string.
#
# @option options [String] :client_side_monitoring_host ("127.0.0.1")
# Allows you to specify the DNS hostname or IPv4 or IPv6 address that the client
# side monitoring agent is running on, where client metrics will be published via UDP.
#
# @option options [Integer] :client_side_monitoring_port (31000)
# Required for publishing client metrics. The port that the client side monitoring
# agent is running on, where client metrics will be published via UDP.
#
# @option options [Aws::ClientSideMonitoring::Publisher] :client_side_monitoring_publisher (Aws::ClientSideMonitoring::Publisher)
# Allows you to provide a custom client-side monitoring publisher class. By default,
# will use the Client Side Monitoring Agent Publisher.
#
# @option options [Boolean] :convert_params (true)
# When `true`, an attempt is made to coerce request parameters into
# the required types.
#
# @option options [Boolean] :correct_clock_skew (true)
# Used only in `standard` and adaptive retry modes. Specifies whether to apply
# a clock skew correction and retry requests with skewed client clocks.
#
# @option options [Boolean] :disable_host_prefix_injection (false)
# Set to true to disable SDK automatically adding host prefix
# to default service endpoint when available.
#
# @option options [String] :endpoint
# The client endpoint is normally constructed from the `:region`
# option. You should only configure an `:endpoint` when connecting
# to test or custom endpoints. This should be a valid HTTP(S) URI.
#
# @option options [Integer] :endpoint_cache_max_entries (1000)
# Used for the maximum size limit of the LRU cache storing endpoints data
# for endpoint discovery enabled operations. Defaults to 1000.
#
# @option options [Integer] :endpoint_cache_max_threads (10)
# Used for the maximum threads in use for polling endpoints to be cached, defaults to 10.
#
# @option options [Integer] :endpoint_cache_poll_interval (60)
# When :endpoint_discovery and :active_endpoint_cache is enabled,
# Use this option to config the time interval in seconds for making
# requests fetching endpoints information. Defaults to 60 sec.
#
# @option options [Boolean] :endpoint_discovery (false)
# When set to `true`, endpoint discovery will be enabled for operations when available.
#
# @option options [Aws::Log::Formatter] :log_formatter (Aws::Log::Formatter.default)
# The log formatter.
#
# @option options [Symbol] :log_level (:info)
# The log level to send messages to the `:logger` at.
#
# @option options [Logger] :logger
# The Logger instance to send log messages to. If this option
# is not set, logging will be disabled.
#
# @option options [Integer] :max_attempts (3)
# An integer representing the maximum number attempts that will be made for
# a single request, including the initial attempt. For example,
# setting this value to 5 will result in a request being retried up to
# 4 times. Used in `standard` and `adaptive` retry modes.
#
# @option options [String] :profile ("default")
# Used when loading credentials from the shared credentials file
# at HOME/.aws/credentials. When not specified, 'default' is used.
#
# @option options [Proc] :retry_backoff
# A proc or lambda used for backoff. Defaults to 2**retries * retry_base_delay.
# This option is only used in the `legacy` retry mode.
#
# @option options [Float] :retry_base_delay (0.3)
# The base delay in seconds used by the default backoff function. This option
# is only used in the `legacy` retry mode.
#
# @option options [Symbol] :retry_jitter (:none)
# A delay randomiser function used by the default backoff function.
# Some predefined functions can be referenced by name - :none, :equal, :full,
# otherwise a Proc that takes and returns a number. This option is only used
# in the `legacy` retry mode.
#
# @see https://www.awsarchitectureblog.com/2015/03/backoff.html
#
# @option options [Integer] :retry_limit (3)
# The maximum number of times to retry failed requests. Only
# ~ 500 level server errors and certain ~ 400 level client errors
# are retried. Generally, these are throttling errors, data
# checksum errors, networking errors, timeout errors, auth errors,
# endpoint discovery, and errors from expired credentials.
# This option is only used in the `legacy` retry mode.
#
# @option options [Integer] :retry_max_delay (0)
# The maximum number of seconds to delay between retries (0 for no limit)
# used by the default backoff function. This option is only used in the
# `legacy` retry mode.
#
# @option options [String] :retry_mode ("legacy")
# Specifies which retry algorithm to use. Values are:
#
# * `legacy` - The pre-existing retry behavior. This is default value if
# no retry mode is provided.
#
# * `standard` - A standardized set of retry rules across the AWS SDKs.
# This includes support for retry quotas, which limit the number of
# unsuccessful retries a client can make.
#
# * `adaptive` - An experimental retry mode that includes all the
# functionality of `standard` mode along with automatic client side
# throttling. This is a provisional mode that may change behavior
# in the future.
#
#
# @option options [String] :secret_access_key
#
# @option options [String] :session_token
#
# @option options [Boolean] :stub_responses (false)
# Causes the client to return stubbed responses. By default
# fake responses are generated and returned. You can specify
# the response data to return or errors to raise by calling
# {ClientStubs#stub_responses}. See {ClientStubs} for more information.
#
# ** Please note ** When response stubbing is enabled, no HTTP
# requests are made, and retries are disabled.
#
# @option options [Boolean] :validate_params (true)
# When `true`, request parameters are validated before
# sending the request.
#
# @option options [URI::HTTP,String] :http_proxy A proxy to send
# requests through. Formatted like 'http://proxy.com:123'.
#
# @option options [Float] :http_open_timeout (15) The number of
# seconds to wait when opening a HTTP session before raising a
# `Timeout::Error`.
#
# @option options [Integer] :http_read_timeout (60) The default
# number of seconds to wait for response data. This value can
# safely be set per-request on the session.
#
# @option options [Float] :http_idle_timeout (5) The number of
# seconds a connection is allowed to sit idle before it is
# considered stale. Stale connections are closed and removed
# from the pool before making a request.
#
# @option options [Float] :http_continue_timeout (1) The number of
# seconds to wait for a 100-continue response before sending the
# request body. This option has no effect unless the request has
# "Expect" header set to "100-continue". Defaults to `nil` which
# disables this behaviour. This value can safely be set per
# request on the session.
#
# @option options [Boolean] :http_wire_trace (false) When `true`,
# HTTP debug output will be sent to the `:logger`.
#
# @option options [Boolean] :ssl_verify_peer (true) When `true`,
# SSL peer certificates are verified when establishing a
# connection.
#
# @option options [String] :ssl_ca_bundle Full path to the SSL
# certificate authority bundle file that should be used when
# verifying peer certificates. If you do not pass
# `:ssl_ca_bundle` or `:ssl_ca_directory` the the system default
# will be used if available.
#
# @option options [String] :ssl_ca_directory Full path of the
# directory that contains the unbundled SSL certificate
# authority files for verifying peer certificates. If you do
# not pass `:ssl_ca_bundle` or `:ssl_ca_directory` the the
# system default will be used if available.
#
def initialize(*args)
super
end
# @!group API Operations
# Creates a new Channel.
#
# @option params [String] :description
#
# @option params [required, String] :id
#
# @option params [Hash<String,String>] :tags
# A collection of tags associated with a resource
#
# @return [Types::CreateChannelResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::CreateChannelResponse#arn #arn} => String
# * {Types::CreateChannelResponse#description #description} => String
# * {Types::CreateChannelResponse#hls_ingest #hls_ingest} => Types::HlsIngest
# * {Types::CreateChannelResponse#id #id} => String
# * {Types::CreateChannelResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.create_channel({
# description: "__string",
# id: "__string", # required
# tags: {
# "__string" => "__string",
# },
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.description #=> String
# resp.hls_ingest.ingest_endpoints #=> Array
# resp.hls_ingest.ingest_endpoints[0].id #=> String
# resp.hls_ingest.ingest_endpoints[0].password #=> String
# resp.hls_ingest.ingest_endpoints[0].url #=> String
# resp.hls_ingest.ingest_endpoints[0].username #=> String
# resp.id #=> String
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/CreateChannel AWS API Documentation
#
# @overload create_channel(params = {})
# @param [Hash] params ({})
def create_channel(params = {}, options = {})
req = build_request(:create_channel, params)
req.send_request(options)
end
# Creates a new HarvestJob record.
#
# @option params [required, String] :end_time
#
# @option params [required, String] :id
#
# @option params [required, String] :origin_endpoint_id
#
# @option params [required, Types::S3Destination] :s3_destination
# Configuration parameters for where in an S3 bucket to place the
# harvested content
#
# @option params [required, String] :start_time
#
# @return [Types::CreateHarvestJobResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::CreateHarvestJobResponse#arn #arn} => String
# * {Types::CreateHarvestJobResponse#channel_id #channel_id} => String
# * {Types::CreateHarvestJobResponse#created_at #created_at} => String
# * {Types::CreateHarvestJobResponse#end_time #end_time} => String
# * {Types::CreateHarvestJobResponse#id #id} => String
# * {Types::CreateHarvestJobResponse#origin_endpoint_id #origin_endpoint_id} => String
# * {Types::CreateHarvestJobResponse#s3_destination #s3_destination} => Types::S3Destination
# * {Types::CreateHarvestJobResponse#start_time #start_time} => String
# * {Types::CreateHarvestJobResponse#status #status} => String
#
# @example Request syntax with placeholder values
#
# resp = client.create_harvest_job({
# end_time: "__string", # required
# id: "__string", # required
# origin_endpoint_id: "__string", # required
# s3_destination: { # required
# bucket_name: "__string", # required
# manifest_key: "__string", # required
# role_arn: "__string", # required
# },
# start_time: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.channel_id #=> String
# resp.created_at #=> String
# resp.end_time #=> String
# resp.id #=> String
# resp.origin_endpoint_id #=> String
# resp.s3_destination.bucket_name #=> String
# resp.s3_destination.manifest_key #=> String
# resp.s3_destination.role_arn #=> String
# resp.start_time #=> String
# resp.status #=> String, one of "IN_PROGRESS", "SUCCEEDED", "FAILED"
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/CreateHarvestJob AWS API Documentation
#
# @overload create_harvest_job(params = {})
# @param [Hash] params ({})
def create_harvest_job(params = {}, options = {})
req = build_request(:create_harvest_job, params)
req.send_request(options)
end
# Creates a new OriginEndpoint record.
#
# @option params [Types::Authorization] :authorization
# CDN Authorization credentials
#
# @option params [required, String] :channel_id
#
# @option params [Types::CmafPackageCreateOrUpdateParameters] :cmaf_package
# A Common Media Application Format (CMAF) packaging configuration.
#
# @option params [Types::DashPackage] :dash_package
# A Dynamic Adaptive Streaming over HTTP (DASH) packaging configuration.
#
# @option params [String] :description
#
# @option params [Types::HlsPackage] :hls_package
# An HTTP Live Streaming (HLS) packaging configuration.
#
# @option params [required, String] :id
#
# @option params [String] :manifest_name
#
# @option params [Types::MssPackage] :mss_package
# A Microsoft Smooth Streaming (MSS) packaging configuration.
#
# @option params [String] :origination
#
# @option params [Integer] :startover_window_seconds
#
# @option params [Hash<String,String>] :tags
# A collection of tags associated with a resource
#
# @option params [Integer] :time_delay_seconds
#
# @option params [Array<String>] :whitelist
#
# @return [Types::CreateOriginEndpointResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::CreateOriginEndpointResponse#arn #arn} => String
# * {Types::CreateOriginEndpointResponse#authorization #authorization} => Types::Authorization
# * {Types::CreateOriginEndpointResponse#channel_id #channel_id} => String
# * {Types::CreateOriginEndpointResponse#cmaf_package #cmaf_package} => Types::CmafPackage
# * {Types::CreateOriginEndpointResponse#dash_package #dash_package} => Types::DashPackage
# * {Types::CreateOriginEndpointResponse#description #description} => String
# * {Types::CreateOriginEndpointResponse#hls_package #hls_package} => Types::HlsPackage
# * {Types::CreateOriginEndpointResponse#id #id} => String
# * {Types::CreateOriginEndpointResponse#manifest_name #manifest_name} => String
# * {Types::CreateOriginEndpointResponse#mss_package #mss_package} => Types::MssPackage
# * {Types::CreateOriginEndpointResponse#origination #origination} => String
# * {Types::CreateOriginEndpointResponse#startover_window_seconds #startover_window_seconds} => Integer
# * {Types::CreateOriginEndpointResponse#tags #tags} => Hash<String,String>
# * {Types::CreateOriginEndpointResponse#time_delay_seconds #time_delay_seconds} => Integer
# * {Types::CreateOriginEndpointResponse#url #url} => String
# * {Types::CreateOriginEndpointResponse#whitelist #whitelist} => Array<String>
#
# @example Request syntax with placeholder values
#
# resp = client.create_origin_endpoint({
# authorization: {
# cdn_identifier_secret: "__string", # required
# secrets_role_arn: "__string", # required
# },
# channel_id: "__string", # required
# cmaf_package: {
# encryption: {
# key_rotation_interval_seconds: 1,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# hls_manifests: [
# {
# ad_markers: "NONE", # accepts NONE, SCTE35_ENHANCED, PASSTHROUGH, DATERANGE
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# id: "__string", # required
# include_iframe_only_stream: false,
# manifest_name: "__string",
# playlist_type: "NONE", # accepts NONE, EVENT, VOD
# playlist_window_seconds: 1,
# program_date_time_interval_seconds: 1,
# },
# ],
# segment_duration_seconds: 1,
# segment_prefix: "__string",
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# },
# dash_package: {
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# encryption: {
# key_rotation_interval_seconds: 1,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# manifest_layout: "FULL", # accepts FULL, COMPACT
# manifest_window_seconds: 1,
# min_buffer_time_seconds: 1,
# min_update_period_seconds: 1,
# period_triggers: ["ADS"], # accepts ADS
# profile: "NONE", # accepts NONE, HBBTV_1_5
# segment_duration_seconds: 1,
# segment_template_format: "NUMBER_WITH_TIMELINE", # accepts NUMBER_WITH_TIMELINE, TIME_WITH_TIMELINE, NUMBER_WITH_DURATION
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# suggested_presentation_delay_seconds: 1,
# },
# description: "__string",
# hls_package: {
# ad_markers: "NONE", # accepts NONE, SCTE35_ENHANCED, PASSTHROUGH, DATERANGE
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# encryption: {
# constant_initialization_vector: "__string",
# encryption_method: "AES_128", # accepts AES_128, SAMPLE_AES
# key_rotation_interval_seconds: 1,
# repeat_ext_x_key: false,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# include_iframe_only_stream: false,
# playlist_type: "NONE", # accepts NONE, EVENT, VOD
# playlist_window_seconds: 1,
# program_date_time_interval_seconds: 1,
# segment_duration_seconds: 1,
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# use_audio_rendition_group: false,
# },
# id: "__string", # required
# manifest_name: "__string",
# mss_package: {
# encryption: {
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# manifest_window_seconds: 1,
# segment_duration_seconds: 1,
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# },
# origination: "ALLOW", # accepts ALLOW, DENY
# startover_window_seconds: 1,
# tags: {
# "__string" => "__string",
# },
# time_delay_seconds: 1,
# whitelist: ["__string"],
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.authorization.cdn_identifier_secret #=> String
# resp.authorization.secrets_role_arn #=> String
# resp.channel_id #=> String
# resp.cmaf_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.cmaf_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.resource_id #=> String
# resp.cmaf_package.encryption.speke_key_provider.role_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.system_ids #=> Array
# resp.cmaf_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.cmaf_package.encryption.speke_key_provider.url #=> String
# resp.cmaf_package.hls_manifests #=> Array
# resp.cmaf_package.hls_manifests[0].ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.cmaf_package.hls_manifests[0].id #=> String
# resp.cmaf_package.hls_manifests[0].include_iframe_only_stream #=> Boolean
# resp.cmaf_package.hls_manifests[0].manifest_name #=> String
# resp.cmaf_package.hls_manifests[0].playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.cmaf_package.hls_manifests[0].playlist_window_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].program_date_time_interval_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].url #=> String
# resp.cmaf_package.segment_duration_seconds #=> Integer
# resp.cmaf_package.segment_prefix #=> String
# resp.cmaf_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.ad_triggers #=> Array
# resp.dash_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.dash_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.dash_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.dash_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.dash_package.encryption.speke_key_provider.resource_id #=> String
# resp.dash_package.encryption.speke_key_provider.role_arn #=> String
# resp.dash_package.encryption.speke_key_provider.system_ids #=> Array
# resp.dash_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.dash_package.encryption.speke_key_provider.url #=> String
# resp.dash_package.manifest_layout #=> String, one of "FULL", "COMPACT"
# resp.dash_package.manifest_window_seconds #=> Integer
# resp.dash_package.min_buffer_time_seconds #=> Integer
# resp.dash_package.min_update_period_seconds #=> Integer
# resp.dash_package.period_triggers #=> Array
# resp.dash_package.period_triggers[0] #=> String, one of "ADS"
# resp.dash_package.profile #=> String, one of "NONE", "HBBTV_1_5"
# resp.dash_package.segment_duration_seconds #=> Integer
# resp.dash_package.segment_template_format #=> String, one of "NUMBER_WITH_TIMELINE", "TIME_WITH_TIMELINE", "NUMBER_WITH_DURATION"
# resp.dash_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.suggested_presentation_delay_seconds #=> Integer
# resp.description #=> String
# resp.hls_package.ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.hls_package.ad_triggers #=> Array
# resp.hls_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.hls_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.hls_package.encryption.constant_initialization_vector #=> String
# resp.hls_package.encryption.encryption_method #=> String, one of "AES_128", "SAMPLE_AES"
# resp.hls_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.hls_package.encryption.repeat_ext_x_key #=> Boolean
# resp.hls_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.hls_package.encryption.speke_key_provider.resource_id #=> String
# resp.hls_package.encryption.speke_key_provider.role_arn #=> String
# resp.hls_package.encryption.speke_key_provider.system_ids #=> Array
# resp.hls_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.hls_package.encryption.speke_key_provider.url #=> String
# resp.hls_package.include_iframe_only_stream #=> Boolean
# resp.hls_package.playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.hls_package.playlist_window_seconds #=> Integer
# resp.hls_package.program_date_time_interval_seconds #=> Integer
# resp.hls_package.segment_duration_seconds #=> Integer
# resp.hls_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.hls_package.use_audio_rendition_group #=> Boolean
# resp.id #=> String
# resp.manifest_name #=> String
# resp.mss_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.mss_package.encryption.speke_key_provider.resource_id #=> String
# resp.mss_package.encryption.speke_key_provider.role_arn #=> String
# resp.mss_package.encryption.speke_key_provider.system_ids #=> Array
# resp.mss_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.mss_package.encryption.speke_key_provider.url #=> String
# resp.mss_package.manifest_window_seconds #=> Integer
# resp.mss_package.segment_duration_seconds #=> Integer
# resp.mss_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origination #=> String, one of "ALLOW", "DENY"
# resp.startover_window_seconds #=> Integer
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
# resp.time_delay_seconds #=> Integer
# resp.url #=> String
# resp.whitelist #=> Array
# resp.whitelist[0] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/CreateOriginEndpoint AWS API Documentation
#
# @overload create_origin_endpoint(params = {})
# @param [Hash] params ({})
def create_origin_endpoint(params = {}, options = {})
req = build_request(:create_origin_endpoint, params)
req.send_request(options)
end
# Deletes an existing Channel.
#
# @option params [required, String] :id
#
# @return [Struct] Returns an empty {Seahorse::Client::Response response}.
#
# @example Request syntax with placeholder values
#
# resp = client.delete_channel({
# id: "__string", # required
# })
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/DeleteChannel AWS API Documentation
#
# @overload delete_channel(params = {})
# @param [Hash] params ({})
def delete_channel(params = {}, options = {})
req = build_request(:delete_channel, params)
req.send_request(options)
end
# Deletes an existing OriginEndpoint.
#
# @option params [required, String] :id
#
# @return [Struct] Returns an empty {Seahorse::Client::Response response}.
#
# @example Request syntax with placeholder values
#
# resp = client.delete_origin_endpoint({
# id: "__string", # required
# })
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/DeleteOriginEndpoint AWS API Documentation
#
# @overload delete_origin_endpoint(params = {})
# @param [Hash] params ({})
def delete_origin_endpoint(params = {}, options = {})
req = build_request(:delete_origin_endpoint, params)
req.send_request(options)
end
# Gets details about a Channel.
#
# @option params [required, String] :id
#
# @return [Types::DescribeChannelResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::DescribeChannelResponse#arn #arn} => String
# * {Types::DescribeChannelResponse#description #description} => String
# * {Types::DescribeChannelResponse#hls_ingest #hls_ingest} => Types::HlsIngest
# * {Types::DescribeChannelResponse#id #id} => String
# * {Types::DescribeChannelResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.describe_channel({
# id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.description #=> String
# resp.hls_ingest.ingest_endpoints #=> Array
# resp.hls_ingest.ingest_endpoints[0].id #=> String
# resp.hls_ingest.ingest_endpoints[0].password #=> String
# resp.hls_ingest.ingest_endpoints[0].url #=> String
# resp.hls_ingest.ingest_endpoints[0].username #=> String
# resp.id #=> String
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/DescribeChannel AWS API Documentation
#
# @overload describe_channel(params = {})
# @param [Hash] params ({})
def describe_channel(params = {}, options = {})
req = build_request(:describe_channel, params)
req.send_request(options)
end
# Gets details about an existing HarvestJob.
#
# @option params [required, String] :id
#
# @return [Types::DescribeHarvestJobResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::DescribeHarvestJobResponse#arn #arn} => String
# * {Types::DescribeHarvestJobResponse#channel_id #channel_id} => String
# * {Types::DescribeHarvestJobResponse#created_at #created_at} => String
# * {Types::DescribeHarvestJobResponse#end_time #end_time} => String
# * {Types::DescribeHarvestJobResponse#id #id} => String
# * {Types::DescribeHarvestJobResponse#origin_endpoint_id #origin_endpoint_id} => String
# * {Types::DescribeHarvestJobResponse#s3_destination #s3_destination} => Types::S3Destination
# * {Types::DescribeHarvestJobResponse#start_time #start_time} => String
# * {Types::DescribeHarvestJobResponse#status #status} => String
#
# @example Request syntax with placeholder values
#
# resp = client.describe_harvest_job({
# id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.channel_id #=> String
# resp.created_at #=> String
# resp.end_time #=> String
# resp.id #=> String
# resp.origin_endpoint_id #=> String
# resp.s3_destination.bucket_name #=> String
# resp.s3_destination.manifest_key #=> String
# resp.s3_destination.role_arn #=> String
# resp.start_time #=> String
# resp.status #=> String, one of "IN_PROGRESS", "SUCCEEDED", "FAILED"
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/DescribeHarvestJob AWS API Documentation
#
# @overload describe_harvest_job(params = {})
# @param [Hash] params ({})
def describe_harvest_job(params = {}, options = {})
req = build_request(:describe_harvest_job, params)
req.send_request(options)
end
# Gets details about an existing OriginEndpoint.
#
# @option params [required, String] :id
#
# @return [Types::DescribeOriginEndpointResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::DescribeOriginEndpointResponse#arn #arn} => String
# * {Types::DescribeOriginEndpointResponse#authorization #authorization} => Types::Authorization
# * {Types::DescribeOriginEndpointResponse#channel_id #channel_id} => String
# * {Types::DescribeOriginEndpointResponse#cmaf_package #cmaf_package} => Types::CmafPackage
# * {Types::DescribeOriginEndpointResponse#dash_package #dash_package} => Types::DashPackage
# * {Types::DescribeOriginEndpointResponse#description #description} => String
# * {Types::DescribeOriginEndpointResponse#hls_package #hls_package} => Types::HlsPackage
# * {Types::DescribeOriginEndpointResponse#id #id} => String
# * {Types::DescribeOriginEndpointResponse#manifest_name #manifest_name} => String
# * {Types::DescribeOriginEndpointResponse#mss_package #mss_package} => Types::MssPackage
# * {Types::DescribeOriginEndpointResponse#origination #origination} => String
# * {Types::DescribeOriginEndpointResponse#startover_window_seconds #startover_window_seconds} => Integer
# * {Types::DescribeOriginEndpointResponse#tags #tags} => Hash<String,String>
# * {Types::DescribeOriginEndpointResponse#time_delay_seconds #time_delay_seconds} => Integer
# * {Types::DescribeOriginEndpointResponse#url #url} => String
# * {Types::DescribeOriginEndpointResponse#whitelist #whitelist} => Array<String>
#
# @example Request syntax with placeholder values
#
# resp = client.describe_origin_endpoint({
# id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.authorization.cdn_identifier_secret #=> String
# resp.authorization.secrets_role_arn #=> String
# resp.channel_id #=> String
# resp.cmaf_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.cmaf_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.resource_id #=> String
# resp.cmaf_package.encryption.speke_key_provider.role_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.system_ids #=> Array
# resp.cmaf_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.cmaf_package.encryption.speke_key_provider.url #=> String
# resp.cmaf_package.hls_manifests #=> Array
# resp.cmaf_package.hls_manifests[0].ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.cmaf_package.hls_manifests[0].id #=> String
# resp.cmaf_package.hls_manifests[0].include_iframe_only_stream #=> Boolean
# resp.cmaf_package.hls_manifests[0].manifest_name #=> String
# resp.cmaf_package.hls_manifests[0].playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.cmaf_package.hls_manifests[0].playlist_window_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].program_date_time_interval_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].url #=> String
# resp.cmaf_package.segment_duration_seconds #=> Integer
# resp.cmaf_package.segment_prefix #=> String
# resp.cmaf_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.ad_triggers #=> Array
# resp.dash_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.dash_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.dash_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.dash_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.dash_package.encryption.speke_key_provider.resource_id #=> String
# resp.dash_package.encryption.speke_key_provider.role_arn #=> String
# resp.dash_package.encryption.speke_key_provider.system_ids #=> Array
# resp.dash_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.dash_package.encryption.speke_key_provider.url #=> String
# resp.dash_package.manifest_layout #=> String, one of "FULL", "COMPACT"
# resp.dash_package.manifest_window_seconds #=> Integer
# resp.dash_package.min_buffer_time_seconds #=> Integer
# resp.dash_package.min_update_period_seconds #=> Integer
# resp.dash_package.period_triggers #=> Array
# resp.dash_package.period_triggers[0] #=> String, one of "ADS"
# resp.dash_package.profile #=> String, one of "NONE", "HBBTV_1_5"
# resp.dash_package.segment_duration_seconds #=> Integer
# resp.dash_package.segment_template_format #=> String, one of "NUMBER_WITH_TIMELINE", "TIME_WITH_TIMELINE", "NUMBER_WITH_DURATION"
# resp.dash_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.suggested_presentation_delay_seconds #=> Integer
# resp.description #=> String
# resp.hls_package.ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.hls_package.ad_triggers #=> Array
# resp.hls_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.hls_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.hls_package.encryption.constant_initialization_vector #=> String
# resp.hls_package.encryption.encryption_method #=> String, one of "AES_128", "SAMPLE_AES"
# resp.hls_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.hls_package.encryption.repeat_ext_x_key #=> Boolean
# resp.hls_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.hls_package.encryption.speke_key_provider.resource_id #=> String
# resp.hls_package.encryption.speke_key_provider.role_arn #=> String
# resp.hls_package.encryption.speke_key_provider.system_ids #=> Array
# resp.hls_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.hls_package.encryption.speke_key_provider.url #=> String
# resp.hls_package.include_iframe_only_stream #=> Boolean
# resp.hls_package.playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.hls_package.playlist_window_seconds #=> Integer
# resp.hls_package.program_date_time_interval_seconds #=> Integer
# resp.hls_package.segment_duration_seconds #=> Integer
# resp.hls_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.hls_package.use_audio_rendition_group #=> Boolean
# resp.id #=> String
# resp.manifest_name #=> String
# resp.mss_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.mss_package.encryption.speke_key_provider.resource_id #=> String
# resp.mss_package.encryption.speke_key_provider.role_arn #=> String
# resp.mss_package.encryption.speke_key_provider.system_ids #=> Array
# resp.mss_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.mss_package.encryption.speke_key_provider.url #=> String
# resp.mss_package.manifest_window_seconds #=> Integer
# resp.mss_package.segment_duration_seconds #=> Integer
# resp.mss_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origination #=> String, one of "ALLOW", "DENY"
# resp.startover_window_seconds #=> Integer
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
# resp.time_delay_seconds #=> Integer
# resp.url #=> String
# resp.whitelist #=> Array
# resp.whitelist[0] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/DescribeOriginEndpoint AWS API Documentation
#
# @overload describe_origin_endpoint(params = {})
# @param [Hash] params ({})
def describe_origin_endpoint(params = {}, options = {})
req = build_request(:describe_origin_endpoint, params)
req.send_request(options)
end
# Returns a collection of Channels.
#
# @option params [Integer] :max_results
#
# @option params [String] :next_token
#
# @return [Types::ListChannelsResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::ListChannelsResponse#channels #channels} => Array<Types::Channel>
# * {Types::ListChannelsResponse#next_token #next_token} => String
#
# The returned {Seahorse::Client::Response response} is a pageable response and is Enumerable. For details on usage see {Aws::PageableResponse PageableResponse}.
#
# @example Request syntax with placeholder values
#
# resp = client.list_channels({
# max_results: 1,
# next_token: "__string",
# })
#
# @example Response structure
#
# resp.channels #=> Array
# resp.channels[0].arn #=> String
# resp.channels[0].description #=> String
# resp.channels[0].hls_ingest.ingest_endpoints #=> Array
# resp.channels[0].hls_ingest.ingest_endpoints[0].id #=> String
# resp.channels[0].hls_ingest.ingest_endpoints[0].password #=> String
# resp.channels[0].hls_ingest.ingest_endpoints[0].url #=> String
# resp.channels[0].hls_ingest.ingest_endpoints[0].username #=> String
# resp.channels[0].id #=> String
# resp.channels[0].tags #=> Hash
# resp.channels[0].tags["__string"] #=> String
# resp.next_token #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/ListChannels AWS API Documentation
#
# @overload list_channels(params = {})
# @param [Hash] params ({})
def list_channels(params = {}, options = {})
req = build_request(:list_channels, params)
req.send_request(options)
end
# Returns a collection of HarvestJob records.
#
# @option params [String] :include_channel_id
#
# @option params [String] :include_status
#
# @option params [Integer] :max_results
#
# @option params [String] :next_token
#
# @return [Types::ListHarvestJobsResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::ListHarvestJobsResponse#harvest_jobs #harvest_jobs} => Array<Types::HarvestJob>
# * {Types::ListHarvestJobsResponse#next_token #next_token} => String
#
# The returned {Seahorse::Client::Response response} is a pageable response and is Enumerable. For details on usage see {Aws::PageableResponse PageableResponse}.
#
# @example Request syntax with placeholder values
#
# resp = client.list_harvest_jobs({
# include_channel_id: "__string",
# include_status: "__string",
# max_results: 1,
# next_token: "__string",
# })
#
# @example Response structure
#
# resp.harvest_jobs #=> Array
# resp.harvest_jobs[0].arn #=> String
# resp.harvest_jobs[0].channel_id #=> String
# resp.harvest_jobs[0].created_at #=> String
# resp.harvest_jobs[0].end_time #=> String
# resp.harvest_jobs[0].id #=> String
# resp.harvest_jobs[0].origin_endpoint_id #=> String
# resp.harvest_jobs[0].s3_destination.bucket_name #=> String
# resp.harvest_jobs[0].s3_destination.manifest_key #=> String
# resp.harvest_jobs[0].s3_destination.role_arn #=> String
# resp.harvest_jobs[0].start_time #=> String
# resp.harvest_jobs[0].status #=> String, one of "IN_PROGRESS", "SUCCEEDED", "FAILED"
# resp.next_token #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/ListHarvestJobs AWS API Documentation
#
# @overload list_harvest_jobs(params = {})
# @param [Hash] params ({})
def list_harvest_jobs(params = {}, options = {})
req = build_request(:list_harvest_jobs, params)
req.send_request(options)
end
# Returns a collection of OriginEndpoint records.
#
# @option params [String] :channel_id
#
# @option params [Integer] :max_results
#
# @option params [String] :next_token
#
# @return [Types::ListOriginEndpointsResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::ListOriginEndpointsResponse#next_token #next_token} => String
# * {Types::ListOriginEndpointsResponse#origin_endpoints #origin_endpoints} => Array<Types::OriginEndpoint>
#
# The returned {Seahorse::Client::Response response} is a pageable response and is Enumerable. For details on usage see {Aws::PageableResponse PageableResponse}.
#
# @example Request syntax with placeholder values
#
# resp = client.list_origin_endpoints({
# channel_id: "__string",
# max_results: 1,
# next_token: "__string",
# })
#
# @example Response structure
#
# resp.next_token #=> String
# resp.origin_endpoints #=> Array
# resp.origin_endpoints[0].arn #=> String
# resp.origin_endpoints[0].authorization.cdn_identifier_secret #=> String
# resp.origin_endpoints[0].authorization.secrets_role_arn #=> String
# resp.origin_endpoints[0].channel_id #=> String
# resp.origin_endpoints[0].cmaf_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.resource_id #=> String
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.role_arn #=> String
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.system_ids #=> Array
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.origin_endpoints[0].cmaf_package.encryption.speke_key_provider.url #=> String
# resp.origin_endpoints[0].cmaf_package.hls_manifests #=> Array
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].id #=> String
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].include_iframe_only_stream #=> Boolean
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].manifest_name #=> String
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].playlist_window_seconds #=> Integer
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].program_date_time_interval_seconds #=> Integer
# resp.origin_endpoints[0].cmaf_package.hls_manifests[0].url #=> String
# resp.origin_endpoints[0].cmaf_package.segment_duration_seconds #=> Integer
# resp.origin_endpoints[0].cmaf_package.segment_prefix #=> String
# resp.origin_endpoints[0].cmaf_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].cmaf_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].cmaf_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origin_endpoints[0].dash_package.ad_triggers #=> Array
# resp.origin_endpoints[0].dash_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.origin_endpoints[0].dash_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.origin_endpoints[0].dash_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.resource_id #=> String
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.role_arn #=> String
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.system_ids #=> Array
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.origin_endpoints[0].dash_package.encryption.speke_key_provider.url #=> String
# resp.origin_endpoints[0].dash_package.manifest_layout #=> String, one of "FULL", "COMPACT"
# resp.origin_endpoints[0].dash_package.manifest_window_seconds #=> Integer
# resp.origin_endpoints[0].dash_package.min_buffer_time_seconds #=> Integer
# resp.origin_endpoints[0].dash_package.min_update_period_seconds #=> Integer
# resp.origin_endpoints[0].dash_package.period_triggers #=> Array
# resp.origin_endpoints[0].dash_package.period_triggers[0] #=> String, one of "ADS"
# resp.origin_endpoints[0].dash_package.profile #=> String, one of "NONE", "HBBTV_1_5"
# resp.origin_endpoints[0].dash_package.segment_duration_seconds #=> Integer
# resp.origin_endpoints[0].dash_package.segment_template_format #=> String, one of "NUMBER_WITH_TIMELINE", "TIME_WITH_TIMELINE", "NUMBER_WITH_DURATION"
# resp.origin_endpoints[0].dash_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].dash_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].dash_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origin_endpoints[0].dash_package.suggested_presentation_delay_seconds #=> Integer
# resp.origin_endpoints[0].description #=> String
# resp.origin_endpoints[0].hls_package.ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.origin_endpoints[0].hls_package.ad_triggers #=> Array
# resp.origin_endpoints[0].hls_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.origin_endpoints[0].hls_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.origin_endpoints[0].hls_package.encryption.constant_initialization_vector #=> String
# resp.origin_endpoints[0].hls_package.encryption.encryption_method #=> String, one of "AES_128", "SAMPLE_AES"
# resp.origin_endpoints[0].hls_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.origin_endpoints[0].hls_package.encryption.repeat_ext_x_key #=> Boolean
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.resource_id #=> String
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.role_arn #=> String
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.system_ids #=> Array
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.origin_endpoints[0].hls_package.encryption.speke_key_provider.url #=> String
# resp.origin_endpoints[0].hls_package.include_iframe_only_stream #=> Boolean
# resp.origin_endpoints[0].hls_package.playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.origin_endpoints[0].hls_package.playlist_window_seconds #=> Integer
# resp.origin_endpoints[0].hls_package.program_date_time_interval_seconds #=> Integer
# resp.origin_endpoints[0].hls_package.segment_duration_seconds #=> Integer
# resp.origin_endpoints[0].hls_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].hls_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].hls_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origin_endpoints[0].hls_package.use_audio_rendition_group #=> Boolean
# resp.origin_endpoints[0].id #=> String
# resp.origin_endpoints[0].manifest_name #=> String
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.resource_id #=> String
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.role_arn #=> String
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.system_ids #=> Array
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.origin_endpoints[0].mss_package.encryption.speke_key_provider.url #=> String
# resp.origin_endpoints[0].mss_package.manifest_window_seconds #=> Integer
# resp.origin_endpoints[0].mss_package.segment_duration_seconds #=> Integer
# resp.origin_endpoints[0].mss_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].mss_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.origin_endpoints[0].mss_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origin_endpoints[0].origination #=> String, one of "ALLOW", "DENY"
# resp.origin_endpoints[0].startover_window_seconds #=> Integer
# resp.origin_endpoints[0].tags #=> Hash
# resp.origin_endpoints[0].tags["__string"] #=> String
# resp.origin_endpoints[0].time_delay_seconds #=> Integer
# resp.origin_endpoints[0].url #=> String
# resp.origin_endpoints[0].whitelist #=> Array
# resp.origin_endpoints[0].whitelist[0] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/ListOriginEndpoints AWS API Documentation
#
# @overload list_origin_endpoints(params = {})
# @param [Hash] params ({})
def list_origin_endpoints(params = {}, options = {})
req = build_request(:list_origin_endpoints, params)
req.send_request(options)
end
# @option params [required, String] :resource_arn
#
# @return [Types::ListTagsForResourceResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::ListTagsForResourceResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.list_tags_for_resource({
# resource_arn: "__string", # required
# })
#
# @example Response structure
#
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/ListTagsForResource AWS API Documentation
#
# @overload list_tags_for_resource(params = {})
# @param [Hash] params ({})
def list_tags_for_resource(params = {}, options = {})
req = build_request(:list_tags_for_resource, params)
req.send_request(options)
end
# Changes the Channel's first IngestEndpoint's username and password.
# WARNING - This API is deprecated. Please use
# RotateIngestEndpointCredentials instead
#
# @option params [required, String] :id
#
# @return [Types::RotateChannelCredentialsResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::RotateChannelCredentialsResponse#arn #arn} => String
# * {Types::RotateChannelCredentialsResponse#description #description} => String
# * {Types::RotateChannelCredentialsResponse#hls_ingest #hls_ingest} => Types::HlsIngest
# * {Types::RotateChannelCredentialsResponse#id #id} => String
# * {Types::RotateChannelCredentialsResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.rotate_channel_credentials({
# id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.description #=> String
# resp.hls_ingest.ingest_endpoints #=> Array
# resp.hls_ingest.ingest_endpoints[0].id #=> String
# resp.hls_ingest.ingest_endpoints[0].password #=> String
# resp.hls_ingest.ingest_endpoints[0].url #=> String
# resp.hls_ingest.ingest_endpoints[0].username #=> String
# resp.id #=> String
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/RotateChannelCredentials AWS API Documentation
#
# @overload rotate_channel_credentials(params = {})
# @param [Hash] params ({})
def rotate_channel_credentials(params = {}, options = {})
req = build_request(:rotate_channel_credentials, params)
req.send_request(options)
end
# Rotate the IngestEndpoint's username and password, as specified by
# the IngestEndpoint's id.
#
# @option params [required, String] :id
#
# @option params [required, String] :ingest_endpoint_id
#
# @return [Types::RotateIngestEndpointCredentialsResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::RotateIngestEndpointCredentialsResponse#arn #arn} => String
# * {Types::RotateIngestEndpointCredentialsResponse#description #description} => String
# * {Types::RotateIngestEndpointCredentialsResponse#hls_ingest #hls_ingest} => Types::HlsIngest
# * {Types::RotateIngestEndpointCredentialsResponse#id #id} => String
# * {Types::RotateIngestEndpointCredentialsResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.rotate_ingest_endpoint_credentials({
# id: "__string", # required
# ingest_endpoint_id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.description #=> String
# resp.hls_ingest.ingest_endpoints #=> Array
# resp.hls_ingest.ingest_endpoints[0].id #=> String
# resp.hls_ingest.ingest_endpoints[0].password #=> String
# resp.hls_ingest.ingest_endpoints[0].url #=> String
# resp.hls_ingest.ingest_endpoints[0].username #=> String
# resp.id #=> String
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/RotateIngestEndpointCredentials AWS API Documentation
#
# @overload rotate_ingest_endpoint_credentials(params = {})
# @param [Hash] params ({})
def rotate_ingest_endpoint_credentials(params = {}, options = {})
req = build_request(:rotate_ingest_endpoint_credentials, params)
req.send_request(options)
end
# @option params [required, String] :resource_arn
#
# @option params [required, Hash<String,String>] :tags
#
# @return [Struct] Returns an empty {Seahorse::Client::Response response}.
#
# @example Request syntax with placeholder values
#
# resp = client.tag_resource({
# resource_arn: "__string", # required
# tags: { # required
# "__string" => "__string",
# },
# })
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/TagResource AWS API Documentation
#
# @overload tag_resource(params = {})
# @param [Hash] params ({})
def tag_resource(params = {}, options = {})
req = build_request(:tag_resource, params)
req.send_request(options)
end
# @option params [required, String] :resource_arn
#
# @option params [required, Array<String>] :tag_keys
#
# @return [Struct] Returns an empty {Seahorse::Client::Response response}.
#
# @example Request syntax with placeholder values
#
# resp = client.untag_resource({
# resource_arn: "__string", # required
# tag_keys: ["__string"], # required
# })
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/UntagResource AWS API Documentation
#
# @overload untag_resource(params = {})
# @param [Hash] params ({})
def untag_resource(params = {}, options = {})
req = build_request(:untag_resource, params)
req.send_request(options)
end
# Updates an existing Channel.
#
# @option params [String] :description
#
# @option params [required, String] :id
#
# @return [Types::UpdateChannelResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::UpdateChannelResponse#arn #arn} => String
# * {Types::UpdateChannelResponse#description #description} => String
# * {Types::UpdateChannelResponse#hls_ingest #hls_ingest} => Types::HlsIngest
# * {Types::UpdateChannelResponse#id #id} => String
# * {Types::UpdateChannelResponse#tags #tags} => Hash<String,String>
#
# @example Request syntax with placeholder values
#
# resp = client.update_channel({
# description: "__string",
# id: "__string", # required
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.description #=> String
# resp.hls_ingest.ingest_endpoints #=> Array
# resp.hls_ingest.ingest_endpoints[0].id #=> String
# resp.hls_ingest.ingest_endpoints[0].password #=> String
# resp.hls_ingest.ingest_endpoints[0].url #=> String
# resp.hls_ingest.ingest_endpoints[0].username #=> String
# resp.id #=> String
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/UpdateChannel AWS API Documentation
#
# @overload update_channel(params = {})
# @param [Hash] params ({})
def update_channel(params = {}, options = {})
req = build_request(:update_channel, params)
req.send_request(options)
end
# Updates an existing OriginEndpoint.
#
# @option params [Types::Authorization] :authorization
# CDN Authorization credentials
#
# @option params [Types::CmafPackageCreateOrUpdateParameters] :cmaf_package
# A Common Media Application Format (CMAF) packaging configuration.
#
# @option params [Types::DashPackage] :dash_package
# A Dynamic Adaptive Streaming over HTTP (DASH) packaging configuration.
#
# @option params [String] :description
#
# @option params [Types::HlsPackage] :hls_package
# An HTTP Live Streaming (HLS) packaging configuration.
#
# @option params [required, String] :id
#
# @option params [String] :manifest_name
#
# @option params [Types::MssPackage] :mss_package
# A Microsoft Smooth Streaming (MSS) packaging configuration.
#
# @option params [String] :origination
#
# @option params [Integer] :startover_window_seconds
#
# @option params [Integer] :time_delay_seconds
#
# @option params [Array<String>] :whitelist
#
# @return [Types::UpdateOriginEndpointResponse] Returns a {Seahorse::Client::Response response} object which responds to the following methods:
#
# * {Types::UpdateOriginEndpointResponse#arn #arn} => String
# * {Types::UpdateOriginEndpointResponse#authorization #authorization} => Types::Authorization
# * {Types::UpdateOriginEndpointResponse#channel_id #channel_id} => String
# * {Types::UpdateOriginEndpointResponse#cmaf_package #cmaf_package} => Types::CmafPackage
# * {Types::UpdateOriginEndpointResponse#dash_package #dash_package} => Types::DashPackage
# * {Types::UpdateOriginEndpointResponse#description #description} => String
# * {Types::UpdateOriginEndpointResponse#hls_package #hls_package} => Types::HlsPackage
# * {Types::UpdateOriginEndpointResponse#id #id} => String
# * {Types::UpdateOriginEndpointResponse#manifest_name #manifest_name} => String
# * {Types::UpdateOriginEndpointResponse#mss_package #mss_package} => Types::MssPackage
# * {Types::UpdateOriginEndpointResponse#origination #origination} => String
# * {Types::UpdateOriginEndpointResponse#startover_window_seconds #startover_window_seconds} => Integer
# * {Types::UpdateOriginEndpointResponse#tags #tags} => Hash<String,String>
# * {Types::UpdateOriginEndpointResponse#time_delay_seconds #time_delay_seconds} => Integer
# * {Types::UpdateOriginEndpointResponse#url #url} => String
# * {Types::UpdateOriginEndpointResponse#whitelist #whitelist} => Array<String>
#
# @example Request syntax with placeholder values
#
# resp = client.update_origin_endpoint({
# authorization: {
# cdn_identifier_secret: "__string", # required
# secrets_role_arn: "__string", # required
# },
# cmaf_package: {
# encryption: {
# key_rotation_interval_seconds: 1,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# hls_manifests: [
# {
# ad_markers: "NONE", # accepts NONE, SCTE35_ENHANCED, PASSTHROUGH, DATERANGE
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# id: "__string", # required
# include_iframe_only_stream: false,
# manifest_name: "__string",
# playlist_type: "NONE", # accepts NONE, EVENT, VOD
# playlist_window_seconds: 1,
# program_date_time_interval_seconds: 1,
# },
# ],
# segment_duration_seconds: 1,
# segment_prefix: "__string",
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# },
# dash_package: {
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# encryption: {
# key_rotation_interval_seconds: 1,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# manifest_layout: "FULL", # accepts FULL, COMPACT
# manifest_window_seconds: 1,
# min_buffer_time_seconds: 1,
# min_update_period_seconds: 1,
# period_triggers: ["ADS"], # accepts ADS
# profile: "NONE", # accepts NONE, HBBTV_1_5
# segment_duration_seconds: 1,
# segment_template_format: "NUMBER_WITH_TIMELINE", # accepts NUMBER_WITH_TIMELINE, TIME_WITH_TIMELINE, NUMBER_WITH_DURATION
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# suggested_presentation_delay_seconds: 1,
# },
# description: "__string",
# hls_package: {
# ad_markers: "NONE", # accepts NONE, SCTE35_ENHANCED, PASSTHROUGH, DATERANGE
# ad_triggers: ["SPLICE_INSERT"], # accepts SPLICE_INSERT, BREAK, PROVIDER_ADVERTISEMENT, DISTRIBUTOR_ADVERTISEMENT, PROVIDER_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_PLACEMENT_OPPORTUNITY, PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY, DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY
# ads_on_delivery_restrictions: "NONE", # accepts NONE, RESTRICTED, UNRESTRICTED, BOTH
# encryption: {
# constant_initialization_vector: "__string",
# encryption_method: "AES_128", # accepts AES_128, SAMPLE_AES
# key_rotation_interval_seconds: 1,
# repeat_ext_x_key: false,
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# include_iframe_only_stream: false,
# playlist_type: "NONE", # accepts NONE, EVENT, VOD
# playlist_window_seconds: 1,
# program_date_time_interval_seconds: 1,
# segment_duration_seconds: 1,
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# use_audio_rendition_group: false,
# },
# id: "__string", # required
# manifest_name: "__string",
# mss_package: {
# encryption: {
# speke_key_provider: { # required
# certificate_arn: "__string",
# resource_id: "__string", # required
# role_arn: "__string", # required
# system_ids: ["__string"], # required
# url: "__string", # required
# },
# },
# manifest_window_seconds: 1,
# segment_duration_seconds: 1,
# stream_selection: {
# max_video_bits_per_second: 1,
# min_video_bits_per_second: 1,
# stream_order: "ORIGINAL", # accepts ORIGINAL, VIDEO_BITRATE_ASCENDING, VIDEO_BITRATE_DESCENDING
# },
# },
# origination: "ALLOW", # accepts ALLOW, DENY
# startover_window_seconds: 1,
# time_delay_seconds: 1,
# whitelist: ["__string"],
# })
#
# @example Response structure
#
# resp.arn #=> String
# resp.authorization.cdn_identifier_secret #=> String
# resp.authorization.secrets_role_arn #=> String
# resp.channel_id #=> String
# resp.cmaf_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.cmaf_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.resource_id #=> String
# resp.cmaf_package.encryption.speke_key_provider.role_arn #=> String
# resp.cmaf_package.encryption.speke_key_provider.system_ids #=> Array
# resp.cmaf_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.cmaf_package.encryption.speke_key_provider.url #=> String
# resp.cmaf_package.hls_manifests #=> Array
# resp.cmaf_package.hls_manifests[0].ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.cmaf_package.hls_manifests[0].id #=> String
# resp.cmaf_package.hls_manifests[0].include_iframe_only_stream #=> Boolean
# resp.cmaf_package.hls_manifests[0].manifest_name #=> String
# resp.cmaf_package.hls_manifests[0].playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.cmaf_package.hls_manifests[0].playlist_window_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].program_date_time_interval_seconds #=> Integer
# resp.cmaf_package.hls_manifests[0].url #=> String
# resp.cmaf_package.segment_duration_seconds #=> Integer
# resp.cmaf_package.segment_prefix #=> String
# resp.cmaf_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.cmaf_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.ad_triggers #=> Array
# resp.dash_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.dash_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.dash_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.dash_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.dash_package.encryption.speke_key_provider.resource_id #=> String
# resp.dash_package.encryption.speke_key_provider.role_arn #=> String
# resp.dash_package.encryption.speke_key_provider.system_ids #=> Array
# resp.dash_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.dash_package.encryption.speke_key_provider.url #=> String
# resp.dash_package.manifest_layout #=> String, one of "FULL", "COMPACT"
# resp.dash_package.manifest_window_seconds #=> Integer
# resp.dash_package.min_buffer_time_seconds #=> Integer
# resp.dash_package.min_update_period_seconds #=> Integer
# resp.dash_package.period_triggers #=> Array
# resp.dash_package.period_triggers[0] #=> String, one of "ADS"
# resp.dash_package.profile #=> String, one of "NONE", "HBBTV_1_5"
# resp.dash_package.segment_duration_seconds #=> Integer
# resp.dash_package.segment_template_format #=> String, one of "NUMBER_WITH_TIMELINE", "TIME_WITH_TIMELINE", "NUMBER_WITH_DURATION"
# resp.dash_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.dash_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.dash_package.suggested_presentation_delay_seconds #=> Integer
# resp.description #=> String
# resp.hls_package.ad_markers #=> String, one of "NONE", "SCTE35_ENHANCED", "PASSTHROUGH", "DATERANGE"
# resp.hls_package.ad_triggers #=> Array
# resp.hls_package.ad_triggers[0] #=> String, one of "SPLICE_INSERT", "BREAK", "PROVIDER_ADVERTISEMENT", "DISTRIBUTOR_ADVERTISEMENT", "PROVIDER_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_PLACEMENT_OPPORTUNITY", "PROVIDER_OVERLAY_PLACEMENT_OPPORTUNITY", "DISTRIBUTOR_OVERLAY_PLACEMENT_OPPORTUNITY"
# resp.hls_package.ads_on_delivery_restrictions #=> String, one of "NONE", "RESTRICTED", "UNRESTRICTED", "BOTH"
# resp.hls_package.encryption.constant_initialization_vector #=> String
# resp.hls_package.encryption.encryption_method #=> String, one of "AES_128", "SAMPLE_AES"
# resp.hls_package.encryption.key_rotation_interval_seconds #=> Integer
# resp.hls_package.encryption.repeat_ext_x_key #=> Boolean
# resp.hls_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.hls_package.encryption.speke_key_provider.resource_id #=> String
# resp.hls_package.encryption.speke_key_provider.role_arn #=> String
# resp.hls_package.encryption.speke_key_provider.system_ids #=> Array
# resp.hls_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.hls_package.encryption.speke_key_provider.url #=> String
# resp.hls_package.include_iframe_only_stream #=> Boolean
# resp.hls_package.playlist_type #=> String, one of "NONE", "EVENT", "VOD"
# resp.hls_package.playlist_window_seconds #=> Integer
# resp.hls_package.program_date_time_interval_seconds #=> Integer
# resp.hls_package.segment_duration_seconds #=> Integer
# resp.hls_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.hls_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.hls_package.use_audio_rendition_group #=> Boolean
# resp.id #=> String
# resp.manifest_name #=> String
# resp.mss_package.encryption.speke_key_provider.certificate_arn #=> String
# resp.mss_package.encryption.speke_key_provider.resource_id #=> String
# resp.mss_package.encryption.speke_key_provider.role_arn #=> String
# resp.mss_package.encryption.speke_key_provider.system_ids #=> Array
# resp.mss_package.encryption.speke_key_provider.system_ids[0] #=> String
# resp.mss_package.encryption.speke_key_provider.url #=> String
# resp.mss_package.manifest_window_seconds #=> Integer
# resp.mss_package.segment_duration_seconds #=> Integer
# resp.mss_package.stream_selection.max_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.min_video_bits_per_second #=> Integer
# resp.mss_package.stream_selection.stream_order #=> String, one of "ORIGINAL", "VIDEO_BITRATE_ASCENDING", "VIDEO_BITRATE_DESCENDING"
# resp.origination #=> String, one of "ALLOW", "DENY"
# resp.startover_window_seconds #=> Integer
# resp.tags #=> Hash
# resp.tags["__string"] #=> String
# resp.time_delay_seconds #=> Integer
# resp.url #=> String
# resp.whitelist #=> Array
# resp.whitelist[0] #=> String
#
# @see http://docs.aws.amazon.com/goto/WebAPI/mediapackage-2017-10-12/UpdateOriginEndpoint AWS API Documentation
#
# @overload update_origin_endpoint(params = {})
# @param [Hash] params ({})
def update_origin_endpoint(params = {}, options = {})
req = build_request(:update_origin_endpoint, params)
req.send_request(options)
end
# @!endgroup
# @param params ({})
# @api private
def build_request(operation_name, params = {})
handlers = @handlers.for(operation_name)
context = Seahorse::Client::RequestContext.new(
operation_name: operation_name,
operation: config.api.operation(operation_name),
client: self,
params: params,
config: config)
context[:gem_name] = 'aws-sdk-mediapackage'
context[:gem_version] = '1.31.0'
Seahorse::Client::Request.new(handlers, context)
end
# @api private
# @deprecated
def waiter_names
[]
end
class << self
# @api private
attr_reader :identifier
# @api private
def errors_module
Errors
end
end
end
end
| 52.506122 | 317 | 0.685101 |
bfce5f2f9f6dac3ddf9b650e6c81ee6d28ca92bf | 463 | module UsersHelper
# Link to a user (default is by name).
def user_link(text, user = nil, html_options = nil)
if user.nil?
user = text
text = user.name
elsif user.is_a?(Hash)
html_options = user
user = text
text = user.name
end
# We normally write link_to(..., user) for brevity, but that breaks
# activities_helper_spec due to an RSpec bug.
link_to(h(text), profile_path(user), html_options)
end
end | 27.235294 | 71 | 0.643629 |
38efffcb148086d8f6a1d5e9497898a3a64cb853 | 1,301 | $:.push File.expand_path("../lib", __FILE__)
# Maintain your gem's version:
require "spud_media/version"
# Describe your gem and declare its dependencies:
Gem::Specification.new do |s|
s.name = "spud_media"
s.version = Spud::Media::VERSION
s.authors = ["David Estes"]
s.email = ["[email protected]"]
s.homepage = "http://www.github.com/spud-rails/spud_media"
s.summary = "Spud File upload/management module"
s.description = "Spud Media allows you to upload files to your site and manage them in the spud administrative panel. It also uses paperclip and supports s3 storage"
s.files = Dir["{app,config,db,lib}/**/*"] + ["MIT-LICENSE", "Rakefile", "Readme.markdown"]
s.test_files = Dir["test/**/*"]
s.add_dependency "rails", ">= 4.0.0"
s.add_dependency 'spud_core', ">= 1.0.0"
s.add_dependency "paperclip", ">= 4.2.0"
s.add_development_dependency 'mysql2'
s.add_development_dependency 'rspec', '2.14.0'
s.add_development_dependency 'rspec-rails', '2.14.0'
s.add_development_dependency 'shoulda', '~> 3.0.1'
s.add_development_dependency 'factory_girl', '~> 3.0'
s.add_development_dependency 'database_cleaner', '1.0.0.RC1'
s.add_development_dependency 'mocha', '0.14.0'
s.add_development_dependency 'simplecov', '~> 0.6.4'
end
| 39.424242 | 167 | 0.691776 |
bb774e232e46deb801417e8762398758941b7b59 | 2,986 | require 'pxp-agent/test_helper.rb'
require 'yaml'
test_name 'Run puppet agent as non-root' do
agents.each do |agent|
platform = agent.platform
skip_test "Test is not compatible with #{platform}" if platform =~ /windows/
step 'create non-root user on all nodes' do
@user_name = 'foo'
@group_name = 'foobar'
if platform =~ /solaris/
@user_home_dir = "/export/home/#{@user_name}"
elsif platform =~ /osx/
@user_home_dir = "/Users/#{@user_name}"
else
@user_home_dir = "/home/#{@user_name}"
end
@user_puppetlabs_dir = "#{@user_home_dir}/.puppetlabs"
@user_puppet_dir = "#{@user_puppetlabs_dir}/etc/puppet"
@user_pxp_dir = "#{@user_puppetlabs_dir}/etc/pxp-agent"
on(agent, "mkdir -p #{@user_puppet_dir}")
on(agent, "mkdir -p #{@user_pxp_dir}")
on(agent, puppet("resource group #{@group_name} ensure=present"))
if platform =~ /eos/
#arista
on(agent, "useradd #{@user_name} -p p@ssw0rd")
else
on(agent, puppet("resource user #{@user_name} ensure=present home=#{@user_home_dir} groups=#{@group_name}"))
end
end
teardown do
get_process_pids(agent, 'pxp-agent').each do |pid|
on(agent, "kill -9 #{pid}", :accept_all_exit_codes => true)
end
on(agent, puppet("resource user #{@user_name} ensure=absent"))
on(agent, "rm -rf #{@user_home_dir}")
end
step 'Ensure pxp-agent is stopped' do
on(agent, puppet("resource service pxp-agent ensure=stopped enable=false"))
end
step 'Copy certs and keys to new users home directory' do
puppet_ssldir = on(agent, puppet('config print ssldir')).stdout.chomp
#ssl-key ssl-ca-cert ssl-cert
on(agent, "cp -R #{puppet_ssldir} #{@user_puppet_dir}")
end
step 'Attempt start of pxp-agent as non-root user' do
ssl_config = {
:ssl_key => "#{@user_puppet_dir}/ssl/private_keys/#{agent}.pem",
:ssl_ca_cert => "#{@user_puppet_dir}/ssl/certs/ca.pem",
:ssl_cert => "#{@user_puppet_dir}/ssl/certs/#{agent}.pem"
}
create_remote_file(agent, "#{@user_pxp_dir}/pxp-agent.conf", pxp_config_hocon(master, agent, ssl_config).to_s)
on(agent, "chown -R #{@user_name}:#{@group_name} #{@user_home_dir}")
if platform =~ /solaris|aix|eos/
command = "cd #{@user_home_dir} && HOME=#{@user_home_dir} su #{@user_name} -c \"/opt/puppetlabs/puppet/bin/pxp-agent\""
else
command = "su -l #{@user_name} -c \"/opt/puppetlabs/puppet/bin/pxp-agent\""
end
on(agent, command, :accept_all_exit_codes => true) do |result|
assert_equal(0, result.exit_code, "The expected exit code was not observed \n #{result.output}")
end
assert(is_associated?(master, "pcp://#{agent}/agent"),
"At the start of the test, #{agent} (with PCP identity pcp://#{agent}/agent ) should be associated with pcp-broker")
end
end
end
| 38.779221 | 129 | 0.623912 |
f837e96b2bb26e84feb9ace0466cd17cc15888c4 | 2,236 | class PostfixLogLine < ActiveRecord::Base
belongs_to :delivery
after_save :update_status!
def dsn_class
match = dsn.match(/^(\d)\.(\d+)\.(\d+)/)
if match
match[1].to_i
else
raise "Unexpected form for dsn code"
end
end
def status
case dsn_class
when 2
"delivered"
when 4
"soft_bounce"
when 5
"hard_bounce"
else
raise "Unknown dsn class"
end
end
# My status has changed. Tell those effected.
def update_status!
delivery.update_status!
end
def self.create_from_line(line)
values = match_main_content(line)
program = values.delete(:program)
to = values.delete(:to)
queue_id = values.delete(:queue_id)
# Only log delivery attempts
if program == "smtp"
delivery = Delivery.joins(:email, :address).order("emails.created_at DESC").find_by("addresses.text" => to, postfix_queue_id: queue_id)
if delivery
# Don't resave duplicates
delivery.postfix_log_lines.find_or_create_by(values)
else
puts "Skipping address #{to} from postfix queue id #{queue_id} - it's not recognised: #{line}"
end
end
end
def self.match_main_content(line)
# Assume the log file was written using syslog and parse accordingly
p = SyslogProtocol.parse("<13>" + line)
content_match = p.content.match /^postfix\/(\w+)\[(\d+)\]: (([0-9A-F]+): )?(.*)/
program_content = content_match[5]
to_match = program_content.match(/to=<([^>]+)>/)
relay_match = program_content.match(/relay=([^,]+)/)
delay_match = program_content.match(/delay=([^,]+)/)
delays_match = program_content.match(/delays=([^,]+)/)
dsn_match = program_content.match(/dsn=([^,]+)/)
status_match = program_content.match(/status=(.*)$/)
result = {
:time => p.time,
:program => content_match[1],
:queue_id => content_match[4],
}
result[:to] = to_match[1] if to_match
result[:relay] = relay_match[1] if relay_match
result[:delay] = delay_match[1] if delay_match
result[:delays] = delays_match[1] if delays_match
result[:dsn] = dsn_match[1] if dsn_match
result[:extended_status] = status_match[1] if status_match
result
end
end
| 27.95 | 141 | 0.639982 |
39c09323164a0ce795d9c6749205b3379e8e8e20 | 4,278 | module Fog
module Network
class OpenStack
class Real
# Create a new security group
#
# ==== Parameters
# * options<~Hash>:
# * 'name'<~String> - Name of the security group
# * 'description'<~String> - Description of the security group
# * 'tenant_id'<~String> - TenantId different than the current user, that should own the security group. Only allowed if user has 'admin' role.
#
# ==== Returns
# * response<~Excon::Response>:
# * body<~Hash>:
# * 'security_groups'<~Array>:
# * 'id'<~String> - UUID of the security group
# * 'name'<~String> - Name of the security group
# * 'description'<~String> - Description of the security group
# * 'tenant_id'<~String> - Tenant id that owns the security group
# * 'security_group_rules'<~Array>: - Array of security group rules
# * 'id'<~String> - UUID of the security group rule
# * 'direction'<~String> - Direction of traffic, must be in ['ingress', 'egress']
# * 'port_range_min'<~Integer> - Start port for rule i.e. 22 (or -1 for ICMP wildcard)
# * 'port_range_max'<~Integer> - End port for rule i.e. 22 (or -1 for ICMP wildcard)
# * 'protocol'<~String> - IP protocol for rule, must be in ['tcp', 'udp', 'icmp']
# * 'ethertype'<~String> - Type of ethernet support, must be in ['IPv4', 'IPv6']
# * 'security_group_id'<~String> - UUID of the parent security group
# * 'remote_group_id'<~String> - UUID of the remote security group
# * 'remote_ip_prefix'<~String> - IP cidr range address i.e. '0.0.0.0/0'
# * 'tenant_id'<~String> - Tenant id that owns the security group rule
def create_security_group(options = {})
data = {"security_group" => {}}
desired_options = [:name, :description, :tenant_id]
selected_options = desired_options.select{|o| options[o]}
selected_options.each { |key| data["security_group"][key] = options[key] }
request(
:body => Fog::JSON.encode(data),
:expects => 201,
:method => "POST",
:path => "security-groups"
)
end
end
class Mock
def create_security_group(options = {})
# Spaces are NOT removed from name and description, as in case of compute sec groups
tenant_id = Fog::Mock.random_numbers(14).to_s
sec_group_id = Fog::UUID.uuid
response = Excon::Response.new
response.status = 201
# by default every security group will come setup with an egress rule to "allow all out"
data = {
"security_group_rules" => [
{ "remote_group_id" => nil,
"direction" => "egress",
"remote_ip_prefix" => nil,
"protocol" => nil,
"ethertype" => "IPv4",
"tenant_id" => tenant_id,
"port_range_max" => nil,
"port_range_min" => nil,
"id" => Fog::UUID.uuid,
"security_group_id" => sec_group_id
},
{ "remote_group_id" => nil,
"direction" => "egress",
"remote_ip_prefix" => nil,
"protocol" => nil,
"ethertype" => "IPv6",
"tenant_id" => tenant_id,
"port_range_max" => nil,
"port_range_min" => nil,
"id" => Fog::UUID.uuid,
"security_group_id" => sec_group_id
}
],
"id" => sec_group_id,
"tenant_id" => tenant_id,
"name" => options[:name] || "",
"description" => options[:description] || ""
}
self.data[:security_groups][data["id"]] = data
response.body = {"security_group" => data}
response
end
end
end
end
end
| 45.031579 | 153 | 0.491117 |
f76d1d6acb05529c6b6836516aef743e43105cc0 | 337 | # frozen_string_literal: true
require 'active_support/concern'
module BetterRecord
module Authenticatable
extend ActiveSupport::Concern
included do
include BetterRecord::JWT::ControllerMethods
before_action :check_user
if use_bearer_token
after_action :set_auth_header
end
end
end
end
| 17.736842 | 50 | 0.732938 |
7a90572dc56a8bd329e37f077d63816af1457b99 | 327 | require 'rails_helper'
require 'dwca/generator'
describe Dwca::Generator do
specify "stores a compressed file in rails' temp directory" do
path = Dwca::Generator.get_archive
expect(File.exists?(path)).to be_truthy
File.delete(path)
expect(path.to_s.index(Rails.root.join('tmp').to_s)).to eq(0)
end
end
| 23.357143 | 65 | 0.718654 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.