add eslint、csscomb...
General purpose glob-based configuration matching.
Turns off all rules that are unnecessary or might conflict with Prettier.
Helper utilities for creating ESLint configuration
ESLint rules for React Hooks
Recommended shareable config for Stylelint
The recommended shareable SCSS config for Stylelint
Airbnb's ESLint config, following our styleguide
The standard shareable SCSS config for Stylelint
ESLint config for React Native
This package is part of the [React Native CLI](../../README.md). It contains commands for managing the configuration of React Native app.
Jest plugin for filtering by filename or test name
A Storybook builder to dev and build with Vite
Metro configuration for React Native.
Airbnb's base JS ESLint config, following our styleguide
Share target browsers between different front-end tools, like Autoprefixer, Stylelint and babel-env-preset
SVGR command line.
JavaScript Standard Style - ESLint Shareable Config
Expose config variables to React Native apps
ESLint config for Expo apps
Use Typescript for configuration files. Types for safety. Compiled for speed.
Security rules for eslint
google-artifactregistry-auth is an npm module that allows you to configure npm to interact with npm repositories stored in Artifact Registry.
CSS modules shareable config for stylelint
Compose configurations for any class.
Used by tribunals_frontend and tribunals_api to share configuration. To use: 1) add "gem 'moj_tribunals_config'" to your Gemfile 2) in an initializer, add the following code: require 'moj_tribunals_config' my_config = Moj::Tribunals::ConfigLoader.new.load This will load the default config files from the gem. To load different files, you can provide an alternative path to the ConfigLoader.new method, e.g. my_config = Moj::Tribunals::ConfigLoader.new('/my/alternative/config/path').load To just load config for a specific tribunal, you can do: config_loader = Moj::Tribunals::ConfigLoader.new config_file = config_loader.config_file_for('utiac') config_loader.load_file( config_file ) RailsConfig integration ======================= If you're using the RailsConfig gem, your intializer can just do something like: files = Moj::Tribunals::ConfigLoader.new.config_files files.each{ |f| Settings.add_source!( f ) } Settings.reload!
Quickly copy files (e.g. YMLs or configuration files) to multiple EngineYard servers
SpreePiwik ========== Adds piwik tracking with Ecommerce tracking Status ------ [](https://travis-ci.org/berkes/spree_piwik) [](https://codeclimate.com/github/berkes/spree_piwik) Installation ------------ Add spree_piwik to your Gemfile: ```ruby gem 'spree_piwik' ``` Bundle your dependencies and run the installation generator: ```shell bundle bundle exec rails g spree_piwik:install ``` Add your Piwik URL and site-id to the `config/initializers/spree_piwik.rb` For example: ```ruby Spree::Piwik::Config[:piwik_url] = "piwik.example.com" Spree::Piwik::Config[:piwik_id] = 1337 ``` Will use http(s)://piwik.example.com/ as url for your Piwik. And track stats for the site that has the id 1337 in Piwik. Screenshot ---------- . Testing ------- First bundle your dependencies, then run `rake`. `rake` will default to building the dummy app if it does not exist, then it will run specs. The dummy app can be regenerated by using `rake test_app`. ```shell bundle bundle exec rake ``` When testing your applications integration with this extension you may use it's factories. Simply add this require statement to your spec_helper: License ------- SpreePiwik is released under the [New BSD License](https://github.com/spree/spree/blob/master/license.md) similar to Spree.
= Barcode Creating barcodes (at the moment only Interleaved2of5). == Usage Create the barcode string and the barcode graphics data i2o5 = Interleave2of5("01199") code = i2o5.encode barcode = i2o5.barcode pdf = Prawn::Document.new barcode.to_pdf(pdf) When used with rails add require 'interleave2of5' to config/application.rb The barcode can be used to create a graphical representation of the barcode. == Release Notes * Version 0.0.1 Create barcode Interleaved 2 of 5 that can be added to a pdf file * Version 0.0.2 Fix check digit calculation * Version 0.0.3 Add valid? to check whether a decoded value (e.g. by a barcode scanner) is valid == Licencse Barcode is published under the MIT license
Send SMS messages
Quickly copy files (e.g. YMLs or configuration files) to multiple EngineYard servers
# Payfast Payfast is a Ruby gem that simplifies the process of integrating the PayFast payment gateway into your Ruby on Rails application. It provides a generator that helps scaffold the necessary configuration, routes, models, and controllers required to integrate PayFast seamlessly. ## Demo  ## Installation Add this line to your application's Gemfile: ```bash bundle add payfast ``` ## Usage ```bash rails generate payfast:install ``` ## This generator will perform the following actions: insert config/routes.rb create app/controllers/carts_controller.rb create app/views/carts/index.html.erb create app/views/carts/make_payment.html.erb create app/helpers/carts_helper.rb create db/migrate/20230824105530_create_carts.rb create config/payfast.yml create app/models/cart.rb insert app/views/layouts/application.html.erb insert config/environments/development.rb ## Additional configuration Setup payfast credentials for your environment rails EDITOR="code --wait" bin/rails credentials:edit This will allow you to securely edit and store your credentials. once you save and exit the file, the credentials will be encrypted and can only be accessed withe rails master key. payfast: merchant_id: {your_merchant_id} merchant_key: {your_merchant_key} passphrase: {{your_passphrase}} ## Update your `payfast.yml` config file - setup the credentials to be use by the rails app - uncomment `Rails.application.credentials.payfast.merchant_id ` and wrap it in erb tags as instructed in the comments. ## Templates Update the `make_payment.html.erb` as instructed in the file. it should look like so: ```js <script> // set the uuid to uuid = @cart.payment_uid. surround @carts.payment_uid with erb tags const uuid = `<%= @cart.payment_uuid %>` window.payfast_do_onsite_payment({uuid}, function (result) { if (result === true) { // redirect success_path(@cart) window.location.href = `<%= success_cart_path(@cart) %>` } else { // Redirect to failure_path(@cart) window.location.href = `<%= failure_cart_path(@cart) %>` } }); </script> ``` ## Testing - payfast api allows only SSL communication from your server. inorder to test locally. you will have to use a tunneling service that allows you to expose your local development server to the internet. your rails development config has was modified by the generator to allow ngrok hosts to hit your rails server ```ruby config.hosts << /[a-z0-9-]+\.ngrok-free\.app/ ``` ## Contributing Thank you for considering contributing to our project! We welcome contributions from the community to help improve this project and make it better for everyone. ### Issues If you encounter any issues or bugs while using our project, please [open a new issue](https://github.com/mactunechy/payfast/issues) on GitHub. Please make sure to include detailed information about the problem, steps to reproduce it, and the environment in which you encountered it. ### Pull Requests We encourage pull requests from the community! If you have an improvement or new feature you'd like to contribute, please follow these steps: 1. Fork the repository and create a new branch for your feature or bug fix. 2. Make your changes and write tests to cover any new functionality. 3. Ensure that the existing tests pass and write additional tests for any bug fixes. 4. Commit your changes and push the new branch to your forked repository. 5. Submit a pull request to our main repository, including a detailed description of the changes you made and any relevant information. We will review your pull request as soon as possible and provide feedback if needed. We value your contributions and will work with you to ensure your changes are integrated smoothly. d Your contributions are essential to the success of this project, and we are grateful for your help in making it better for everyone. If you have any questions or need further assistance, feel free to reach out to us. Happy coding!
# CheckChefConverge This is a Nagios/Sensu check that can check if nodes returned from a chef search have converged recently. ## Installation Add this line to your application's Gemfile: ```ruby gem 'check_chef_converge' ``` And then execute: $ bundle Or install it yourself as: $ gem install check_chef_converge ## Usage ``` Usage: check_chef_converge -w, --warn-minutes MINUTES Warning when chef has not converged in minutes.Default 65 -c, --crit-minutes MINUTES Critical when chef has not converged in minutes.Default 70 -q, --query SEARCH Chef query to filter on. Default 'fqdn:travis-work-mbp.local' --chef-client-config CONFIG Chef client configuration. --chef-server-url URL Chef Server URL. Must pass client-name and client-key or client-key-file with this option. --chef-client-name NAME Chef Client Name. Only used with server-url --chef-client-key KEY Chef Client Key (string). Only used with server-url. Takes precedence over client-key-file. --chef-client-key-file PATH Chef Client Key File. Only used with server-url -h, --help Show this message --version Show version ``` ## Development After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment. To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org). ## Contributing Bug reports and pull requests are welcome on GitHub at https://github.com/Altiscale/check_chef_converge. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](contributor-covenant.org) code of conduct.
== README.md: #ScheduledResource This gem is for displaying how things are used over time -- a schedule for a set of "resources". You can configure the elements of the schedule and there are utilities and protocols to connect them: - Configuration (specification and management), - Query interfaces (a REST-like API and internal protocols to query the models), and - A basic Rails controller implementation. We have a way to configure the schedule, internal methods to generate the data, and a way to retrieve data from the client. However this gem is largely view-framework agnostic. We could use a variety of client-side packages or even more traditional Rails view templates to generate HTML. In any case, to get a good feel in a display like this we need some client-side code. The gem includes client-side modules to: - Manage <b>time and display geometries</b> with "infinite" scroll along the time axis. - <b>Format display cells</b> in ways specific to the resource models. - <b>Update text justification</b> as the display is scrolled horizontally. ## Configuration A **scheduled resource** is something that can be used for one thing at a time. So if "Rocky & Bullwinkle" is on channel 3 from 10am to 11am on Saturday, then 'channel 3' is the <u>resource</u> and that showing of the episode is a <u>resource-use</u> block. Resources and use-blocks are typically Rails models. Each resource and its use-blocks get one row in the display. That row has a label to the left with some timespan visible on the rest of the row. Something else you would expect see in a schedule would be headers and labels -- perhaps one row with the date and another row with the hour. Headers and labels also fit the model of resources and use-blocks. Basic timezone-aware classes (ZTime*) for those are included in this gem. ### Config File The schedule configuration comes from <tt>config/resource_schedule.yml</tt> which has three top-level sections: - ResourceKinds: A hash where the key is a Resource and the value is a UseBlock. (Both are class names), - Resources: A list where each item is a Resource Class followed by one or more resource ids, and - visibleTime: The visible timespan of the schedule in seconds. The example file <tt>config/resource_schedule.yml</tt> (installed when you run <tt>schedulize</tt>) should be enough to display a two-row schedule with just the date above and the hour below. Of course you can monkey-patch or subclass these classes for your own needs. ### The schedule API The 'schedule' endpoint uses parameters <tt>t1</tt> and <tt>t2</tt> to specify a time interval for the request. A third parameter <tt>inc</tt> allows an initial time window to be expanded without repeating blocks that span those boundaries. The time parameters _plus the configured resources_ define the data to be returned. ### More About Configuration Management The <b>ScheduledResource</b> class manages resource and use-block class names, id's and labels for a schedule according to the configuration file. A ScheduledResource instance ties together: 1. A resource class (eg TvStation), 2. An id (a channel number in this example), and 3. Strings and other assets that will go into the DOM. The id is used to - select a resource _instance_ and - select instances of the _resource use block_ class (eg Program instances). The id _could_ be a database id but more often is something a little more suited to human use in the configuration. In any case it is used by model class method <tt>(resource_use_block_class).get_all_blocks()</tt> to select the right use-blocks for the resource. A resource class name and id are are joined with a '_' to form a tag that also serves as an id for the DOM. Once the configuration yaml is loaded that data is maintained in the session structure. Of course having a single configuration file limits the application's usefulness. A more general approach would be to have a user model with login and configuration would be associated with the user. ## Installation Add this line to your application's Gemfile: ```ruby gem 'scheduled_resource' ``` And then execute: $ bundle Or install it yourself as: $ gem install scheduled_resource Then from your application's root execute: $ schedulize . This will install a few image placeholders, client-side modules and a stylesheet under <tt>vendor/assets</tt>, an example configuration in <tt>config/resource_schedule.yml</tt> and an example controller in <tt>app/controllers/schedule_controller.rb</tt>. Also, if you use $ bundle show scheduled_resource to locate the installed source you can browse example classes <tt>lib/z_time_*.rb</tt> and the controller helper methods in <tt>lib/scheduled_resource/helper.rb</tt> ## Testing This gem also provides for a basic test application using angularjs to display a minimal but functional schedule showing just the day and hour headers in two different timezones (US Pacific and Eastern). Proceed as follows, starting with a fresh Rails app: $ rails new test_sr As above, add the gem to the Gemfile, then $ cd test_sr $ bundle $ schedulize . Add lines such as these to <tt>config/routes.rb</tt> get "/schedule/index" => "schedule#index" get "/schedule" => "schedule#schedule" Copy / merge these files from the gem source into the test app: $SR_SRC/app/views/layouts/application.html.erb $SR_SRC/app/views/schedule/index.html.erb $SR_SRC/app/assets/javascripts/{angular.js,script.js,controllers.js} and add <tt>//= require angular</tt> to application.js just below the entries for <tt>jquery</tt>. After you run the server and browse to http://0.0.0.0:3000/schedule/index you should see the four time-header rows specified by the sample config file. ## More Examples A better place to see the use of this gem is at [tv4](https://github.com/emeyekayee/tv4). Specifically, models <tt>app/models/event.rb</tt> and <tt>app/models/station.rb</tt> give better examples of implementing the ScheduledResource protocol and adapting to a db schema organized along somewhat different lines. ## Contributing 1. Fork it ( https://github.com/emeyekayee/scheduled_resource/fork ) 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Add some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create a new Pull Request
# Fresh::Auth This gem makes it really, REALLY easy to use the Freshbooks API. It couldn't be easier. With only 3 functions you'll ever need to use, and only 2 required configuration values, it can't get any easier. ## Installation Add this line to your application's Gemfile: gem 'fresh-auth' And then execute: $ bundle Or install it yourself as: $ gem install fresh-auth ## Usage ### Configuration: You must define your Freshbooks subdomain and your OAuth Secret in your application code before using Fresh::Auth. For Ruby on Rails apps, a new file at config/initializers/fresh-auth.rb would be appropriate. Your configuration file should look like this (you fill in the three empty strings): Fresh::Auth.configure do |config| # The part of your login url between 'http://' and '.freshbooks.com' config.url.subdomain = "" # Under 'My Account' (on the top right when you're logged into Freshbooks) # -> 'Freshbooks API' -> 'OAuth Developer Access' -> 'OAuth Secret' # You'll need to request this from Freshbooks initially. config.oauth_secret = "" # Optional. Any string of your choice. Be creative or check out http://www.thebitmill.com/tools/password.html config.nonce_salt = "" end Fear not: If you try to use Fresh::Auth without configuring it first, an exception will be thrown that clearly describes the problem. ### Public API: There are two modules in this API: Fresh::Auth::Authentication and Fresh::Auth::Api #### Fresh::Auth::Authentication This module authenticates you with Freshbooks, storing the authentication in an array called `session`. This integrates seamlessly with Ruby on Rails' controller environment. If you're using some framework other than Ruby on Rails, make sure to define session in your class before including the Authentication module. This isn't recommended because your class will also need to define other objects called `params` and `request` and implement a `redirect_to` method. It gets complicated. Better leave it to Rails to handle this for you. The only public function of this module is AuthenticateWithFreshbooks. To use it, just add the following line of code to your controller: ` include Fresh::Auth::Authentication ` Then, the following line of code authenticates with Freshbooks from any method in your controller: ` AuthenticateWithFreshbooks() ` Note that, after authenticating with Freshbooks, the user will be redirected back to the same path using HTTP GET, so make sure the resource supports HTTP GET and that in the business logic executed on GET, AuthenticateWihFreshbooks() is called. #### Fresh::Auth::Api Once you've authenticated, you want to send XML requests to Freshbooks. The first step is preparing the XML with Fresh::Auth::Api.GenerateXml, which you'll supply with a block that defines all the nested XML that you want in your request. GenerateXml also takes two arguments before the block: the class and method that you want to call. First, in your controller: `include Fresh::Auth::Api` Then, in some method in that controller: my_xml = GenerateXml :invoice, :update do |xml| xml.client_id 20 xml.status 'sent' xml.notes 'Pick up the car by 5' xml.terms 'Cash only' xml.lines { xml.line { xml.name 'catalytic converter' xml.quantity 1 xml.unit_cost 450 xml.type 'Item' } xml.line { xml.name 'labor' xml.quantity 1 xml.unit_cost 60 xml.type 'Time' } } end Ok, you created the XML. Now you want to send it. Sounds pretty complicated, right? Not at all! Ready? Let's go! `_response = PostToFreshbooksApi my_xml` Now, are you wondering what's in `_response`? I'll tell you shortly, but before we discuss that, we have to know about the exception that PostToFreshbooksApi might raise. It raises a detailed error message if the response status is not 'ok'. Makes sense, right? Now, you still want to know what's in `_response`? Oh, nothing fancy. Just a Nokogiri XML object, representing the root element of the xml response. Could this get any easier? ## Contributing 1. Fork it 2. Create your feature branch (`git checkout -b my-new-feature`) 3. Commit your changes (`git commit -am 'Added some feature'`) 4. Push to the branch (`git push origin my-new-feature`) 5. Create new Pull Request
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.
No description provided.