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
d5ea3e43a1d1989ca4043a277f536ba99d690b90
555
class Approval::ApprovalFlow < ApplicationRecord include Sys::Model::Base include Cms::Model::Rel::Content include Cms::Model::Auth::Content column_attribute :sort_no, default: 10 # Content belongs_to :content, class_name: 'Approval::Content::ApprovalFlow', required: true belongs_to :group, class_name: 'Sys::Group' has_many :approvals, dependent: :destroy has_many :approval_requests, dependent: :destroy validates :title, presence: true scope :for_user, ->(user) { where(group_id: [nil] + user.groups.map(&:id)) } end
25.227273
84
0.722523
bbc122cc9ec351756dafb7dd5a8e527ee7e965ad
7,485
# Copyright 2020 Google LLC # # 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 'date' require 'google/apis/core/base_service' require 'google/apis/core/json_representation' require 'google/apis/core/hashable' require 'google/apis/errors' module Google module Apis module AdexchangebuyerV1_2 class Account class Representation < Google::Apis::Core::JsonRepresentation; end class BidderLocation class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end include Google::Apis::Core::JsonObjectSupport end class AccountsList class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Creative class Representation < Google::Apis::Core::JsonRepresentation; end class Correction class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class DisapprovalReason class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class FilteringReasons class Representation < Google::Apis::Core::JsonRepresentation; end class Reason class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end include Google::Apis::Core::JsonObjectSupport end include Google::Apis::Core::JsonObjectSupport end class CreativesList class Representation < Google::Apis::Core::JsonRepresentation; end include Google::Apis::Core::JsonObjectSupport end class Account # @private class Representation < Google::Apis::Core::JsonRepresentation collection :bidder_location, as: 'bidderLocation', class: Google::Apis::AdexchangebuyerV1_2::Account::BidderLocation, decorator: Google::Apis::AdexchangebuyerV1_2::Account::BidderLocation::Representation property :cookie_matching_nid, as: 'cookieMatchingNid' property :cookie_matching_url, as: 'cookieMatchingUrl' property :id, as: 'id' property :kind, as: 'kind' property :maximum_active_creatives, as: 'maximumActiveCreatives' property :maximum_total_qps, as: 'maximumTotalQps' property :number_active_creatives, as: 'numberActiveCreatives' end class BidderLocation # @private class Representation < Google::Apis::Core::JsonRepresentation property :maximum_qps, as: 'maximumQps' property :region, as: 'region' property :url, as: 'url' end end end class AccountsList # @private class Representation < Google::Apis::Core::JsonRepresentation collection :items, as: 'items', class: Google::Apis::AdexchangebuyerV1_2::Account, decorator: Google::Apis::AdexchangebuyerV1_2::Account::Representation property :kind, as: 'kind' end end class Creative # @private class Representation < Google::Apis::Core::JsonRepresentation property :html_snippet, as: 'HTMLSnippet' property :account_id, as: 'accountId' collection :advertiser_id, as: 'advertiserId' property :advertiser_name, as: 'advertiserName' property :agency_id, :numeric_string => true, as: 'agencyId' property :api_upload_timestamp, as: 'apiUploadTimestamp', type: DateTime collection :attribute, as: 'attribute' property :buyer_creative_id, as: 'buyerCreativeId' collection :click_through_url, as: 'clickThroughUrl' collection :corrections, as: 'corrections', class: Google::Apis::AdexchangebuyerV1_2::Creative::Correction, decorator: Google::Apis::AdexchangebuyerV1_2::Creative::Correction::Representation collection :disapproval_reasons, as: 'disapprovalReasons', class: Google::Apis::AdexchangebuyerV1_2::Creative::DisapprovalReason, decorator: Google::Apis::AdexchangebuyerV1_2::Creative::DisapprovalReason::Representation property :filtering_reasons, as: 'filteringReasons', class: Google::Apis::AdexchangebuyerV1_2::Creative::FilteringReasons, decorator: Google::Apis::AdexchangebuyerV1_2::Creative::FilteringReasons::Representation property :height, as: 'height' collection :impression_tracking_url, as: 'impressionTrackingUrl' property :kind, as: 'kind' collection :product_categories, as: 'productCategories' collection :restricted_categories, as: 'restrictedCategories' collection :sensitive_categories, as: 'sensitiveCategories' property :status, as: 'status' collection :vendor_type, as: 'vendorType' property :version, as: 'version' property :video_url, as: 'videoURL' property :width, as: 'width' end class Correction # @private class Representation < Google::Apis::Core::JsonRepresentation collection :details, as: 'details' property :reason, as: 'reason' end end class DisapprovalReason # @private class Representation < Google::Apis::Core::JsonRepresentation collection :details, as: 'details' property :reason, as: 'reason' end end class FilteringReasons # @private class Representation < Google::Apis::Core::JsonRepresentation property :date, as: 'date' collection :reasons, as: 'reasons', class: Google::Apis::AdexchangebuyerV1_2::Creative::FilteringReasons::Reason, decorator: Google::Apis::AdexchangebuyerV1_2::Creative::FilteringReasons::Reason::Representation end class Reason # @private class Representation < Google::Apis::Core::JsonRepresentation property :filtering_count, :numeric_string => true, as: 'filteringCount' property :filtering_status, as: 'filteringStatus' end end end end class CreativesList # @private class Representation < Google::Apis::Core::JsonRepresentation collection :items, as: 'items', class: Google::Apis::AdexchangebuyerV1_2::Creative, decorator: Google::Apis::AdexchangebuyerV1_2::Creative::Representation property :kind, as: 'kind' property :next_page_token, as: 'nextPageToken' end end end end end
39.394737
229
0.644623
3999b436f667b22852f1048cd56c8dbb4c201cd8
1,049
class Seqkit < Formula # Shen_2016: "https://doi.org/10.1371/journal.pone.0163962" desc "Ultrafast FASTA/Q file manipulation" homepage "https://bioinf.shenwei.me/seqkit/" # We use binaries to avoid compiling Go code if OS.mac? url "https://github.com/shenwei356/seqkit/releases/download/v0.10.0/seqkit_darwin_amd64.tar.gz" sha256 "73d446b961d65e814bdad49f91aa9ae56bee08163800eb9e3615b5281972d458" else url "https://github.com/shenwei356/seqkit/releases/download/v0.10.0/seqkit_linux_amd64.tar.gz" sha256 "4d286e08df697ab0e66e79b7b953f52361afd14855be4905193833746da47798" end version "0.10.0" bottle do root_url "https://linuxbrew.bintray.com/bottles-bio" cellar :any_skip_relocation sha256 "741feef9e75df707b1af3123a1acbae39a7bebeabb3c89159537e5528e221e33" => :sierra sha256 "0a0371893365cf4a6a493eab9d367f054e2e63a1cf5e1d010cf1d4c3a17dba47" => :x86_64_linux end def install bin.install "seqkit" end test do assert_match version.to_s, shell_output("#{bin}/seqkit 2>&1") end end
34.966667
99
0.771211
bbe3c76ed58639313361136e05b5f7c87729c1a0
4,175
module Spree class BookkeepingDocument < ActiveRecord::Base PERSISTED_ATTRS = [ :firstname, :lastname, :email, :total, :number ] # Spree::BookkeepingDocument cares about creating PDFs. Whenever it needs to know # anything about the document to send to the view, it asks a view object. # # +printable+ should be an Object, such as Spree::Order or Spree::Shipment. # template should be a string, such as "invoice" or "packaging_slip" # belongs_to :printable, polymorphic: true validates :printable, :template, presence: true validates *PERSISTED_ATTRS, presence: true, if: -> { self.persisted? } scope :invoices, -> { where(template: 'invoice') } before_create :copy_view_attributes after_save :after_save_actions # An instance of Spree::Printable::#{YourModel}::#{YourTemplate}Presenter # def view @_view ||= view_class.new(printable) end def date created_at.to_date end def template_name "spree/printables/#{single_lower_case_name(printable.class.name)}/#{template}" end # If the document is called from the view with some method it doesn't know, # just call the view object. It should know. def method_missing(method_name, *args, &block) if view.respond_to? method_name view.send(method_name, *args, &block) else super end end def document_type "#{printable_type.demodulize.tableize.singularize}_#{template}" end # Returns the given template as pdf binary suitable for Rails send_data # # If the file is already present it returns this # else it generates a new file, stores and returns this. # # You can disable the pdf file generation with setting # # Spree::PrintInvoice::Config.store_pdf to false # def pdf if Spree::PrintInvoice::Config.store_pdf send_or_create_pdf else render_pdf end end # = The PDF file_name # def file_name @_file_name ||= "#{template}-D#{id}-N#{number}.pdf" end # = PDF file path # def file_path @_file_path ||= Rails.root.join(storage_path, "#{file_name}") end # = PDF storage folder path for given template name # # Configure the storage path with +Spree::PrintInvoice::Config.storage_path+ # # Each template type gets it own pluralized folder inside # of +Spree::PrintInvoice::Config.storage_path+ # # == Example: # # storage_path('invoice') => "tmp/pdf_prints/invoices" # # Creates the folder if it's not present yet. # def storage_path storage_path = Rails.root.join(Spree::PrintInvoice::Config.storage_path, template.pluralize) FileUtils.mkdir_p(storage_path) storage_path end # Renders the prawn template for give template name in context of ActionView. # # Prawn templates need to be placed in the correct folder. For example, for a PDF from # a Spree::Order with the invoice template, it would be # the +app/views/spree/printables/order/invoices+ folder. # # Assigns +@doc+ instance variable # def render_pdf ApplicationController.render( template: "#{template_name}.pdf.prawn", assigns: { doc: self } ) end private def copy_view_attributes PERSISTED_ATTRS.each do |attr| send("#{attr}=", view.send(attr)) end end # For a Spree::Order printable and an "invoice" template, # you would get "spree/documents/order/invoice_view" # --> Spree::Printables::Order::InvoiceView # def view_class @_view_class ||= "#{template_name}_view".classify.constantize end def single_lower_case_name(class_string) @_single_lower_class_name ||= class_string.demodulize.tableize.singularize end # Sends stored pdf for given template from disk. # # Renders and stores it if it's not yet present. # def send_or_create_pdf unless File.exist?(file_path) File.open(file_path, 'wb') { |f| f.puts render_pdf } end IO.binread(file_path) end end end
28.020134
98
0.654132
33a150fd15b6cd53f1f02765b7d6897a7d12aed8
826
Gem::Specification.new do |s| s.name = 'aws-s3' s.version = '0.6.2.20110114001' s.summary = "Client library for Amazon's Simple Storage Service's REST API" s.description = s.summary s.email = '[email protected]' s.author = 'Marcel Molina Jr.' s.has_rdoc = true s.extra_rdoc_files = %w(README COPYING INSTALL) s.homepage = 'http://amazon.rubyforge.org' s.rubyforge_project = 'amazon' s.files = ['Rakefile'] + Dir['lib/**/*.rb'] + Dir['bin/*'] + Dir['support/**/*.rb'] s.executables << 's3sh' s.test_files = Dir['test/**/*'] s.add_dependency 'xml-simple' s.add_dependency 'builder' s.add_dependency 'mime-types' s.rdoc_options = ['--title', "AWS::S3 -- Support for Amazon S3's REST api", '--main', 'README', '--line-numbers', '--inline-source'] end
35.913043
85
0.617433
62e80425ed5e3be1f80736230f16429ae9845b6d
1,294
module Kit::Auth::Endpoints::Web::Users::Settings::Oauth::Index def self.endpoint(router_conn:) Kit::Organizer.call( list: [ [:alias, :web_require_session_user!], self.method(:list), self.method(:render), ], ctx: { router_conn: router_conn }, ) end Kit::Router::Services::Router.register( uid: 'kit_auth|web|settings|oauth|index', aliases: { 'web|settings|oauth|index': { 'web|settings|oauth' => [ # OAuth 'web|users|oauth|sign_in|after_with_new_identity', 'web|users|oauth|new_identity', 'web|users|oauth|error|already_linked', 'web|users|oauth|error|users_oauth_identity_conflict', 'web|users|oauth|error|users_conflict', ], }, }, target: self.method(:endpoint), ) def self.list(router_conn:) list = Kit::Auth::Models::Read::UserOauthIdentity .where(user_id: router_conn.metadata[:session_user].id) .load [:ok, list: list] end def self.render(router_conn:, list:) Kit::Domain::Endpoints::Http.render( router_conn: router_conn, component: Kit::Auth::Components::Pages::Users::Settings::Oauth::IndexComponent, params: { list: list, }, ) end end
25.88
88
0.602009
e9a09b69228ca43c88e711dec5541f708e7617e9
6,974
=begin #OpenAPI Petstore #This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\ OpenAPI spec version: 1.0.0 Generated by: https://openapi-generator.tech OpenAPI Generator version: 3.1.1-SNAPSHOT =end require 'date' module Petstore class MapTest attr_accessor :map_map_of_string attr_accessor :map_of_enum_string attr_accessor :direct_map attr_accessor :indirect_map class EnumAttributeValidator attr_reader :datatype attr_reader :allowable_values def initialize(datatype, allowable_values) @allowable_values = allowable_values.map do |value| case datatype.to_s when /Integer/i value.to_i when /Float/i value.to_f else value end end end def valid?(value) !value || allowable_values.include?(value) end end # Attribute mapping from ruby-style variable name to JSON key. def self.attribute_map { :'map_map_of_string' => :'map_map_of_string', :'map_of_enum_string' => :'map_of_enum_string', :'direct_map' => :'direct_map', :'indirect_map' => :'indirect_map' } end # Attribute type mapping. def self.openapi_types { :'map_map_of_string' => :'Hash<String, Hash<String, String>>', :'map_of_enum_string' => :'Hash<String, String>', :'direct_map' => :'Hash<String, BOOLEAN>', :'indirect_map' => :'StringBooleanMap' } end # Initializes the object # @param [Hash] attributes Model attributes in the form of hash def initialize(attributes = {}) return unless attributes.is_a?(Hash) # convert string to symbol for hash key attributes = attributes.each_with_object({}) { |(k, v), h| h[k.to_sym] = v } if attributes.has_key?(:'map_map_of_string') if (value = attributes[:'map_map_of_string']).is_a?(Hash) self.map_map_of_string = value end end if attributes.has_key?(:'map_of_enum_string') if (value = attributes[:'map_of_enum_string']).is_a?(Hash) self.map_of_enum_string = value end end if attributes.has_key?(:'direct_map') if (value = attributes[:'direct_map']).is_a?(Hash) self.direct_map = value end end if attributes.has_key?(:'indirect_map') self.indirect_map = attributes[:'indirect_map'] 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 && map_map_of_string == o.map_map_of_string && map_of_enum_string == o.map_of_enum_string && direct_map == o.direct_map && indirect_map == o.indirect_map end # @see the `==` method # @param [Object] Object to be compared def eql?(o) self == o end # Calculates hash code according to all attributes. # @return [Fixnum] Hash code def hash [map_map_of_string, map_of_enum_string, direct_map, indirect_map].hash 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 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 temp_model = Petstore.const_get(type).new temp_model.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) next if value.nil? 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.179916
157
0.618727
1c6aba968eda9941cf1e1eef7a86429a7c045243
856
# # Be sure to run `pod lib lint GLArithmetic.podspec' to ensure this is a # valid spec before submitting. # # Any lines starting with a # are optional, but their use is encouraged # To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html # Pod::Spec.new do |s| s.name = 'GLArithmetic' s.version = '0.2.3' s.summary = 'GLArithmetic.' s.description = <<-DESC GLArithmetic Caculate DESC s.homepage = 'https://gitee.com/guoleiCoder' s.license = { :type => 'MIT', :file => 'LICENSE' } s.author = { 'guolei' =>'[email protected]' } s.source = { :git => 'https://github.com/GreyLove/GLArithmetic.git', :tag => s.version.to_s } s.ios.deployment_target = '7.0' s.source_files = 'GLArithmetic/Classes/**/*' end
29.517241
105
0.598131
6a91027677c75ae21a05aa48e638b240e1f1fc3b
45
collection @users extends 'api/v1/users/show'
22.5
27
0.8
bb15972ff99d0487f9720d19e843505ed18a2c83
4,697
require_relative "../helper" require "fluent/test/driver/output" require "fluent/plugin/out_rabbitmq" class RabbitMQOutputTest < Test::Unit::TestCase def setup Fluent::Test.setup @time = Fluent::Engine.now @tag = "test.test" bunny = Bunny.new bunny.start @channel = bunny.create_channel @queue = @channel.queue("test_out_fanout") fanout_exchange = Bunny::Exchange.new(@channel, "fanout", "test_out_fanout") @queue.bind(fanout_exchange) end def teardown super Fluent::Engine.stop end CONFIG = %[ host localhost port 5672 user guest pass guest vhost / exchange test_out_fanout exchange_type fanout heartbeat 10 ] def create_driver(conf = CONFIG) Fluent::Test::Driver::Output.new(Fluent::Plugin::RabbitMQOutput).configure(conf) end def test_configure d = create_driver assert_equal "localhost", d.instance.host assert_equal 5672, d.instance.port assert_equal "guest", d.instance.user assert_equal "guest", d.instance.pass assert_equal "/", d.instance.vhost assert_equal "test_out_fanout", d.instance.exchange assert_equal "fanout", d.instance.exchange_type assert_equal 10, d.instance.heartbeat end def test_start_and_shutdown d = create_driver d.instance.start d.instance.shutdown end def test_emit d = create_driver record = {"test_emit" => 1} d.run(default_tag: "test.test") do d.feed(@time, record) end _, _, body = @queue.pop assert_equal(record, JSON.parse(body)) end def test_topic d = create_driver(%[ exchange test_out_topic exchange_type topic routing_key test_out_topic ]) queue = @channel.queue("test_out_topic") topic_exchange = Bunny::Exchange.new(@channel, "topic", "test_out_topic") queue.bind(topic_exchange, routing_key: "test_out_topic") record = {"test_topic" => 1} d.run(default_tag: "test.test") do d.feed(@time, record) end _, _, body = queue.pop assert_equal(record, JSON.parse(body)) end def test_timestamp d = create_driver(%[ exchange test_out_fanout exchange_type fanout timestamp true ]) record = {"test_timestamp" => true} d.run(default_tag: "test.test") do d.feed(@time, record) end _, properties, _ = @queue.pop assert_equal(@time, properties[:timestamp].to_i) end def test_id_key d = create_driver(%[ exchange test_out_fanout exchange_type fanout id_key test_id ]) message_id = "abc123" record = {"test_id" => message_id, "foo" => "bar"} d.run(default_tag: "test.test") do d.feed(@time, record) end _, properties, _ = @queue.pop assert_equal(message_id, properties[:message_id]) end def test_server_interval d = create_driver(%[ exchange test exchange_type fanout heartbeat server ]) assert_equal(:server, d.instance.heartbeat) end def test_server_interval_invalid_string assert_raise ArgumentError do create_driver(%[ exchange test exchange_type fanout heartbeat invalid ]) end end def test_emit_ltsv d = create_driver(%[ exchange test_out_fanout exchange_type fanout format ltsv ]) record = {test_emit_ltsv: "2"} d.run(default_tag: "test.test") do d.feed(@time, record) end _, _, body = @queue.pop assert_equal(record, LTSV.parse(body).first) end def test_emit_msgpack d = create_driver(%[ exchange test_out_fanout exchange_type fanout format msgpack ]) record = {"test_emit_msgpack" => true} d.run(default_tag: "test.test") do d.feed(@time, record) end _, _, body = @queue.pop assert_equal(record, MessagePack.unpack(body)) end def test_emit_single_value d = create_driver(%[ exchange test_out_fanout exchange_type fanout format single_value ]) string = "test_emit_single_value" record = {"message" => string} d.run(default_tag: "test.test") do d.feed(@time, record) end _, _, body = @queue.pop body.force_encoding("utf-8") assert_equal(string, body.chomp) end def test_buffered_emit d = create_driver(%[ exchange test_out_fanout exchange_type fanout format json timestamp true <buffer> </buffer> ]) record = {"test_emit" => 1} d.run(default_tag: "test.test") do d.feed(@time, record) end _, properties, body = @queue.pop assert_equal(record, JSON.parse(body)) assert_equal(@time, properties[:timestamp].to_i) end end
22.051643
84
0.650841
acca5216a0e899517a351e90c88f778ab49060bf
456
Pod::Spec.new do |s| s.name = 'Base32' s.version = '1.0.2' s.license = 'Public Domain' s.summary = 'RFC 4648 Base32 implementation in Objective-C ARC.' s.homepage = 'http://github.com/ekscrypto/Base32' s.author = { 'Dave Poirier' => '[email protected]' } s.source = { :git => 'https://github.com/ekscrypto/Base32.git', :tag => '1.0.2' } s.source_files = 'Classes', 'Base32/MF_Base32Additions.{h,m}' s.requires_arc = true end
38
85
0.638158
acefae4f3a04cb10785fc4e8113bcdcd63d56203
79
# frozen_string_literal: true require_relative '../asciidoctor/pdf/converter'
19.75
47
0.810127
ff7e7aee46d8b0e64c7dd514f908648022b61cf8
3,876
describe AirbrakeApi::V3::NoticeParser do let(:app) { Fabricate(:app) } let(:notifier_params) do { "name" => "notifiername", "version" => "notifierversion", "url" => "notifierurl" } end it "raises error when errors attribute is missing" do expect do described_class.new({}).report end.to raise_error(AirbrakeApi::ParamsError) expect do described_class.new("errors" => []).report end.to raise_error(AirbrakeApi::ParamsError) end it "does not raise an error for the optional environment field" do expect do described_class.new("errors" => ["MyError"]).report end.not_to raise_error end it "parses JSON payload and returns ErrorReport" do params = build_params_for("api_v3_request.json", key: app.api_key) report = described_class.new(params).report notice = report.generate_notice! expect(report.error_class).to eq("Error") expect(report.message).to eq("Error: TestError") expect(report.backtrace.lines.size).to eq(9) expect(notice.user_attributes).to include( "id" => 1, "name" => "John Doe", "email" => "[email protected]", "username" => "john" ) expect(notice.session).to include("isAdmin" => true) expect(notice.params).to include("returnTo" => "dashboard") expect(notice.env_vars).to include( "navigator_vendor" => "Google Inc.", "HTTP_USER_AGENT" => "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_9_5) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/39.0.2171.99 Safari/537.36" ) end it "parses JSON payload when api_key is missing but project_id is present" do params = build_params_for("api_v3_request.json", key: nil, project_id: app.api_key) report = described_class.new(params).report expect(report).to be_valid end it "parses JSON payload with missing backtrace" do json = Rails.root.join("spec", "fixtures", "api_v3_request_without_backtrace.json").read params = JSON.parse(json) params["key"] = app.api_key report = described_class.new(params).report report.generate_notice! expect(report.error_class).to eq("Error") expect(report.message).to eq("Error: TestError") expect(report.backtrace.lines.size).to eq(0) end it "parses JSON payload with deprecated user keys" do params = build_params_for("api_v3_request_with_deprecated_user_keys.json", key: app.api_key) report = AirbrakeApi::V3::NoticeParser.new(params).report notice = report.generate_notice! expect(notice.user_attributes).to include( "id" => 1, "name" => "John Doe", "email" => "[email protected]", "username" => "john" ) end it "takes the notifier from root" do parser = described_class.new( "errors" => ["MyError"], "notifier" => notifier_params, "environment" => {}) expect(parser.attributes[:notifier]).to eq(notifier_params) end it "takes the notifier from the context" do parser = described_class.new( "errors" => ["MyError"], "context" => { "notifier" => notifier_params }, "environment" => {}) expect(parser.attributes[:notifier]).to eq(notifier_params) end it "takes the hostname from the context" do parser = described_class.new( "errors" => ["MyError"], "context" => { "hostname" => "app01.infra.example.com", "url" => "http://example.com/some-page" }, "environment" => {}) expect(parser.attributes[:server_environment]["hostname"]).to eq("app01.infra.example.com") end def build_params_for(fixture, options={}) json = Rails.root.join("spec", "fixtures", fixture).read data = JSON.parse(json) data["key"] = options[:key] if options.key?(:key) data["project_id"] = options[:project_id] if options.key?(:project_id) data end end
32.847458
149
0.653767
288a7e0d41a55d024c5a87d291d9b794c6661efc
1,015
# frozen_string_literal: true module Gitlab module Checks class PushFileCountCheck < BaseChecker attr_reader :repository, :newrev, :limit, :logger LOG_MESSAGES = { diff_content_check: "Validating diff contents being single file..." }.freeze ERROR_MESSAGES = { upper_limit: "The repository can contain at most %{limit} file(s).", lower_limit: "The repository must contain at least 1 file." }.freeze def initialize(change, repository:, limit:, logger:) @repository = repository @newrev = change[:newrev] @limit = limit @logger = logger end def validate! file_count = repository.ls_files(newrev).size if file_count > limit raise ::Gitlab::GitAccess::ForbiddenError, ERROR_MESSAGES[:upper_limit] % { limit: limit } end if file_count == 0 raise ::Gitlab::GitAccess::ForbiddenError, ERROR_MESSAGES[:lower_limit] end end end end end
26.710526
100
0.629557
f88ac0f91a0235d6d551b765c62bcab52617349b
3,036
module SynapsePayRest class CardUsNode < BaseNode class << self private def payload_for_create(nickname:, document_id:, card_type:, **options) args = { type: 'CARD-US', nickname: nickname, document_id: document_id, card_type: card_type, }.merge(options) super(args) end end def update_preferences(**options) if options.empty? raise ArgumentError, 'must provide some key-value pairs to update' end payload = payload_for_preferences(options) response = user.client.nodes.patch(user_id: user.id, node_id: id, payload: payload) self.class.from_response(user, response) end def update_allowed(allowed:) if allowed.empty? raise ArgumentError, 'must provide some key-value pairs to update' end payload = { 'allowed': allowed } response = user.client.nodes.patch(user_id: user.id, node_id: id, payload: payload) self.class.from_response(user, response) end # Reissues Debit Card on a node # Use Reissue if you wish to change the card number associated with the debit card. # This is meant to be used in instances where the user wishes to change their existing card # number (due to fraud or any other reason). # # @raise [SynapsePayRest::Error] if wrong guess or HTTP error # # @return [SynapsePayRest::CardUsNode] def reissue_card() response = user.client.nodes.reissue_card(user_id: user.id, node_id: id) self.class.from_response(user, response) end # Reorders Debit Card on a node # Use Reorder if the user wishes to keep the same card number but want to order a new plastic. #Can be used in scenarios where the user's card was destroyed. # # @raise [SynapsePayRest::Error] if wrong guess or HTTP error # # @return [SynapsePayRest::cardUsNode] def reorder_card() response = user.client.nodes.reorder_card(user_id: user.id, node_id: id) self.class.from_response(user, response) end private def payload_for_preferences(**options) payload = { 'preferences' => {} } if options[:allow_foreign_transactions] payload['preferences']['allow_foreign_transactions'] = options[:allow_foreign_transactions] end if options[:atm_withdrawal_limit] payload['preferences']['atm_withdrawal_limit'] = options[:atm_withdrawal_limit] end if options[:max_pin_attempts] payload['preferences']['max_pin_attempts'] = options[:max_pin_attempts] end if options[:pos_withdrawal_limit] payload['preferences']['pos_withdrawal_limit'] = options[:pos_withdrawal_limit] end if options[:security_alerts] payload['preferences']['security_alerts'] = options[:security_alerts] end payload end end end
32.645161
101
0.635375
ff1ba36eb8e98fc633eae5c2dc5fec91c3705e18
839
RSpec.describe Log4r::DateDirectoryFileOutputter do before do Timecop.freeze(2018, 1, 23) end let(:params) { { file_path: '/tmp/%Y/%m/%d/request.log', trunc: 'false' } } it 'should be directory file path' do outputter = described_class.new('logfile', params) file_path = outputter.instance_variable_get(:@out).path expect(file_path).to eq('/tmp/2018/01/23/request.log') end it 'should change directory file path' do outputter = described_class.new('logfile', params) Timecop.freeze(2018, 1, 24) file_path = outputter.instance_variable_get(:@out).path expect(file_path).to eq('/tmp/2018/01/23/request.log') outputter.send(:write, 'test') file_path = outputter.instance_variable_get(:@out).path expect(file_path).to eq('/tmp/2018/01/24/request.log') end end
28.931034
59
0.681764
28c90c088e0d5a72bcfa78d9825eeaa2b35922d5
73
class BestSellerList < ActiveRecord::Base has_many :best_sellers end
12.166667
41
0.794521
f8e0700e7a3c8b44821b29fe07bdd34dd6c02a7c
552
require 'formula' class Capnp < Formula homepage 'http://kentonv.github.io/capnproto/' url 'http://capnproto.org/capnproto-c++-0.4.1.tar.gz' sha1 '18ce1a404c2bf68e6625e44927bfe6b67186cb15' needs :cxx11 def install system "./configure", "--disable-debug", "--disable-dependency-tracking", "--disable-silent-rules", "--prefix=#{prefix}" system "make", "check" system "make", "install" end test do system "#{bin}/capnp", "--version" end end
24
58
0.576087
ac6dd3a29ca4923998e0d677115a93804b628c16
8,385
# frozen_string_literal: true require 'rails_helper' RSpec.describe Spree::OrderInventory, type: :model do let(:order) { create :completed_order_with_totals } let(:line_item) { order.line_items.first } let(:shipment) { order.shipments.first } let(:variant) { subject.variant } let(:stock_item) { shipment.stock_location.stock_item(variant) } subject { described_class.new(order, line_item) } context "insufficient inventory units" do let(:old_quantity) { 1 } let(:new_quantity) { 3 } before do line_item.update_attributes!(quantity: old_quantity) line_item.update_column(:quantity, new_quantity) subject.line_item.reload end it 'creates the proper number of inventory units' do expect(line_item.inventory_units.count).to eq(old_quantity) subject.verify(shipment) expect(line_item.inventory_units.count).to eq(new_quantity) end it "unstocks items" do expect { subject.verify(shipment) }.to change { stock_item.reload.count_on_hand }.by(-2) end context "order is not completed" do before { order.update_columns completed_at: nil } it "doesn't unstock items" do expect { subject.verify(shipment) }.not_to change { stock_item.reload.count_on_hand } end end context "inventory units state" do before { shipment.inventory_units.destroy_all } let(:new_quantity) { 5 } it 'sets inventory_units state as per stock location availability' do stock_item.update_columns( backorderable: true, count_on_hand: 3 ) subject.verify units = shipment.inventory_units_for(subject.variant).group_by(&:state) expect(units['backordered'].size).to eq(2) expect(units['on_hand'].size).to eq(3) end end context "store doesnt track inventory" do let(:new_quantity) { 1 } before { Spree::Config.track_inventory_levels = false } it "creates on hand inventory units" do variant.stock_items.each(&:really_destroy!) subject.verify(shipment) units = shipment.inventory_units_for(variant) expect(units.count).to eq 1 expect(units.first).to be_on_hand end end context "variant doesnt track inventory" do before { variant.update_attributes!(track_inventory: false) } let(:new_quantity) { 1 } it "creates on hand inventory units" do variant.stock_items.each(&:really_destroy!) subject.verify(shipment) units = shipment.inventory_units_for(variant) expect(units.count).to eq 1 expect(units.first).to be_on_hand end end it 'should create stock_movement' do expect(subject.send(:add_to_shipment, shipment, 5)).to eq(5) stock_item = shipment.stock_location.stock_item(subject.variant) movement = stock_item.stock_movements.last expect(movement.originator).to eq(shipment) expect(movement.quantity).to eq(-5) end context "calling multiple times" do it "creates the correct number of inventory units" do line_item.update_columns(quantity: 2) subject.verify(shipment) expect(line_item.inventory_units.count).to eq(2) line_item.update_columns(quantity: 3) subject.verify(shipment) expect(line_item.inventory_units.count).to eq(3) end end end context "#determine_target_shipment" do let(:stock_location) { create :stock_location } let(:variant) { line_item.variant } before do subject.verify order.shipments.create(stock_location_id: stock_location.id, cost: 5) shipped = order.shipments.create(stock_location_id: order.shipments.first.stock_location.id, cost: 10) shipped.update_column(:state, 'shipped') end it 'should select first non-shipped shipment that already contains given variant' do shipment = subject.send(:determine_target_shipment) expect(shipment.shipped?).to be false expect(shipment.inventory_units_for(variant)).not_to be_empty expect(variant.stock_location_ids.include?(shipment.stock_location_id)).to be true end context "when no shipments already contain this varint" do before do subject.line_item.reload subject.inventory_units.destroy_all end it 'selects first non-shipped shipment that leaves from same stock_location' do shipment = subject.send(:determine_target_shipment) shipment.reload expect(shipment.shipped?).to be false expect(shipment.inventory_units_for(variant)).to be_empty expect(variant.stock_location_ids.include?(shipment.stock_location_id)).to be true end end end context 'when order has too many inventory units' do let(:old_quantity) { 3 } let(:new_quantity) { 2 } before do line_item.update_attributes!(quantity: old_quantity) line_item.update_column(:quantity, new_quantity) subject.line_item.reload end it 'should be a messed up order' do expect(order.shipments.first.inventory_units_for(line_item.variant).size).to eq(3) expect(line_item.quantity).to eq(2) end it 'should decrease the number of inventory units' do subject.verify expect(line_item.inventory_units.count).to eq 2 expect(order.inventory_units.count).to eq 2 end context "order is not completed" do before { order.update_columns(completed_at: nil) } it "doesn't restock items" do expect(shipment.stock_location).not_to receive(:restock) expect { subject.verify(shipment) }.not_to change { stock_item.reload.count_on_hand } expect(line_item.inventory_units.count).to eq(new_quantity) end end it 'should change count_on_hand' do expect { subject.verify(shipment) }.to change { stock_item.reload.count_on_hand }.by(1) end it 'should create stock_movement' do stock_item = shipment.stock_location.stock_item(variant) expect { subject.verify(shipment) }.to change { stock_item.stock_movements.count }.by(1) movement = stock_item.stock_movements.last expect(movement.originator).to eq shipment expect(movement.quantity).to eq(1) end context 'with some backordered' do let(:new_quantity) { 1 } before do line_item.inventory_units[0].update_columns(state: 'backordered') line_item.inventory_units[1].update_columns(state: 'on_hand') line_item.inventory_units[2].update_columns(state: 'backordered') end it 'should destroy backordered units first' do on_hand_unit = line_item.inventory_units.find_by state: 'on_hand' subject.verify(shipment) expect(line_item.inventory_units.reload).to eq([on_hand_unit]) end end context 'with some shipped items' do let(:old_quantity) { 2 } let(:new_quantity) { 1 } let(:shipped_unit) { line_item.inventory_units[0] } before do shipped_unit.update_columns(state: 'shipped') end it 'should destroy unshipped units first' do subject.verify(shipment) expect(line_item.inventory_units.reload).to eq([shipped_unit]) end context 'trying to remove shipped units' do let(:new_quantity) { 0 } it 'only attempts to destroy as many units as are eligible, and return amount destroyed' do subject.verify(shipment) expect(line_item.inventory_units.reload).to eq([shipped_unit]) end end end context 'destroying all units' do let(:new_quantity) { 0 } it 'should destroy shipment' do expect { subject.verify(shipment) }.to change{ order.shipments.count }.from(1).to(0) end end context "inventory unit line item and variant points to different products" do let(:new_quantity) { 0 } let(:different_line_item) { create(:line_item, order: order) } let!(:different_inventory) do shipment.set_up_inventory("on_hand", variant, order, different_line_item) end it "removes only units that match both line item and variant" do subject.verify(shipment) expect(different_inventory.reload).to be_persisted end end end end
30.053763
108
0.677281
e2576ccb7f4ab6f05e253722df0efadedeb9cd4c
697
cask "steermouse" do version "5.5.5" sha256 "9aa09144b17ec0199a9ea2aa4ad000abc6839aba02a227fcfcce3f04a61a1af3" url "https://plentycom.jp/ctrl/files_sm/SteerMouse#{version}.dmg" name "SteerMouse" homepage "https://plentycom.jp/en/steermouse/" livecheck do url "https://plentycom.jp/en/steermouse/download.php" regex(/href=.*?SteerMouse[._-]?v?(\d+(?:\.\d+)+)\.dmg/i) end prefpane "SteerMouse.prefPane" zap trash: "~/Library/Application Support/SteerMouse & CursorSense/Device.smsetting", rmdir: [ "~/Library/Application Support/SteerMouse & CursorSense/Device Definitions/", "~/Library/Application Support/SteerMouse & CursorSense/", ] end
31.681818
87
0.705882
1885acea28c59706332138151b7f399fc50b18aa
452
module Dave class Request attr_reader :args attr_reader :method attr_reader :path attr_reader :requestor def initialize method, args, path, requestor = nil @args, @method, @path, @requestor = args, method, path, requestor end def self.from_request request self.new request.method.downcase, request.params.dup, request.path end def get_response RequestHandler.handle self end end end
18.08
72
0.683628
e9d97d7b68cec41b4b8d3c90a7c504b2a4216103
23,614
module Fleximage # Container for Fleximage model method inclusion modules module Model class MasterImageNotFound < RuntimeError #:nodoc: end # Include acts_as_fleximage class method def self.included(base) #:nodoc: base.extend(ClassMethods) end # Provides class methods for Fleximage for use in model classes. The only class method is # acts_as_fleximage which integrates Fleximage functionality into a model class. # # The following class level accessors also get inserted. # # * +image_directory+: (String, no default) Where the master images are stored, directory path relative to your # app root. # * +use_creation_date_based_directories+: (Boolean, default +true+) If true, master images will be stored in # directories based on creation date. For example: <tt>"#{image_directory}/2007/11/24/123.png"</tt> for an # image with an id of 123 and a creation date of November 24, 2007. Turing this off would cause the path # to be "#{image_directory}/123.png" instead. This helps keep the OS from having directories that are too # full. # * +image_storage_format+: (:png or :jpg, default :png) The format of your master images. Using :png will give # you the best quality, since the master images as stored as lossless version of the original upload. :jpg # will apply lossy compression, but the master image file sizes will be much smaller. If storage space is a # concern, us :jpg. # * +require_image+: (Boolean, default +true+) The model will raise a validation error if no image is uploaded # with the record. Setting to false allows record to be saved with no images. # * +missing_image_message+: (String, default "is required") Validation message to display when no image was uploaded for # a record. # * +invalid_image_message+: (String default "was not a readable image") Validation message when an image is uploaded, but is not an # image format that can be read by RMagick. # * +output_image_jpg_quality+: (Integer, default 85) When rendering JPGs, this represents the amount of # compression. Valid values are 0-100, where 0 is very small and very ugly, and 100 is near lossless but # very large in filesize. # * +default_image_path+: (String, nil default) If no image is present for this record, the image at this path will be # used instead. Useful for a placeholder graphic for new content that may not have an image just yet. # * +default_image+: A hash which defines an empty starting image. This hash look like: <tt>:size => '123x456', # :color => :transparent</tt>, where <tt>:size</tt> defines the dimensions of the default image, and <tt>:color</tt> # defines the fill. <tt>:color</tt> can be a named color as a string ('red'), :transparent, or a Magick::Pixel object. # * +preprocess_image+: (Block, no default) Call this class method just like you would call +operate+ in a view. # The image transoformation in the provided block will be run on every uploaded image before its saved as the # master image. # # Example: # # class Photo < ActiveRecord::Base # acts_as_fleximage do # image_directory 'public/images/uploaded' # use_creation_date_based_directories true # image_storage_format :png # require_image true # missing_image_message 'is required' # invalid_image_message 'was not a readable image'\ # default_image_path 'public/images/no_photo_yet.png' # default_image nil # output_image_jpg_quality 85 # # preprocess_image do |image| # image.resize '1024x768' # end # end # # # normal model methods... # end module ClassMethods # Use this method to include Fleximage functionality in your model. It takes an # options hash with a single required key, :+image_directory+. This key should # point to the directory you want your images stored on your server. Or # configure with a nice looking block. def acts_as_fleximage(options = {}) # Include the necesary instance methods include Fleximage::Model::InstanceMethods # Call this class method just like you would call +operate+ in a view. # The image transoformation in the provided block will be run on every uploaded image before its saved as the # master image. def self.preprocess_image(&block) preprocess_image_operation(block) end # Internal method to ask this class if it stores image in the DB. def self.db_store? columns.find do |col| col.name == 'image_file_data' end end def self.has_store? db_store? || image_directory end # validation callback validate :validate_image # The filename of the temp image. Used for storing of good images when validation fails # and the form needs to be redisplayed. attr_reader :image_file_temp # Setter for jpg compression quality at the instance level attr_accessor :jpg_compression_quality # Where images get stored dsl_accessor :image_directory # Put uploads from different days into different subdirectories dsl_accessor :use_creation_date_based_directories, :default => true # The format are master images are stored in dsl_accessor :image_storage_format, :default => Proc.new { :png } # Require a valid image. Defaults to true. Set to false if its ok to have no image for dsl_accessor :require_image, :default => true def self.translate_error_message(name, fallback, options = {}) translation = I18n.translate "activerecord.errors.models.#{self.model_name.underscore}.#{name}", options if translation.match /translation missing:/ I18n.translate "activerecord.errors.messages.#{name}", options.merge({ :default => fallback }) end end # Missing image message #dsl_accessor :missing_image_message, :default => 'is required' def self.missing_image_message(str = nil) if str.nil? if @missing_image_message @missing_image_message else translate_error_message("missing_image", "is required") end else @missing_image_message = str end end # Invalid image message #dsl_accessor :invalid_image_message, :default => 'was not a readable image' def self.invalid_image_message(str = nil) if str.nil? if @invalid_image_message @invalid_image_message else translate_error_message("invalid_image", "was not a readable image") end else @invalid_image_message = str end end # Image too small message # Should include {{minimum}} def self.image_too_small_message(str = nil) fb = "is too small (Minimum: {{minimum}})" if str.nil? if @image_too_small_message @image_too_small_message.gsub("{{minimum}}", minimum_image_size_to_s) else translate_error_message("image_too_small", fb.gsub("{{minimum}}", minimum_image_size_to_s), :minimum => minimum_image_size_to_s) end else @image_too_small_message = str end end def self.minimum_image_size_to_s if minimum_image_size.is_a?(Array) && minimum_image_size.size == 2 "#{minimum_image_size[0]}x#{minimum_image_size[1]}" end end # Sets the quality of rendered JPGs dsl_accessor :output_image_jpg_quality, :default => 85 # Set a default image to use when no image has been assigned to this record dsl_accessor :default_image_path # Set a default image based on a a size and fill dsl_accessor :default_image # A block that processes an image before it gets saved as the master image of a record. # Can be helpful to resize potentially huge images to something more manageable. Set via # the "preprocess_image { |image| ... }" class method. dsl_accessor :preprocess_image_operation # Set a minimum size ([x, y] e.g. [800, 600]) # Set [0, 600] to just enforce y size or # [800, 0] to just validate x size. dsl_accessor :minimum_image_size # Image related save and destroy callbacks after_destroy :delete_image_file before_save :pre_save after_save :post_save # execute configuration block yield if block_given? # set the image directory from passed options image_directory options[:image_directory] if options[:image_directory] # Require the declaration of a master image storage directory if !image_directory && !db_store? && !default_image && !default_image_path raise "No place to put images! Declare this via the :image_directory => 'path/to/directory' option\n"+ "Or add a database column named image_file_data for DB storage" end end def image_file_exists(file) # File must be a valid object return false if file.nil? # Get the size of the file. file.size works for form-uploaded images, file.stat.size works # for file object created by File.open('foo.jpg', 'rb'). It must have a size > 0. return false if (file.respond_to?(:size) ? file.size : file.stat.size) <= 0 # object must respond to the read method to fetch its contents. return false if !file.respond_to?(:read) # file validation passed, return true true end end # Provides methods that every model instance that acts_as_fleximage needs. module InstanceMethods # Returns the path to the master image file for this record. # # @some_image.directory_path #=> /var/www/myapp/uploaded_images # # If this model has a created_at field, it will use a directory # structure based on the creation date, to prevent hitting the OS imposed # limit on the number files in a directory. # # @some_image.directory_path #=> /var/www/myapp/uploaded_images/2008/3/30 def directory_path raise 'No image directory was defined, cannot generate path' unless self.class.image_directory # base directory directory = "#{RAILS_ROOT}/#{self.class.image_directory}" # specific creation date based directory suffix. creation = self[:created_at] || self[:created_on] if self.class.use_creation_date_based_directories && creation "#{directory}/#{creation.year}/#{creation.month}/#{creation.day}" else directory end end # Returns the path to the master image file for this record. # # @some_image.file_path #=> /var/www/myapp/uploaded_images/123.png def file_path "#{directory_path}/#{id}.#{self.class.image_storage_format}" end # Sets the image file for this record to an uploaded file. This can # be called directly, or passively like from an ActiveRecord mass # assignment. # # Rails will automatically call this method for you, in most of the # situations you would expect it to. # # # via mass assignment, the most common form you'll probably use # Photo.new(params[:photo]) # Photo.create(params[:photo]) # # # via explicit assignment hash # Photo.new(:image_file => params[:photo][:image_file]) # Photo.create(:image_file => params[:photo][:image_file]) # # # Direct Assignment, usually not needed # photo = Photo.new # photo.image_file = params[:photo][:image_file] # # # via an association proxy # p = Product.find(1) # p.images.create(params[:photo]) def image_file=(file) if self.class.image_file_exists(file) # Create RMagick Image object from uploaded file if file.path @uploaded_image = Magick::Image.read(file.path).first else @uploaded_image = Magick::Image.from_blob(file.read).first end # Sanitize image data @uploaded_image.colorspace = Magick::RGBColorspace @uploaded_image.density = '72' # Save meta data to database set_magic_attributes(file) # Success, make sure everything is valid @invalid_image = false save_temp_image(file) unless @dont_save_temp end rescue Magick::ImageMagickError => e error_strings = [ 'Improper image header', 'no decode delegate for this image format', 'UnableToOpenBlob' ] if e.to_s =~ /#{error_strings.join('|')}/ @invalid_image = true else raise e end end # Assign the image via a URL, which will make the plugin go # and fetch the image at the provided URL. The image will be stored # locally as a master image for that record from then on. This is # intended to be used along side the image upload to allow people the # choice to upload from their local machine, or pull from the internet. # # @photo.image_file_url = 'http://foo.com/bar.jpg' def image_file_url=(file_url) @image_file_url = file_url if file_url =~ %r{^https?://} file = open(file_url) # Force a URL based file to have an original_filename eval <<-CODE def file.original_filename "#{file_url}" end CODE self.image_file = file elsif file_url.empty? # Nothing to process, move along else # invalid URL, raise invalid image validation error @invalid_image = true end end # Sets the uploaded image to the name of a file in RAILS_ROOT/tmp that was just # uploaded. Use as a hidden field in your forms to keep an uploaded image when # validation fails and the form needs to be redisplayed def image_file_temp=(file_name) if !@uploaded_image && file_name && file_name.any? @image_file_temp = file_name file_path = "#{RAILS_ROOT}/tmp/fleximage/#{file_name}" @dont_save_temp = true if File.exists?(file_path) File.open(file_path, 'rb') do |f| self.image_file = f end end @dont_save_temp = false end end # Return the @image_file_url that was previously assigned. This is not saved # in the database, and only exists to make forms happy. def image_file_url @image_file_url end # Return true if this record has an image. def has_image? @uploaded_image || @output_image || has_saved_image? end def has_saved_image? self.class.db_store? ? !!image_file_data : File.exists?(file_path) end # Call from a .flexi view template. This enables the rendering of operators # so that you can transform your image. This is the method that is the foundation # of .flexi views. Every view should consist of image manipulation code inside a # block passed to this method. # # # app/views/photos/thumb.jpg.flexi # @photo.operate do |image| # image.resize '320x240' # end def operate(&block) returning self do proxy = ImageProxy.new(load_image, self) block.call(proxy) @output_image = proxy.image end end # Load the image from disk/DB, or return the cached and potentially # processed output image. def load_image #:nodoc: @output_image ||= @uploaded_image # Return the current image if we have loaded it already return @output_image if @output_image # Load the image from disk if self.class.has_store? if self.class.db_store? if image_file_data && image_file_data.any? # Load the image from the database column @output_image = Magick::Image.from_blob(image_file_data).first else master_image_not_found end else # Load the image from the disk @output_image = Magick::Image.read(file_path).first end else master_image_not_found end rescue Magick::ImageMagickError => e if e.to_s =~ /unable to open (file|image)/ master_image_not_found else raise e end end # Convert the current output image to a jpg, and return it in binary form. options support a # :format key that can be :jpg, :gif or :png def output_image(options = {}) #:nodoc: format = (options[:format] || :jpg).to_s.upcase @output_image.format = format @output_image.strip! if format = 'JPG' quality = @jpg_compression_quality || self.class.output_image_jpg_quality @output_image.to_blob { self.quality = quality } else @output_image.to_blob end ensure GC.start end # Delete the image file for this record. This is automatically ran after this record gets # destroyed, but you can call it manually if you want to remove the image from the record. def delete_image_file return unless self.class.has_store? if self.class.db_store? update_attribute :image_file_data, nil unless frozen? else File.delete(file_path) if File.exists?(file_path) end clear_magic_attributes self end # Execute image presence and validity validations. def validate_image #:nodoc: field_name = (@image_file_url && @image_file_url.any?) ? :image_file_url : :image_file if @invalid_image errors.add field_name, self.class.invalid_image_message elsif self.class.require_image && !has_image? errors.add field_name, self.class.missing_image_message elsif self.class.minimum_image_size.is_a?(Array) && self.class.minimum_image_size.size == 2 && !@uploaded_image.nil? if @uploaded_image.columns < self.class.minimum_image_size[0] || @uploaded_image.rows < self.class.minimum_image_size[1] errors.add field_name, self.class.image_too_small_message end end end private # Perform pre save tasks. Preprocess the image, and write it to DB. def pre_save if @uploaded_image # perform preprocessing perform_preprocess_operation # Convert to storage format @uploaded_image.format = self.class.image_storage_format.to_s.upcase # Write image data to the DB field if self.class.db_store? self.image_file_data = @uploaded_image.to_blob end end end # Write image to file system and cleanup garbage. def post_save if @uploaded_image && !self.class.db_store? # Make sure target directory exists FileUtils.mkdir_p(directory_path) # Write master image file @uploaded_image.write(file_path) end # Cleanup temp files delete_temp_image # Start GC to close up memory leaks GC.start if @uploaded_image end # Preprocess this image before saving def perform_preprocess_operation if self.class.preprocess_image_operation operate(&self.class.preprocess_image_operation) set_magic_attributes #update width and height magic columns @uploaded_image = @output_image end end def clear_magic_attributes unless frozen? self.image_filename = nil if respond_to?(:image_filename=) self.image_width = nil if respond_to?(:image_width=) self.image_height = nil if respond_to?(:image_height=) end end # If any magic column names exists fill them with image meta data. def set_magic_attributes(file = nil) if file && self.respond_to?(:image_filename=) filename = file.original_filename if file.respond_to?(:original_filename) filename = file.basename if file.respond_to?(:basename) self.image_filename = filename end self.image_width = @uploaded_image.columns if self.respond_to?(:image_width=) self.image_height = @uploaded_image.rows if self.respond_to?(:image_height=) end # Save the image in the rails tmp directory def save_temp_image(file) file_name = file.respond_to?(:original_filename) ? file.original_filename : file.path @image_file_temp = file_name.split('/').last path = "#{RAILS_ROOT}/tmp/fleximage" FileUtils.mkdir_p(path) File.open("#{path}/#{@image_file_temp}", 'w') do |f| file.rewind f.write file.read end end # Delete the temp image after its no longer needed def delete_temp_image FileUtils.rm_rf "#{RAILS_ROOT}/tmp/fleximage/#{@image_file_temp}" end # Load the default image, or raise an expection def master_image_not_found # Load the default image from a path if self.class.default_image_path @output_image = Magick::Image.read("#{RAILS_ROOT}/#{self.class.default_image_path}").first # Or create a default image elsif self.class.default_image x, y = Fleximage::Operator::Base.size_to_xy(self.class.default_image[:size]) color = self.class.default_image[:color] @output_image = Magick::Image.new(x, y) do self.background_color = color if color && color != :transparent end # No default, not master image, so raise exception else message = "Master image was not found for this record" if !self.class.db_store? message << "\nExpected image to be at:" message << "\n #{file_path}" end raise MasterImageNotFound, message end end end end end
39.687395
142
0.607309
b9643e16ab34c4734cb36960e9fd1d8b68cd47ab
1,727
require "net/https" require "uri" require "json" require "binocular/version" module Binocular class Bin attr_accessor :settings, :bin_number attr_reader :info, :errors DEFAULT_SETTINGS = { proxy_host: nil, proxy_port: nil } def self.info bin_number self.new(bin_number).fetch_info end def initialize(bin_number, settings=DEFAULT_SETTINGS) self.settings = settings self.bin_number = bin_number end def proxy_host self.settings[:proxy_host] ? self.settings[:proxy_host] : nil end def proxy_port self.settings[:proxy_port] ? self.settings[:proxy_port] : nil end def timeout self.settings[:timeout] ? self.settings[:timeout] : 20 end def fetch_info return @errors unless valid? uri = URI.parse("http://www.binlist.net/json/#{self.bin_number}") http = Net::HTTP.new(uri.host, uri.port, self.proxy_host, self.proxy_port) http.use_ssl = false http.open_timeout = self.timeout http.read_timeout = self.timeout request = Net::HTTP::Get.new(uri.request_uri) response = http.request(request) @info = JSON.parse response.body rescue JSON::ParserError => e @errors = { errors: response.body } rescue Exception => e @errors = { errors: e.to_s } end def valid? if (numeric? self.bin_number) && (valid_length? self.bin_number) return true else @errors = { errors: "bin_number should be 6-length numeric" } return false end end private def numeric? val val.to_i.to_s == val.to_s rescue false end def valid_length? val val.size == 6 end end end
23.657534
80
0.633468
5dca25a51cecadf814b61e3581e76e7761c5d4a7
32,575
# -*- coding: binary -*- module Msf class Post module Hardware module Automotive module UDS # # Helper method to take client.automotive response hashes and return a single array in order, This # takes the ISO-TP Packets and assembles them in order, strips out the ISO-TP/UDS related info # and returns just the data section as an array # # @param id [String] Hex value as string. Example: 7e0 # @param hash [Hash] Hash that includes "Packets" => [ { "ID" => "0xXXX", "DATA => [ "XX", "XX" ] } ] # @param start_offset [Integer] First packet start offset after meta data # # @return [Array] Just the data portion of an ISO-TP response represented as Hex Strings # def response_hash_to_data_array(id, hash, start_offset = 5) data = [] return data unless hash bad_count = 0 if hash.key? "Packets" unless hash["Packets"].size > 1 # Not multiple packets pktdata = hash["Packets"][0]["DATA"] if pktdata[1] == 0x7F print_line("Packet response was an error") else data = pktdata[3, pktdata.size-1] end return data end left2combine = hash["Packets"].size counter = 0 while left2combine.positive? && (bad_count < (hash["Packets"].size * 2)) # print_line("DEBUG Current status combine=#{left2combine} data=#{data.inspect}") hash["Packets"].each do |pkt| if (pkt.key? "ID") && pkt["ID"].hex == id.hex if pkt.key? "DATA" if counter.zero? # Get starting packet if pkt["DATA"][0] == "10" data += pkt["DATA"][start_offset, 8 - start_offset] left2combine -= 1 counter += 1 else bad_count += 1 end else # Got the first packet, get the 2x series # TODO: Support rollover counter, rare but technically possible if pkt["DATA"][0] == "%02x" % (0x20 + counter) data += pkt["DATA"][1, pkt["DATA"].size] left2combine -= 1 counter += 1 else bad_count += 1 end end end end end end if bad_count >= (hash["Packets"].size * 2) print_error("bad packet count exceeded normal limits. Packet parser failed") end end data end ### Mode $01 ### # # Shows the vehicles current data # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param pid [Integer] Integer of the PID to get data about # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] client.automotive response def get_current_data(bus, src_id, dst_id, pid, opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x01, pid], opt) end # # Get all supported pids for current data # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Array] All supported pids from Mode $01 get current data def get_current_data_pids(bus, src_id, dst_id) pids = [] packets = get_current_data(bus, src_id, dst_id, 0, { "MAXPKTS" => 1 }) return pids if packets.nil? if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (1..0x20).each do |pid| pids << pid if hexpids[pid-1] == "1" end end if pids.include? 0x20 packets = get_current_data(bus, src_id, dst_id, 0x20, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0x20..0x40).each do |pid| pids << pid if hexpids[pid-0x21] == "1" end end end if pids.include? 0x40 packets = get_current_data(bus, src_id, dst_id, 0x40, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0x40..0x60).each do |pid| pids << pid if hexpids[pid-0x41] == "1" end end end if pids.include? 0x60 packets = get_current_data(bus, src_id, dst_id, 0x60, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0x60..0x80).each do |pid| pids << pid if hexpids[pid-0x61] == "1" end end end if pids.include? 0x80 packets = get_current_data(bus, src_id, dst_id, 0x80, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0x80..0xA0).each do |pid| pids << pid if hexpids[pid-0x81] == "1" end end end if pids.include? 0xA0 packets = get_current_data(bus, src_id, dst_id, 0xA0, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0xA0..0xC0).each do |pid| pids << pid if hexpids[pid-0xA1] == "1" end end end if pids.include? 0xC0 packets = get_current_data(bus, src_id, dst_id, 0xC0, { "MAXPKTS" => 1 }) if (packets.key? "Packets") && !packets["Packets"].empty? hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (0xC0..0xE0).each do |pid| pids << pid if hexpids[pid - 0xC1] == "1" end end end pids end # # Mode $01 Pid $01 gets and parses the monitor status # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Hash] Packet Hash with { "MIL" => true|false "DTC_COUNT" => 0 } def get_monitor_status(bus, src_id, dst_id) packets = get_current_data(bus, src_id, dst_id, 0x01, { "MAXPKTS" => 1 }) return {} if packets.nil? return packets if packets.key? "error" return packets unless packets.key? "Packets" packets["MIL"] = packets["Packets"][0]["DATA"][3].hex & 0xB0 == 1 ? true : false packets["DTC_COUNT"] = packets["Packets"][0]["DATA"][3].hex & 0x7F packets end # # Gets the engine coolant temprature in both Celcious and Fahrenheit # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Hash] Packet Hash with { "TEMP_C" => <Celcious Temp>, "TEMP_F" => <Fahrenheit TEmp> } def get_engine_coolant_temp(bus, src_id, dst_id) packets = get_current_data(bus, src_id, dst_id, 0x05, { "MAXPKTS" => 1 }) return {} if packets.nil? return packets if packets.key? "error" return packets unless packets.key? "Packets" celsius = packets["Packets"][0]["DATA"][3].hex - 40 fahrenheit = celsius * 9 / 5 + 32 packets["TEMP_C"] = celsius packets["TEMP_F"] = fahrenheit packets end # # Gets the engine's current RPMs # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Hash] Packet Hash with { "RPM" => <RPMs> } def get_rpms(bus, src_id, dst_id) packets = get_current_data(bus, src_id, dst_id, 0x0C, { "MAXPKTS" => 1 }) return {} if packets.nil? return packets if packets.key? "error" return packets unless packets.key? "Packets" packets["RPM"] = (256 * packets["Packets"][0]["DATA"][3].hex + packets["Packets"][0]["DATA"][4].hex) / 4 packets end # # Gets the engine's current vehicle speed in km/h and mph # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Hash] Packet Hash with { "SPEED_K" => <km/h>, "SPEED_M" => <mph> } def get_vehicle_speed(bus, src_id, dst_id) packets = get_current_data(bus, src_id, dst_id, 0x0D, { "MAXPKTS" => 1 }) return {} if packets.nil? return packets if packets.key? "error" return packets unless packets.key? "Packets" packets["SPEED_K"] = packets["Packets"][0]["DATA"][3].hex packets["SPEED_M"] = packets["SPEED_K"] / 1.609344 packets end # # Return which OBD standard this bus confirms to. This method could utilizes bitmasks # but currently creates a human readable string instead. This may change in the future. # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [String] Description of standard def get_obd_standards(bus, src_id, dst_id) packets = get_current_data(bus, src_id, dst_id, 0x1C, { "MAXPKTS" => 1 }) return "" if packets.nil? if packets.key? "error" print_error("OBD ERR: #{packets['error']}") return "" end return "" unless packets.key? "Packets" case packets["Packets"][0]["DATA"][3].hex when 1 return "OBD-II as defined by CARB" when 2 return "OBD as defined by EPA" when 3 return "OBD and OBD-II" when 4 return "OBD-I" when 5 return "Not OBD Compliant" when 6 return "EOBD Europe" when 7 return "EOBD and OBD-II" when 8 return "EOBD and OBD" when 9 return "EOBD, OBD, OBD-II" when 10 return "JOBD Japan" when 11 return "JOBD and OBD-II" when 12 return "JOBD and EOBD" when 13 return "JOBD, EOBD, OBD-II" when 17 return "Engine Manufacturer Diagnostics (EMD)" when 18 return "Engine Manufacturer Diagnostics Enhanced (EMD+)" when 19 return "Heavy Duty On-Board Diagnostics (Child/Partial) (HD OBD-C)" when 20 return "Heavy Duty On-Board Diagnostics (HD OBD)" when 21 return "World Wide Harmonized OBD (WWH OBD)" when 23 return "Heavy Duty Euro OBD Stage I without NOx control (HD EOBD-I)" when 24 return "Heavy Duty Euro OBD Stage I with NOx control (HD EOBD-I N)" when 25 return "Heavy Duty Euro OBD Stage II without NOx control (HD EOBD-II)" when 26 return "Heavy Duty Euro OBD Stage II with NOx control (HD EOBD-II N)" when 28 return "Brazil OBD Phase 1 (OBDBr-1)" when 29 return "Brazil OBD Phase 2 (OBDBr-2)" when 30 return "Korean OBD (KOBD)" when 31 return "India OBD I (IOBD I)" when 32 return "India OBD II (IOBD II)" when 33 return "Heavy Duty Euro OBD Stage VI (HD EOBD-IV)" when 14..16, 22, 27, 34..250 return "Reserved" end "SAE J1939 Special Meanings" end ### Mode $02 ### # # Shows the vehicles freeze frame data, Use the same PIDs as supported from Mode $01 # #get_current_data_pids. You must specify which freeze frame you want to recall data from. # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param pid [Integer] Integer of the PID to get data about # @param frame [Integer] Freeze Frame Number # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] client.automotive response def get_freeze_frame_data(bus, src_id, dst_id, pid, frame, opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus pid = pid.to_s(16) frame = frame.to_s(16) unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x02, pid, frame], opt) end ### Mode $03 ### # # Retrieves the Diagnostic Trouble Codes (DTCs) # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Array] Array of DTCs def get_dtcs(bus, src_id, dst_id, opt = {}) dtcs = [] unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end data = client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x03], opt) return [] if data.nil? if data.key? "error" print_error("UDS ERR: #{data['error']}") return [] end if (data.key? "Packets") && !data["Packets"].empty? data = response_hash_to_data_array(dst_id, data, 4) if !data.empty? && data.size.even? (0..data.size / 2).step(2) do |idx| code = "" case data[idx].hex & 0xC0 >> 3 when 0 code = "P" when 1 code = "C" when 2 code = "B" when 3 code = "U" end code += (data[idx].hex & 0x3F).to_s(16).rjust(2, '0') code += data[idx + 1] dtcs << code end end end dtcs end ### Mode $04 ### # # Clears the DTCs and Resets the MIL light back to the off position # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] No packets are expected to return but an error could be returned def clear_dtcs(bus, src_id, dst_id, opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x04], opt) end ### Mode $07 ### # # Retrieves the Frozen Diagnostic Trouble Codes (DTCs) # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Array] Array of DTCs def get_frozen_dtcs(bus, src_id, dst_id, opt = {}) dtcs = [] unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end data = client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x07], opt) return [] if data.nil? if data.key? "error" print_error("UDS ERR: #{data['error']}") return [] end if (data.key? "Packets") && !data["Packets"].empty? data = response_hash_to_data_array(dst_id, data, 4) if !data.empty? && data.size.even? (0..data.size / 2).step(2) do |idx| code = "" case data[idx].hex & 0xC0 >> 3 when 0 code = "P" when 1 code = "C" when 2 code = "B" when 3 code = "U" end code += (data[idx].hex & 0x3F).to_s(16).rjust(2, '0') code += data[idx + 1] dtcs << code end end end dtcs end ### Mode $09 ### # # Requests diagnostics 0x09 vehicle information for any given mode # No formatting is done on the response # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] client.automotive response def get_vehicle_info(bus, src_id, dst_id, mode, opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus mode = mode.to_s(16) unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x09, mode], opt) end # # Get all the supported pids by mode 0x09 Vehicle info # Returns them as an array of ints # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [Array] Array of PIDS supported by Mode $09 def get_vinfo_supported_pids(bus, src_id, dst_id) pids = [] packets = get_vehicle_info(bus, src_id, dst_id, 0, { "MAXPKTS" => 1 }) return pids if packets.nil? if (packets.key? "Packets") && !packets["Packets"].empty? unless packets["Packets"][0]["DATA"][1].hex == 0x49 print_error("ECU Did not return a valid response") return [] end hexpids = packets["Packets"][0]["DATA"][3, 6] hexpids = hexpids.join.hex.to_s(2).rjust(32, '0').split('') # Array of 1s and 0s (1..20).each do |pid| pids << pid if hexpids[pid - 1] == "1" end end pids end # # Requests a VIN and formats the response as ASCII # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [String] VIN as ASCII def get_vin(bus, src_id, dst_id) packets = get_vehicle_info(bus, src_id, dst_id, 0x02) return "" if packets.nil? return "UDS ERR: #{packets['error']}" if packets.key? "error" data = response_hash_to_data_array(dst_id.to_s(16), packets) return "" if data.nil? data.map! { |d| d.hex.chr } data.join end # Gets the vehicle calibration ID and returns it as an ASCII string # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [String] Calibration ID as ASCII def get_calibration_id(bus, src_id, dst_id) packets = get_vehicle_info(bus, src_id, dst_id, 0x04) return "" if packets.nil? return "UDS ERR: #{packets['error']}" if packets.key? "error" data = response_hash_to_data_array(dst_id.to_s(16), packets) return "" if data.nil? data.map! { |d| d.hex.chr } data.join end # Get the vehicles ECU name pid 0x0A # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # # @return [String] ECU Name as ASCII def get_ecu_name(bus, src_id, dst_id) packets = get_vehicle_info(bus, src_id, dst_id, 0x0A) return "" if packets.nil? return "UDS ERR: #{packets['error']}" if packets.key? "error" data = response_hash_to_data_array(dst_id.to_s(16), packets) return "" if data.nil? data.map! { |d| d.hex.chr } data.join end ############################################################################### # Technically from here on down these are known as Service IDs or SIDs but we # # will keep calling them Modes for consitency in our comments # ############################################################################### #### Mode $10 ### # Set the diagnostic session code # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param level [Integer] The desired DSC level # # @return [Hash] client.automtoive response def set_dsc(bus, src_id, dst_id, level) unless client.automotive print_error("Not an automotive hwbridge session") return {} end level = level.to_s(16) src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end opt = {} opt["TIMEOUT"] = 20 opt["MAXPKTS"] = 1 client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x10, level], opt) end ### Mode $11 ### # # Issues a reset of the ECU # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param hard [Boolean] If true a hard reset will be peformed # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] client.automtoive response (Could be no response) def reset_ecu(bus, src_id, dst_id, hard, opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end reset_type = hard ? 1 : 0 client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x11, reset_type], opt) end ### Mode $22 ### # # Reads data from a memory region given a lookup ID value # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param id [Array] 2 Bytes in an array of the identifier. Example [ 0xF1, 0x90 ] # @param show_error [Boolean] If an error, return the Packet hash instead, Default false # # @return [Array] Data retrieved. If show_error is true and an error is detected, then packet hash will be returned instead def read_data_by_id(bus, src_id, dst_id, id, show_error = false) data = [] unless client.automotive print_error("Not an automotive hwbridge session") return {} if show_error return [] end unless id.is_a? Array print_error("ID paramater must be a two byte array") return {} if show_error return [] end unless id.size == 2 print_error("ID paramater must be a two byte array") return {} if show_error return [] end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) id.map! { |i| i.to_s(16) } if id[0].is_a? Integer bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end opt = {} opt["MAXPKTS"] = 15 packets = client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x22] + id, opt) return [] if packets.nil? if packets.key? "error" return packets if show_error else data = response_hash_to_data_array(dst_id, packets) end data end ### Mode $27 ### # # Retrieves the security access token # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param level [Integer] Requested security access level. Default is 1 # # @return [Hash] Packet Hash with { "SEED" => [ XX, XX ] } def get_security_token(bus, src_id, dst_id, level = 1) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) level = level.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end opt = {} opt["MAXPKTS"] = 1 packets = client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x27, level], opt) return {} if packets.nil? unless packets.key? "error" packets["SEED"] = response_hash_to_data_array(dst_id, packets) end packets end # # Sends a security access tokens response to the seed request # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # param key [Array] Array of Hex to be used as the key. Same size as the seed # @param response_level [Integer] Requested security access level response. Usually level + 1. Default is 2 # # @return [Hash] packet response from client.automotoive def send_security_token_response(bus, src_id, dst_id, key, response_level = 2) unless client.automotive print_error("Not an automotive hwbridge session") return {} end unless key.is_a? Array print_error("Key must be an array of hex values") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) key.map! { |k| k.to_s(16) } if key[0].is_a? Integer response_level = response_level.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end opt = {} opt["MAXPKTS"] = 1 client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x27, response_level] + key, opt) end ### Mode $2E ### # # Writes data by ID # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param id [Array] 2 Bytes in an array of the identifier. Example [ 0xF1, 0x90 ] # @param data [Array] Array of bytes to write # # @return [Hash] Packet hash from client.automotive def write_data_by_id(bus, src_id, dst_id, id, data) unless client.automotive print_error("Not an automotive hwbridge session") return {} end unless id.is_a? Array print_error("ID must be an array of hex values") return {} end unless data.is_a? Array print_error("DATA must be an array of hex values") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) id.map! { |i| i.to_s(16) } if id[0].is_a? Integer data.map! { |d| d.to_s(16) } if data[0].is_a? Integer bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end opt = {} opt["MAXPKTS"] = 1 client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x27] + id + data, opt) end ### Mode $31 ### # # Executes a builtin routine. Routines are a series of pre-programmed acutions setup by the # manufacturer. # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param routine_type [Integer] Type or routine request. Example: 1 = Start, 3 = Report # param id [Array] 2 byte Array for the routine identifier # @param data [Array] Array of routine data/params. Specific to the routine. Optional, Default [] # @param opt [Hash] Additional options to be passed to automotive.send_isotp_and_wait_for_response # # @return [Hash] Packet hash from client.automotive def routine_control(bus, src_id, dst_id, routine_type, id, data = [], opt = {}) unless client.automotive print_error("Not an automotive hwbridge session") return {} end unless id.is_a? Array print_error("ID must be an array of hex values") return {} end unless data.is_a? Array print_error("DATA must be an array of hex values") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) routine_type = routine_type.to_s(16) id.map! { |i| i.to_s(16) } if id[0].is_a? Integer data.map! { |d| d.to_s(16) } if !data.empty? && (data[0].is_a? Integer) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x31, routine_type] + id + data, opt) end ### Mode $3E ### # # Sends a TestPresent message. This message maintains previously set DSCs or Security Access levels so # they don't timeout and revert back to normal. TesterPresent is typically transmitted on 2-3 second # intervals # # @param bus [String] unique CAN bus identifier # @param src_id [Integer] Integer representation of the Sending CAN ID # @param dst_id [Integer] Integer representation of the receiving CAN ID # @param suppress_response [Boolean] By default suppress ACK from ECU. Set to false if you want confirmation # # @return [Hash] Packet hash from client.automotive. Typically blank unless suppress_response is false def send_tester_present(bus, src_id, dst_id, suppress_response = true) unless client.automotive print_error("Not an automotive hwbridge session") return {} end src_id = src_id.to_s(16) dst_id = dst_id.to_s(16) bus = client.automotive.active_bus unless bus unless bus print_line("No active bus, use 'connect' or specify bus via the options") return {} end suppress = 0x80 suppress = 0 unless suppress_response opt = {} opt["MAXPKTS"] = 1 client.automotive.send_isotp_and_wait_for_response(bus, src_id, dst_id, [0x3E, suppress], opt) end end end end end end
36.114191
126
0.643776
f74fe133bdd63509c31a202b7657a82c3cc8a5d9
210
# frozen_string_literal: true class Settings::ProfilePolicy < ApplicationPolicy def update? !!account end def permitted_attributes_for_update %i[nickname public_name biography avatar] end end
17.5
49
0.771429
5d1d83b90773a11b488980d6e34ef3a051077202
1,527
class Okteto < Formula desc "Build better apps by developing and testing code directly in Kubernetes" homepage "https://okteto.com" url "https://github.com/okteto/okteto/archive/1.13.10.tar.gz" sha256 "b50bfebb8d1cad07411624c3c4946a140f32c5f64db0b2e5b393c1f5d82a860e" license "Apache-2.0" head "https://github.com/okteto/okteto.git", branch: "master" bottle do sha256 cellar: :any_skip_relocation, arm64_big_sur: "01cdb4fc7ca14324fc88fd4a9bb3a457815a58f3ab3b952a2fe92bdf8536e276" sha256 cellar: :any_skip_relocation, big_sur: "7ed993aea5d84a466f509e49010a37943ccfb4c76201fb3f4d1b46b5a50b270e" sha256 cellar: :any_skip_relocation, catalina: "a227a63909907f8fc88d116767faa6f1ccfc5e59bfc5cb4359323208df5c756b" sha256 cellar: :any_skip_relocation, mojave: "103f8eeeb69f72545147b9b25aa509db4290eb94a6f3f86b604f1a4a51f41b37" sha256 cellar: :any_skip_relocation, x86_64_linux: "d4128995d7421e7d9289343783d21b21cbaa4ce203613e0b27c73b5dda213422" # linuxbrew-core end depends_on "go" => :build def install ldflags = "-s -w -X github.com/okteto/okteto/pkg/config.VersionString=#{version}" tags = "osusergo netgo static_build" system "go", "build", *std_go_args(ldflags: ldflags), "-tags", tags end test do assert_match "okteto version #{version}", shell_output("#{bin}/okteto version") touch "test.rb" assert_match "Failed to load your local Kubeconfig", shell_output("echo | #{bin}/okteto init --overwrite --file test.yml 2>&1") end end
46.272727
139
0.764898
18b0d6480baf561ed458476623649bd82cf099d6
4,187
class NodeAT14 < Formula desc "Platform built on V8 to build network applications" homepage "https://nodejs.org/" url "https://nodejs.org/dist/v14.18.3/node-v14.18.3.tar.xz" sha256 "783ac443cd343dd6c68d2abcf7e59e7b978a6a428f6a6025f9b84918b769d608" license "MIT" livecheck do url "https://nodejs.org/dist/" regex(%r{href=["']?v?(14(?:\.\d+)+)/?["' >]}i) end bottle do sha256 cellar: :any, arm64_monterey: "6b9253752640227577d928d4fcb6240a83576f81acc6b14a1e267996b5413dfa" sha256 cellar: :any, arm64_big_sur: "c076e981b52d8b86f15cde4a7e72b7c1efad26124fb794419a88599aef0f9e34" sha256 cellar: :any, monterey: "8ffbe3b5442a8299aac505a363d35658f41dce00668007e7c3bf685c295d6646" sha256 cellar: :any, big_sur: "ac8e30ff8b49d14a4c76ec6c0c106f9ad2eb0c947725fe73575cfaa49592afb3" sha256 cellar: :any, catalina: "4189902048c2a2f17e808a62193d9ebe090babb4241fa877e628ad7d3bdda4e1" sha256 cellar: :any_skip_relocation, x86_64_linux: "cbbf40544135a658477ce4a006eaebf145bebd98353e1941db345f641cb38ad8" end keg_only :versioned_formula depends_on "pkg-config" => :build depends_on "[email protected]" => :build depends_on "brotli" depends_on "c-ares" depends_on "icu4c" depends_on "libnghttp2" depends_on "libuv" depends_on "[email protected]" uses_from_macos "zlib" on_macos do depends_on "macos-term-size" end def install # make sure subprocesses spawned by make are using our Python 3 ENV["PYTHON"] = which("python3") args = %W[ --prefix=#{prefix} --with-intl=system-icu --shared-libuv --shared-nghttp2 --shared-openssl --shared-zlib --shared-brotli --shared-cares --shared-libuv-includes=#{Formula["libuv"].include} --shared-libuv-libpath=#{Formula["libuv"].lib} --shared-nghttp2-includes=#{Formula["libnghttp2"].include} --shared-nghttp2-libpath=#{Formula["libnghttp2"].lib} --shared-openssl-includes=#{Formula["[email protected]"].include} --shared-openssl-libpath=#{Formula["[email protected]"].lib} --shared-brotli-includes=#{Formula["brotli"].include} --shared-brotli-libpath=#{Formula["brotli"].lib} --shared-cares-includes=#{Formula["c-ares"].include} --shared-cares-libpath=#{Formula["c-ares"].lib} --openssl-use-def-ca-store ] system "python3", "configure.py", *args system "make", "install" term_size_vendor_dir = lib/"node_modules/npm/node_modules/term-size/vendor" term_size_vendor_dir.rmtree # remove pre-built binaries if OS.mac? macos_dir = term_size_vendor_dir/"macos" macos_dir.mkpath # Replace the vendored pre-built term-size with one we build ourselves ln_sf (Formula["macos-term-size"].opt_bin/"term-size").relative_path_from(macos_dir), macos_dir end end def post_install (lib/"node_modules/npm/npmrc").atomic_write("prefix = #{HOMEBREW_PREFIX}\n") end test do path = testpath/"test.js" path.write "console.log('hello');" output = shell_output("#{bin}/node #{path}").strip assert_equal "hello", output output = shell_output("#{bin}/node -e 'console.log(new Intl.NumberFormat(\"en-EN\").format(1234.56))'").strip assert_equal "1,234.56", output output = shell_output("#{bin}/node -e 'console.log(new Intl.NumberFormat(\"de-DE\").format(1234.56))'").strip assert_equal "1.234,56", output # make sure npm can find node ENV.prepend_path "PATH", opt_bin ENV.delete "NVM_NODEJS_ORG_MIRROR" assert_equal which("node"), opt_bin/"node" assert_predicate bin/"npm", :exist?, "npm must exist" assert_predicate bin/"npm", :executable?, "npm must be executable" npm_args = ["-ddd", "--cache=#{HOMEBREW_CACHE}/npm_cache", "--build-from-source"] system "#{bin}/npm", *npm_args, "install", "npm@latest" system "#{bin}/npm", *npm_args, "install", "ref-napi" assert_predicate bin/"npx", :exist?, "npx must exist" assert_predicate bin/"npx", :executable?, "npx must be executable" assert_match "< hello >", shell_output("#{bin}/npx cowsay hello") end end
38.768519
123
0.678529
01d36142b77be6b837584b4f83d7b49c5f0cc328
681
require 'rails_helper' RSpec.describe User, type: :model do context 'associations' do it { should have_many(:posts) } it { should have_many(:comments) } it { should have_many(:likes) } it { should have_many(:friendships) } it { should have_many(:inverse_friendships).class_name(:Friendship) } it { should have_many(:confirmed_friendships).class_name(:Friendship) } it { should have_many(:friends) } it { should have_many(:pending_friendships).class_name(:Friendship) } it { should have_many(:pending_friends) } it { should have_many(:inverted_friendships).class_name(:Friendship) } it { should have_many(:friend_requests) } end end
37.833333
75
0.713656
033a8ef9aef1257e72174314915e702339d0be3d
1,661
class Juliaup < Formula desc "Julia installer and version multiplexer" homepage "https://github.com/JuliaLang/juliaup" url "https://github.com/JuliaLang/juliaup/archive/v1.5.29.tar.gz" sha256 "4dc02d9e7ecddf7364b1862d8b478c2a6f01e0eea9dd755e40e171c42d0b3511" license "MIT" head "https://github.com/JuliaLang/juliaup.git", branch: "master" livecheck do url :stable strategy :github_latest end bottle do rebuild 1 sha256 cellar: :any_skip_relocation, arm64_monterey: "1ca0f2e8e6e98e45f0dd9647d7581c6f0b5cabca77576b39e895f4e62a4705db" sha256 cellar: :any_skip_relocation, arm64_big_sur: "b4f9c40b4fc2fc599e3fcef9b584080a80fdf0b71614c0b1281a02b61fb3c9eb" sha256 cellar: :any_skip_relocation, monterey: "b68cf73a6963151c99cc5510fe0ce54a3a68aa40d2b6ded789f0b3a1e27b545f" sha256 cellar: :any_skip_relocation, big_sur: "794caa4602c36b66823fb2026ffb235b78ddd7dadda9ed170686de31b896ee00" sha256 cellar: :any_skip_relocation, catalina: "df949186d6c8448d6296230f4dff2f7ba1cd80e8638b9dafc4b4cb3f6b563420" sha256 cellar: :any_skip_relocation, x86_64_linux: "3557bbacc945d70f86b497de9054f2bc6fc2fb0db121d00b40cabbceb6431efd" end depends_on "rust" => :build conflicts_with "julia", because: "both install `julia` binaries" def install system "cargo", "install", "--bin", "juliaup", *std_cargo_args system "cargo", "install", "--bin", "julialauncher", *std_cargo_args bin.install_symlink "julialauncher" => "julia" end test do expected = "Default Channel Version Update" assert_equal expected, shell_output("#{bin}/juliaup status").lines.first.strip end end
41.525
123
0.775436
1da2015f7b2893a827957eb3148a62a54983e6ba
266
class FontBayon < Formula head "https://github.com/google/fonts/raw/master/ofl/bayon/Bayon-Regular.ttf" desc "Bayon" homepage "https://www.google.com/fonts/specimen/Bayon" def install (share/"fonts").install "Bayon-Regular.ttf" end test do end end
24.181818
79
0.718045
ff2a55ba6c63a19d47f13626ef8a7b4bb74d2074
291
class User < ApplicationRecord # Include default devise modules. Others available are: # :confirmable, :lockable, :timeoutable and :omniauthable devise :database_authenticatable, :registerable, :recoverable, :rememberable, :trackable, :validatable,:confirmable, :lockable end
41.571429
86
0.766323
e832452377599fcdbaee83f3d68b2f982b1fedb4
1,280
# frozen_string_literal: true class ActionMessage < MessageComponent self.ignored_columns = %w[completing_message_type] # TODO: was polymorphic, need to remove belongs_to :completing_message, class_name: "Message" validates :description, presence: true def completed? completing_message.try(:message).try(:approved?) || completing_message end end # == Schema Information # # Table name: action_messages # # id :integer not null, primary key # description :string not null # created_at :datetime not null # updated_at :datetime not null # completing_message_id :integer # created_by_id :integer not null # message_id :integer not null # thread_id :integer not null # # Indexes # # index_action_messages_on_completing_message_id (completing_message_id) # index_action_messages_on_created_by_id (created_by_id) # index_action_messages_on_message_id (message_id) # index_action_messages_on_thread_id (thread_id) # # Foreign Keys # # fk_rails_... (created_by_id => users.id) # fk_rails_... (message_id => messages.id) # fk_rails_... (thread_id => message_threads.id) #
31.219512
92
0.659375
799d977868fece689e64f300da60e32dfb900787
1,018
lib = File.expand_path('lib', __dir__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require 'rspec/any_of/version' Gem::Specification.new do |spec| spec.name = 'rspec-any_of' spec.version = RSpec::AnyOf::VERSION spec.authors = ['Arkadiy Zabazhanov'] spec.email = ['[email protected]'] spec.summary = "rspec-any_of-#{RSpec::AnyOf::VERSION}" spec.description = 'HTML equivalence RSpec matcher' spec.homepage = 'https://github.com/toptal/rspec-any_of' spec.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR) spec.test_files = spec.files.grep(%r{^spec/}) spec.require_paths = ['lib'] spec.add_runtime_dependency 'rspec-expectations', '~> 3.0' spec.add_development_dependency 'rake', '~> 10.0' spec.add_development_dependency 'rspec', '~> 3.0' spec.add_development_dependency 'rubocop', '~> 0.68.1' spec.add_development_dependency 'rubocop-rspec', '~> 1.32.0' spec.add_development_dependency 'yard', '0.9.19' end
37.703704
69
0.682711
87140e13b7242ed76bf2e6873564a7c3d947e515
517
require "graphql/api/unauthorized_exception" module GraphQL::Api class Policy attr_reader :ctx, :model def initialize(ctx, model) @model = model @ctx = ctx end def user ctx[:current_user] end def create? true end def update? true end def destroy? true end def read? true end def unauthorized! raise UnauthorizedException.new end def unauthorized_field_access(name) nil end end end
12.309524
44
0.588008
18f4f4928569b30657f16cd2f86b9c07931c6ab5
131
# Chef Provisioning Azure driver class Chef module Provisioning module AzureDriver VERSION = "0.6.0" end end end
14.555556
32
0.687023
e8f9e24d82847c9df8bd413965f476133116b6a6
642
class CapsuleSyncMonitor @queue = :signup extend CapsuleHelper # This monitors capsuleCRM for changes and queues up individual changes for update in the frontend app def self.perform [ :orgs, :people ].each do |type| self.send(type).each { |t| enqueue_sync(t, t.class.name.demodulize) } end end def self.enqueue_sync(org, type) if org.updated_at > 2.hours.ago Resque.enqueue(SyncCapsuleData, org.id, type) end end def self.orgs CapsuleCRM::Organisation.find_all(:tag => "Membership") end def self.people CapsuleCRM::Person.find_all(:tag => "Membership") end end
20.709677
104
0.676012
283f70b852078e109f52c0437bf132c50cc88377
827
# frozen_string_literal: true RSpec.feature "List Schedule for System Admin", :all_dbs do let!(:current_user) { User.authenticate!(roles: ["System Admin"]) } context "Correct buttons are displayed" do let!(:hearing) { create(:hearing) } let!(:hearing_day) { create(:hearing_day) } scenario "Correct days are displayed" do visit "hearings/schedule" expect(page).to have_content(Hearing::HEARING_TYPES[HearingDay.first.request_type.to_sym]) end scenario "All buttons are visible" do visit "hearings/schedule" expect(page).to have_content(COPY::HEARING_SCHEDULE_JUDGE_DEFAULT_VIEW_PAGE_HEADER) expect(page).to have_content("Schedule Veterans") expect(page).to have_content("Build Schedule") expect(page).to have_content("Add Hearing Date") end end end
31.807692
96
0.71584
f83415acfbf52f3aff9207dea5d70412ac83a261
1,205
# DO NOT EDIT THIS FILE DIRECTLY! Instead, use lib/gemspec.rb to generate it. Gem::Specification.new do |s| s.name = %q{refinerycms-base} s.version = %q{1.1.0} s.summary = %q{Base engine for Refinery CMS} s.description = %q{This provides a base for Refinery CMS which handles things like settings on the Refinery namespace.} s.date = %q{2011-06-02} s.email = %q{[email protected]} s.homepage = %q{http://refinerycms.com} s.rubyforge_project = %q{refinerycms} s.authors = ['Resolve Digital', 'Philip Arndt', 'David Jones', 'Steven Heidel'] s.license = %q{MIT} s.require_paths = %w(lib) s.executables = %w() s.files = [ 'db', 'db/migrate', 'db/migrate/20100913234706_create_refinerycms_core_schema.rb', 'db/migrate/20101217113424_add_locale_to_slugs.rb', 'lib', 'lib/base', 'lib/base/refinery.rb', 'lib/gemspec.rb', 'lib/generators', 'lib/generators/refinerycms_base_generator.rb', 'lib/refinery', 'lib/refinery/version.rb', 'lib/refinerycms-base.rb', 'license.md', 'refinerycms-base.gemspec' ] end
34.428571
127
0.609129
bb4c7c1816c8abce0474ef30eaeb89fc697ab027
277
FactoryBot.define do # Define your Spree extensions Factories within this file to enable applications, and other extensions to use and override them. # # Example adding this to your spec_helper will load these Factories for use: # require 'spree_cropper/factories' end
39.571429
130
0.787004
793e9d0a65ced9ede7fa65708974532c30b28dbb
1,615
class MediaInfo < Formula desc "Unified display of technical and tag data for audio/video" homepage "https://mediaarea.net/" url "https://mediaarea.net/download/binary/mediainfo/0.7.98/MediaInfo_CLI_0.7.98_GNU_FromSource.tar.bz2" version "0.7.98" sha256 "d194ff6fb32880e5f0e3c11b2d9139c65f647b8049d57258258870e9f2b316e4" bottle do cellar :any sha256 "39f1004281cd63be5c93d71e00846d46f1996c10adad8ea3714e26b2cb37483d" => :sierra sha256 "caaa25dd252801f0aa1a14926625fb20bea751ccaced9d6a0b700bfb427faf52" => :el_capitan sha256 "afbc58c6d01aa35cca42ce7d103836c495cfa621ef093cb2c048125a789a6167" => :yosemite end depends_on "pkg-config" => :build def install cd "ZenLib/Project/GNU/Library" do args = ["--disable-debug", "--disable-dependency-tracking", "--enable-static", "--enable-shared", "--prefix=#{prefix}"] system "./configure", *args system "make", "install" end cd "MediaInfoLib/Project/GNU/Library" do args = ["--disable-debug", "--disable-dependency-tracking", "--with-libcurl", "--enable-static", "--enable-shared", "--prefix=#{prefix}"] system "./configure", *args system "make", "install" end cd "MediaInfo/Project/GNU/CLI" do system "./configure", "--disable-debug", "--disable-dependency-tracking", "--prefix=#{prefix}" system "make", "install" end end test do pipe_output("#{bin}/mediainfo", test_fixtures("test.mp3")) end end
32.3
106
0.634056
38845bd42c64e686f669cedeff48db7c1d3e3c76
1,321
class Dune < Formula desc "Composable build system for OCaml" homepage "https://dune.build/" url "https://github.com/ocaml/dune/releases/download/2.6.1/dune-2.6.1.tbz" sha256 "5ef959f286448ee172f1cffc86c439a6f7b662676e6015b282db071bb88899a0" head "https://github.com/ocaml/dune.git" bottle do cellar :any_skip_relocation sha256 "20b66d941c17e2490aa2aff29db3aea6b5f857bc622affdae9621bd8f85ef175" => :catalina sha256 "359eb57c1c81d632082e05dfd43299cd972271beff51817d9f8463369b096f0b" => :mojave sha256 "2806c727b972d5e3b8d1050155c3cc7380e1ce5d5dd2939d8839df9958be8d3d" => :high_sierra sha256 "b534a47eae1ba3e05a8949bc0b27375301ed808e65f466743822f0c5d865ba7a" => :x86_64_linux end depends_on "ocaml" => [:build, :test] def install system "ocaml", "configure.ml" system "ocaml", "bootstrap.ml" system "./dune.exe", "build", "-p", "dune", "--profile", "dune-bootstrap" bin.install "_build/default/bin/dune.exe" mv bin/"dune.exe", bin/"dune" end test do contents = "bar" target_fname = "foo.txt" (testpath/"dune").write("(rule (with-stdout-to #{target_fname} (echo #{contents})))") system bin/"dune", "build", "foo.txt", "--root", "." output = File.read(testpath/"_build/default/#{target_fname}") assert_match contents, output end end
37.742857
94
0.72218
6a74ab916022cc006cdb762c5a09cae58adcc05a
1,101
require File.expand_path('../../../../spec_helper', __FILE__) require 'set' describe "SortedSet#classify" do before(:each) do @set = SortedSet["one", "two", "three", "four"] end it "yields each Object in self in sorted order" do res = [] @set.classify { |x| res << x } res.should == ["one", "two", "three", "four"].sort end ruby_version_is "" ... "1.8.8" do it "raises a LocalJumpError when passed no block" do lambda { @set.classify }.should raise_error(LocalJumpError) end end ruby_version_is "1.8.8" do it "returns an Enumerator when passed no block" do enum = @set.classify enum.should be_an_instance_of(enumerator_class) classified = enum.each { |x| x.length } classified.should == { 3 => SortedSet["one", "two"], 4 => SortedSet["four"], 5 => SortedSet["three"] } end end it "classifies the Objects in self based on the block's return value" do classified = @set.classify { |x| x.length } classified.should == { 3 => SortedSet["one", "two"], 4 => SortedSet["four"], 5 => SortedSet["three"] } end end
30.583333
108
0.625795
ab64f0df2d2957bdcf21662cc63f0fc73571b866
328
# -*- encoding: utf-8 -*- # # Para manter compatibilidade com ActiveModel require 'date' require 'time' class Date def self.current Time.respond_to?(:zone) && Time.zone ? Time.zone.today : Date.today end end class Time def self.current Time.respond_to?(:zone) && Time.zone ? Time.zone.now : Time.now end end
16.4
71
0.679878
f802e30dda16ab2742d96e397364f395bedffd72
2,813
# frozen_string_literal: true require_relative "../test_helper" class ResponseTest < Minitest::Test def setup @redis = DB.pool.checkout @meeting = Meeting.new(id: :test, account: :account) @meeting.cleanup @person = Person.new(id: :foo, name: :bar) end def teardown @meeting.cleanup DB.pool.checkin end def test_winner @meeting << @person @person.meeting_id = :test response = Response.winner(@person) assert_equal :winner, response.type json = response.as_json(additional_context) assert_instance_of Hash, json sharing_action = json.dig("content", "body", 0, "sections", 2, "items", 0, "value") assert_equal "mark-sharing:account.test.foo", sharing_action draw_again_action = json.dig("content", "body", 0, "sections", 2, "items", 1, "value") assert_equal "draw-again:account.test", draw_again_action end def test_unknown_meeting_id response = Response.unknown_meeting_id(:foo) assert response.sendable? assert_equal :unknown_meeting_id, response.type assert_instance_of Hash, response.as_json(additional_context) end def test_person_sharing response = Response.person_sharing(:foo) assert response.sendable? assert_equal :person_sharing, response.type json = response.as_json(additional_context) assert_instance_of Hash, json draw_again_action = json.dig("content", "body", 0, "sections", 1, "items", 0, "value") assert_equal "draw-again:account.foo", draw_again_action reset_shared_action = json.dig("content", "body", 0, "sections", 1, "items", 1) assert_nil reset_shared_action end def test_sharing_reset response = Response.sharing_reset(:foo) assert response.sendable? assert_equal :sharing_reset, response.type json = response.as_json(additional_context) assert_instance_of Hash, json draw_again_action = json.dig("content", "body", 0, "sections", 1, "items", 0, "value") assert_equal "draw-again:account.foo", draw_again_action end def test_empty_draw response = Response.empty_draw(:foo) assert response.sendable? assert_equal :empty_draw, response.type json = response.as_json(additional_context) assert_instance_of Hash, json draw_again_action = json.dig("content", "body", 0, "sections", 1, "items", 0, "value") assert_equal "draw-again:account.foo", draw_again_action reset_shared_action = json.dig("content", "body", 0, "sections", 1, "items", 1, "value") assert_equal "reset-shared:account.foo", reset_shared_action end def test_blank response = Response.blank assert_equal :blank, response.type refute response.sendable? end def additional_context { account_id: :account, to_jid: :to_jid, robot_jid: :robot_jid } end end
29
92
0.707074
ff26cbe24ba0a9a062b221e49e09bb4ab8cee718
366
cask 'maltego-ce' do version '4.0.11.9358' sha256 'eed48ed7d6a32cbb6d963c1af0c0fd7f9c78e89351aa746804889e521469ac3f' url "https://www.paterva.com/malv#{version.major}/community/MaltegoCE.v#{version}.dmg" name 'Maltego CE' homepage 'https://www.paterva.com/web7/buy/maltego-clients/maltego-ce.php' app "Maltego CE v#{version.major_minor_patch}.app" end
33.272727
88
0.76776
267eeee61339fca539ee7e934bbda9d92aba5e96
842
# == Schema Information # # Table name: illustration_crops # # id :integer not null, primary key # illustration_id :integer # image_file_name :string(255) # image_content_type :string(255) # image_file_size :integer # image_updated_at :datetime # created_at :datetime # updated_at :datetime # image_processing :boolean # crop_details :text # image_meta :text # storage_location :string(255) # smart_crop_details :text # require 'rails_helper' RSpec.describe IllustrationCrop, :type => :model do it {should belong_to(:illustration)} it {should have_attached_file(:image)} #it {should validate_attachment_presence(:image)} #it {should validate_attachment_content_type(:image).allowing('image/png').allowing('image/jpeg').rejecting('text/plain')} end
29.034483
124
0.693587
033f0a36013c5fc3dda3bdfe4ff0348eebf762c5
274
module WordpressHelper def wordpress_age(hit) content_tag(:span, t('views.otrs.age', age: time_ago_in_words(Time.parse(hit['date'])))) end def wordpress_excerpt(hit) strip_tags(hit['excerpt']['rendered']).html_safe end end
22.833333
67
0.631387
61cf81a60128414906581dbcd0e7998c103691e3
1,656
# encoding: utf-8 # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. See License.txt in the project root for license information. lib = File.expand_path('../lib', __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require '../azure_mgmt_signlr/lib/module_definition' require '../azure_mgmt_signlr/lib/version' Gem::Specification.new do |spec| spec.name = 'azure_mgmt_signlr' spec.version = Azure::Signlr::Mgmt::VERSION spec.authors = 'Microsoft Corporation' spec.email = '[email protected]' spec.homepage = 'https://aka.ms/azure-sdk-for-ruby' spec.summary = 'Official Ruby client library to consume Signlr' spec.license = 'MIT' spec.metadata = { 'bug_tracker_uri' => 'https://github.com/Azure/azure-sdk-for-ruby/issues', 'changelog_uri' => 'https://github.com/Azure/azure-sdk-for-ruby/blob/master/ChangeLog.md', 'documentation_uri' => 'https://azure.microsoft.com/en-us/develop/ruby/', 'homepage_uri' => 'https://aka.ms/azure-sdk-for-ruby' } spec.files = Dir["LICENSE.txt", "lib/**/*"] spec.files.reject! { |fn| fn.include? "build.json" } spec.bindir = 'bin' spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) } spec.require_paths = ['lib'] spec.required_ruby_version = '>= 2.0.0' spec.add_development_dependency 'bundler', '~> 2.2.10' spec.add_development_dependency 'rake', '~> 10' spec.add_development_dependency 'rspec', '~> 3' spec.add_development_dependency 'dotenv', '~> 2' spec.add_runtime_dependency 'ms_rest_azure', '~> 0.12.0' end
40.390244
94
0.677536
e9ee40a4c2e9c1b48af068090ae48570f9d2b396
869
# frozen_string_literal: true module Stupidedi module Versions module ThirtyTen module SegmentDefs s = Schema e = ElementDefs r = ElementReqs BCH = s::SegmentDef.build(:BCH, "Beginning Segment for Purchase Order Change", "To indicate the beginning of the Purchase Order Change Transaction Set and transmit identifying numbers and dates", e::E353 .simple_use(r::Mandatory, s::RepeatCount.bounded(1)), e::E92 .simple_use(r::Mandatory, s::RepeatCount.bounded(1)), e::E324 .simple_use(r::Mandatory, s::RepeatCount.bounded(1)), e::E328 .simple_use(r::Mandatory, s::RepeatCount.bounded(1)), e::E327 .simple_use(r::Optional, s::RepeatCount.bounded(1)), e::E323 .simple_use(r::Mandatory, s::RepeatCount.bounded(1))) end end end end
37.782609
86
0.637514
4a56506ba03f7b60ced7895810dd8945bcf74794
1,974
class Packetbeat < Formula desc "Lightweight Shipper for Network Data" homepage "https://www.elastic.co/products/beats/packetbeat" url "https://github.com/elastic/beats/archive/v5.4.3.tar.gz" sha256 "a7714383de1a610c7318e8a2751a230b64c8ca243058abd59b1886aabcc3965b" head "https://github.com/elastic/beats.git" bottle do cellar :any_skip_relocation sha256 "f7fa33228dce3364c6312b5b68d85ac13153e14fb1bbdf78a2748010fd1f2423" => :sierra sha256 "28a47907c1074b01c7ce9f22e62b2a16fcbb2f3d6d7cc70b5a620e15fbb0beed" => :el_capitan sha256 "0f3a170e874403fe513e1c95aa1f73e92c9fe7925cc0ed81a44f92f96281e188" => :yosemite end depends_on "go" => :build def install gopath = buildpath/"gopath" (gopath/"src/github.com/elastic/beats").install Dir["{*,.git,.gitignore}"] ENV["GOPATH"] = gopath cd gopath/"src/github.com/elastic/beats/packetbeat" do system "make" libexec.install "packetbeat" inreplace "packetbeat.yml", "packetbeat.interfaces.device: any", "packetbeat.interfaces.device: en0" (etc/"packetbeat").install("packetbeat.yml", "packetbeat.template.json", "packetbeat.template-es2x.json") end (bin/"packetbeat").write <<-EOS.undent #!/bin/sh exec #{libexec}/packetbeat -path.config #{etc}/packetbeat \ -path.home #{prefix} -path.logs #{var}/log/packetbeat \ -path.data #{var}/packetbeat $@ EOS end plist_options :manual => "packetbeat" def plist; <<-EOS.undent <?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE plist PUBLIC "-//Apple Computer//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd"> <plist version="1.0"> <dict> <key>Label</key> <string>#{plist_name}</string> <key>Program</key> <string>#{opt_bin}/packetbeat</string> <key>RunAtLoad</key> <true/> </dict> </plist> EOS end test do system "#{bin}/packetbeat", "--devices" end end
30.84375
111
0.676798
7a7da63429d3a046d8c1d661f6f675092d8856a4
508
module Roles roles = [ { label: "System Admin", description: "Super user, given only to people who can manage the entire system (Team JD8112)." }, { label: "Expo Admin", description: "Expo admin, for all intents will be identical to system admin." }, { label: "Team Member", description: "Manages their own project at a fair. Can edit descriptions of their own projects." } ] roles.each do |role| Role.find_or_create_by!(role) end end
24.190476
102
0.627953
abe20a3f39a39bb1d4646667d2ef11aa2a75b9bb
1,994
class ProfilesController < ApplicationController before_action :set_profile, only: [:show, :edit, :update, :destroy] before_action :authenticate_user! # GET /profiles # GET /profiles.json def index @profiles = Profile.all end # GET /profiles/1 # GET /profiles/1.json def show end # GET /profiles/new def new @profile = Profile.new end # GET /profiles/1/edit def edit end # POST /profiles # POST /profiles.json def create @profile = Profile.new(profile_params) respond_to do |format| if @profile.save format.html { redirect_to @profile, notice: 'Profile was successfully created.' } format.json { render :show, status: :created, location: @profile } else format.html { render :new } format.json { render json: @profile.errors, status: :unprocessable_entity } end end end # PATCH/PUT /profiles/1 # PATCH/PUT /profiles/1.json def update respond_to do |format| if @profile.update(profile_params) format.html { redirect_to @profile, notice: 'Profile was successfully updated.' } format.json { render :show, status: :ok, location: @profile } else format.html { render :edit } format.json { render json: @profile.errors, status: :unprocessable_entity } end end end # DELETE /profiles/1 # DELETE /profiles/1.json def destroy @profile.destroy respond_to do |format| format.html { redirect_to profiles_url, notice: 'Profile was successfully destroyed.' } format.json { head :no_content } end end private # Use callbacks to share common setup or constraints between actions. def set_profile @profile = Profile.find(params[:id]) end # Only allow a list of trusted parameters through. def profile_params params.require(:profile).permit(:name, :username, :website, :bio) end end
26.586667
94
0.636409
7956305a739f4c59dc2320e569f4b741cc4f41b7
419
require 'test_helper' require 'generators/landing_boi/landing_boi_generator' module LandingBoi class LandingBoiGeneratorTest < Rails::Generators::TestCase tests LandingBoiGenerator destination Rails.root.join('tmp/generators') setup :prepare_destination # test "generator runs without errors" do # assert_nothing_raised do # run_generator ["arguments"] # end # end end end
24.647059
61
0.735084
2624396d540b5c7089a5a78c7b5b8ce02ba4a1b7
948
Spree::Product.class_eval do def option_values @_option_values ||= Spree::OptionValue.for_product(self) end def grouped_option_values @_grouped_option_values ||= option_values.group_by(&:option_type) @_grouped_option_values.sort_by { |option_type, option_values| option_type.position } end def variants_for_option_value(value) @_variant_option_values ||= variants.includes(:option_values) @_variant_option_values.select { |i| i.option_value_ids.include?(value.id) } end def variant_options_hash return @_variant_options_hash if @_variant_options_hash hash = {} variants.includes(:option_values).each do |variant| variant.option_values.each do |ov| otid = ov.option_type_id.to_s ovid = ov.id.to_s hash[otid] ||= {} hash[otid][ovid] ||= {} hash[otid][ovid][variant.id.to_s] = variant.to_hash end end @_variant_options_hash = hash end end
29.625
89
0.703586
1c88fda8b4f708b130db93f22b09db82f736286c
4,269
## # This module requires Metasploit: http://metasploit.com/download # Current source: https://github.com/rapid7/metasploit-framework ## require 'msf/core/post/windows/priv' require 'msf/core/post/common' require 'msf/core/post/windows/registry' class MetasploitModule < Msf::Post include Msf::Post::Windows::Priv include Msf::Post::Common include Msf::Post::Windows::Registry def initialize(info={}) super(update_info(info, 'Name' => "Windows Enumerate LSA Secrets", 'Description' => %q{ This module will attempt to enumerate the LSA Secrets keys within the registry. The registry value used is: HKEY_LOCAL_MACHINE\\Security\\Policy\\Secrets\\. Thanks goes to Maurizio Agazzini and Mubix for decrypt code from cachedump. }, 'License' => MSF_LICENSE, 'Platform' => ['win'], 'SessionTypes' => ['meterpreter'], 'Author' => ['Rob Bathurst <rob.bathurst[at]foundstone.com>'] )) end # Decrypted LSA key is passed into this method def get_secret(lsa_key) output = "\n" # LSA Secret key location within the registry root_regkey = "HKLM\\Security\\Policy\\Secrets\\" services_key = "HKLM\\SYSTEM\\CurrentControlSet\\Services\\" secrets = registry_enumkeys(root_regkey) secrets.each do |secret_regkey| sk_arr = registry_enumkeys(root_regkey + "\\" + secret_regkey) next unless sk_arr sk_arr.each do |mkeys| # CurrVal stores the currently set value of the key. In the case # of services, this is usually the password for the service # account. next unless mkeys == "CurrVal" val_key = root_regkey + "\\" + secret_regkey + "\\" + mkeys encrypted_secret = registry_getvaldata(val_key, "") next unless encrypted_secret if lsa_vista_style? # Magic happens here decrypted = decrypt_lsa_data(encrypted_secret, lsa_key) else # and here if sysinfo['Architecture'] == ARCH_X64 encrypted_secret = encrypted_secret[0x10..-1] else # 32 bits encrypted_secret = encrypted_secret[0xC..-1] end decrypted = decrypt_secret_data(encrypted_secret, lsa_key) end next unless decrypted.length > 0 # axe all the non-printables decrypted = decrypted.scan(/[[:print:]]/).join if secret_regkey.start_with?("_SC_") # Service secrets are named like "_SC_yourmom" for a service # with name "yourmom". Strip off the "_SC_" to get something # we can lookup in the list of services to find out what # account this secret is associated with. svc_name = secret_regkey[4,secret_regkey.length] svc_user = registry_getvaldata(services_key + svc_name, "ObjectName") # if the unencrypted value is not blank and is a service, print print_good("Key: #{secret_regkey}\n Username: #{svc_user} \n Decrypted Value: #{decrypted}\n") output << "Key: #{secret_regkey}\n Username: #{svc_user} \n Decrypted Value: #{decrypted}\n" else # if the unencrypted value is not blank, print print_good("Key: #{secret_regkey}\n Decrypted Value: #{decrypted}\n") output << "Key: #{secret_regkey}\n Decrypted Value: #{decrypted}\n" end end end return output end # The sauce starts here def run hostname = sysinfo['Computer'] print_status("Executing module against #{hostname}") print_status('Obtaining boot key...') bootkey = capture_boot_key vprint_status("Boot key: #{bootkey.unpack("H*")[0]}") print_status('Obtaining Lsa key...') lsa_key = capture_lsa_key(bootkey) if lsa_key.nil? print_error("Could not retrieve LSA key. Are you SYSTEM?") return end vprint_status("Lsa Key: #{lsa_key.unpack("H*")[0]}") secrets = hostname + get_secret(lsa_key) print_status("Writing to loot...") path = store_loot( 'registry.lsa.sec', 'text/plain', session, secrets, 'reg_lsa_secrts.txt', 'Registry LSA Secret Decrypted File' ) print_status("Data saved in: #{path}") end end
32.587786
115
0.635278
f8f7a57b115f639dfce02e3068c22604f0f8bd7f
7,819
# encoding: utf-8 require 'spec_helper' describe "mail encoding" do it "should allow you to assign a mail wide charset" do mail = Mail.new mail.charset = 'utf-8' mail.charset.should eq 'utf-8' end describe "using default encoding" do it "should allow you to send in unencoded strings to fields and encode them" do mail = Mail.new mail.charset = 'utf-8' mail.subject = "This is あ string" result = "Subject: =?UTF-8?Q?This_is_=E3=81=82_string?=\r\n" mail[:subject].encoded.should eq result end it "should allow you to send in unencoded strings to address fields and encode them" do mail = Mail.new mail.charset = 'utf-8' mail.to = "Mikel Lindsああr <[email protected]>" result = "To: Mikel =?UTF-8?B?TGluZHPjgYLjgYJy?= <[email protected]>\r\n" mail[:to].encoded.should eq result end it "should allow you to send in unencoded strings to address fields and encode them" do mail = Mail.new mail.charset = 'utf-8' mail.to = "あdあ <[email protected]>" result = "To: =?UTF-8?B?44GCZOOBgg==?= <[email protected]>\r\n" mail[:to].encoded.should eq result end it "should allow you to send in multiple unencoded strings to address fields and encode them" do mail = Mail.new mail.charset = 'utf-8' mail.to = ["Mikel Lindsああr <[email protected]>", "あdあ <[email protected]>"] result = "To: Mikel =?UTF-8?B?TGluZHPjgYLjgYJy?= <[email protected]>, \r\n\s=?UTF-8?B?44GCZOOBgg==?= <[email protected]>\r\n" mail[:to].encoded.should eq result end it "should allow you to send unquoted non us-ascii strings, with spaces in them" do mail = Mail.new mail.charset = 'utf-8' mail.to = ["Foo áëô îü <[email protected]>"] result = "To: Foo =?UTF-8?B?w6HDq8O0?= =?UTF-8?B?IMOuw7w=?= <[email protected]>\r\n" mail[:to].encoded.should eq result end it "should allow you to send in multiple unencoded strings to any address field" do mail = Mail.new mail.charset = 'utf-8' ['To', 'From', 'Cc', 'Reply-To'].each do |field| mail.send("#{field.downcase.gsub("-", '_')}=", ["Mikel Lindsああr <[email protected]>", "あdあ <[email protected]>"]) result = "#{field}: Mikel =?UTF-8?B?TGluZHPjgYLjgYJy?= <[email protected]>, \r\n\s=?UTF-8?B?44GCZOOBgg==?= <[email protected]>\r\n" mail[field].encoded.should eq result end end it "should handle groups" do mail = Mail.new mail.charset = 'utf-8' mail.to = "[email protected], group: [email protected], [email protected];" result = "To: [email protected], \r\n\sgroup: [email protected], \r\n\[email protected];\r\n" mail[:to].encoded.should eq result end it "should handle groups with funky characters" do mail = Mail.new mail.charset = 'utf-8' mail.to = '"Mikel Lindsああr" <[email protected]>, group: "あdあ" <[email protected]>, [email protected];' result = "To: =?UTF-8?B?TWlrZWwgTGluZHPjgYLjgYJy?= <[email protected]>, \r\n\sgroup: =?UTF-8?B?44GCZOOBgg==?= <[email protected]>, \r\n\[email protected];\r\n" mail[:to].encoded.should eq result end describe "quoting token safe chars" do it "should not quote the display name if unquoted" do mail = Mail.new mail.charset = 'utf-8' mail.to = 'Mikel Lindsaar <[email protected]>' mail[:to].encoded.should eq %{To: Mikel Lindsaar <[email protected]>\r\n} end it "should not quote the display name if already quoted" do mail = Mail.new mail.charset = 'utf-8' mail.to = '"Mikel Lindsaar" <[email protected]>' mail[:to].encoded.should eq %{To: Mikel Lindsaar <[email protected]>\r\n} end end describe "quoting token unsafe chars" do it "should quote the display name" do pending mail = Mail.new mail.charset = 'utf-8' mail.to = "Mikel @ me Lindsaar <[email protected]>" mail[:to].encoded.should eq %{To: "Mikel @ me Lindsaar" <[email protected]>\r\n} end it "should preserve quotes needed from the user and not double quote" do mail = Mail.new mail.charset = 'utf-8' mail.to = %{"Mikel @ me Lindsaar" <[email protected]>} mail[:to].encoded.should eq %{To: "Mikel @ me Lindsaar" <[email protected]>\r\n} end end end describe "specifying an email wide encoding" do it "should allow you to send in unencoded strings to fields and encode them" do mail = Mail.new mail.charset = 'ISO-8859-1' subject = "This is あ string" subject.force_encoding('ISO8859-1') if RUBY_VERSION > '1.9' mail.subject = subject result = mail[:subject].encoded string = "Subject: =?ISO-8859-1?Q?This_is_=E3=81=82_string?=\r\n" if RUBY_VERSION > '1.9' string.force_encoding('ISO8859-1') result.force_encoding('ISO8859-1') end result.should eq string end it "should allow you to send in unencoded strings to address fields and encode them" do mail = Mail.new mail.charset = 'ISO-8859-1' string = "Mikel Lindsああr <[email protected]>" string.force_encoding('ISO8859-1') if RUBY_VERSION > '1.9' mail.to = string result = mail[:to].encoded string = "To: Mikel =?ISO-8859-1?B?TGluZHPjgYLjgYJy?= <[email protected]>\r\n" if RUBY_VERSION > '1.9' string.force_encoding('ISO8859-1') result.force_encoding('ISO8859-1') end result.should eq string end it "should allow you to send in multiple unencoded strings to address fields and encode them" do mail = Mail.new mail.charset = 'ISO-8859-1' array = ["Mikel Lindsああr <[email protected]>", "あdあ <[email protected]>"] array.map! { |a| a.force_encoding('ISO8859-1') } if RUBY_VERSION > '1.9' mail.to = array result = mail[:to].encoded string = "To: Mikel =?ISO-8859-1?B?TGluZHPjgYLjgYJy?= <[email protected]>, \r\n\s=?ISO-8859-1?B?44GCZOOBgg==?= <[email protected]>\r\n" if RUBY_VERSION > '1.9' string.force_encoding('ISO8859-1') result.force_encoding('ISO8859-1') end result.should eq string end it "should allow you to send in multiple unencoded strings to any address field" do mail = Mail.new array = ["Mikel Lindsああr <[email protected]>", "あdあ <[email protected]>"] array.map! { |a| a.force_encoding('ISO8859-1') } if RUBY_VERSION > '1.9' mail.charset = 'ISO-8859-1' ['To', 'From', 'Cc', 'Reply-To'].each do |field| mail.send("#{field.downcase.gsub("-", '_')}=", array) string = "#{field}: Mikel =?ISO-8859-1?B?TGluZHPjgYLjgYJy?= <[email protected]>, \r\n\s=?ISO-8859-1?B?44GCZOOBgg==?= <[email protected]>\r\n" result = mail[field].encoded if RUBY_VERSION > '1.9' string.force_encoding('ISO8859-1') result.force_encoding('ISO8859-1') end result.should eq string end end end it "should let you define a charset per part" do mail = Mail.new part = Mail::Part.new part.content_type = "text/html" part.charset = "ISO-8859-1" part.body = "blah" mail.add_part(part) mail.parts[0].content_type.should eq "text/html; charset=ISO-8859-1" end it "should skip invalid characters" do m = Mail.new m['Subject'] = Mail::SubjectField.new("=?utf-8?Q?Hello_=96_World?=") if RUBY_VERSION > '1.9' lambda { m.subject.should be_valid_encoding }.should_not raise_error else m.subject.should eq "Hello World" end end end
39.291457
166
0.630388
bf5cf2a2e0197f1779278b6d1240dea92aa8dcd3
1,855
# Copyright 2015 Google 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 'google/apis/compute_v1/service.rb' require 'google/apis/compute_v1/classes.rb' require 'google/apis/compute_v1/representations.rb' module Google module Apis # Compute Engine API # # Creates and runs virtual machines on Google Cloud Platform. # # @see https://developers.google.com/compute/docs/reference/latest/ module ComputeV1 VERSION = 'V1' REVISION = '20161019' # View and manage your data across Google Cloud Platform services AUTH_CLOUD_PLATFORM = 'https://www.googleapis.com/auth/cloud-platform' # View and manage your Google Compute Engine resources AUTH_COMPUTE = 'https://www.googleapis.com/auth/compute' # View your Google Compute Engine resources AUTH_COMPUTE_READONLY = 'https://www.googleapis.com/auth/compute.readonly' # Manage your data and permissions in Google Cloud Storage AUTH_DEVSTORAGE_FULL_CONTROL = 'https://www.googleapis.com/auth/devstorage.full_control' # View your data in Google Cloud Storage AUTH_DEVSTORAGE_READ_ONLY = 'https://www.googleapis.com/auth/devstorage.read_only' # Manage your data in Google Cloud Storage AUTH_DEVSTORAGE_READ_WRITE = 'https://www.googleapis.com/auth/devstorage.read_write' end end end
37.1
94
0.738544
33408bb4aefa417f2933c80620c45fd5e6c7fd50
1,507
# This file is automatically generated by puppet-swagger-generator and # any manual changes are likely to be clobbered when the files # are regenerated. require_relative '../../../puppet_x/puppetlabs/kubernetes/provider' Puppet::Type.type(:kubernetes_downward_api_projection).provide(:swagger, :parent => PuppetX::Puppetlabs::Kubernetes::Provider) do mk_resource_methods def self.instance_to_hash(instance) { ensure: :present, name: instance.metadata.name, items: instance.items.respond_to?(:to_hash) ? instance.items.to_hash : instance.items, object: instance, } end def create Puppet.info("Creating kubernetes_downward_api_projection #{name}") create_instance_of('downward_api_projection', name, build_params) end def flush unless @property_hash.empty? unless resource[:ensure] == :absent flush_instance_of('downward_api_projection', name, @property_hash[:object], build_params) end end end def destroy Puppet.info("Deleting kubernetes_downward_api_projection #{name}") destroy_instance_of('downward_api_projection', name) @property_hash[:ensure] = :absent end private def self.list_instances list_instances_of('downward_api_projection') end def build_params params = { items: resource[:items], } params.delete_if { |key, value| value.nil? } params end end
24.704918
130
0.671533
f79f07b9acd351e0e2939d63e3addaf9eee43cb5
5,928
=begin #OpenAPI Petstore #This spec is mainly for testing Petstore server and contains fake endpoints, models. Please do not use this for any other purpose. Special characters: \" \\ The version of the OpenAPI document: 1.0.0 Generated by: https://openapi-generator.tech OpenAPI Generator version: 4.0.1-SNAPSHOT =end require 'date' module Petstore class AdditionalPropertiesString attr_accessor :name # Attribute mapping from ruby-style variable name to JSON key. def self.attribute_map { :'name' => :'name' } end # Attribute type mapping. def self.openapi_types { :'name' => :'String' } 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 `Petstore::AdditionalPropertiesString` 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 `Petstore::AdditionalPropertiesString`. 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 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 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].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 Petstore.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) next if value.nil? 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
30.091371
214
0.627024
abdad802db37b74009700f2f168a2f145b4c6342
693
require 'dragonfly' Dragonfly.app.configure do # Allow all URLs to be fetched. fetch_url_whitelist [ /.*/ ] plugin :imagemagick verify_urls true secret Rails.application.secrets.dragonfly_secret url_format "/media/:job/:name" if Rails.env.test? datastore :memory else datastore :file, root_path: Rails.root.join('public/system/dragonfly', Rails.env), server_root: Rails.root.join('public') end end # Logger Dragonfly.logger = Rails.logger # Mount as middleware Rails.application.middleware.use Dragonfly::Middleware # Add model functionality ActiveRecord::Base.extend Dragonfly::Model ActiveRecord::Base.extend Dragonfly::Model::Validations
20.382353
71
0.741703
1103e4dd0fc48e951932b79d56f9af3b67275696
3,953
require 'spec_helper' module Bmg module Operator describe Ungroup do subject { Ungroup.new(Type::ANY.with_keys(keys), operand, attrlist) } context 'with a candidate key that does not use the attrlist' do let(:keys) { [[:id], [:id, :grouped]] } describe 'with a single attribute' do let(:attrlist) { [:grouped] } let(:operand) { Relation.new [ { id: 1, :grouped => [{ foo: "Bar" }, {foo: "Baz"}] }, { id: 2, :grouped => [{ foo: "Fuu" }] }, { id: 3, :grouped => [] } ] } it 'works' do expected = [ { id: 1, foo: "Bar" }, { id: 1, foo: "Baz" }, { id: 2, foo: "Fuu" }, ] expect(subject.to_a).to eql(expected) end end describe 'with two attributes' do let(:attrlist) { [:grouped, :second] } let(:operand) { Relation.new [ { id: 1, :grouped => [{ foo: "Bar" }, {foo: "Baz"}], :second => [{bar: "Baz"}, {bar: "Boz"}] }, { id: 2, :grouped => [{ foo: "Fuu" }], :second => [{bar: "Buz"}] }, { id: 3, :grouped => [], :second => [{bar: "Fuz"}] }, { id: 4, :grouped => [], :second => nil }, { id: 5, :grouped => [{ foo: "Bar" }], :second => nil }, { id: 6, :grouped => nil, :second => [{bar: "Baz"}] }, { id: 7, :grouped => nil, :second => nil } ] } it 'works' do expected = [ { id: 1, foo: "Bar", bar: "Baz" }, { id: 1, foo: "Bar", bar: "Boz" }, { id: 1, foo: "Baz", bar: "Baz" }, { id: 1, foo: "Baz", bar: "Boz" }, { id: 2, foo: "Fuu", bar: "Buz" }, ] expect(subject.to_a).to eql(expected) end end describe 'when yielding duplicates (key violation)' do let(:attrlist) { [:grouped] } let(:operand) { Relation.new [ { id: 1, :grouped => [{ foo: "Bar" }, {foo: "Baz"}] }, { id: 1, :grouped => [{ foo: "Bar" }] }, ] } it 'yields them (because PRE is wrong, POST is wrong too)' do expected = [ { id: 1, foo: "Bar" }, { id: 1, foo: "Baz" }, { id: 1, foo: "Bar" } ] expect(subject.to_a).to eql(expected) end end end context 'with no candidate key' do let(:keys) { nil } describe 'when yielding duplicates' do let(:attrlist) { [:grouped] } let(:operand) { Relation.new [ { id: 1, :grouped => [{ foo: "Bar" }, {foo: "Baz"}] }, { id: 1, :grouped => [{ foo: "Bar" }] }, ] } it 'removes them' do expected = [ { id: 1, foo: "Bar" }, { id: 1, foo: "Baz" }, ] expect(subject.to_a).to eql(expected) end end end context 'with only candidate keys using grouped' do let(:keys) { [[:id, :grouped]] } describe 'when yielding duplicates' do let(:attrlist) { [:grouped] } let(:operand) { Relation.new [ { id: 1, :grouped => [{ foo: "Bar" }, {foo: "Baz"}] }, { id: 1, :grouped => [{ foo: "Bar" }] }, ] } it 'removes them' do expected = [ { id: 1, foo: "Bar" }, { id: 1, foo: "Baz" }, ] expect(subject.to_a).to eql(expected) end end end end end end
26.891156
109
0.374146
f7dc77edd54ff7f9044ac21e5ac3dbff13b11b17
2,328
require 'bosh/director/core/templates' require 'bosh/director/core/templates/job_template_renderer' require 'bosh/director/core/templates/source_erb' module Bosh::Director class JobTemplateUnpackFailed < StandardError end module Core::Templates class JobTemplateLoader def initialize(logger, template_blob_cache, link_provider_intents, dns_encoder) @logger = logger @template_blob_cache = template_blob_cache @link_provider_intents = link_provider_intents @dns_encoder = dns_encoder end def process(job_template) template_dir = extract_template(job_template) manifest = Psych.load_file(File.join(template_dir, 'job.MF')) monit_erb_file = File.read(File.join(template_dir, 'monit')) monit_source_erb = SourceErb.new('monit', 'monit', monit_erb_file, job_template.name) source_erbs = [] template_name = manifest.fetch('name', {}) manifest.fetch('templates', {}).each_pair do |src_name, dest_name| erb_file = File.read(File.join(template_dir, 'templates', src_name)) source_erbs << SourceErb.new(src_name, dest_name, erb_file, job_template.name) end JobTemplateRenderer.new(job_template: job_template, template_name: template_name, monit_erb: monit_source_erb, source_erbs: source_erbs, logger: @logger, link_provider_intents: @link_provider_intents, dns_encoder: @dns_encoder) ensure FileUtils.rm_rf(template_dir) if template_dir end private def extract_template(job_template) @logger.debug("Extracting job #{job_template.name}") cached_blob_path = @template_blob_cache.download_blob(job_template) template_dir = Dir.mktmpdir('template_dir') output = `tar -C #{template_dir} -xzf #{cached_blob_path} 2>&1` if $?.exitstatus != 0 raise Bosh::Director::JobTemplateUnpackFailed, "Cannot unpack '#{job_template.name}' job template, " + "tar returned #{$?.exitstatus}, " + "tar output: #{output}" end template_dir end end end end
35.815385
93
0.630155
e834bc83cbba1bedc70c242d8492483e6fc051b6
3,925
require 'rails_helper' feature 'Event Creation', js: true do before do create :venue, title: 'Empire State Building' create :venue, title: 'New Relic' create :venue, title: 'Urban Airship' end scenario 'User adds an event at an existing venue' do # visit '/' # click_on 'Add an event' visit '/events/new' fill_in 'Event Name', with: 'Ruby Newbies' find_field('Venue').native.send_keys 'empire' expect(page).to have_text('Empire State Building') click_on 'Empire State Building' fill_in 'start_date', with: '2014-08-05' fill_in 'start_time', with: '06:00 PM' fill_in 'end_date', with: '2014-08-06' fill_in 'end_time', with: '11:00 PM' fill_in 'Website', with: 'www.rubynewbies.com' fill_in 'Description', with: 'An event for beginners' fill_in 'Venue details', with: 'On the third floor' fill_in 'Tags', with: 'beginners,ruby' click_on 'Create Event' expect(page).to have_content 'Event was successfully saved' expect(page).to have_content 'Ruby Newbies' expect(page).to have_content 'Empire State Building' expect(page).to have_content 'Tuesday, August 5, 2014 at 6pm through Wednesday, August 6, 2014 at 11pm' expect(page).to have_content 'Website http://www.rubynewbies.com' expect(page).to have_content 'Description An event for beginners' expect(page).to have_content 'On the third floor' expect(page).to have_content 'Tags beginners, ruby' end scenario 'User adds an event at a new venue' do visit '/' click_on 'Add an event' fill_in 'Event Name', with: 'Ruby Zoo' fill_in 'Venue', with: 'Portland Zoo' fill_in 'start_date', with: '2014-05-15' fill_in 'start_time', with: '04:00 PM' fill_in 'end_time', with: '09:00 PM' fill_in 'end_date', with: '2014-05-15' fill_in 'Website', with: 'www.rubyzoo.com' fill_in 'Description', with: 'An ruby event at the zoo' fill_in 'Venue details', with: 'Next to the gorillas' fill_in 'Tags', with: 'ruby,zoo' click_on 'Create Event' expect(page).to have_content 'Event was successfully saved' expect(page).to have_content "Please tell us more about where it's being held." expect(page).to have_content(/Version [\d\D]+ Editing: Portland Zoo/) expect(find_field('Venue Name').value).to have_content 'Portland Zoo' fill_in 'Venue Name', with: 'Zoo of Portland' fill_in 'Full Address', with: '4001 SW Canyon Rd, Portland, OR 97221' fill_in 'Street address', with: '4001 SW Canyon Rd' fill_in 'City', with: 'Portland' fill_in 'State', with: 'OR' fill_in 'Zip Code', with: '97221' fill_in 'Web Link', with: 'www.portland.zoo' fill_in 'Email', with: '[email protected]' fill_in 'Telephone', with: '123-444-5555' click_on 'Update Venue' expect(page).to have_content 'Venue was successfully saved' expect(page).to have_content 'Ruby Zoo' expect(page).to have_content 'Zoo of Portland' expect(page).to have_content 'Thursday, May 15, 2014 from 4–9pm' expect(page).to have_content 'Zoo of Portland 4001 SW Canyon Rd Portland, OR 97221 (map)' expect(page).to have_content 'Next to the gorillas' expect(page).to have_content 'Website http://www.rubyzoo.com' expect(page).to have_content 'Description An ruby event at the zoo' expect(page).to have_content 'Tags ruby, zoo' click_link 'Zoo of Portland' expect(page).to have_content 'Zoo of Portland' expect(page).to have_content '4001 SW Canyon Rd Portland, OR 97221 (map)' expect(page).to have_content 'www.portland.zoo' expect(page).to have_content '[email protected]' expect(page).to have_content '123-444-5555' end scenario 'User begins typing a venue name' do visit '/events/new' find_field('Venue').native.send_keys 'urban' expect(page).to have_text('Urban Airship') expect(page).to have_no_text('New Relic') end end
37.740385
107
0.690191
e88479cc3b16b3229d18d83530833a5b00cf15b6
1,794
# # Be sure to run `pod lib lint Libmuse.podspec' to ensure this is a # valid spec before submitting. # # Any lines starting with a # are optional, but their use is encouraged # To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html # Pod::Spec.new do |s| s.name = 'Libmuse' s.version = '0.1.0' s.summary = 'A short description of Libmuse.' # This description is used to generate tags and improve search results. # * Think: What does it do? Why did you write it? What is the focus? # * Try to keep it short, snappy and to the point. # * Write the description between the DESC delimiters below. # * Finally, don't worry about the indent, CocoaPods strips it! s.description = <<-DESC TODO: Add long description of the pod here. DESC s.homepage = 'https://github.com/<GITHUB_USERNAME>/Libmuse' # s.screenshots = 'www.example.com/screenshots_1', 'www.example.com/screenshots_2' s.license = { :type => 'MIT', :file => 'LICENSE' } s.author = { "Jordan Howlett" => '[email protected]' } s.source = { :git => 'https://github.com/<GITHUB_USERNAME>/Libmuse.git', :tag => s.version.to_s } # s.social_media_url = 'https://twitter.com/<TWITTER_USERNAME>' s.ios.deployment_target = '10.0' # s.source_files = 'Libmuse/Classes/**/*' s.requires_arc = true # s.public_header_files = 'Pod/Headers/**/*.h' s.ios.source_files = 'Headers/Muse/*.h' s.ios.vendored_libraries = 'libMuse.a' s.xcconfig = { 'OTHER_LDFLAGS' => '-lc++' } # s.resource_bundles = { # 'Libmuse' => ['Libmuse/Assets/*.png'] # } # s.public_header_files = 'Pod/Classes/**/*.h' s.frameworks = 'CoreBluetooth' # s.dependency 'AFNetworking', '~> 2.3' end
35.88
109
0.636009
3929aa66dcfcbd520724c682785c606f186710a7
814
client = DocSpring::Client.new template_id = 'tpl_000000000000000001' <% if @template_type != :doc -%> expect(client).to receive(:sleep).with(1).once <% end -%> response = client.generate_pdf( template_id: template_id, data: { title: 'Test PDF', description: 'This PDF is great!', }, field_overrides: { title: { required: false } } ) submission = response.submission <% if @template_type == :doc -%> puts "Download your PDF at: #{submission.download_url}" <% else -%> expect(response.status).to eq 'success' expect(submission.id).to start_with 'sub_' expect(submission.expired).to eq false expect(submission.state).to eq 'processed' expect(submission.pdf_hash).to eq 'TEST_SUBMISSION_SHA256_HASH' expect(submission.download_url).to include 'submissions/submission.pdf' <% end -%>
26.258065
71
0.710074
5d944ec12badcc2973a4968613e550a49828da5f
864
# # Copyright (c) 2016 Sam4Mobile # # 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. # actions :create default_action :create attribute :host, kind_of: String, name_attribute: true attribute :bin, kind_of: String, default: '/usr/sbin/gluster' attribute :peer_wait_retries, kind_of: Integer, default: 10 attribute :peer_wait_retry_delay, kind_of: Integer, default: 10
36
74
0.769676
33e791de49f519e414f8792c24a27ca862e70ba0
2,299
cask 'omnifocus' do if MacOS.version <= :mavericks version '2.0.4' sha256 '3282eb7e41ec2638f68a92a6509eddd96a96c39b65b954dcedcc4e62289f22a9' url "https://downloads.omnigroup.com/software/MacOSX/10.9/OmniFocus-#{version}.dmg" elsif MacOS.version <= :yosemite version '2.7.4' sha256 'a273e55c15f82540fe305344f9e49ad7d0d9c326ba2c37c312076ffd73780f80' url "https://downloads.omnigroup.com/software/MacOSX/10.10/OmniFocus-#{version}.dmg" elsif MacOS.version <= :el_capitan version '2.10' sha256 'e808a72e60cdff9ff5aa1046d856bf62d6418e4915248816c4640e32e52fd8e8' url "https://downloads.omnigroup.com/software/MacOSX/10.11/OmniFocus-#{version}.dmg" elsif MacOS.version <= :sierra version '2.12.4' sha256 '8a2dc53331dba804f6781773fef546a03c181fc4ff0eb7ee4f871c10342621f0' url "https://downloads.omnigroup.com/software/MacOSX/10.12/OmniFocus-#{version}.dmg" elsif MacOS.version <= :high_sierra version '3.4.6' sha256 'b770b046c2c59f6e55f54d0ad822d5aa755a18aa201d333341de14ebbbcc6a85' url "https://downloads.omnigroup.com/software/MacOSX/10.13/OmniFocus-#{version}.dmg" else version '3.6.3' sha256 'f05de4406155bf5bf7893f4cc4505480b89edf5d211d67bb82e5e7c603c4dd0f' url "https://downloads.omnigroup.com/software/MacOSX/10.14/OmniFocus-#{version}.dmg" end appcast "https://update.omnigroup.com/appcast/com.omnigroup.OmniFocus#{version.major}" name 'OmniFocus' homepage 'https://www.omnigroup.com/omnifocus/' auto_updates true app 'OmniFocus.app' uninstall quit: "com.omnigroup.OmniFocus#{version.major}" zap trash: [ "~/Library/Containers/com.omnigroup.OmniFocus#{version}", "~/Library/Preferences/com.omnigroup.OmniFocus#{version}.LSSharedFileList.plist", '~/Library/Preferences/com.omnigroup.OmniSoftwareUpdate.plist', "~/Library/Caches/Metadata/com.omnigroup.OmniFocus#{version}", "~/Library/Application Support/com.apple.sharedfilelist/com.apple.LSSharedFileList.ApplicationRecentDocuments/com.omnigroup.omnifocus#{version}.sfl*", '~/Library/Group Containers/34YW5XSRB7.com.omnigroup.OmniFocus', "~/Library/Saved Application State/com.omnigroup.OmniFocus#{version}.savedState", ] end
47.895833
165
0.736407
79dd98ff052d95b63255d7a3c3286e8d73ac7c27
6,575
module BlobHelper def highlighter(blob_name, blob_content, nowrap: false) Gitlab::Highlight.new(blob_name, blob_content, nowrap: nowrap) end def highlight(blob_name, blob_content, nowrap: false, plain: false) Gitlab::Highlight.highlight(blob_name, blob_content, nowrap: nowrap, plain: plain) end def no_highlight_files %w(credits changelog news copying copyright license authors) end def edit_blob_link(project = @project, ref = @ref, path = @path, options = {}) return unless current_user blob = project.repository.blob_at(ref, path) rescue nil return unless blob && blob_text_viewable?(blob) from_mr = options[:from_merge_request_id] link_opts = {} link_opts[:from_merge_request_id] = from_mr if from_mr edit_path = namespace_project_edit_blob_path(project.namespace, project, tree_join(ref, path), link_opts) if !on_top_of_branch?(project, ref) button_tag "编辑", class: "btn disabled has-tooltip btn-file-option", title: "你只能在分支上修改编辑文件", data: { container: 'body' } elsif can_edit_blob?(blob, project, ref) link_to "编辑", edit_path, class: 'btn btn-file-option' elsif can?(current_user, :fork_project, project) continue_params = { to: edit_path, notice: edit_in_new_fork_notice, notice_now: edit_in_new_fork_notice_now } fork_path = namespace_project_forks_path(project.namespace, project, namespace_key: current_user.namespace.id, continue: continue_params) link_to "编辑", fork_path, class: 'btn btn-file-option', method: :post end end def modify_file_link(project = @project, ref = @ref, path = @path, label:, action:, btn_class:, modal_type:) return unless current_user blob = project.repository.blob_at(ref, path) rescue nil return unless blob if !on_top_of_branch?(project, ref) button_tag label, class: "btn btn-#{btn_class} disabled has-tooltip", title: "你只能在分支上#{action}文件", data: { container: 'body' } elsif blob.lfs_pointer? button_tag label, class: "btn btn-#{btn_class} disabled has-tooltip", title: "不能使用网页界面#{action}存储在 LFS 上的文件", data: { container: 'body' } elsif can_edit_blob?(blob, project, ref) button_tag label, class: "btn btn-#{btn_class}", 'data-target' => "#modal-#{modal_type}-blob", 'data-toggle' => 'modal' elsif can?(current_user, :fork_project, project) continue_params = { to: request.fullpath, notice: edit_in_new_fork_notice + "请重新尝试#{action}此文件。", notice_now: edit_in_new_fork_notice_now } fork_path = namespace_project_forks_path(project.namespace, project, namespace_key: current_user.namespace.id, continue: continue_params) link_to label, fork_path, class: "btn btn-#{btn_class}", method: :post end end def replace_blob_link(project = @project, ref = @ref, path = @path) modify_file_link( project, ref, path, label: "替换", action: "replace", btn_class: "default", modal_type: "upload" ) end def delete_blob_link(project = @project, ref = @ref, path = @path) modify_file_link( project, ref, path, label: "删除", action: "delete", btn_class: "remove", modal_type: "remove" ) end def can_edit_blob?(blob, project = @project, ref = @ref) !blob.lfs_pointer? && can_edit_tree?(project, ref) end def leave_edit_message "离开编辑模式?\n所有未保存的修改都会丢失。" end def editing_preview_title(filename) if Gitlab::MarkupHelper.previewable?(filename) '预览' else '预览修改' end end # Return an image icon depending on the file mode and extension # # mode - File unix mode # mode - File name def blob_icon(mode, name) icon("#{file_type_icon_class('file', mode, name)} fw") end def blob_text_viewable?(blob) blob && blob.text? && !blob.lfs_pointer? end def blob_size(blob) if blob.lfs_pointer? blob.lfs_size else blob.size end end # SVGs can contain malicious JavaScript; only include whitelisted # elements and attributes. Note that this whitelist is by no means complete # and may omit some elements. def sanitize_svg(blob) blob.data = Gitlab::Sanitizers::SVG.clean(blob.data) blob end # If we blindly set the 'real' content type when serving a Git blob we # are enabling XSS attacks. An attacker could upload e.g. a Javascript # file to a Git repository, trick the browser of a victim into # downloading the blob, and then the 'application/javascript' content # type would tell the browser to execute the attacker's Javascript. By # overriding the content type and setting it to 'text/plain' (in the # example of Javascript) we tell the browser of the victim not to # execute untrusted data. def safe_content_type(blob) if blob.text? 'text/plain; charset=utf-8' elsif blob.image? blob.content_type else 'application/octet-stream' end end def cached_blob? stale = stale?(etag: @blob.id) # The #stale? method sets cache headers. # Because we are opionated we set the cache headers ourselves. response.cache_control[:public] = @project.public? if @ref && @commit && @ref == @commit.id # This is a link to a commit by its commit SHA. That means that the blob # is immutable. The only reason to invalidate the cache is if the commit # was deleted or if the user lost access to the repository. response.cache_control[:max_age] = Blob::CACHE_TIME_IMMUTABLE else # A branch or tag points at this blob. That means that the expected blob # value may change over time. response.cache_control[:max_age] = Blob::CACHE_TIME end response.etag = @blob.id !stale end def licenses_for_select return @licenses_for_select if defined?(@licenses_for_select) licenses = Licensee::License.all @licenses_for_select = { 常用: licenses.select(&:featured).map { |license| [license.name, license.key] }, 其他: licenses.reject(&:featured).map { |license| [license.name, license.key] } } end def gitignore_names return @gitignore_names if defined?(@gitignore_names) @gitignore_names = { Global: Gitlab::Gitignore.global.map { |gitignore| { name: gitignore.name } }, # Note that the key here doesn't cover it really Languages: Gitlab::Gitignore.languages_frameworks.map{ |gitignore| { name: gitignore.name } } } end end
33.207071
143
0.675589
1d350ece3cdb81eceeeb596f5482383e18896c8f
1,025
class Staff::Base < ApplicationController before_action :authorize before_action :check_account before_action :check_timeout private def current_staff_member if session[:staff_member_id] @current_staff_member ||= StaffMember.find_by(id: session[:staff_member_id]) end end private def authorize unless current_staff_member flash.alert = "職員としてログインしてください。" redirect_to :staff_login end end private def check_account if current_staff_member && !current_staff_member.active? session.delete(:staff_member_id) flash.alert = "アカウントが無効になりました" redirect_to :staff_login end end TIMEOUT = 60.minutes private def check_timeout if current_staff_member if session[:last_access_time] >= TIMEOUT.ago session[:last_access_time] = Time.current else session.delete(:staff_member_id) flash.alert = "セッションがタイムアウトしました。" redirect_to :staff_login end end end helper_method :current_staff_member end
23.837209
82
0.717073
f8488972f8fac44d79f8a2b52491bd8f7e685090
872
# frozen_string_literal: true require_relative 'lib/chinese_remainder' input = ARGF.readlines.map(&:chomp) class Bus attr_accessor :id, :departure def initialize(id) @id = id.to_i @departure = @id end end # Part 1 start_time = input[0].to_i buses = input[1].split(/,/).filter_map do |bus_id| Bus.new(bus_id) unless bus_id == 'x' end while true behind_schedule = buses.reject { |bus| bus.departure >= start_time } break if behind_schedule.empty? behind_schedule.map { |bus| bus.departure += bus.id } end first_bus = buses.min_by(&:departure) p (first_bus.departure - start_time) * first_bus.id # => 174 # Part 2 departure_offsets = [] input[1].split(/,/).filter_map.with_index do |bus_id, index| departure_offsets << index * -1 unless bus_id == 'x' end p ChineseRemainder.solve(buses.map(&:id), departure_offsets) # => 780601154795940
20.27907
81
0.705275
0879fce69ca1a808b636546c7ee66e50e30df5e4
1,208
require 'test_helper' class Accounts::AccountCreatedEventTest < ActiveSupport::TestCase def test_create account = FactoryBot.build_stubbed(:simple_buyer, id: 1, provider_account_id: 2) event = Accounts::AccountCreatedEvent.create(account, user) assert event assert_equal event.account, account assert_equal event.provider, account.provider_account assert_equal event.user, user assert_equal event.metadata[:provider_id], 2 end def test_provider # master for master master = master_account event = Accounts::AccountCreatedEvent.create(master, user) assert_equal event.provider, master # provider for master provider = FactoryBot.build_stubbed(:simple_provider, provider_account: master) event = Accounts::AccountCreatedEvent.create(provider, user) assert_equal event.provider, master # buyer for provider buyer = FactoryBot.build_stubbed(:simple_buyer, provider_account: provider) event = Accounts::AccountCreatedEvent.create(buyer, user) assert_equal event.provider, provider end private def user @_user ||= FactoryBot.build_stubbed(:simple_user) end end
28.093023
83
0.725166
f7308c1b416112500db62f381a983a382e2b94f6
1,463
#-- encoding: UTF-8 #-- copyright # OpenProject is a project management system. # Copyright (C) 2012-2017 the OpenProject Foundation (OPF) # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License version 3. # # OpenProject is a fork of ChiliProject, which is a fork of Redmine. The copyright follows: # Copyright (C) 2006-2017 Jean-Philippe Lang # Copyright (C) 2010-2013 the ChiliProject Team # # This program is free software; you can redistribute it and/or # modify it under the terms of the GNU General Public License # as published by the Free Software Foundation; either version 2 # of the License, or (at your option) any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. # # See doc/COPYRIGHT.rdoc for more details. #++ class CustomActions::Conditions::Status < CustomActions::Conditions::Base def self.key :status end private def associated ::Status .select(:id, :name) .order(:name) .map { |u| [u.id, u.name] } end end
32.511111
91
0.734108
62178e3c3b76481dbc674197734f74f44163b5d4
5,308
#== # Copyright (C) 2008 James S Urquhart # # Permission is hereby granted, free of charge, to any person # obtaining a copy of this software and associated documentation # files (the "Software"), to deal in the Software without # restriction, including without limitation the rights to use, # copy, modify, merge, publish, distribute, sublicense, and/or sell # copies of the Software, and to permit persons to whom the # Software is furnished to do so, subject to the following # conditions: # # The above copyright notice and this permission notice shall be # included in all copies or substantial portions of the Software. # # THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, # EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES # OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND # NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT # HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, # WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING # FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR # OTHER DEALINGS IN THE SOFTWARE. #++ class ListItemsController < ApplicationController before_filter :grab_page before_filter :grab_list cache_sweeper :page_sweeper, :only => [:create, :update, :destroy, :status] # GET /list_items # GET /list_items.xml def index if params[:completed] conds = ['completed_on NOT NULL'] else conds = nil end @list_items = @list.list_items.find(:all, :conditions => conds, :offset => params[:offset], :limit => params[:limit]) respond_to do |format| format.html # index.html.erb format.js format.xml { render :xml => @list_items } end end # GET /list_items/1 # GET /list_items/1.xml def show @list_item = @list.list_items.find(params[:id]) respond_to do |format| format.html # show.html.erb format.js format.xml { render :xml => @list_item } end end # GET /list_items/new # GET /list_items/new.xml def new return error_status(true, :cannot_create_listitem) unless (ListItem.can_be_created_by(@logged_user, @list)) @list_item = @list.list_items.build respond_to do |format| format.html # new.html.erb format.xml { render :xml => @list_item } end end # GET /list_items/1/edit def edit @list_item = @list.list_items.find(params[:id]) return error_status(true, :cannot_edit_listitem) unless (@list_item.can_be_edited_by(@logged_user)) end # POST /list_items # POST /list_items.xml def create return error_status(true, :cannot_create_listitem) unless (ListItem.can_be_created_by(@logged_user, @list)) @list_item = @list.list_items.build(params[:list_item]) @list_item.created_by = @logged_user respond_to do |format| if @list_item.save flash[:notice] = 'ListItem was successfully created.' format.html { redirect_to(@list_item) } format.js format.xml { render :xml => @list_item, :status => :created, :location => page_list_list_item_path(:page_id => @page.id, :list_id => @list.id, :id => @list_item.id) } else format.html { render :action => "new" } format.js format.xml { render :xml => @list_item.errors, :status => :unprocessable_entity } end end end # PUT /list_items/1 # PUT /list_items/1.xml def update @list_item = @list.list_items.find(params[:id]) return error_status(true, :cannot_edit_listitem) unless (@list_item.can_be_edited_by(@logged_user)) @list_item.updated_by = @logged_user respond_to do |format| if @list_item.update_attributes(params[:list_item]) flash[:notice] = 'ListItem was successfully updated.' format.html { redirect_to(@list_item) } format.js format.xml { head :ok } else format.html { render :action => "edit" } format.js format.xml { render :xml => @list_item.errors, :status => :unprocessable_entity } end end end # DELETE /list_items/1 # DELETE /list_items/1.xml def destroy @list_item = @list.list_items.find(params[:id]) return error_status(true, :cannot_edit_listitem) unless (@list_item.can_be_deleted_by(@logged_user)) @list_item.updated_by = @logged_user @list_item.destroy respond_to do |format| format.html { redirect_to(list_items_url) } format.js format.xml { head :ok } end end # PUT /list_items/1 def status @list_item = @list.list_items.find(params[:id]) return error_status(true, :cannot_edit_listitem) unless (@list_item.can_be_completed_by(@logged_user)) @list_item.set_completed(params[:list_item][:completed] == 'true', @logged_user) @list_item.position = @list.list_items.length @list_item.save respond_to do |format| format.html { redirect_to(list_items_url) } format.js format.xml { head :ok } end end protected def grab_list begin @list = @page.lists.find(params[:list_id]) rescue ActiveRecord::RecordNotFound error_status(true, :cannot_find_list) return false end true end end
30.682081
175
0.666918
e8c13d0d158033a7a32ef213811149d40e6d09bf
785
module Kuby::KubeDB::DSL::Catalog::V1alpha1 class RedisVersionSpec < ::KubeDSL::DSLObject value_fields :deprecated, :version object_field(:exporter) { Kuby::KubeDB::DSL::Catalog::V1alpha1::RedisVersionExporter.new } object_field(:db) { Kuby::KubeDB::DSL::Catalog::V1alpha1::RedisVersionDatabase.new } object_field(:pod_security_policies) { Kuby::KubeDB::DSL::Catalog::V1alpha1::RedisVersionPodSecurityPolicy.new } def serialize {}.tap do |result| result[:deprecated] = deprecated result[:version] = version result[:exporter] = exporter.serialize result[:db] = db.serialize result[:podSecurityPolicies] = pod_security_policies.serialize end end def kind_sym :redis_version_spec end end end
34.130435
116
0.696815
380a18818ab068d903319df2012dcd7f3bbff204
646
# frozen_string_literal: true class Projects::GrafanaApiController < Projects::ApplicationController include RenderServiceResults include MetricsDashboard def proxy result = ::Grafana::ProxyService.new( project, params[:datasource_id], params[:proxy_path], query_params.to_h ).execute return continue_polling_response if result.nil? return error_response(result) if result[:status] == :error success_response(result) end private def metrics_dashboard_params params.permit(:embedded, :grafana_url) end def query_params params.permit(:query, :start, :end, :step) end end
20.83871
70
0.724458
08ced4a9b946b25d6ed88238c52aa08e7fa41cd7
687
# frozen_string_literal: true # == Schema Information # # Table name: player_histories # # id :bigint not null, primary key # kit_no :integer # ovr :integer # recorded_on :date # value :integer # created_at :datetime not null # updated_at :datetime not null # player_id :bigint # # Indexes # # index_player_histories_on_player_id (player_id) # FactoryBot.define do factory :player_history do recorded_on { Date.new } ovr { Faker::Number.between(from: 50, to: 90) } value { Faker::Number.between(from: 50_000, to: 200_000_000) } kit_no { Faker::Number.between(from: 1, to: 99) } player end end
22.9
66
0.63901
bbf3fe32a3235e651adb80d6b7d3f6bb9240a77c
416
# frozen_string_literal: true module InvisibleCollector module Model class Debit < AbstractModel attr_accessor :number attr_accessor :date attr_accessor :gross_total def initialize(options = {}) options = options.with_indifferent_access @number = options[:number] @date = options[:date] @gross_total = options[:gross_total] end end end end
21.894737
49
0.661058
bf42fdbda0b8ae860419e94fc90595636837feb5
280
module Pageflow class SubmitFileToZencoderJob @queue = :default extend StateMachineJob def self.perform_with_result(file, options, api = ZencoderApi.instance) file.job_id = api.create_job(file.output_definition) file.save! :ok end end end
18.666667
75
0.703571
216fb33d2afb7fa24387ee0435673033aa28cd90
12,194
require 'puppet/parameter/value_collection' require 'pathname' class Puppet::Type::Acl # Ace is an Access Control Entry for use with the Access # Control List (ACL) type. ACEs contain information about # the trustee, the rights, and on some systems how they are # inherited and propagated to subtypes. class Ace < Hash # < Hash is due to a bug with how Puppet::Resource.to_manifest # does not work through quite the same code and needs to # believe this custom object is a Hash. If issues are later # found, this should be reviewed. require Pathname.new(__FILE__).dirname + '../../../' + 'puppet/type/acl/rights' attr_reader :identity attr_reader :rights attr_reader :perm_type attr_reader :child_types attr_reader :affects attr_reader :is_inherited attr_reader :mask def initialize(permission_hash, provider = nil) @provider = provider id = permission_hash['identity'] id = permission_hash['id'] if id.nil? || id.empty? self.identity = id self.id = permission_hash['id'] @mask = permission_hash['mask'] self.rights = permission_hash['rights'] self.perm_type = permission_hash['perm_type'] if permission_hash['type'] Puppet.deprecation_warning('Permission `type` is deprecated and has been replaced with perm_type for allow or deny') if permission_hash['perm_type'] && permission_hash['type'] != permission_hash['perm_type'] raise ArgumentError, "Can not accept both `type` => #{permission_hash['type']} and `perm_type` => #{permission_hash['perm_type']}" end self.perm_type = permission_hash['type'] end self.child_types = permission_hash['child_types'] self.affects = permission_hash['affects'] @is_inherited = permission_hash['is_inherited'] || false @hash = nil end def validate(value, *allowed_values) validator = Puppet::Parameter::ValueCollection.new validator.newvalues(*allowed_values) validator.validate(value) value end def inherited? is_inherited end def convert_to_symbol(value) return nil if value.nil? || value.empty? return value if value.is_a?(Symbol) value.downcase.to_sym end def validate_non_empty(name, value) if value.nil? || value == '' raise ArgumentError, "A non-empty #{name} must be specified." end if value.is_a?(Array) && value.count.zero? raise ArgumentError, "Value for #{name} should have least one element in the array." end value end def validate_array(name, values) raise ArgumentError, "Value for #{name} should be an array. Perhaps try ['#{values}']?" unless values.is_a?(Array) values end def validate_individual_values(values, *allowed_values) values.each do |value| validate(value, *allowed_values) end values end def convert_to_symbols(values) value_syms = [] values.each do |value| value_syms << convert_to_symbol(value) end value_syms end def convert_from_symbols(symbols) values = [] symbols.each do |value| values << value.to_s end values end def ensure_rights_order @rights.sort_by! { |r| Puppet::Type::Acl::Rights.new(r).order } end def ensure_rights_values_compatible if @rights.include?(:mask_specific) && rights.count != 1 raise ArgumentError, "In each ace, when specifying rights, if you include 'mask_specific', it should be without anything else e.g. rights => ['mask_specific']. Please decide whether 'mask_specific' or predetermined rights and correct the manifest. Reference: #{inspect}" # rubocop:disable Metrics/LineLength end if @rights.include?(:full) && rights.count != 1 Puppet.warning("In each ace, when specifying rights, if you include 'full', it should be without anything else e.g. rights => ['full']. Please remove the extraneous rights from the manifest to remove this warning. Reference: #{inspect}") # rubocop:disable Metrics/LineLength @rights = [:full] end if @rights.include?(:modify) && rights.count != 1 # rubocop:disable Style/GuardClause Changing this to a guard clause makes the line long and unreadable Puppet.warning("In each ace, when specifying rights, if you include 'modify', it should be without anything else e.g. rights => ['modify']. Please remove the extraneous rights from the manifest to remove this warning. Reference: #{inspect}") # rubocop:disable Metrics/LineLength @rights = [:modify] end end def ensure_mask_when_mask_specific if @rights.include?(:mask_specific) && (@mask.nil? || @mask.empty?) # rubocop:disable Style/GuardClause Changing this to a guard clause makes the line long and unreadable raise ArgumentError, "If you specify rights => ['mask_specific'], you must also include mask => 'value'. Reference: #{inspect}" end end def ensure_unique_values(values) if values.is_a?(Array) return values.uniq end values end def ensure_none_or_self_only_sync return if @child_types.nil? || @affects.nil? return if @child_types == :none && @affects == :self_only return unless @child_types == :none || @affects == :self_only if @child_types == :none && (@affects != :all && @affects != :self_only) Puppet.warning("If child_types => 'none', affects => value will be ignored. Please remove affects or set affects => 'self_only' to remove this warning. Reference: #{inspect}") end @affects = :self_only if @child_types == :none if @affects == :self_only && (@child_types != :all && @child_types != :none) Puppet.warning("If affects => 'self_only', child_types => value will be ignored. Please remove child_types or set child_types => 'none' to remove this warning. Reference: #{inspect}") end @child_types = :none if @affects == :self_only end def identity=(value) @identity = validate_non_empty('identity', value) @hash = nil end def id if @id.nil? || @id.empty? if @identity && @provider && @provider.respond_to?(:get_account_id) @id = @provider.get_account_id(@identity) end end @id end def id=(value) @id = value @hash = nil end def rights=(value) @rights = ensure_unique_values( convert_to_symbols( validate_individual_values( validate_array( 'rights', validate_non_empty('rights', value), ), :full, :modify, :write, :read, :execute, :mask_specific ), ), ) ensure_rights_order ensure_rights_values_compatible ensure_mask_when_mask_specific if @rights.include?(:mask_specific) @hash = nil end def mask=(value) @mask = value @hash = nil end def perm_type=(value) @perm_type = convert_to_symbol(validate(value || :allow, :allow, :deny)) @hash = nil end def child_types=(value) @child_types = convert_to_symbol(validate(value || :all, :all, :objects, :containers, :none)) ensure_none_or_self_only_sync @hash = nil end def affects=(value) @affects = convert_to_symbol(validate(value || :all, :all, :self_only, :children_only, :self_and_direct_children_only, :direct_children_only)) ensure_none_or_self_only_sync @hash = nil end def get_comparison_ids(other = nil) ignore_other = true id_has_value = false other_id_has_value = false other_id = nil unless other.nil? ignore_other = false other_id_has_value = true unless other.id.nil? || other.id.empty? end id_has_value = true unless id.nil? || id.empty? if id_has_value && (ignore_other || other_id_has_value) id = self.id other_id = other.id unless ignore_other elsif @provider && @provider.respond_to?(:get_account_name) id = @provider.get_account_name(@identity) other_id = @provider.get_account_name(other.identity) unless ignore_other else id = @identity other_id = other.identity unless ignore_other end [id, other_id] end # This ensures we are looking at the same ace even if the # rights are different. Contextually we have two ace objects # and we are trying to determine if they are the same ace or # different given all of the different compare points. # # @param other [Ace] The ace that we are comparing to. # @return [Boolean] true if all points are equal def same?(other) return false unless other.is_a?(Ace) account_ids = get_comparison_ids(other) account_ids[0] == account_ids[1] && @child_types == other.child_types && @affects == other.affects && @is_inherited == other.is_inherited && @perm_type == other.perm_type end # This ensures we are looking at the same ace with the same # rights. We want to know if the two aces are equal on all # important data points. # # @param other [Ace] The ace that we are comparing to. # @return [Boolean] true if all points are equal def ==(other) return false unless other.is_a?(Ace) same?(other) && @rights == other.rights end alias eql? == def hash get_comparison_ids[0].hash ^ @rights.hash ^ @perm_type.hash ^ @child_types.hash ^ @affects.hash ^ @is_inherited.hash end def to_hash return @hash if @hash ace_hash = {} ace_hash['identity'] = identity ace_hash['rights'] = convert_from_symbols(rights) ace_hash['mask'] = mask if rights == [:mask_specific] && !mask.nil? ace_hash['perm_type'] = perm_type unless perm_type == :allow || perm_type.nil? ace_hash['child_types'] = child_types unless child_types == :all || child_types == :none || child_types.nil? ace_hash['affects'] = affects unless affects == :all || affects.nil? ace_hash['is_inherited'] = is_inherited if is_inherited @hash = ace_hash @hash end # The following methods: keys, values, [](key) make # `puppet resource acl somelocation` believe that # this is actually a Hash and can pull the values # from this object. def keys to_hash.keys end def values to_hash.values end def [](key) to_hash[key] end def inspect hash = to_hash return_value = hash.keys.map { |key| key_value = hash[key] if key_value.is_a? Array "#{key} => #{key_value}" else "#{key} => '#{key_value}'" end }.join(', ') "\n { #{return_value} }" end alias to_s inspect # added to support Ruby 2.3 which serializes Hashes differently when # writing YAML than previous Ruby versions, which can break the last # run report or corrective changes reports due to attempts to # serialize the attached provider def encode_with(coder) # produce a set of plain key / value pairs by removing the "tag" # by setting it to nil, producing YAML serialization like # "---\nidentity: Administrators\nrights:\n- full\n" # with the tag set to its default value, serialization appears like # "--- !ruby/object:Puppet::Type::Acl::Ace\nidentity: Administrators\nrights:\n- full\n" coder.represent_map nil, to_hash # rubocop:disable Metrics/LineLength # without this method implemented, serialization varies based on Ruby version like: # Ruby 2.3 # "--- !ruby/hash-with-ivars:Puppet::Type::Acl::Ace\nelements: {}\nivars:\n :@provider: \n :@identity: Administrators\n :@hash: \n :@id: S-32-12-0\n :@mask: '2023422'\n :@rights:\n - :full\n :@perm_type: :allow\n :@child_types: :all\n :@affects: :all\n :@is_inherited: false\n" # Ruby 2.1.9 # "--- !ruby/hash:Puppet::Type::Acl::Ace {}\n" # rubocop:enable Metrics/LineLength end end end
34.156863
315
0.644169
4aa53081f7b4b00796f13ee6cd09d1599a3e51fa
1,116
#-------------------------- # # @class Memberships::BecomeFormerIndividualMemberActions # # @desc Responsibility: Do all the things that need to be done when an individual membership # enters the renewal grace period # # # @author Ashley Engelund ([email protected] weedySeaDragon @ github) # @date 4/1/21 # #-------------------------------------------------------------------------------------------------- module Memberships class BecomeFormerIndividualMemberActions < MembershipActions LOGMSG_MEMBERSHIP_FORMER = 'Membership now a former membership' def self.other_keyword_args_valid?(_other_keyword_args) true end # Set membership to false # If we should send email: # send email to the user saying they are now a former member and have to re-apply # def self.accomplish_actions(user, _send_email: SEND_EMAIL_DEFAULT, **other_keyword_args) user.update!(member: false) # MemberMailer.membership_now_is_former(user).deliver if send_email true end def self.log_message_success LOGMSG_MEMBERSHIP_FORMER end end end
27.219512
99
0.655018
edfc52599e73e76439887ca33b0d7c65c1305129
38
class Bucket < ActiveRecord::Base end
12.666667
33
0.789474
1859cc89de9c5f3a4f526f6938b7610cb9b6ca71
781
class FightClubApp configure :development do set :database, 'sqlite:///dev.db' set :show_exceptions, true end configure :production do db = URI.parse(ENV['DATABASE_URL'] || 'postgres:///localhost/mydb') ActiveRecord::Base.establish_connection( :adapter => db.scheme == 'postgres' ? 'postgresql' : db.scheme, :host => db.host, :username => db.user, :password => db.password, :database => db.path[1..-1], :encoding => 'utf8' ) end configure do if ENV["REDISCLOUD_URL"] uri = URI.parse(ENV["REDISCLOUD_URL"]) $redis = Redis.new(:host => uri.host, :port => uri.port, :password => uri.password) # else # raise "Please set the REDISCLOUD_URL env variable. See the README for more information." end end end
27.892857
96
0.640205
18d63306159f9304fa4488ed8e97d9dcbc7913df
113
module AthenaHealth class AnalyteCollection < BaseCollection attribute :analytes, Array[Analyte] end end
18.833333
42
0.787611
613dfd9d7f4076a8d20855a1a5f73785d77cadae
1,330
# Clean this up. Have it assume there's an install? $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib')) $LOAD_PATH.unshift(File.dirname(__FILE__)) require "panini" grammar = Panini::Grammar.new # ================ # = Nonterminals = # ================ expression = grammar.add_nonterminal("EXPR") term = grammar.add_nonterminal("TERM") factor = grammar.add_nonterminal("FACT") identifier = grammar.add_nonterminal("ID") number = grammar.add_nonterminal("NUM") # ============= # = Terminals = # ============= expression.add_production([term, '+', term]) expression.add_production([term, '-', term]) expression.add_production([term]) term.add_production([factor, '*', term]) term.add_production([factor, '/', term]) term.add_production([factor]) factor.add_production([identifier]) factor.add_production([number]) factor.add_production(['(', expression, ')']) ('a'..'z').each do |v| identifier.add_production([v]) end # It would be cool to have a way to create a random number. (0..100).each do |n| number.add_production([n]) end # =============================================== # = Choose a strategy and create some sentences = # =============================================== deriver = Panini::DerivationStrategy::RandomDampened.new(grammar) 10.times do puts "#{deriver.sentence.join(' ')}" end
25.576923
66
0.631579
267c7b65edf69ad1611619cfa58596f3865b7eda
1,962
# # Be sure to run `pod lib lint FlexLib.podspec' to ensure this is a # valid spec before submitting. # # Any lines starting with a # are optional, but their use is encouraged # To learn more about a Podspec see http://guides.cocoapods.org/syntax/podspec.html # Pod::Spec.new do |s| s.name = 'FlexLib' s.version = '1.8.5' s.summary = 'An obj-c flex layout framework for IOS' # This description is used to generate tags and improve search results. # * Think: What does it do? Why did you write it? What is the focus? # * Try to keep it short, snappy and to the point. # * Write the description between the DESC delimiters below. # * Finally, don't worry about the indent, CocoaPods strips it! s.description = <<-DESC It's a layout framework based on yoga engine. The main purpose is to provide easy and fast usage. DESC s.homepage = 'https://github.com/zhenglibao/FlexLib' # s.screenshots = 'www.example.com/screenshots_1', 'www.example.com/screenshots_2' s.license = { :type => 'MIT', :file => 'LICENSE' } s.author = { '[email protected]' => '[email protected]' } s.source = { :git => 'https://github.com/zhenglibao/FlexLib.git', :tag => s.version.to_s } # s.social_media_url = 'https://twitter.com/<TWITTER_USERNAME>' s.ios.deployment_target = '8.0' s.source_files = 'FlexLib/Classes/**/*' s.resource_bundles = { 'FlexLib' => ['FlexLib/Assets/*'] } # s.frameworks = 'UIKit', 'MapKit' s.dependency 'Yoga', '1.6.0' s.library = 'xml2' s.xcconfig = { 'HEADER_SEARCH_PATHS' => '/usr/include/libxml2' } #s.private_header_files = 'FlexLib/Classes/private/*.h' #s.public_header_files = 'FlexLib/Classes/*.h' non_arc_files = 'FlexLib/Classes/GDataXMLNode.{h,m}' s.exclude_files = non_arc_files s.subspec 'no-arc' do |sna| sna.requires_arc = false sna.source_files = non_arc_files end end
35.035714
102
0.650866
11064409a858388e897b13a788f4a3cd8c0b6021
401
class Api::UsersController < ApplicationController def index @users = User.all end def create @user = User.new(user_params) if @user.save sign_in!(@user) render 'api/users/show' else render( json: @user.errors.full_messages, status: 422 ) end end def user_params params.require(:user).permit(:username, :password) end end
16.708333
54
0.618454
f85eeadd90a59a39d63ededd3b90284f852175b7
496
# Be sure to restart your server when you modify this file. # Your secret key for verifying the integrity of signed cookies. # If you change this key, all old signed cookies will become invalid! # Make sure the secret is at least 30 characters and all random, # no regular words or you'll be exposed to dictionary attacks. Dummy::Application.config.secret_token = 'b60a14ba9bc5e860fb35696b5cd5fb3485b4b57b9739e65c6ee479b2ba290b8a3f89019349b6d3361a22025fcafbd88f7b4bad7b8f5e08f6170c404c1231648b'
62
171
0.832661
bf855c37e36853e2b0172e7ff69555ecd5ab00a7
5,273
# # Be sure to run `pod spec lint WalrusKit.podspec' to ensure this is a # valid spec and to remove all comments including this before submitting the spec. # # To learn more about Podspec attributes see https://guides.cocoapods.org/syntax/podspec.html # To see working Podspecs in the CocoaPods repo see https://github.com/CocoaPods/Specs/ # Pod::Spec.new do |spec| # ――― Spec Metadata ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # These will help people to find your library, and whilst it # can feel like a chore to fill in it's definitely to your advantage. The # summary should be tweet-length, and the description more in depth. # spec.name = "WalrusKit" spec.version = "0.0.3" spec.summary = "Design system by Delivery Club" # This description is used to generate tags and improve search results. # * Think: What does it do? Why did you write it? What is the focus? # * Try to keep it short, snappy and to the point. # * Write the description between the DESC delimiters below. # * Finally, don't worry about the indent, CocoaPods strips it! spec.description = <<-DESC In Delivery Club we desided to create Design system named Walrus. We want to share with you what we've got so far. DESC spec.homepage = "https://github.com/delivery-club/WalrusKit" # spec.screenshots = "www.example.com/screenshots_1.gif", "www.example.com/screenshots_2.gif" # ――― Spec License ――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # Licensing your code is important. See https://choosealicense.com for more info. # CocoaPods will detect a license file if there is a named LICENSE* # Popular ones are 'MIT', 'BSD' and 'Apache License, Version 2.0'. # spec.license = { :type => "MIT", :file => "FILE_LICENSE" } # ――― Author Metadata ――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # Specify the authors of the library, with email addresses. Email addresses # of the authors are extracted from the SCM log. E.g. $ git log. CocoaPods also # accepts just a name if you'd rather not provide an email address. # # Specify a social_media_url where others can refer to, for example a twitter # profile URL. # spec.author = { "Aleksandr Anosov" => "[email protected]" } # Or just: spec.author = "Aleksandr Anosov" # spec.authors = { "Aleksandr Anosov" => "[email protected]" } # spec.social_media_url = "https://twitter.com/Aleksandr Anosov" # ――― Platform Specifics ――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # If this Pod runs only on iOS or OS X, then specify the platform and # the deployment target. You can optionally include the target after the platform. # spec.platform = :ios spec.platform = :ios, "12.2" # When using multiple platforms # spec.ios.deployment_target = "5.0" # spec.osx.deployment_target = "10.7" # spec.watchos.deployment_target = "2.0" # spec.tvos.deployment_target = "9.0" # ――― Source Location ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # Specify the location from where the source should be retrieved. # Supports git, hg, bzr, svn and HTTP. # spec.source = { :git => "https://github.com/delivery-club/WalrusKit.git", :tag => "#{spec.version}" } # ――― Source Code ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # CocoaPods is smart about how it includes source code. For source files # giving a folder will include any swift, h, m, mm, c & cpp files. # For header files it will include any header in the folder. # Not including the public_header_files will make all headers public. # spec.source_files = "WalrusKit/**/*.{h,m,swift}" # spec.public_header_files = "Classes/**/*.h" # ――― Resources ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # A list of resources included with the Pod. These are copied into the # target bundle with a build phase script. Anything else will be cleaned. # You can preserve files from being cleaned, please don't preserve # non-essential files like tests, examples and documentation. # # spec.resource = "icon.png" # spec.resources = "Resources/*.png" # spec.preserve_paths = "FilesToSave", "MoreFilesToSave" # ――― Project Linking ―――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # Link your library with frameworks, or libraries. Libraries do not include # the lib prefix of their name. # # spec.framework = "SomeFramework" # spec.frameworks = "SomeFramework", "AnotherFramework" # spec.library = "iconv" # spec.libraries = "iconv", "xml2" # ――― Project Settings ――――――――――――――――――――――――――――――――――――――――――――――――――――――――― # # # If your library depends on compiler flags you can set them in the xcconfig hash # where they will only apply to your library. If you depend on other Podspecs # you can include multiple dependencies to ensure it works. # spec.requires_arc = true # spec.xcconfig = { "HEADER_SEARCH_PATHS" => "$(SDKROOT)/usr/include/libxml2" } # spec.dependency "JSONKit", "~> 1.4" spec.swift_versions = "5" end
37.935252
109
0.604969
6a68365b9c9253a5aefbf85af067acca43bba126
1,298
# frozen_string_literal: true ORIG_ARGV = ARGV.dup require "active_support/core_ext/kernel/reporting" silence_warnings do Encoding.default_internal = Encoding::UTF_8 Encoding.default_external = Encoding::UTF_8 end require "active_support/testing/autorun" require "active_support/testing/method_call_assertions" ENV["NO_RELOAD"] = "1" require "active_support" Thread.abort_on_exception = true # Show backtraces for deprecated behavior for quicker cleanup. ActiveSupport::Deprecation.debug = true # Default to old to_time behavior but allow running tests with new behavior ActiveSupport.to_time_preserves_timezone = ENV["PRESERVE_TIMEZONES"] == "1" # Disable available locale checks to avoid warnings running the test suite. I18n.enforce_available_locales = false class ActiveSupport::TestCase include ActiveSupport::Testing::MethodCallAssertions private # Skips the current run on Rubinius using Minitest::Assertions#skip def rubinius_skip(message = "") skip message if RUBY_ENGINE == "rbx" end # Skips the current run on JRuby using Minitest::Assertions#skip def jruby_skip(message = "") skip message if defined?(JRUBY_VERSION) end end # Contains logic for running in "BUILDKITE" CI environment. # require_relative "../../tools/test_common"
28.217391
75
0.77735
18dc0c05b3feb90b698a090c4a0fc68138aee3c5
681
require 'spec_helper' describe GatherContent::Api::Account, vcr: true do let(:account_id) { 123456 } let(:account) { GatherContent::Api::Account.new(account_id) } describe '.new' do subject { account } it { is_expected.to be_a GatherContent::Api::Account } end describe '#fetch' do subject { account.fetch } it { is_expected.to be_a Hash } end describe "[]" do subject { account } it "returns the data related to the supplied key" do expect(subject["id"]).to eq("123456") expect(subject["name"]).to eq("Example") expect(subject["slug"]).to eq("example") expect(subject["timezone"]).to eq("UTC") end end end
23.482759
63
0.643172
39d94c9a73e4412465daa8ae6b00ab80c7ab4ddb
2,359
lib = File.expand_path("../lib", __FILE__) $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib) require "blue_cross_pets/version" Gem::Specification.new do |spec| spec.name = "blue_cross_pets" spec.version = BlueCrossPets::VERSION spec.summary = %q{CLI that display Blue Cross UK adoptable dogs/cats} spec.description = %q{Displays all the available dogs/cats listed on the Blue Cross UK website. This is my first gem, so please feel free to add suggestions.} spec.authors = ["'Jessica Gomes-Ng'"] spec.email = ["'[email protected]'"] spec.files = ["bin/blue_cross_pets", "lib/blue_cross_pets.rb", "lib/blue_cross_pets/version.rb", "lib/blue_cross_pets/cli.rb", "lib/blue_cross_pets/scraper.rb", "lib/blue_cross_pets/dog.rb", "lib/blue_cross_pets/cat.rb", "lib/blue_cross_pets/pet.rb"] # spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do # `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } # end spec.homepage = "https://github.com/jessicagomesng/blue_cross_pets" spec.license = "MIT" # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host' # to allow pushing to a single host or delete this section to allow pushing to any host. #if spec.respond_to?(:metadata) # spec.metadata["allowed_push_host"] = "https://rubygems.org" # spec.metadata["homepage_uri"] = spec.homepage # spec.metadata["source_code_uri"] = "https://github.com/jessicagomesng/blue_cross_pets" # spec.metadata["changelog_uri"] = "https://github.com/jessicagomesng/blue_cross_pets" #else # raise "RubyGems 2.0 or newer is required to protect against " \ # "public gem pushes." #end # Specify which files should be added to the gem when it is released. # The `git ls-files -z` loads the files in the RubyGem that have been added into git. spec.bindir = "bin" spec.executables = ["blue_cross_pets"] spec.require_paths = ["lib"] spec.add_development_dependency "bundler", "~> 2.0" spec.add_development_dependency 'rake', '~> 12.3', '>= 12.3.3' spec.add_development_dependency "pry", '~> 0.13.1' spec.add_development_dependency "rspec", '~> 3.9.0' spec.add_dependency "nokogiri", '~> 1.10.9' spec.add_dependency "colorize", '~> 0.8.1' end
51.282609
260
0.686732
919096f739369a15e65301ffd3a6cef45eecdae6
503
# Copyright (c) 2016 Oracle and/or its affiliates. All rights reserved. This # code is released under a tri EPL/GPL/LGPL license. You can use it, # redistribute it and/or modify it under the terms of the: # # Eclipse Public License version 1.0 # GNU General Public License version 2 # GNU Lesser General Public License version 2.1 # The Truffle API's this uses are different from GraalVM 0.12 and Truffle 0.13 tagged main_thread example "Truffle::Interop.eval('application/javascript', '14 + 2')", 16
45.727273
90
0.759443
ac14d7e35b46a70164e534b0d43e3007a61757ac
110
FactoryGirl.define do factory :subject do sequence(:name) { |n| "#{Faker::Lorem.word} #{n}" } end end
18.333333
55
0.627273
e92c783ea37176d1d7de7825e9f97f1e40be40f9
362
class Ruian class Model class Row < Struct.new(:adm_code, :city_code, :city_name, :momc_code, :momc_name, :mop_code, :mop_name, :city_part_code, :city_part_name, :street_name_code, :street_name, :so_type, :e, :o, :o_code, :zip, :gis_y, :gis_x, :valid_from) end end end
36.2
86
0.549724
b9e5cacb697e31b883755f0cd3e71aa7a471e64a
135
# frozen_string_literal: true class VACOLS::Actcode < VACOLS::Record self.table_name = "actcode" self.primary_key = "actckey" end
19.285714
38
0.748148
611226e48adc170aad7f03035b6102dfb9f0e646
653
# frozen_string_literal: true module Mutations module Issues class SetLocked < Base graphql_name 'IssueSetLocked' argument :locked, GraphQL::BOOLEAN_TYPE, required: true, description: 'Whether or not to lock discussion on the issue.' def resolve(project_path:, iid:, locked:) issue = authorized_find!(project_path: project_path, iid: iid) ::Issues::UpdateService.new(issue.project, current_user, discussion_locked: locked) .execute(issue) { issue: issue, errors: errors_on_object(issue) } end end end end
24.185185
91
0.614089
abfebcd74c32a59cdd56317d5039822c572f77eb
867
# デフォルト # max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 } # min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count } # threads min_threads_count, max_threads_count # worker_timeout 3600 if ENV.fetch("RAILS_ENV", "development") == "development" # port ENV.fetch("PORT") { 3000 } # environment ENV.fetch("RAILS_ENV") { "development" } # pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" } # plugin :tmp_restart # Pumaの設定ファイル max_threads_count = ENV.fetch("RAILS_MAX_THREADS") { 5 } min_threads_count = ENV.fetch("RAILS_MIN_THREADS") { max_threads_count } threads min_threads_count, max_threads_count port ENV.fetch("PORT") { 3000 } environment ENV.fetch("RAILS_ENV") { ENV['RACK_ENV'] || "production" } pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" } workers ENV.fetch("WEB_CONCURRENCY") { 2 } preload_app! plugin :tmp_restart
43.35
79
0.739331
1d55b2db52a3743bb02c4bdc5df117dfdb845a33
281
require "vagrant" module VagrantPlugins module GuestFedora autoload :Guest, File.expand_path("../guest", __FILE__) class Plugin < Vagrant.plugin("1") name "Fedora guest" description "Fedora guest support." guest("fedora") { Guest } end end end
18.733333
59
0.661922
01862ee6b0b3b0c6e98638cebe6e7c9eafe5adb3
411
# encoding: UTF-8 require "#{File.dirname(__FILE__)}/../lib/hammer" module HammerMocks def self.included(base) base.let(:container_mock) { mock(:container, :drop_context => true) } base.let(:context_mock) { mock(:context, :conteiner => container_mock) } base.let(:component_mock) { mock(:component, :context => context_mock) } end end RSpec.configure do |config| config.mock_with :rspec end
27.4
76
0.705596
5ddca3b1b260821adc1d3f2b5459bf2460c43cf5
5,538
require 'test_helper' class RequestChangeTest < ActiveSupport::TestCase # заявка на изменение - выслана на согласование def setup @admin = users(:admin) @budget_owner = users(:budget_owner) @budget_top_owner = users(:budget_top_owner) @fo_user = users(:fo_user) current_user = @admin @request_change = request_changes(:one) # b_service # budget_owner -> budget_top_owner -> fo_user # b_nakladn_management: # parent: b_nakladn # owner: budget_top_owner # b_service: # name: Бюджет Сервисного Центра # parent: b_nakladn_management # owner: budget_owner @request_change.set_state "На согласовании", current_user end test "exists and class" do assert_instance_of RequestChange, @request_change end test "budgets owners" do assert_equal @request_change.budget.owner, users(:budget_owner) assert_equal @request_change.budget.parent.owner, users(:budget_top_owner) end # budget_owner, budget_top_owner, user_fo # при посылке на согласование - трем сотрудникам уходит на согласование # владельцам бюджетов (текущего и вышестоящего) и сотруднику ФО test "init state" do assert_equal "На согласовании", @request_change.state assert_equal 3, @request_change.request_change_signs.size end # начальный согласователь test "current confirm" do assert_equal @budget_owner, @request_change.current_sign.user assert_equal false, @request_change.is_all_confirmed? end # согласовывает первый - переходит на согласование к следующему test "do confirm first" do @request_change.sign(RequestChangeSign::CONFIRMED, @budget_owner) assert_equal false, @request_change.is_all_confirmed? assert_equal "На согласовании", @request_change.state assert_equal @budget_top_owner, @request_change.current_sign.user assert_equal RequestChangeSign::CONFIRMED, @request_change.request_change_signs[0].result end # согласовывает второй - переходит на согласование к ФО test "do confirm second" do @request_change.sign(RequestChangeSign::CONFIRMED, @budget_owner) @request_change.sign(RequestChangeSign::CONFIRMED, @budget_top_owner) assert_equal false, @request_change.is_all_confirmed? assert_equal "На согласовании", @request_change.state assert_equal @fo_user, @request_change.current_sign.user assert_equal RequestChangeSign::CONFIRMED, @request_change.request_change_signs[1].result end # согласовывает третий - заявка согласована test "do confirm third - all confirmed" do @request_change.sign(RequestChangeSign::CONFIRMED, @budget_owner) @request_change.sign(RequestChangeSign::CONFIRMED, @budget_top_owner) @request_change.sign(RequestChangeSign::CONFIRMED, @fo_user) assert_equal true, @request_change.is_all_confirmed? assert_equal true, @request_change.request_change_histories.map{|h| h.state}.include?("Согласована") assert_equal "Обработано", @request_change.state end # отклоняет первый - переходит на Отклонена test "do rejected first" do @request_change.sign(RequestChangeSign::REJECTED, @budget_owner) assert_equal "Отклонена", @request_change.state assert_equal RequestChangeSign::REJECTED, @request_change.request_change_signs[0].result end # отклонение и на редактирование test "do rejected first and edit" do @request_change.sign(RequestChangeSign::REJECTED, @budget_owner) assert_equal "Отклонена", @request_change.state @request_change.set_state "Редактируется", @budget_owner assert_equal "Редактируется", @request_change.state end # отклонение и на редактирование, и на согласование (вторая попытка) # владелец бюджета (меньше согласователей) - 2 test "do rejected first then edit and to confirm" do @request_change.sign(RequestChangeSign::REJECTED, @budget_owner) @request_change.set_state "Редактируется", @budget_owner @request_change.set_state "На согласовании", @budget_owner assert_equal "На согласовании", @request_change.state assert_equal 2, @request_change.current_signs.size end test "fot change" do fot_change = request_changes(:fot_change) assert fot_change assert_equal 1, fot_change.request_change_actions.size # '{ "state_unit_id": 109958, # "salaries": [[1,"25300.0"],[2,"25300.0"],[3,"25300.0"],[4,"25300.0"],[5,"233444"],[6,"233444"],[7,"233444"],[8,"233444"],[9,"233444"],[10,"233444"],[11,"233444"],[12,"233444"]], # "selectedStatZatrFot": 12345, # "deltaStatZatrFot": 1665152}' assert_equal 109958, fot_change.request_change_actions.first.content['state_unit_id'] fot_delta = 1_665_152 assert_equal fot_delta, fot_change.request_change_actions.first.content['deltaStatZatrFot'] assert_equal 12345, fot_change.request_change_actions.first.content['selectedStatZatrFot'] fot_stat_zatr = stat_zatrs(:fot_stat_zatr) # zp before, for - 25300 * 12 = 303600.00 st_unit = state_units(:cfo_1_fzp_next_user1) assert_equal 109958, st_unit.id assert_equal 12, st_unit.salaries.size assert_equal 303_600.00, st_unit.fzp # fot stat zatr assert fot_stat_zatr.budget.get_fot_stat_zatr assert_equal 2_000_000.00, fot_stat_zatr.budget.fot_value # fot_change fot_change.proceed(users(:admin)) # new fot 1,968,752.00 st_unit = StateUnit.find(109958) assert_equal 1_968_752.00, st_unit.fzp # fot changed assert_equal 2_000_000.00 - fot_delta.to_f, fot_change.budget.fot_value end end
36.196078
191
0.747382