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

Dataset 1: TheStack - Ruby - Cleaned

Description: This dataset is drawn from TheStack Corpus, an open-source code dataset with over 3TB of GitHub data covering 48 programming languages. We selected a small portion of this dataset to optimize smaller language models for Ruby, a popular statically typed language.

Target Language: Ruby

Dataset Size:

  • Training: 900,000 files
  • Validation: 50,000 files
  • Test: 50,000 files

Preprocessing:

  1. Selected Ruby as the target language due to its popularity on GitHub.
  2. Filtered out files with average line length > 100 characters, maximum line length > 1000 characters, and alphabet ratio < 25%.
  3. Split files into 90% training, 5% validation, and 5% test sets.

Tokenizer: Byte Pair Encoding (BPE) tokenizer with tab and whitespace tokens. GPT-2 vocabulary extended with special tokens.

Training Sequences: Sequences constructed by joining training data text to reach a context length of 2048 tokens (1024 tokens for full fine-tuning).

Downloads last month
81
Edit dataset card

Models trained or fine-tuned on ammarnasr/the-stack-ruby-clean